pi-browser-harness 0.1.0 → 0.3.1

package/src/domains/tabs.ts

@@ -0,0 +1,121 @@
+import { Type } from "typebox";
+import { type Result, err, ok } from "../util/result";
+import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
+
+const ListTabsArgs = Type.Object({
+  includeInternal: Type.Optional(Type.Boolean({ default: true, description: "Include chrome:// pages" })),
+});
+
+export const listTabsTool = defineBrowserTool({
+  name: "browser_list_tabs",
+  label: "Browser List Tabs",
+  description: "List all open browser tabs (page targets).",
+  promptSnippet: "List browser tabs",
+  promptGuidelines: [
+    "Use to find a full targetId for browser_switch_tab.",
+    "Internal tabs (chrome://) included by default; pass includeInternal=false to exclude them.",
+    "Each tab shows its full 32-char hex targetId — use the exact value with browser_switch_tab.",
+  ],
+  parameters: ListTabsArgs,
+  async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
+    const r = await client.listTabs(args.includeInternal ?? true);
+    if (!r.success) return err({ kind: "cdp_error", message: r.error.message });
+    const lines = r.data.map((t, i) => `  [${i}] ${t.targetId} ${t.url}\n      ${t.title}`);
+    return ok({
+      text: `Tabs (${r.data.length}):\n${lines.join("\n")}`,
+      details: { tabs: r.data },
+    });
+  },
+});
+
+export const currentTabTool = defineBrowserTool({
+  name: "browser_current_tab",
+  label: "Browser Current Tab",
+  description: "Get info about the currently attached tab.",
+  promptSnippet: "Get current tab info",
+  promptGuidelines: ["Returns targetId, url, title."],
+  parameters: Type.Object({}),
+  async handler(_a, { client }): Promise<Result<ToolOk, ToolErr>> {
+    const cur = client.current();
+    if (!cur) return err({ kind: "invalid_state", message: "No tab attached." });
+    const ti = await client.session().callBrowser("Target.getTargetInfo", { targetId: cur.targetId });
+    if (!ti.success) return err({ kind: "cdp_error", message: ti.error.message });
+    const info = (ti.data as { targetInfo: { targetId: string; url: string; title: string } }).targetInfo; // CDP boundary cast: Target.getTargetInfo returns { targetInfo: { targetId, url, title } }
+    return ok({
+      text: `Current tab:\n  ${info.targetId}\n  ${info.url}\n  ${info.title}`,
+      details: { targetId: info.targetId, url: info.url, title: info.title },
+    });
+  },
+});
+
+const SwitchTabArgs = Type.Object({
+  targetId: Type.String({ description: "Target ID from browser_list_tabs" }),
+});
+
+export const switchTabTool = defineBrowserTool({
+  name: "browser_switch_tab",
+  label: "Browser Switch Tab",
+  description: "Switch to and attach to a different tab by targetId.",
+  promptSnippet: "Switch tabs",
+  promptGuidelines: [
+    "Get a targetId via browser_list_tabs first.",
+    "Accepts exact targetId or a unique prefix of at least 8 hex characters.",
+  ],
+  parameters: SwitchTabArgs,
+  async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
+    // Try exact match first
+    let r = await client.switchTab(args.targetId);
+    if (r.success) {
+      return ok({ text: `Switched to ${args.targetId}`, details: { targetId: args.targetId } });
+    }
+    // If exact match failed and input looks like a short prefix (≥8 hex chars), try prefix resolution
+    const isHexPrefix = /^[0-9A-Fa-f]{8,}$/.test(args.targetId);
+    if (!isHexPrefix) {
+      return err({ kind: "cdp_error", message: r.error.message });
+    }
+    const tabs = await client.listTabs(true);
+    if (!tabs.success) return err({ kind: "cdp_error", message: r.error.message });
+    const matches = tabs.data.filter((t) => t.targetId.startsWith(args.targetId));
+    if (matches.length === 0) {
+      return err({ kind: "cdp_error", message: `No tab found with prefix "${args.targetId}"` });
+    }
+    if (matches.length > 1) {
+      const ids = matches.map((t) => t.targetId).join(", ");
+      return err({
+        kind: "invalid_state",
+        message: `Ambiguous prefix "${args.targetId}" matches ${matches.length} tabs: ${ids}`,
+        details: { matches: matches.map((t) => ({ targetId: t.targetId, url: t.url })) },
+      });
+    }
+    const resolved = matches[0]!.targetId;
+    r = await client.switchTab(resolved);
+    if (!r.success) return err({ kind: "cdp_error", message: r.error.message });
+    return ok({
+      text: `Switched to ${resolved} (resolved from prefix "${args.targetId}")`,
+      details: { targetId: resolved, resolvedPrefix: args.targetId },
+    });
+  },
+});
+
+const NewTabArgs = Type.Object({
+  url: Type.Optional(Type.String({ description: "Optional URL to navigate to" })),
+});
+
+export const newTabTool = defineBrowserTool({
+  name: "browser_new_tab",
+  label: "Browser New Tab",
+  description: "Open a new tab and switch to it. Optionally navigate to a URL.",
+  promptSnippet: "Open a new tab",
+  promptGuidelines: ["Pass url to navigate immediately."],
+  parameters: NewTabArgs,
+  async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
+    const r = await client.newTab(args.url);
+    if (!r.success) return err({ kind: "cdp_error", message: r.error.message });
+    return ok({
+      text: `New tab: ${r.data}${args.url ? ` (${args.url})` : ""}`,
+      details: args.url !== undefined
+        ? { targetId: r.data, url: args.url }
+        : { targetId: r.data },
+    });
+  },
+});

package/src/domains/viewport.ts

@@ -0,0 +1,40 @@
+import { Type } from "typebox";
+import { type Result, err, ok } from "../util/result";
+import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
+
+const ViewportArgs = Type.Object({
+  width: Type.Integer({ minimum: 100, maximum: 8000, description: "Viewport CSS pixel width" }),
+  height: Type.Integer({ minimum: 100, maximum: 8000, description: "Viewport CSS pixel height" }),
+  deviceScaleFactor: Type.Optional(
+    Type.Number({ minimum: 0.5, maximum: 4, default: 1, description: "Device pixel ratio" }),
+  ),
+});
+
+export const viewportResizeTool = defineBrowserTool({
+  name: "browser_viewport_resize",
+  label: "Browser Viewport Resize",
+  description: "Override the viewport size and device pixel ratio for responsive testing.",
+  promptSnippet: "Resize the viewport (responsive testing)",
+  promptGuidelines: [
+    "Width/height in CSS pixels (e.g., 375x667 for iPhone SE).",
+    "Pass deviceScaleFactor=2 to simulate retina displays.",
+  ],
+  parameters: ViewportArgs,
+  async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
+    const r = await client.session().call("Emulation.setDeviceMetricsOverride", {
+      width: args.width,
+      height: args.height,
+      deviceScaleFactor: args.deviceScaleFactor ?? 1,
+      mobile: false,
+    });
+    if (!r.success) return err({ kind: "cdp_error", message: r.error.message });
+    return ok({
+      text: `Viewport set to ${args.width}x${args.height} @${args.deviceScaleFactor ?? 1}x`,
+      details: {
+        width: args.width,
+        height: args.height,
+        deviceScaleFactor: args.deviceScaleFactor ?? 1,
+      },
+    });
+  },
+});

package/src/index.ts

@@ -2,8 +2,9 @@
  * pi-browser-harness — browser control extension for pi.
  *
  * Gives pi agents full control of a real Chrome browser via CDP.
- * Spawns the browser-harness daemon, registers browser_* tools,
- * and injects browser control guidance into the system prompt.
+ * Connects to the user's running Chrome (chrome://inspect/#remote-debugging),
+ * registers browser_* tools, and injects browser control guidance into the
+ * system prompt.
  *
  * Install:
  *   pi install npm:pi-browser-harness
@@ -11,39 +12,32 @@
  *
  * Commands:
  *   /browser-setup          — guided setup wizard
- *   /browser-status         — show daemon status and current page
- *   /browser-reload-daemon  — restart the daemon
+ *   /browser-status         — show client status and current page
+ *   /browser-reload-daemon  — restart the browser client
  *
  * Flags:
- *   --browser-namespace <name>  — override BU_NAME (default: auto)
+ *   --browser-namespace <name>   — override namespace (default: auto)
  *   --browser-debug-clicks       — enable debug click overlay
  */
 
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { BrowserDaemon } from "./daemon";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { type BrowserClient, createBrowserClient } from "./client";
 import { getBrowserSystemPrompt } from "./prompt";
-import { registerRenderers } from "./renderers";
 import { registerSetupCommand } from "./setup";
 import { type BrowserState, defaultState, persistState, restoreState } from "./state";
-import { cleanupTempDirs, registerTools } from "./tools";
+import { registerAllTools } from "./registry";
+import { cleanupTempDirs } from "./util/truncate";
 
-export default function browserHarnessExtension(pi: ExtensionAPI) {
-  // ── Resolve namespace ──────────────────────────────────────────────────────
+export default function browserHarnessExtension(pi: ExtensionAPI): void {
   const flagNs = pi.getFlag("browser-namespace") as string | undefined;
-  const namespace = flagNs || `pi-${Math.random().toString(36).slice(2, 10)}`;
+  const namespace = flagNs ?? `pi-${Math.random().toString(36).slice(2, 10)}`;
 
-  // ── State ──────────────────────────────────────────────────────────────────
   let state: BrowserState = defaultState(namespace);
-  let daemon: BrowserDaemon | null = null;
-
-  // ── Tool initialization flag ───────────────────────────────────────────────
+  let client: BrowserClient | null = null;
   let toolsRegistered = false;
 
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Flags
-  // ═══════════════════════════════════════════════════════════════════════════
   pi.registerFlag("browser-namespace", {
-    description: "Browser daemon namespace (BU_NAME). Default: auto-generated",
+    description: "Browser daemon namespace. Default: auto-generated",
     type: "string",
   });
   pi.registerFlag("browser-debug-clicks", {
@@ -52,172 +46,101 @@ export default function browserHarnessExtension(pi: ExtensionAPI) {
     default: false,
   });
 
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Commands
-  // ═══════════════════════════════════════════════════════════════════════════
   pi.registerCommand("browser-status", {
     description: "Show browser connection status and current page",
     handler: async (_args, ctx) => {
-      if (!daemon) {
-        ctx.ui.notify("Browser daemon not started. Run /browser-setup first.", "warning");
+      if (!client) {
+        ctx.ui.notify("Browser client not started. Run /browser-setup first.", "warning");
         return;
       }
-
-      const status = daemon.getStatus();
+      const s = client.status();
       const lines = [
-        `Browser: ${status.alive ? "🟢 Connected" : "🔴 Disconnected"}`,
-        `Session: ${status.sessionId || "none"}`,
+        `Browser: ${s.alive ? "🟢 Connected" : "🔴 Disconnected"}`,
+        `Session: ${s.sessionId ?? "none"}`,
       ];
-
-      if (status.remoteBrowserId) {
-        lines.push(`Browser ID: ${status.remoteBrowserId}`);
-      }
-
-      // Try to get current page info
-      if (status.alive) {
-        try {
-          const info = await daemon.getPageInfo();
-          if ("dialog" in info) {
-            lines.push(`\n⚠️  Dialog open: ${info.dialog.type} — "${info.dialog.message}"`);
+      if (s.remoteBrowserId) lines.push(`Browser ID: ${s.remoteBrowserId}`);
+      if (s.alive) {
+        const info = await client.pageInfo();
+        if (info.success) {
+          if ("dialog" in info.data) {
+            lines.push(`\n⚠️  Dialog open: ${info.data.dialog.type} — "${info.data.dialog.message}"`);
           } else {
-            lines.push(`\nCurrent Page:`);
-            lines.push(`  URL: ${info.url}`);
-            lines.push(`  Title: ${info.title}`);
-            lines.push(`  Viewport: ${info.width}x${info.height}`);
+            lines.push(
+              `\nCurrent Page:`,
+              `  URL: ${info.data.url}`,
+              `  Title: ${info.data.title}`,
+              `  Viewport: ${info.data.width}x${info.data.height}`,
+            );
           }
-        } catch {
-          lines.push("\n(Could not read page info)");
         }
       }
-
       ctx.ui.notify(lines.join("\n"), "info");
     },
   });
 
   pi.registerCommand("browser-reload-daemon", {
-    description: "Restart the browser daemon",
+    description: "Restart the browser client",
     handler: async (_args, ctx) => {
-      if (!daemon) {
-        ctx.ui.notify("Browser daemon not started.", "warning");
+      if (!client) {
+        ctx.ui.notify("Browser client not started.", "warning");
         return;
       }
-
-      ctx.ui.notify("Restarting browser daemon...", "info");
-      try {
-        await daemon.stop();
-        await daemon.start();
-        ctx.ui.notify("Browser daemon restarted ✓", "info");
-      } catch (err) {
-        ctx.ui.notify(
-          `Restart failed: ${err instanceof Error ? err.message : String(err)}`,
-          "error",
-        );
+      ctx.ui.notify("Restarting browser client...", "info");
+      await client.stop();
+      const r = await client.start();
+      if (r.success) {
+        ctx.ui.notify("Browser client restarted ✓", "info");
+      } else {
+        ctx.ui.notify(`Restart failed: ${r.error.message}`, "error");
       }
     },
   });
 
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Session lifecycle
-  // ═══════════════════════════════════════════════════════════════════════════
   pi.on("session_start", async (_event, ctx) => {
-    // Restore persisted state (preserving the current namespace from flag)
     state = restoreState(ctx, state.namespace);
-
-    // Create daemon instance
-    daemon = new BrowserDaemon(state.namespace);
-
-    // Attempt to start daemon (will fail gracefully if Chrome not connected)
-    try {
-      await daemon.start();
-    } catch {
-      // Don't block — user can run /browser-setup later
-    }
-
-    // Register tools (once)
-    if (!toolsRegistered && daemon) {
-      registerTools(pi, daemon);
+    client = createBrowserClient({ namespace: state.namespace });
+    // failure is fine — surfaced via tool errors when the agent first tries to use the browser
+    await client.start();
+    if (!toolsRegistered) {
+      registerAllTools(pi, client);
       toolsRegistered = true;
     }
-
-    // Register renderers
-    registerRenderers(pi);
-
-    // Setup command (always available)
-    if (daemon) {
-      registerSetupCommand(pi, daemon);
-    }
-
-    // Update status
-    if (daemon.getStatus().alive) {
-      ctx.ui.setStatus("browser", "🟢 Browser connected");
-    } else {
-      ctx.ui.setStatus("browser", "🔴 Browser — run /browser-setup");
-    }
+    registerSetupCommand(pi, client);
+    ctx.ui.setStatus(
+      "browser",
+      client.status().alive ? "🟢 Browser connected" : "🔴 Browser — run /browser-setup",
+    );
   });
 
-  pi.on("session_shutdown", async (_event) => {
-    // Persist current state
-    if (state) {
-      persistState(pi, state);
-    }
-
-    // Stop daemon
-    if (daemon) {
+  pi.on("session_shutdown", async () => {
+    persistState(pi, state);
+    if (client) {
       try {
-        await daemon.stop();
-      } catch {
-        // best-effort
+        await client.stop();
+      } catch (e) {
+        // Shutdown is best-effort, but a stuck stop() points at a transport
+        // bug worth surfacing for debugging.
+        console.warn("[pi-browser-harness] client.stop() failed during shutdown:", e);
       }
-      daemon = null;
+      client = null;
     }
-
     toolsRegistered = false;
-
-    // Clean up temp files from truncated tool outputs
     await cleanupTempDirs();
   });
 
-  // Restore state on tree navigation
   pi.on("session_tree", async (_event, ctx) => {
-    state = restoreState(ctx, daemon?.namespace);
-    if (daemon) {
-      persistState(pi, state);
-    }
+    state = restoreState(ctx, client?.namespace);
+    persistState(pi, state);
   });
 
-  // ═══════════════════════════════════════════════════════════════════════════
-  // System prompt injection
-  // ═══════════════════════════════════════════════════════════════════════════
   pi.on("before_agent_start", async (event) => {
-    if (!daemon || !daemon.getStatus().alive) {
-      // Browser not connected — inject minimal note
+    if (!client || !client.status().alive) {
       return {
         systemPrompt:
           event.systemPrompt +
-          `\n\n## Browser Control\n\nBrowser tools (browser_*) are available but the browser daemon is not connected. ` +
-          `Run /browser-setup to connect to Chrome, or /browser-status to check.`,
+          `\n\n## Browser Control\n\nBrowser tools (browser_*) are available but the browser is not connected. Run /browser-setup.`,
       };
     }
-
-    return {
-      systemPrompt: event.systemPrompt + getBrowserSystemPrompt(),
-    };
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // Tool result hook: track tab history
-  // ═══════════════════════════════════════════════════════════════════════════
-  pi.on("tool_result", async (event) => {
-    if (event.toolName === "browser_new_tab" || event.toolName === "browser_navigate") {
-      // Track new tabs in history
-      const details = event.details as { targetId?: string } | undefined;
-      if (details?.targetId) {
-        state = {
-          ...state,
-          tabHistory: [details.targetId, ...state.tabHistory.filter((id) => id !== details.targetId)].slice(0, 20),
-        };
-        persistState(pi, state);
-      }
-    }
+    return { systemPrompt: event.systemPrompt + getBrowserSystemPrompt() };
   });
 }

package/src/prompt.ts

@@ -21,12 +21,12 @@ to interact with pages visually, and other tools alongside them.
 
 | Tool | Purpose |
 |------|---------|
-| browser_screenshot | Capture a PNG screenshot of the current page |
+| browser_screenshot | Capture a PNG screenshot of the current page (result details include path and attached: false — the LLM reads the image via the saved file path) |
 | browser_click | Click at viewport coordinates |
 | browser_type | Type text into the focused element |
 | browser_press_key | Press a keyboard key (Enter, Tab, Escape, arrows, etc.) |
 | browser_scroll | Scroll the page at coordinates |
-| browser_navigate | Navigate to a URL |
+| browser_navigate | Navigate to a URL (result details.outcome.kind is "in_place" or "new_tab_created") |
 | browser_new_tab | Open a new tab, optionally navigate |
 | browser_open_urls | Open multiple URLs in new tabs (parallel) |
 | browser_go_back / browser_go_forward / browser_reload | History navigation |
@@ -37,7 +37,7 @@ to interact with pages visually, and other tools alongside them.
 | browser_execute_js | Execute JavaScript and return the result |
 | browser_http_get | Direct HTTP GET (outside browser, for APIs) |
 | browser_wait | Wait N seconds |
-| browser_wait_for_load | Wait for document.readyState === 'complete' |
+| browser_wait_for_load | Wait for document.readyState === 'complete' (returns a typed timeout error if the page doesn't reach readyState=complete in N seconds, default 15) |
 | browser_handle_dialog | Accept or dismiss a JS dialog |
 | browser_run_script | Execute a temporary script file with daemon access (write script to disk, then run) |
 
@@ -87,6 +87,7 @@ browser_http_get("https://api.example.com/data")
 \`\`\`
 browser_screenshot() → browser_scroll({ deltaY: -500 }) → browser_screenshot()
 \`\`\`
+Note: deltaY follows W3C wheel-event convention: positive=up, negative=down. Default deltaY=-300 scrolls down.
 
 **Research Workflow (search + browser):**
 \`\`\`
@@ -102,5 +103,17 @@ browser_execute_js("document.querySelector('.main').innerText") → extract cont
 \`\`\`
 write("/tmp/extract.js", "...script with daemon access...") → browser_run_script("/tmp/extract.js")
 \`\`\`
+
+### Additional Tools
+
+| Tool | Purpose |
+|------|---------|
+| browser_upload_file | Upload a file to a file input (bypasses file picker) |
+| browser_dispatch_key | Dispatch a DOM KeyboardEvent on a specific element (for React/Vue inputs); returns details.matched (number of elements) |
+| browser_download | Configure download directory and disable save-as prompts |
+| browser_viewport_resize | Resize the viewport for responsive testing |
+| browser_drag_and_drop | Perform drag-and-drop from one coordinate to another |
+| browser_print_to_pdf | Print the current page to a PDF file |
+| browser_get_network_log | Get buffered network request/response events |
 `;
 }

package/src/registry.ts

@@ -0,0 +1,52 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { BrowserClient } from "./client";
+import { type AnyBrowserToolDefinition, registerBrowserTool } from "./util/tool";
+import { clickTool } from "./domains/click";
+import { typeTool, pressKeyTool, dispatchKeyTool } from "./domains/keyboard";
+import { pageInfoTool, waitTool, waitForLoadTool } from "./domains/page";
+import { scrollTool } from "./domains/scroll";
+import { handleDialogTool } from "./domains/dialog";
+import { screenshotTool } from "./domains/screenshot";
+import { navigateTool, openUrlsTool } from "./domains/navigate";
+import { goBackTool, goForwardTool, reloadTool } from "./domains/history";
+import { listTabsTool, currentTabTool, switchTabTool, newTabTool } from "./domains/tabs";
+import { uploadFileTool, downloadTool, printToPdfTool } from "./domains/files";
+import { viewportResizeTool } from "./domains/viewport";
+import { dragAndDropTool } from "./domains/drag";
+import { httpGetTool, getNetworkLogTool } from "./domains/network";
+import { executeJsTool, runScriptTool } from "./domains/js";
+
+const TOOLS: ReadonlyArray<AnyBrowserToolDefinition> = [
+  clickTool,
+  typeTool,
+  pressKeyTool,
+  dispatchKeyTool,
+  scrollTool,
+  pageInfoTool,
+  waitTool,
+  waitForLoadTool,
+  handleDialogTool,
+  screenshotTool,
+  navigateTool,
+  openUrlsTool,
+  goBackTool,
+  goForwardTool,
+  reloadTool,
+  listTabsTool,
+  currentTabTool,
+  switchTabTool,
+  newTabTool,
+  uploadFileTool,
+  downloadTool,
+  printToPdfTool,
+  viewportResizeTool,
+  dragAndDropTool,
+  httpGetTool,
+  getNetworkLogTool,
+  executeJsTool,
+  runScriptTool,
+];
+
+export const registerAllTools = (pi: ExtensionAPI, client: BrowserClient): void => {
+  for (const t of TOOLS) registerBrowserTool(pi, client, t);
+};

package/src/schemas/common.ts

@@ -0,0 +1,11 @@
+import { Type } from "typebox";
+
+export const Coords = Type.Object({
+  x: Type.Number({ description: "X coordinate in CSS pixels from left edge of viewport" }),
+  y: Type.Number({ description: "Y coordinate in CSS pixels from top edge of viewport" }),
+});
+
+export const MouseButton = Type.Union(
+  [Type.Literal("left"), Type.Literal("right"), Type.Literal("middle")],
+  { description: 'Mouse button: "left", "right", or "middle"' },
+);

package/src/setup.ts

@@ -5,18 +5,18 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { execSync } from "node:child_process";
-import type { BrowserDaemon } from "./daemon";
+import type { BrowserClient } from "./client";
 
-export function registerSetupCommand(pi: ExtensionAPI, daemon: BrowserDaemon): void {
+export function registerSetupCommand(pi: ExtensionAPI, client: BrowserClient): void {
   pi.registerCommand("browser-setup", {
     description: "Connect pi to your Chrome browser",
     handler: async (_args, ctx) => {
-      await runSetup(ctx, daemon);
+      await runSetup(ctx, client);
     },
   });
 }
 
-async function runSetup(ctx: ExtensionContext, daemon: BrowserDaemon): Promise<void> {
+async function runSetup(ctx: ExtensionContext, client: BrowserClient): Promise<void> {
   ctx.ui.notify("browser setup: checking Chrome...", "info");
 
   // Step 1: Check Chrome is running
@@ -32,11 +32,9 @@ async function runSetup(ctx: ExtensionContext, daemon: BrowserDaemon): Promise<v
 
   // Step 2: Try to connect to Chrome DevTools
   ctx.ui.notify("Connecting to Chrome DevTools...", "info");
-  try {
-    await daemon.start();
-    ctx.ui.notify("Connected to Chrome ✓", "info");
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+  const startResult = await client.start();
+  if (!startResult.success) {
+    const msg = startResult.error.message;
     const lower = msg.toLowerCase();
 
     if (
@@ -58,25 +56,26 @@ async function runSetup(ctx: ExtensionContext, daemon: BrowserDaemon): Promise<v
     ctx.ui.notify(`Connection failed: ${msg}`, "error");
     return;
   }
+  ctx.ui.notify("Connected to Chrome ✓", "info");
 
   // Step 3: Verify with test navigation
   ctx.ui.notify("Testing browser control...", "info");
-  try {
-    await daemon.newTab("https://github.com");
-    const info = await daemon.getPageInfo();
-    if ("dialog" in info) {
-      await daemon.cdp("Page.handleJavaScriptDialog", { accept: true });
-    }
-    ctx.ui.notify(
-      `Browser control verified ✓\nNavigated to: ${"url" in info ? info.url : "github.com"}`,
-      "info",
-    );
-  } catch (err) {
+  const tabResult = await client.newTab("https://github.com");
+  if (!tabResult.success) {
     ctx.ui.notify(
-      `Browser connected but test navigation failed: ${err instanceof Error ? err.message : String(err)}`,
+      `Browser connected but test navigation failed: ${tabResult.error.message}`,
       "warning",
     );
+    return;
+  }
+
+  const info = await client.pageInfo();
+  if (info.success && "dialog" in info.data) {
+    await client.session().call("Page.handleJavaScriptDialog", { accept: true });
   }
+
+  const pageUrl = info.success && !("dialog" in info.data) ? info.data.url : "github.com";
+  ctx.ui.notify(`Browser control verified ✓\nNavigated to: ${pageUrl}`, "info");
 }
 
 function checkChromeRunning(): boolean {