pi-browser-harness 0.12.0 → 0.13.0

package/src/domains/js.ts

@@ -4,28 +4,53 @@ import { isPathWithin } from "../util/paths";
 import { tmpdir } from "node:os";
 import { createRequire } from "node:module";
 import { Type } from "typebox";
-import { Markdown, Text } from "@mariozechner/pi-tui";
+import { Markdown } from "@mariozechner/pi-tui";
 import { getMarkdownTheme, keyHint } from "@mariozechner/pi-coding-agent";
 import { type Result, err, ok } from "../util/result";
 import { formatBytes } from "../util/truncate";
-import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
+import { type DetailsOf, defineBrowserTool, isJsonObject, type ToolErr, type ToolOk } from "../util/tool";
 import { evalJs } from "./cdp-call";
 import { applyTruncation } from "../util/truncate";
-import { asNumber, asRecord, asString, isRecord } from "../util/guards";
+import { isRecord } from "../util/guards";
 
 const COMPACT_PREVIEW_BYTES = 120;
 
-// The AsyncFunction constructor is the documented way to compile user source; a plain `unknown` cast would lose the constructor signature, so this typed cast stays.
-const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor as
-  new (...args: ReadonlyArray<string>) => (...args: ReadonlyArray<unknown>) => Promise<unknown>;
+type AsyncFunctionConstructor = new (...args: ReadonlyArray<string>) => (...args: ReadonlyArray<unknown>) => Promise<unknown>;
+
+// The AsyncFunction constructor is the documented way to compile user source. It is only reachable through
+// Object.getPrototypeOf, which returns `any`; this is the one sanctioned cast (budgeted in boundary-allowlist.ts)
+// because a plain `unknown` would lose the constructor signature and nothing can narrow back to it.
+/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-type-assertion -- the constructor is only reachable through an `any`-typed prototype lookup */
+const AsyncFunction = Object.getPrototypeOf(async () => { /* only its prototype is wanted */ }).constructor as
+  AsyncFunctionConstructor;
+/* eslint-enable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-type-assertion */
 
 const requireFromHere = createRequire(import.meta.url);
 
+// Pretty-prints for the expanded renderer; a truncated (unparseable) payload is shown as-is.
+const prettyJson = (text: string): string => {
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return JSON.stringify(parsed, null, 2);
+  } catch {
+    return text;
+  }
+};
+
 const ExecuteJsArgs = Type.Object({
   expression: Type.String({ description: "JavaScript expression. `return X` is auto-wrapped in an IIFE." }),
   targetId: Type.Optional(Type.String({ description: "Optional iframe targetId; default = current page." })),
 });
 
+const ExecuteJsDetailsSchema = Type.Object({
+  valueLength: Type.Number(),
+  preview: Type.String(),
+  isJson: Type.Boolean(),
+  fullOutputPath: Type.Optional(Type.String()),
+});
+
+export type ExecuteJsDetails = DetailsOf<typeof ExecuteJsDetailsSchema>;
+
 export const executeJsTool = defineBrowserTool({
   name: "browser_execute_js",
   label: "Browser Execute JS",
@@ -40,46 +65,35 @@ export const executeJsTool = defineBrowserTool({
     "Result must be JSON-serializable (Runtime.evaluate returnByValue=true).",
   ],
   parameters: ExecuteJsArgs,
+  details: ExecuteJsDetailsSchema,
   concurrency: "parallel",
-  async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
+  async handler(args, { client }): Promise<Result<ToolOk<ExecuteJsDetails>, ToolErr>> {
     const r = await evalJs(client, args.expression, args.targetId);
     if (!r.success) return r;
     const valueStr = r.data === undefined ? "undefined" : JSON.stringify(r.data);
+    // The full value lives in the text (and in fullOutputPath when truncated); details carry only what the
+    // renderer needs so a large result is not persisted twice.
+    const isJson = r.data !== undefined;
     const truncated = await applyTruncation(valueStr, "js");
-    let pretty: string | undefined;
-    try {
-      const parsed: unknown = JSON.parse(valueStr);
-      pretty = JSON.stringify(parsed, null, 2);
-    } catch {
-      pretty = undefined;
-    }
+    const preview = valueStr.length > COMPACT_PREVIEW_BYTES ? valueStr.slice(0, COMPACT_PREVIEW_BYTES) + "…" : valueStr;
     return ok({
       text: truncated.text,
       details: {
         valueLength: valueStr.length,
-        full: valueStr.length > 200_000 ? valueStr.slice(0, 200_000) : valueStr,
-        ...(pretty !== undefined ? { pretty: pretty.length > 200_000 ? pretty.slice(0, 200_000) : pretty } : {}),
+        preview,
+        isJson,
         ...(truncated.fullOutputPath !== undefined ? { fullOutputPath: truncated.fullOutputPath } : {}),
       },
     });
   },
 
-  renderResult(result, expanded, theme) {
-    const raw = asRecord(result.details);
-    if (raw === undefined) return new Text(theme.fg("error", "execute_js: no details"), 0, 0);
-    const details = {
-      valueLength: asNumber(raw["valueLength"]),
-      full: asString(raw["full"]),
-      pretty: asString(raw["pretty"]),
-      fullOutputPath: asString(raw["fullOutputPath"]),
-    };
-
-    const len = details.valueLength ?? 0;
-    const full = details.full ?? "";
-    const isJson = details.pretty !== undefined;
+  renderResult(result, expanded) {
+    const { valueLength: len, preview, isJson, fullOutputPath } = result.details;
+    const content = result.content[0];
+    const fullText = content?.type === "text" ? content.text : preview;
+    const body = isJson ? prettyJson(fullText) : fullText;
 
     if (!expanded) {
-      const preview = full.length > COMPACT_PREVIEW_BYTES ? full.slice(0, COMPACT_PREVIEW_BYTES) + "…" : full;
       const md = [
         `**${formatBytes(len)}** ${isJson ? "JSON" : "value"}`,
         "```",
@@ -90,10 +104,9 @@ export const executeJsTool = defineBrowserTool({
       return new Markdown(md, 0, 0, getMarkdownTheme());
     }
 
-    const body = details.pretty ?? full;
     const fence = isJson ? "```json" : "```";
-    const tail = details.fullOutputPath
-      ? `\n\nFull value at \`${details.fullOutputPath}\` · ${keyHint("app.tools.expand", "to collapse")}`
+    const tail = fullOutputPath !== undefined
+      ? `\n\nFull value at \`${fullOutputPath}\` · ${keyHint("app.tools.expand", "to collapse")}`
       : `\n\n${keyHint("app.tools.expand", "to collapse")}`;
     const md = [`**${formatBytes(len)}** ${isJson ? "JSON" : "value"}`, fence, body, "```", tail].join("\n");
     return new Markdown(md, 0, 0, getMarkdownTheme());
@@ -144,11 +157,11 @@ export const runScriptTool = defineBrowserTool({
   concurrency: "parallel",
   async handler(args, { client, signal, onUpdate, extensionCtx }): Promise<Result<ToolOk, ToolErr>> {
     if (!isAbsolute(args.path)) {
-      return err({ kind: "invalid_state", message: "Script path must be absolute" });
+      return err({ kind: "invalid_args", message: "Script path must be absolute" });
     }
     if (!isPathAllowed(args.path)) {
       return err({
-        kind: "invalid_state",
+        kind: "invalid_args",
         message: `Script path outside allowed directories (allowed: ${allowedRoots().join(", ")})`,
       });
     }
@@ -161,9 +174,9 @@ export const runScriptTool = defineBrowserTool({
         message: `Failed to read script: ${e instanceof Error ? e.message : String(e)}`,
       });
     }
-    if (source.length === 0) return err({ kind: "invalid_state", message: "Script is empty" });
+    if (source.length === 0) return err({ kind: "invalid_args", message: "Script is empty" });
     if (source.length > MAX_SOURCE_BYTES) {
-      return err({ kind: "invalid_state", message: `Script exceeds ${MAX_SOURCE_BYTES}B size cap` });
+      return err({ kind: "invalid_args", message: `Script exceeds ${MAX_SOURCE_BYTES}B size cap` });
     }
 
     let executeFn: (...a: ReadonlyArray<unknown>) => Promise<unknown>;
@@ -175,16 +188,16 @@ export const runScriptTool = defineBrowserTool({
       );
     } catch (e) {
       return err({
-        kind: "invalid_state",
+        kind: "invalid_args",
         message: `Syntax error: ${e instanceof Error ? e.message : String(e)}`,
       });
     }
 
     const timeoutMs = args.timeoutMs ?? 60_000;
     const ac = new AbortController();
-    const onAbort = (): void => ac.abort();
+    const onAbort = (): void => { ac.abort(); };
     if (signal !== undefined) signal.addEventListener("abort", onAbort, { once: true });
-    const timeoutTimer = setTimeout(() => ac.abort(), timeoutMs);
+    const timeoutTimer = setTimeout(onAbort, timeoutMs);
 
     try {
       const scriptPromise = executeFn(
@@ -200,13 +213,17 @@ export const runScriptTool = defineBrowserTool({
           if (!isRecord(first)) return;
           const txt = first["text"];
           if (typeof txt !== "string") return;
-          try { onUpdate({ text: txt }); } catch {}
+          try {
+            onUpdate({ text: txt });
+          } catch {
+            // Progress is best-effort; a renderer failure must not abort the script.
+          }
         },
-        extensionCtx ?? { cwd: process.cwd() },
+        extensionCtx,
         console, fetch, JSON, Buffer, setTimeout, clearTimeout,
       );
       const abortPromise = new Promise<never>((_, reject) => {
-        ac.signal.addEventListener("abort", () => reject(new Error("script aborted (timeout or cancellation)")), { once: true });
+        ac.signal.addEventListener("abort", () => { reject(new Error("script aborted (timeout or cancellation)")); }, { once: true });
       });
       const result = await Promise.race([scriptPromise, abortPromise]);
       clearTimeout(timeoutTimer);
@@ -224,7 +241,11 @@ export const runScriptTool = defineBrowserTool({
       }
       const textOut = content.map((c) => c.text).join("\n");
       const details = result["details"];
-      return isRecord(details) ? ok({ text: textOut, details }) : ok({ text: textOut });
+      if (details === undefined) return ok({ text: textOut });
+      if (!isJsonObject(details)) {
+        return err({ kind: "invalid_state", message: "Script details must be a plain JSON object (no Map, function or undefined values)" });
+      }
+      return ok({ text: textOut, details });
     } catch (e) {
       clearTimeout(timeoutTimer);
       if (signal !== undefined) signal.removeEventListener("abort", onAbort);

package/src/domains/keyboard.ts

@@ -1,14 +1,22 @@
 import { Type } from "typebox";
+import type { ParamsOf } from "../cdp/commands";
 import { safeJs } from "../util/js-template";
 import { type Result, err, ok } from "../util/result";
 import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
 import { cdpCall, evalJs } from "./cdp-call";
-import { resolveRefToObjectId } from "./ref-resolve";
+import { runOnElement } from "./element-call";
+import { elementFunctionSource } from "./page/inject";
+import { dispatchKeyEvent, type KeyEventSpec } from "./page/keyboard.page";
+
+const DISPATCH_KEY_FN = elementFunctionSource(dispatchKeyEvent);
 
 const VIRTUAL_KEY_CODES: Readonly<Record<string, number>> = {
   Enter: 13, Tab: 9, Backspace: 8, Escape: 27, Delete: 46, " ": 32,
   ArrowLeft: 37, ArrowUp: 38, ArrowRight: 39, ArrowDown: 40,
   Home: 36, End: 35, PageUp: 33, PageDown: 34,
+  Insert: 45, Shift: 16, Control: 17, Alt: 18, Meta: 91, CapsLock: 20, ContextMenu: 93,
+  F1: 112, F2: 113, F3: 114, F4: 115, F5: 116, F6: 117,
+  F7: 118, F8: 119, F9: 120, F10: 121, F11: 122, F12: 123,
 };
 
 const virtualKeyCode = (key: string): number =>
@@ -92,7 +100,7 @@ export const pressKeyTool = defineBrowserTool({
     const code = virtualKeyCode(k);
     const modifiers = args.modifiers ?? 0;
     const isChar = k.length === 1;
-    const downParams: Record<string, unknown> = {
+    const downParams: ParamsOf<"Input.dispatchKeyEvent"> = {
       type: "keyDown",
       key: k,
       code: k,
@@ -147,14 +155,9 @@ export const dispatchKeyTool = defineBrowserTool({
     // Legacy handlers branch on e.keyCode/e.which rather than e.key, so populate both.
     const code = virtualKeyCode(args.key);
     if (args.ref !== undefined) {
-      const objectId = await resolveRefToObjectId(client, args.ref);
-      if (!objectId.success) return objectId;
-      const r = await cdpCall(client, "Runtime.callFunctionOn", {
-        objectId: objectId.data,
-        functionDeclaration: `function (type, key, keyCode) { this.dispatchEvent(new KeyboardEvent(type, { key, keyCode, which: keyCode, bubbles: true, cancelable: true })); return 1; }`,
-        arguments: [{ value: eventType }, { value: args.key }, { value: code }],
-        returnByValue: true,
-      });
+      // Through runOnElement so the resolved RemoteObject is released after the call.
+      const spec: KeyEventSpec = { type: eventType, key: args.key, code };
+      const r = await runOnElement(client, { ref: args.ref, functionDeclaration: DISPATCH_KEY_FN, args: [spec] });
       if (!r.success) return r;
       return ok({
         text: `Dispatched ${eventType}('${args.key}') on ${target}`,
@@ -162,7 +165,7 @@ export const dispatchKeyTool = defineBrowserTool({
       });
     }
     if (args.selector === undefined) {
-      return err({ kind: "invalid_state", message: "Provide either `ref` or `selector`." });
+      return err({ kind: "invalid_args", message: "Provide either `ref` or `selector`." });
     }
     const expr = safeJs`
       (() => {

package/src/domains/navigate.ts

@@ -1,11 +1,13 @@
 import { Type } from "typebox";
 import { Text } from "@mariozechner/pi-tui";
+import type { BrowserClient } from "../client";
 import { type Result, err, ok } from "../util/result";
 import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
 import { applyTruncation } from "../util/truncate";
 import { safeJs } from "../util/js-template";
-import { ensureHarnessWindow, openHarnessTab } from "../cdp/target-factory";
-import { cdpCall, cdpCallBrowser, cdpCallOnTarget, evalJs } from "./cdp-call";
+import { borrowSession, ensureHarnessWindow, openHarnessTab } from "../cdp/target-factory";
+import { cdpCall, cdpCallBrowser, cdpCallOnTarget, evalJs, fromClient } from "./cdp-call";
+import { pollUntil, READY_STATE_COMPLETE } from "./poll";
 
 const NavigateArgs = Type.Object({
   url: Type.String({ description: "Full URL to navigate to (e.g. https://github.com)" }),
@@ -29,12 +31,12 @@ export const navigateTool = defineBrowserTool({
   concurrency: "serialized",
   renderCall: (a) => new Text(`🌐 Navigate to ${a.url}`, 0, 0),
   async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
-    const tabs = await client.listTabs(false);
-    if (!tabs.success) return err({ kind: "cdp_error", message: tabs.error.message });
+    const tabs = fromClient(await client.listTabs(false), "Target.getTargets");
+    if (!tabs.success) return tabs;
     let outcome: NavOutcome;
     if (tabs.data.length === 0) {
-      const created = await client.newTab(args.url);
-      if (!created.success) return err({ kind: "cdp_error", message: created.error.message });
+      const created = fromClient(await client.newTab(args.url), "Target.createTarget");
+      if (!created.success) return created;
       outcome = { kind: "new_tab_created", targetId: created.data, reason: "no_tabs" };
     } else {
       const nav = await cdpCall(client, "Page.navigate", { url: args.url });
@@ -43,9 +45,9 @@ export const navigateTool = defineBrowserTool({
       if (!cur) return err({ kind: "internal", message: "navigate succeeded but no current target tracked" });
       outcome = { kind: "in_place", targetId: cur.targetId };
     }
-    const info = await client.pageInfo();
-    if (!info.success) return err({ kind: "cdp_error", message: info.error.message });
-    if ("dialog" in info.data) {
+    const info = fromClient(await client.pageInfo(), "pageInfo");
+    if (!info.success) return info;
+    if (info.data.kind === "dialog") {
       return ok({
         text: `Navigated to ${args.url}\nTarget: ${outcome.targetId}\n⚠️  Dialog open: ${info.data.dialog.type} — "${info.data.dialog.message}"\nUse browser_handle_dialog.`,
         details: { outcome, dialog: info.data.dialog },
@@ -68,6 +70,76 @@ type TabResult = {
   readonly targetId: string;
   readonly ok: boolean;
   readonly error?: string;
+  readonly note?: string;
+};
+
+// The marker is applied once the document has loaded; applying it right after Page.navigate would mark the
+// outgoing document and be overwritten by the incoming one.
+const TITLE_MARK_TIMEOUT_MS = 10_000;
+
+// Opens one tab per url in a single harness window. All tabs must land in ONE window: a parallel newWindow:true
+// per url would scatter them across N windows, so the first url seeds the window and the rest open as its children.
+const createTabs = async (client: BrowserClient, urls: ReadonlyArray<string>): Promise<Result<ReadonlyArray<TabResult>, ToolErr>> => {
+  const url0 = urls[0];
+  if (url0 === undefined) return err({ kind: "invalid_args", message: "no URLs provided" });
+  const window = await ensureHarnessWindow(client);
+  if (!window.success) return fromClient(window, "Target.createTarget");
+  const seededWindow = window.data.targetId;
+  const seedResult: TabResult | undefined = window.data.freshlyCreated
+    ? { url: url0, targetId: seededWindow, ok: true }
+    : undefined;
+  const created = await Promise.all(urls.map(async (url, i): Promise<TabResult> => {
+    if (i === 0 && seedResult) return seedResult;
+    const r = await openHarnessTab(client, seededWindow);
+    if (!r.success) return { url, targetId: "", ok: false, error: r.error.message };
+    return { url, targetId: r.data, ok: true };
+  }));
+  return ok(created);
+};
+
+// Cosmetic, and polled per tab in parallel: a slow interval keeps N tabs from hammering the daemon socket.
+const TITLE_MARK_POLL_MS = 250;
+
+const markTitle = async (client: BrowserClient, sessionId: string, signal: AbortSignal | undefined): Promise<Result<void, ToolErr>> => {
+  const loaded = await pollUntil(client, READY_STATE_COMPLETE, { timeoutMs: TITLE_MARK_TIMEOUT_MS, intervalMs: TITLE_MARK_POLL_MS, signal, sessionId, what: "page load" });
+  if (!loaded.success) return loaded;
+  const marked = await evalJs(client, safeJs`if(!document.title.startsWith('🟢'))document.title='🟢 '+document.title`, sessionId);
+  if (!marked.success) return marked;
+  return ok(undefined);
+};
+
+// Borrows a session on a created tab, navigates it, and marks its title after load. A marker failure is a note, not a failure.
+// The borrowed session is released in every path so an untracked attach never leaks past this call.
+const navigateTab = async (client: BrowserClient, tab: TabResult, signal: AbortSignal | undefined): Promise<TabResult> => {
+  const borrowed = fromClient(await borrowSession(client, tab.targetId), "Target.attachToTarget");
+  if (!borrowed.success) return { ...tab, ok: false, error: borrowed.error.message };
+  const sid = borrowed.data.sessionId;
+  try {
+    const enabled = await cdpCallOnTarget(client, "Page.enable", {}, sid);
+    if (!enabled.success) return { ...tab, ok: false, error: enabled.error.message };
+    const nav = await cdpCallOnTarget(client, "Page.navigate", { url: tab.url }, sid);
+    if (!nav.success) return { ...tab, ok: false, error: nav.error.message };
+    const marked = await markTitle(client, sid, signal);
+    return marked.success ? tab : { ...tab, note: "still loading" };
+  } finally {
+    await borrowed.data.release();
+  }
+};
+
+const renderOutcomes = (all: ReadonlyArray<TabResult>, total: number): string => {
+  const okTabs = all.filter((r) => r.ok);
+  const failTabs = all.filter((r) => !r.ok);
+  const lines: string[] = [];
+  if (okTabs.length) {
+    lines.push(
+      `✅ ${okTabs.length}/${total} tabs opened:`,
+      ...okTabs.map((t, i) => `  [${i}] ${t.url} → ${t.targetId}${t.note !== undefined ? ` (${t.note})` : ""}`),
+    );
+  }
+  if (failTabs.length) {
+    lines.push(`❌ ${failTabs.length}/${total} failed:`, ...failTabs.map((t) => `  ${t.url}: ${t.error ?? "unknown"}`));
+  }
+  return lines.join("\n");
 };
 
 export const openUrlsTool = defineBrowserTool({
@@ -82,77 +154,41 @@ export const openUrlsTool = defineBrowserTool({
   parameters: OpenUrlsArgs,
   concurrency: "serialized",
   renderCall: (a) => new Text(`🌐 Opening ${a.urls.length} URL${a.urls.length !== 1 ? "s" : ""}…`, 0, 0),
-  async handler(args, { client, onUpdate }): Promise<Result<ToolOk, ToolErr>> {
+  async handler(args, { client, onUpdate, signal }): Promise<Result<ToolOk, ToolErr>> {
     const total = args.urls.length;
-    // All tabs must land in ONE window: a parallel newWindow:true per url would scatter them across N windows, so the first url creates the window and the rest open as its children.
-    const url0 = args.urls[0];
-    if (url0 === undefined) return err({ kind: "invalid_state", message: "no URLs provided" });
-    const window = await ensureHarnessWindow(client);
-    if (!window.success) return err({ kind: "cdp_error", message: window.error.message });
-    const seededWindow = window.data.targetId;
-    const seedResult: TabResult | undefined = window.data.freshlyCreated
-      ? { url: url0, targetId: seededWindow, ok: true }
-      : undefined;
-    const created = await Promise.all(args.urls.map(async (url, i): Promise<TabResult> => {
-      if (i === 0 && seedResult) return seedResult;
-      const r = await openHarnessTab(client, seededWindow);
-      if (!r.success) return { url, targetId: "", ok: false, error: r.error.message };
-      return { url, targetId: r.data, ok: true };
-    }));
+    const created = await createTabs(client, args.urls);
+    if (!created.success) return created;
+    const toNavigate = created.data.filter((t) => t.ok);
     let completed = 0;
     const settled = await Promise.all(
-      created.filter((t) => t.ok).map(async (tab): Promise<TabResult> => {
+      toNavigate.map(async (tab): Promise<TabResult> => {
         try {
-          const attached = await client.session().attach(tab.targetId);
-          if (!attached.success) return { ...tab, ok: false, error: attached.error.message };
-          const sid = attached.data;
-          const enabled = await cdpCallOnTarget(client, "Page.enable", {}, sid);
-          if (!enabled.success) return { ...tab, ok: false, error: enabled.error.message };
-          const nav = await cdpCallOnTarget(client, "Page.navigate", { url: tab.url }, sid);
-          if (!nav.success) return { ...tab, ok: false, error: nav.error.message };
-          evalJs(
-            client,
-            safeJs`if(!document.title.startsWith('🟢'))document.title='🟢 '+document.title`,
-            sid
-          ).catch(() => {});
-          return tab;
+          return await navigateTab(client, tab, signal);
         } finally {
           completed++;
           // onUpdate must never escape: a renderer crash would otherwise tear down the tool call.
           try {
-            onUpdate({ text: `Opening URLs… ${completed}/${created.filter((t) => t.ok).length} navigated` });
-          } catch {}
+            onUpdate({ text: `Opening URLs… ${completed}/${toNavigate.length} navigated` });
+          } catch {
+            // Progress is best-effort; the navigation outcome is what the tool reports.
+          }
         }
       }),
     );
-    const failures = created.filter((t) => !t.ok);
-    const all: ReadonlyArray<TabResult> = [...settled, ...failures];
+    const all: ReadonlyArray<TabResult> = [...settled, ...created.data.filter((t) => !t.ok)];
     const okTabs = all.filter((r) => r.ok);
-    const failTabs = all.filter((r) => !r.ok);
-    if (okTabs.length > 0) {
-      const last = okTabs[okTabs.length - 1];
-      if (last) {
-        await cdpCallBrowser(client, "Target.activateTarget", { targetId: last.targetId });
-      }
-    }
-    const lines: string[] = [];
-    if (okTabs.length) {
-      lines.push(`✅ ${okTabs.length}/${total} tabs opened:`, ...okTabs.map((t, i) => `  [${i}] ${t.url} → ${t.targetId}`));
+    const last = okTabs[okTabs.length - 1];
+    if (last !== undefined) {
+      await cdpCallBrowser(client, "Target.activateTarget", { targetId: last.targetId });
     }
-    if (failTabs.length) {
-      lines.push(`❌ ${failTabs.length}/${total} failed:`, ...failTabs.map((t) => `  ${t.url}: ${t.error ?? "unknown"}`));
-    }
-    const truncated = await applyTruncation(lines.join("\n"), "urls");
+    const truncated = await applyTruncation(renderOutcomes(all, total), "urls");
+    const details = {
+      tabs: all,
+      ...(truncated.fullOutputPath !== undefined ? { fullOutputPath: truncated.fullOutputPath } : {}),
+    };
     if (okTabs.length === 0) {
-      return err({
-        kind: "cdp_error",
-        message: `All ${total} URLs failed`,
-        ...(truncated.fullOutputPath ? { details: { tabs: all, fullOutputPath: truncated.fullOutputPath } } : { details: { tabs: all } }),
-      });
+      return err({ kind: "cdp_error", message: `All ${total} URLs failed`, details });
     }
-    return ok({
-      text: truncated.text,
-      ...(truncated.fullOutputPath ? { details: { tabs: all, fullOutputPath: truncated.fullOutputPath } } : { details: { tabs: all } }),
-    });
+    return ok({ text: truncated.text, details });
   },
 });