phase-h step 6: cross-platform smoke (Linux x64)

Two new env-gated test files exercise the in-process CDP stack against
headless Chrome (Chrome 147, via google-chrome --headless=new):

- packages/bcode-browser/test/cdp-smoke.test.ts — connect via
  profileDir, attach a target, Page.enable + navigate +
  waitFor("Page.loadEventFired") + Runtime.evaluate("document.title").
  Verifies the vendored CDP layer (session.ts + generated.ts) drives a
  real browser end-to-end.

- packages/bcode-browser/test/browser-execute.test.ts — exercises the
  full Level-1 execute path: AsyncFunction wrapping, console.log
  capture, return-value serialization, multi-call Session reuse via
  SessionStore (a follow-up snippet on the same sessionID sees the
  Session previously connected), and workspace dynamic-import inside
  a snippet (await import(absPath + "?t=" + Date.now())).

Both gated on BCODE_SMOKE_CHROME=1 + BCODE_SMOKE_PROFILE_DIR. Skipped
otherwise — CI does not yet drive a real browser. All 9 tests
(4 workspace-import + 1 cdp-smoke + 4 browser-execute) pass on
Linux x64.

Compiled binary smoke verified separately: bun build --compile
produces bcode-linux-x64 (148 MB) that boots cleanly, prints --help,
and runs without uv on PATH (the only dependency was the deleted
Python harness).

Cloud-browser tool not exercised here — requires BROWSER_USE_API_KEY
and outbound to api.browser-use.com. Defer to admin smoke or Phase D
bring-up.

Smoke matrix: Linux x64 ✓; macOS arm64 + Windows x64 pending
admin-laptop runs (recorded in memory/browsercode/phase_h_smoke_log.md
on the agent side).

Author: bcode

packages/bcode-browser/test/browser-execute.test.ts

@@ -0,0 +1,132 @@
+// browser_execute end-to-end against headless Chrome. Same env-gate as
+// cdp-smoke.test.ts (BCODE_SMOKE_CHROME=1 + BCODE_SMOKE_PROFILE_DIR).
+//
+// Verifies: AsyncFunction snippet wrapping, console.log capture, return-
+// value serialization, multi-call session reuse via SessionStore, workspace
+// dynamic-import inside a snippet.
+
+import { afterAll, beforeAll, expect, test } from "bun:test"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { Effect } from "effect"
+import { BrowserExecute } from "../src/browser-execute"
+import { SessionStore } from "../src/session-store"
+
+const profileDir = process.env.BCODE_SMOKE_PROFILE_DIR
+const enabled = process.env.BCODE_SMOKE_CHROME === "1" && profileDir
+
+const sessionID = "test-" + Math.random().toString(36).slice(2, 8)
+let workspaceDir: string
+let dataDir: string
+
+beforeAll(async () => {
+  workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), "bcode-be-"))
+  dataDir = await fs.mkdtemp(path.join(os.tmpdir(), "bcode-data-"))
+})
+
+afterAll(async () => {
+  await SessionStore.evict(sessionID)
+  await fs.rm(workspaceDir, { recursive: true, force: true })
+  await fs.rm(dataDir, { recursive: true, force: true })
+})
+
+test.skipIf(!enabled)("connect + console.log + return value", async () => {
+  const result = await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const impl = yield* BrowserExecute.make(dataDir)
+        return yield* impl.execute(
+          {
+            code: `await session.connect({ profileDir: ${JSON.stringify(profileDir!)}, timeoutMs: 5000 });
+                   console.log("connected", session.isConnected());
+                   return { ok: session.isConnected() };`,
+          },
+          { sessionID, workspaceDir },
+        )
+      }),
+    ),
+  )
+  expect(result.output).toContain("connected true")
+  expect(JSON.parse(result.result)).toEqual({ ok: true })
+})
+
+test.skipIf(!enabled)("Session is reused across calls (SessionStore)", async () => {
+  const result = await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const impl = yield* BrowserExecute.make(dataDir)
+        return yield* impl.execute(
+          {
+            code: `// connect was called in the previous test on the same sessionID.
+                   console.log("still connected:", session.isConnected());
+                   return session.isConnected();`,
+          },
+          { sessionID, workspaceDir },
+        )
+      }),
+    ),
+  )
+  expect(result.output).toContain("still connected: true")
+  expect(JSON.parse(result.result)).toBe(true)
+})
+
+test.skipIf(!enabled)("workspace import inside a snippet", async () => {
+  const file = path.join(workspaceDir, "title.ts")
+  await fs.writeFile(
+    file,
+    `export const run = async (session) => {
+       const targets = (await session.Target.getTargets({})).targetInfos
+       const page = targets.find((t) => t.type === "page")
+       if (!page) {
+         const created = await session.Target.createTarget({ url: "about:blank" })
+         await session.use(created.targetId)
+       } else {
+         await session.use(page.targetId)
+       }
+       await session.Page.enable()
+       await session.Page.navigate({ url: "data:text/html,<title>bcode-be</title>" })
+       await session.waitFor("Page.loadEventFired", undefined, 5000)
+       const r = await session.Runtime.evaluate({ expression: "document.title", returnByValue: true })
+       return r.result.value
+     }`,
+    "utf8",
+  )
+
+  const result = await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const impl = yield* BrowserExecute.make(dataDir)
+        return yield* impl.execute(
+          {
+            code: `const m = await import(${JSON.stringify(file)} + "?t=" + Date.now());
+                   const t = await m.run(session);
+                   console.log("title:", t);
+                   return t;`,
+          },
+          { sessionID, workspaceDir },
+        )
+      }),
+    ),
+  )
+  expect(result.output).toContain("title: bcode-be")
+  expect(JSON.parse(result.result)).toBe("bcode-be")
+})
+
+test.skipIf(!enabled)("syntax error in snippet surfaces a clean failure", async () => {
+  await expect(
+    Effect.runPromise(
+      Effect.scoped(
+        Effect.gen(function* () {
+          const impl = yield* BrowserExecute.make(dataDir)
+          return yield* impl.execute(
+            {
+              code: `const x = (`,
+            },
+            { sessionID, workspaceDir },
+          )
+        }),
+      ),
+    ),
+  ).rejects.toThrow(/syntax error/)
+})

packages/bcode-browser/test/cdp-smoke.test.ts

@@ -0,0 +1,46 @@
+// CDP layer smoke test against a real Chrome instance. Skipped unless
+// `BCODE_SMOKE_CHROME=1` and a running Chrome with `--remote-debugging-port`
+// is reachable via the supplied profile dir.
+//
+// The point is to verify the vendored CDP stack (session.ts + generated.ts)
+// drives a real browser end-to-end after the port: connect via profileDir,
+// navigate, query document.title, close.
+
+import { expect, test } from "bun:test"
+import { Session } from "../src/cdp/session"
+
+const profileDir = process.env.BCODE_SMOKE_PROFILE_DIR
+const enabled = process.env.BCODE_SMOKE_CHROME === "1" && profileDir
+
+test.skipIf(!enabled)("Session connects, navigates, reads title", async () => {
+  const session = new Session()
+  try {
+    await session.connect({ profileDir: profileDir!, timeoutMs: 5000 })
+    expect(session.isConnected()).toBe(true)
+
+    // Pick an existing page target (chrome:// internals filtered out).
+    const targets = (await session.domains.Target.getTargets({})).targetInfos
+    const page = (targets as Array<{ targetId: string; type: string; url: string }>).find(
+      (t) => t.type === "page" && !t.url.startsWith("chrome://") && !t.url.startsWith("devtools://"),
+    ) ?? (targets as Array<{ targetId: string; type: string; url: string }>).find((t) => t.type === "page")
+    if (!page) {
+      // Open a fresh page if nothing exists.
+      const created = await session.domains.Target.createTarget({ url: "about:blank" })
+      await session.use(created.targetId)
+    } else {
+      await session.use(page.targetId)
+    }
+
+    await session.domains.Page.enable()
+    await session.domains.Page.navigate({ url: "data:text/html,<title>bcode-smoke</title>" })
+    await session.waitFor("Page.loadEventFired", undefined, 5000)
+
+    const r = (await session.domains.Runtime.evaluate({
+      expression: "document.title",
+      returnByValue: true,
+    })) as { result: { value: unknown } }
+    expect(r.result.value).toBe("bcode-smoke")
+  } finally {
+    session.close()
+  }
+})