pi-browser-harness 0.12.0 → 0.13.0

package/src/domains/search/web-search.ts

@@ -3,7 +3,7 @@ import { Compile } from "typebox/compile";
 import { parseJson } from "../../schemas/parse";
 import { type Result, err, ok } from "../../util/result";
 import { applyTruncation } from "../../util/truncate";
-import { defineBrowserTool, type ToolErr, type ToolOk } from "../../util/tool";
+import { type DetailsOf, defineBrowserTool, type ToolErr, type ToolOk } from "../../util/tool";
 import {
   closeIsolatedTab,
   evalInIsolatedTab,
@@ -12,7 +12,10 @@ import {
   openIsolatedTab,
   waitForIsolatedLoad,
 } from "../isolated-tab";
-import { renderExpandableText } from "../render";
+import { pageCallExpression } from "../page/inject";
+import { extractSerp } from "../page/serp.page";
+import type * as extracted from "../page/serp.page";
+import { ExpandableTextSchema, renderExpandableText } from "../render";
 import { classifySerp, parseGoogleSerp, type SearchResult, type SerpExtraction } from "./google-serp";
 
 const LOAD_TIMEOUT_MS = 15_000;
@@ -26,32 +29,13 @@ const WebSearchArgs = Type.Object({
 
 const PAGE_TEXT_LIMIT = 4000;
 
-const buildSerpExtractionExpr = (): string => `
-  (() => {
-    const main = document.querySelector('#search, #rso, #main') || document.body;
-    const headings = Array.from(main.querySelectorAll('a h3'));
-    const seen = new Set();
-    const anchors = [];
-    for (const h3 of headings) {
-      const a = h3.closest('a[href]');
-      if (!a) continue;
-      const href = a.href;
-      if (!href || seen.has(href)) continue;
-      seen.add(href);
-      const container =
-        a.closest('div.g') ||
-        a.closest('div[data-hveid]') ||
-        a.parentElement?.parentElement ||
-        a.parentElement;
-      const containerText = container ? container.innerText || '' : '';
-      const heading = h3.innerText || h3.textContent || '';
-      const snippet = containerText.replace(heading, '').replace(/\\s+/g, ' ').trim().slice(0, 500);
-      anchors.push({ href, heading, snippet });
-    }
-    const pageText = (document.body.innerText || '').slice(0, ${PAGE_TEXT_LIMIT});
-    return JSON.stringify({ anchors, pageText });
-  })()
-`;
+// The page function declares the extraction shape it produces; this pins it to the shape the SERP parser consumes,
+// so the two cannot drift apart silently (the runtime validator below still guards the actual wire value).
+type Pinned<T extends SerpExtraction> = T;
+export type ExtractionFromPage = Pinned<extracted.SerpExtraction>;
+
+// Built once: stringifying the page function per call was the only cost of the thunk.
+const SERP_EXTRACTION_EXPR = pageCallExpression(extractSerp, PAGE_TEXT_LIMIT);
 
 const buildSerpUrl = (query: string, limit: number): string =>
   `https://www.google.com/search?q=${encodeURIComponent(query)}&num=${limit}&hl=en`;
@@ -65,6 +49,26 @@ const SerpExtractionSchema = Type.Object({
 
 const serpExtractionValidator = Compile(SerpExtractionSchema);
 
+export const parseSerpExtraction = (raw: string): Result<SerpExtraction, string> =>
+  parseJson(raw, serpExtractionValidator);
+
+const SearchResultSchema = Type.Object({
+  title: Type.String(),
+  url: Type.String(),
+  snippet: Type.String(),
+  rank: Type.Number(),
+});
+
+const WebSearchDetailsSchema = Type.Object({
+  results: Type.Array(SearchResultSchema),
+  engine: Type.Literal("google"),
+  query: Type.String(),
+  render: ExpandableTextSchema,
+  fullOutputPath: Type.Optional(Type.String()),
+});
+
+export type WebSearchDetails = DetailsOf<typeof WebSearchDetailsSchema>;
+
 const formatResults = (query: string, results: ReadonlyArray<SearchResult>): string => {
   const lines = results.map((r) => `${r.rank}. ${r.title}\n   ${r.url}\n   ${r.snippet}`);
   return `${results.length} result(s) for "${query}":\n\n${lines.join("\n\n")}`;
@@ -82,8 +86,9 @@ export const webSearchTool = defineBrowserTool({
     "Runs in its own isolated tab and never disturbs the user's current tab.",
   ],
   parameters: WebSearchArgs,
+  details: WebSearchDetailsSchema,
   concurrency: "serialized",
-  async handler(args, { client, signal }): Promise<Result<ToolOk, ToolErr>> {
+  async handler(args, { client, signal }): Promise<Result<ToolOk<WebSearchDetails>, ToolErr>> {
     const limit = args.limit ?? 10;
     const serpUrl = buildSerpUrl(args.query, limit);
 
@@ -98,10 +103,10 @@ export const webSearchTool = defineBrowserTool({
       const loaded = await waitForIsolatedLoad(client, tab, LOAD_TIMEOUT_MS, signal);
       if (!loaded.success) return err(loaded.error);
 
-      const extracted = await evalInIsolatedTab(client, tab, buildSerpExtractionExpr(), isJsonText);
+      const extracted = await evalInIsolatedTab(client, tab, SERP_EXTRACTION_EXPR, isJsonText);
       if (!extracted.success) return err(extracted.error);
 
-      const parsedJson = parseJson(extracted.data, serpExtractionValidator);
+      const parsedJson = parseSerpExtraction(extracted.data);
       if (!parsedJson.success) {
         return err({ kind: "internal", message: `SERP extraction returned an unexpected shape: ${parsedJson.error}` });
       }
@@ -137,7 +142,7 @@ export const webSearchTool = defineBrowserTool({
       await closeIsolatedTab(client, tab);
     }
   },
-  renderResult(result, expanded, theme) {
-    return renderExpandableText("web_search", result, expanded, theme);
+  renderResult(result, expanded) {
+    return renderExpandableText(result.details.render, expanded);
   },
 });

package/src/domains/snapshot.ts

@@ -1,9 +1,13 @@
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { Type } from "typebox";
-import { Container, Image, type ImageTheme, Markdown, Text, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { Container, Image, type ImageTheme, Markdown, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import { getMarkdownTheme, keyHint } from "@mariozechner/pi-coding-agent";
+import type { BrowserClient } from "../client";
 import { boxOf } from "./box";
-import { cdpCall } from "./cdp-call";
+import { cdpCall, fromClient } from "./cdp-call";
+import { deadlineSignal, runLimited } from "./concurrency";
+import { writeFileResult } from "./io";
+import { type RefSignature, signatureOf } from "./ref-signature";
 import {
   buildTree,
   collectInteractiveTargets,
@@ -14,11 +18,10 @@ import {
   stripInternals,
   VALUE_ROLES,
 } from "./ax-tree";
-import { type Result, err, ok } from "../util/result";
-import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
+import { type Result, ok } from "../util/result";
+import { type DetailsOf, defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
 import { applyTruncation } from "../util/truncate";
 import { screenshotPath } from "../util/paths";
-import { asBoolean, asNumber, asRecord, asString } from "../util/guards";
 
 const SnapshotArgs = Type.Object({
   includeScreenshot: Type.Optional(
@@ -82,13 +85,28 @@ const renderOutline = (nodes: ReadonlyArray<SlimNode>): string => {
   return lines.join("\n");
 };
 
-type SnapshotDetails = {
-  nodeCount: number;
-  truncated: boolean;
-  fullOutputPath?: string;
-  screenshotPath?: string;
-  url: string;
-  title: string;
+const SnapshotDetailsSchema = Type.Object({
+  nodeCount: Type.Number(),
+  truncated: Type.Boolean(),
+  fullOutputPath: Type.Optional(Type.String()),
+  screenshotPath: Type.Optional(Type.String()),
+  url: Type.String(),
+  title: Type.String(),
+  summary: Type.String(),
+});
+
+export type SnapshotDetails = DetailsOf<typeof SnapshotDetailsSchema>;
+
+const BOX_BUDGET_MS = 1_500;
+const BOX_CONCURRENCY = 8;
+
+// Best-effort: a capture or write failure just drops the screenshot from the result.
+const captureJpeg = async (client: BrowserClient): Promise<string | undefined> => {
+  const shot = await cdpCall(client, "Page.captureScreenshot", { format: "jpeg", quality: 80 });
+  if (!shot.success) return undefined;
+  const path = screenshotPath(client.namespace, "jpeg");
+  const written = await writeFileResult(path, Buffer.from(shot.data.data, "base64"));
+  return written.success ? path : undefined;
 };
 
 export const snapshotTool = defineBrowserTool({
@@ -103,19 +121,20 @@ export const snapshotTool = defineBrowserTool({
     "format:'json' returns the raw slim structure (with `ref` and `box` per node) for programmatic use; default 'outline' is human/LLM-readable.",
   ],
   parameters: SnapshotArgs,
+  details: SnapshotDetailsSchema,
   concurrency: "parallel",
 
-  async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
+  async handler(args, { client, signal }): Promise<Result<ToolOk<SnapshotDetails>, ToolErr>> {
     const session = client.session();
 
     const axRes = await cdpCall(client, "Accessibility.getFullAXTree", {});
     if (!axRes.success) return axRes;
     const rawNodes = axRes.data.nodes;
 
-    const piRes = await client.pageInfo();
-    if (!piRes.success) return err({ kind: "cdp_error", message: piRes.error.message });
-    const pageUrl = "dialog" in piRes.data ? "" : piRes.data.url;
-    const pageTitle = "dialog" in piRes.data ? "" : piRes.data.title;
+    const piRes = fromClient(await client.pageInfo(), "pageInfo");
+    if (!piRes.success) return piRes;
+    const pageUrl = piRes.data.kind === "dialog" ? "" : piRes.data.url;
+    const pageTitle = piRes.data.kind === "dialog" ? "" : piRes.data.title;
 
     const slim = buildTree(rawNodes, {
       interestingOnly: args.interestingOnly ?? true,
@@ -132,101 +151,80 @@ export const snapshotTool = defineBrowserTool({
     });
 
     if (targets.length > 0) {
-      const ac = new AbortController();
-      const timer = setTimeout(() => ac.abort(), 1_500);
-      await Promise.allSettled(
-        targets.map(async ({ node, backendId }) => {
-          if (ac.signal.aborted) return;
-          const box = await boxOf(client, backendId);
-          if (!box.success) return;
-          if (box.data.x < 0 || box.data.y < 0) return;
-          node.box = box.data;
-          if (ac.signal.aborted || !VALUE_ROLES.has(node.role)) return;
-          const live = await liveValue(client, backendId);
-          if (live !== undefined) node.value = live;
-        }),
-      );
-      clearTimeout(timer);
+      // Geometry and live values are best-effort decoration: whatever lands inside the budget is kept, the rest is omitted.
+      const deadline = deadlineSignal(BOX_BUDGET_MS, signal);
+      await runLimited(targets, { limit: BOX_CONCURRENCY, signal: deadline.signal }, async ({ node, backendId }, sig) => {
+        const box = await boxOf(client, backendId);
+        if (!box.success || sig.aborted) return;
+        if (box.data.x < 0 || box.data.y < 0) return;
+        node.box = box.data;
+        if (!VALUE_ROLES.has(node.role)) return;
+        const live = await liveValue(client, backendId);
+        if (live !== undefined) node.value = live;
+      });
+      deadline.clear();
     }
 
-    const refSig = new Map<string, string>();
+    const refSig = new Map<string, RefSignature>();
     for (const { node } of targets) {
       if (node.ref === undefined) continue;
-      refSig.set(node.ref, `${node.role}|${node.name ?? ""}|${node.value ?? ""}|${node.state ?? ""}`);
+      refSig.set(node.ref, signatureOf(node));
     }
     session.setRefMap(refMap, refSig);
 
-    const stripped = stripInternals(slim);
-    const text = (args.format ?? "outline") === "outline" ? renderOutline(slim) : JSON.stringify(stripped, null, 2);
+    const text = (args.format ?? "outline") === "outline" ? renderOutline(slim) : JSON.stringify(stripInternals(slim), null, 2);
     const trunc = await applyTruncation(text, "snapshot");
 
-    let shotPath: string | undefined;
-    if (args.includeScreenshot) {
-      const shot = await cdpCall(client, "Page.captureScreenshot", { format: "jpeg", quality: 80 });
-      if (shot.success) {
-        shotPath = screenshotPath(client.namespace, "jpeg");
-        writeFileSync(shotPath, Buffer.from(shot.data.data, "base64"));
-      }
-    }
+    const shotPath = args.includeScreenshot ? await captureJpeg(client) : undefined;
 
     const details: SnapshotDetails = {
       nodeCount: countNodes(slim),
       truncated: trunc.wasTruncated,
       url: pageUrl,
       title: pageTitle,
+      summary: summarize(slim),
+      ...(trunc.fullOutputPath !== undefined ? { fullOutputPath: trunc.fullOutputPath } : {}),
+      ...(shotPath !== undefined ? { screenshotPath: shotPath } : {}),
     };
-    if (trunc.fullOutputPath !== undefined) details.fullOutputPath = trunc.fullOutputPath;
-    if (shotPath !== undefined) details.screenshotPath = shotPath;
 
-    return ok({ text: trunc.text, details: { ...details, summary: summarize(slim) } });
+    return ok({ text: trunc.text, details });
   },
 
   renderResult(result, expanded, theme) {
-    const raw = asRecord(result.details);
-    if (raw === undefined) return new Text(theme.fg("error", "snapshot: no details"), 0, 0);
-    const details = {
-      nodeCount: asNumber(raw["nodeCount"]),
-      truncated: asBoolean(raw["truncated"]),
-      fullOutputPath: asString(raw["fullOutputPath"]),
-      screenshotPath: asString(raw["screenshotPath"]),
-      url: asString(raw["url"]),
-      title: asString(raw["title"]),
-      summary: asString(raw["summary"]),
-    };
-
-    const titleLine = details.title ? ` "${details.title}"` : "";
-    const summary = details.summary ?? "";
-    const screenshotNote = details.screenshotPath ? "screenshot attached" : "screenshot omitted";
-    const truncNote = details.truncated && details.fullOutputPath ? `\n\nFull tree at \`${details.fullOutputPath}\`` : "";
+    const details = result.details;
+    const titleLine = details.title !== "" ? ` "${details.title}"` : "";
+    const urlLabel = details.url !== "" ? details.url : "(no url)";
+    const screenshotNote = details.screenshotPath !== undefined ? "screenshot attached" : "screenshot omitted";
+    const truncNote = details.truncated && details.fullOutputPath !== undefined ? `\n\nFull tree at \`${details.fullOutputPath}\`` : "";
 
     if (!expanded) {
       const md = [
-        `**AX tree:** ${details.nodeCount} nodes · \`${details.url || "(no url)"}\``,
-        `${titleLine ? "  " + titleLine : ""}`,
-        summary ? `  • ${summary}` : "",
+        `**AX tree:** ${details.nodeCount} nodes · \`${urlLabel}\``,
+        titleLine !== "" ? `  ${titleLine}` : "",
+        details.summary !== "" ? `  • ${details.summary}` : "",
         `  ${keyHint("app.tools.expand", "to expand")} · ${screenshotNote}`,
       ].filter((l) => l !== "").join("\n");
       return new Markdown(md, 0, 0, getMarkdownTheme());
     }
 
     const content = result.content[0];
-    const treeText = content && content.type === "text" ? content.text : "";
+    const treeText = content?.type === "text" ? content.text : "";
 
     const headerMd = [
-      `**AX tree:** ${details.nodeCount} nodes · \`${details.url || "(no url)"}\``,
-      titleLine ? `  ${titleLine}` : "",
+      `**AX tree:** ${details.nodeCount} nodes · \`${urlLabel}\``,
+      titleLine !== "" ? `  ${titleLine}` : "",
       "",
       "```",
       treeText,
       "```",
       truncNote,
       "",
-      `${keyHint("app.tools.expand", "to collapse")}`,
+      keyHint("app.tools.expand", "to collapse"),
     ].filter((l) => l !== "").join("\n");
 
     const treeBlock = new Markdown(headerMd, 0, 0, getMarkdownTheme());
 
-    if (!details.screenshotPath) return treeBlock;
+    if (details.screenshotPath === undefined) return treeBlock;
 
     try {
       const buf = readFileSync(details.screenshotPath);
@@ -238,7 +236,7 @@ export const snapshotTool = defineBrowserTool({
         filename: details.screenshotPath,
       });
       const safeImage = {
-        invalidate: () => image.invalidate(),
+        invalidate: () => { image.invalidate(); },
         render: (width: number) =>
           image.render(width).map((line) => (visibleWidth(line) > width ? truncateToWidth(line, width) : line)),
       };

package/src/domains/tab-resolve.ts

@@ -0,0 +1,36 @@
+import type { BrowserClient } from "../client";
+import { type Result, err, ok } from "../util/result";
+import type { ToolErr } from "../util/tool";
+
+const HEX_PREFIX = /^[0-9A-Fa-f]{8,}$/;
+
+export const ownershipDeniedMessage = (id: string, namespace: string): string =>
+  `Tab ${id} is not owned by this harness session (namespace: ${namespace}). ` +
+  `Use browser_list_tabs with scope:'all' to see it, or browser_new_tab to open one this session can control.`;
+
+// Resolves a user-supplied target id against the tabs this session owns, and only those:
+//   - an exact owned id resolves to itself;
+//   - a hex prefix of 8+ characters resolves when it matches exactly one owned tab;
+//   - a prefix matching several owned tabs is invalid_args;
+//   - anything else (unowned id, prefix matching nothing owned) is invalid_state with the ownership message.
+// Ownership is read from the registry, so no CDP round trip is made.
+export const resolveOwnedTargetId = (client: BrowserClient, input: string): Result<string, ToolErr> => {
+  if (client.owns(input)) return ok(input);
+  if (HEX_PREFIX.test(input)) {
+    const matches = client.ownership().list().filter((id) => id.startsWith(input));
+    const first = matches[0];
+    if (matches.length === 1 && first !== undefined) return ok(first);
+    if (matches.length > 1) {
+      return err({
+        kind: "invalid_args",
+        message: `Ambiguous prefix "${input}" matches ${matches.length} owned tabs: ${matches.join(", ")}`,
+        details: { matches },
+      });
+    }
+  }
+  return err({
+    kind: "invalid_state",
+    message: ownershipDeniedMessage(input, client.namespace),
+    details: { targetId: input, namespace: client.namespace },
+  });
+};

package/src/domains/tabs.ts

@@ -1,7 +1,8 @@
 import { Type } from "typebox";
 import { type Result, err, ok } from "../util/result";
 import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
-import { cdpCallBrowser } from "./cdp-call";
+import { cdpCallBrowser, fromClient } from "./cdp-call";
+import { resolveOwnedTargetId } from "./tab-resolve";
 
 const ListTabsArgs = Type.Object({
   includeInternal: Type.Optional(Type.Boolean({ default: true, description: "Include chrome:// pages" })),
@@ -24,8 +25,8 @@ export const listTabsTool = defineBrowserTool({
   parameters: ListTabsArgs,
   concurrency: "parallel",
   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 r = fromClient(await client.listTabs(args.includeInternal ?? true), "Target.getTargets");
+    if (!r.success) return r;
     const scope = args.scope ?? "owned";
     const filtered = scope === "owned" ? r.data.filter((t) => t.owned) : r.data;
     const lines = filtered.map((t, i) => {
@@ -68,10 +69,6 @@ const SwitchTabArgs = Type.Object({
   targetId: Type.String({ description: "Target ID from browser_list_tabs" }),
 });
 
-const ownershipDeniedMessage = (id: string, namespace: string): string =>
-  `Tab ${id} is not owned by this harness session (namespace: ${namespace}). ` +
-  `Use browser_list_tabs with scope:'all' to see it, or browser_new_tab to open one this session can control.`;
-
 export const switchTabTool = defineBrowserTool({
   name: "browser_switch_tab",
   label: "Browser Switch Tab",
@@ -79,44 +76,16 @@ export const switchTabTool = defineBrowserTool({
   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.",
+    "Accepts exact targetId or a unique prefix (>=8 hex characters) of an owned tab.",
   ],
   parameters: SwitchTabArgs,
   concurrency: "serialized",
   async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
-    let resolved = args.targetId;
-    if (!client.owns(resolved)) {
-      const isHexPrefix = /^[0-9A-Fa-f]{8,}$/.test(args.targetId);
-      if (isHexPrefix) {
-        const tabs = await client.listTabs(true);
-        if (!tabs.success) return err({ kind: "cdp_error", message: tabs.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 first = matches[0];
-        if (first === undefined) return err({ kind: "invalid_state", message: "no matching tab" });
-        resolved = first.targetId;
-      }
-      if (!client.owns(resolved)) {
-        return err({
-          kind: "invalid_state",
-          message: ownershipDeniedMessage(resolved, client.namespace),
-          details: { targetId: resolved, namespace: client.namespace },
-        });
-      }
-    }
-
-    const r = await client.switchTab(resolved);
-    if (!r.success) return err({ kind: "cdp_error", message: r.error.message });
+    const target = resolveOwnedTargetId(client, args.targetId);
+    if (!target.success) return target;
+    const resolved = target.data;
+    const r = fromClient(await client.switchTab(resolved), "Target.attachToTarget");
+    if (!r.success) return r;
     const note = resolved === args.targetId ? "" : ` (resolved from prefix "${args.targetId}")`;
     return ok({
       text: `Switched to ${resolved}${note}`,
@@ -138,8 +107,8 @@ export const newTabTool = defineBrowserTool({
   parameters: NewTabArgs,
   concurrency: "serialized",
   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 });
+    const r = fromClient(await client.newTab(args.url), "Target.createTarget");
+    if (!r.success) return r;
     return ok({
       text: `New tab: ${r.data}${args.url ? ` (${args.url})` : ""}`,
       details: args.url !== undefined
@@ -159,36 +128,16 @@ export const closeTabTool = defineBrowserTool({
   description: "Close a tab the harness owns. Refuses tabs not opened by this session.",
   promptSnippet: "Close an owned tab",
   promptGuidelines: [
-    "Accepts exact targetId or a unique hex prefix (>=8 chars).",
+    "Same targetId rules as browser_switch_tab: exact id or a unique prefix (>=8 hex) of an owned tab.",
   ],
   parameters: CloseTabArgs,
   concurrency: "serialized",
   async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
-    let resolved = args.targetId;
-    if (!client.owns(resolved)) {
-      const isHexPrefix = /^[0-9A-Fa-f]{8,}$/.test(args.targetId);
-      if (isHexPrefix) {
-        const owned = client.ownership().list();
-        const matches = owned.filter((id) => id.startsWith(args.targetId));
-        const first = matches[0];
-        if (matches.length === 1 && first !== undefined) resolved = first;
-        else if (matches.length > 1) {
-          return err({
-            kind: "invalid_state",
-            message: `Ambiguous prefix "${args.targetId}" matches ${matches.length} owned tabs: ${matches.join(", ")}`,
-          });
-        }
-      }
-      if (!client.owns(resolved)) {
-        return err({
-          kind: "invalid_state",
-          message: ownershipDeniedMessage(resolved, client.namespace),
-          details: { targetId: resolved, namespace: client.namespace },
-        });
-      }
-    }
-    const r = await client.closeTab(resolved);
-    if (!r.success) return err({ kind: "cdp_error", message: r.error.message });
+    const target = resolveOwnedTargetId(client, args.targetId);
+    if (!target.success) return target;
+    const resolved = target.data;
+    const r = fromClient(await client.closeTab(resolved), "Target.closeTarget");
+    if (!r.success) return r;
     return ok({ text: `Closed tab ${resolved}`, details: { targetId: resolved } });
   },
 });

package/src/domains/target.ts

@@ -31,5 +31,5 @@ export const resolveTarget = async (
   if (args.x !== undefined && args.y !== undefined) {
     return ok({ x: args.x, y: args.y, label: `(${args.x}, ${args.y})` });
   }
-  return err({ kind: "invalid_state", message: "Provide either `ref` or both `x` and `y`." });
+  return err({ kind: "invalid_args", message: "Provide either `ref` or both `x` and `y`." });
 };