fix(webview): detect dead webview renderer via heartbeat and auto-reload

.github/workflows/code-qa.yml

@@ -110,6 +110,8 @@ jobs:
               run: pnpm agent-evals:check-types
             - name: Model-check task lifecycle protocols
               run: pnpm lifecycle:model-check
+            - name: Model-check webview recovery
+              run: pnpm webview-recovery:check-types && pnpm webview-recovery:model-check
             - name: Validate MCP OAuth integration
               run: pnpm mcp:integration-check
 

.github/workflows/visual-regression.yml

@@ -85,7 +85,8 @@ jobs:
 
     extension-host-visual:
         runs-on: ubuntu-latest
-        timeout-minutes: 20
+        # Includes dependency setup, builds, repeated visuals, and production watchdog waits.
+        timeout-minutes: 35
         container:
             image: mcr.microsoft.com/playwright:v1.62.1-noble@sha256:dcc5531e97840b9b5e794f2814476b21571c5124a3fca2267d73041f56e7580e
             options: --ipc=host

apps/vscode-e2e/playwright-electron.config.ts

@@ -4,12 +4,14 @@ import { defineConfig } from "@playwright/test"
 
 export default defineConfig({
 	testDir: "./src/visual",
-	testMatch: "electron.visual.ts",
 	outputDir: path.resolve(__dirname, "test-results-electron"),
 	snapshotPathTemplate: "{testDir}/__screenshots__/{arg}{ext}",
 	fullyParallel: false,
 	workers: 1,
-	repeatEach: process.env.CI ? 3 : 1,
+	projects: [
+		{ name: "visual", testMatch: "electron.visual.ts", repeatEach: process.env.CI ? 3 : 1 },
+		{ name: "heartbeat", testMatch: "heartbeat.electron.ts", repeatEach: 1 },
+	],
 	timeout: 3 * 60 * 1_000,
 	expect: {
 		timeout: 60_000,

apps/vscode-e2e/src/visual/electron.visual.ts

@@ -1,33 +1,15 @@
-import fs from "fs/promises"
-import { readFileSync } from "fs"
-import os from "os"
-import path from "path"
-
-import { LLMock } from "@copilotkit/aimock"
 import { downloadAndUnzipVSCode } from "@vscode/test-electron"
-import { _electron, expect, test, type ElectronApplication, type Page, type TestInfo } from "@playwright/test"
-import { glob } from "glob"
-
-const packageRoot = path.resolve(__dirname, "../..")
-const repositoryRoot = path.resolve(packageRoot, "../..")
-const extensionDevelopmentPath = path.join(repositoryRoot, "src")
-const extensionTestsPath = path.join(packageRoot, "out", "visual", "sceneController")
-const packageJson = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf8")) as {
-	devDependencies: Record<string, string>
-}
-const vscodeVersion = packageJson.devDependencies["@types/vscode"]
-
-const CHAT_PROMPT = "electron-visual-smoke: render a deterministic completion"
-const CHAT_RESULT = "Electron visual smoke response rendered inside the real VS Code webview."
-
-interface VisualScenario {
-	name: string
-	scene: "welcome" | "chat"
-	themeId: "Default Dark Modern" | "Default High Contrast"
-	landmark: string
-	webviewSnapshot?: string
-	startMock?: boolean
-}
+import { expect, test } from "@playwright/test"
+
+import {
+	attachFailureArtifacts,
+	CHAT_RESULT,
+	extensionDevelopmentPath,
+	startScene,
+	stopScene,
+	vscodeVersion,
+	type VisualScenario,
+} from "./electronHarness"
 
 const scenarios: VisualScenario[] = [
 	{
@@ -52,155 +34,6 @@ const scenarios: VisualScenario[] = [
 	},
 ]
 
-interface RunningScene {
-	app: ElectronApplication
-	donePath: string
-	logPath: string
-	mock?: InstanceType<typeof LLMock>
-	page: Page
-	temporaryRoot: string
-	userDataPath: string
-}
-
-async function waitForJson(filePath: string): Promise<{ landmark: string; scene: string; themeId: string }> {
-	const deadline = Date.now() + 90_000
-	while (Date.now() < deadline) {
-		try {
-			return JSON.parse(await fs.readFile(filePath, "utf8")) as {
-				landmark: string
-				scene: string
-				themeId: string
-			}
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT" && !(error instanceof SyntaxError)) throw error
-			await new Promise((resolve) => setTimeout(resolve, 100))
-		}
-	}
-	throw new Error(`Timed out waiting for Electron visual readiness file: ${filePath}`)
-}
-
-async function attachLogs(userDataPath: string, logPath: string, testInfo: TestInfo) {
-	const sceneLog = await fs.readFile(logPath, "utf8").catch(() => "")
-	if (sceneLog) await testInfo.attach("scene.log", { body: sceneLog, contentType: "text/plain" })
-
-	for (const pattern of ["logs/**/exthost.log", "logs/**/renderer.log", "logs/**/*Zoo-Code.log"]) {
-		const logs = await glob(pattern, { cwd: userDataPath })
-		const latest = logs.at(-1)
-		if (!latest) continue
-		const contents = await fs.readFile(path.join(userDataPath, latest), "utf8").catch(() => "")
-		if (contents) await testInfo.attach(path.basename(latest), { body: contents, contentType: "text/plain" })
-	}
-}
-
-async function stopTracing(app: ElectronApplication, testInfo: TestInfo) {
-	await app
-		.context()
-		.tracing.stop({ path: testInfo.outputPath("trace.zip") })
-		.catch(() => undefined)
-}
-
-async function startScene(
-	vscodeExecutablePath: string,
-	scenario: VisualScenario,
-	testInfo: TestInfo,
-): Promise<RunningScene> {
-	const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "zoo-code-electron-visual-"))
-	const workspacePath = path.join(temporaryRoot, "workspace")
-	const userDataPath = path.join(temporaryRoot, "user-data")
-	const extensionsPath = path.join(temporaryRoot, "extensions")
-	const readyPath = path.join(temporaryRoot, "ready.json")
-	const donePath = path.join(temporaryRoot, "done")
-	const logPath = path.join(temporaryRoot, "scene.log")
-	await Promise.all([fs.mkdir(workspacePath), fs.mkdir(userDataPath), fs.mkdir(extensionsPath)])
-
-	let app: ElectronApplication | undefined
-	let mock: InstanceType<typeof LLMock> | undefined
-	let page: Page | undefined
-	try {
-		if (scenario.startMock) {
-			mock = new LLMock({ port: 0 })
-			mock.addFixture({
-				match: { userMessage: CHAT_PROMPT },
-				response: {
-					toolCalls: [
-						{
-							name: "attempt_completion",
-							arguments: JSON.stringify({ result: CHAT_RESULT }),
-							id: "call_electron_visual_completion",
-						},
-					],
-				},
-			})
-			await mock.start()
-		}
-
-		app = await _electron.launch({
-			executablePath: vscodeExecutablePath,
-			args: [
-				workspacePath,
-				`--extensionDevelopmentPath=${extensionDevelopmentPath}`,
-				`--extensionTestsPath=${extensionTestsPath}`,
-				`--user-data-dir=${userDataPath}`,
-				`--extensions-dir=${extensionsPath}`,
-				"--disable-workspace-trust",
-				"--skip-welcome",
-				"--skip-release-notes",
-				"--disable-updates",
-				"--disable-gpu",
-				"--force-device-scale-factor=1",
-			],
-			env: {
-				...process.env,
-				AIMOCK_URL: mock?.url ?? "",
-				ROO_CODE_VISUAL_CHAT_PROMPT: CHAT_PROMPT,
-				ROO_CODE_VISUAL_CHAT_RESULT: CHAT_RESULT,
-				ROO_CODE_VISUAL_DONE_PATH: donePath,
-				ROO_CODE_VISUAL_LOG_PATH: logPath,
-				ROO_CODE_VISUAL_READY_PATH: readyPath,
-				ROO_CODE_VISUAL_SCENE: scenario.scene,
-				ROO_CODE_VISUAL_THEME: scenario.themeId,
-				ROO_CODE_THEME_FIXTURE_PROBE: "1",
-			},
-			locale: "en-US",
-			timeout: 60_000,
-			timezoneId: "UTC",
-		})
-		await app.context().tracing.start({ screenshots: true, snapshots: true, sources: true })
-		page = await app.firstWindow({ timeout: 60_000 })
-		await app.evaluate(({ BrowserWindow }) => {
-			const window = BrowserWindow.getAllWindows()[0]
-			window?.setBounds({ x: 0, y: 0, width: 1200, height: 800 })
-			window?.focus()
-		})
-		const ready = await waitForJson(readyPath)
-		expect(ready).toMatchObject({ landmark: scenario.landmark, scene: scenario.scene, themeId: scenario.themeId })
-		return { app, donePath, logPath, mock, page, temporaryRoot, userDataPath }
-	} catch (error) {
-		if (page) await page.screenshot({ path: testInfo.outputPath("workbench.png") }).catch(() => undefined)
-		await attachLogs(userDataPath, logPath, testInfo)
-		await fs.writeFile(donePath, "done\n", "utf8").catch(() => undefined)
-		if (app) await stopTracing(app, testInfo)
-		await app?.close().catch(() => undefined)
-		await mock?.stop().catch(() => undefined)
-		await fs.rm(temporaryRoot, { recursive: true, force: true })
-		if (error instanceof Error) throw error
-		throw new Error(String(error))
-	}
-}
-
-async function attachFailureArtifacts(scene: RunningScene, testInfo: TestInfo) {
-	await scene.page.screenshot({ path: testInfo.outputPath("workbench.png") }).catch(() => undefined)
-	await attachLogs(scene.userDataPath, scene.logPath, testInfo)
-}
-
-async function stopScene(scene: RunningScene, testInfo: TestInfo) {
-	await fs.writeFile(scene.donePath, "done\n", "utf8").catch(() => undefined)
-	await stopTracing(scene.app, testInfo)
-	await scene.app.close().catch(() => undefined)
-	await scene.mock?.stop().catch(() => undefined)
-	await fs.rm(scene.temporaryRoot, { recursive: true, force: true })
-}
-
 test.describe.configure({ mode: "serial" })
 
 let vscodeExecutablePath: string