pi-chrome 0.15.19 → 0.15.22

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable user-facing changes to `pi-chrome`.
 
+## 0.15.22 — 2026-05-16
+
+- **Earlier page-load capture.** Companion extension now injects console/network instrumentation at `document_start`, so initial React render errors and early API calls show up in `chrome_list_console_messages` / `chrome_list_network_requests`.
+- **Quieter locked state.** Startup no longer shows a persistent Chrome bridge notification/status item before authorization; status bar appears only when Chrome control is authorized.
+- **Lazy tool registration.** `chrome_*` tools and primer are registered only after `/chrome authorize`, reducing prompt/tool overhead while Chrome control is locked.
+
+## 0.15.21 — 2026-05-16
+
+### Reverted 0.16.x and 0.17.x lines
+
+- Versions 0.16.0 through 0.17.2 were published to npm and subsequently unpublished. 0.17.3 was prepared locally but never published. The work introduced in those versions — mandatory pairing, signed-envelope auth, standalone bridge daemon, idempotent onboard, etc. — is reachable only via git tags (`v0.16.0` … `v0.17.3`) and is not in the current main branch.
+- This release is **tree-equivalent to 0.15.20** with a version-only bump so future patch releases can ship cleanly.
+
+## 0.15.20 — 2026-05-15
+
+- **Interruptible `chrome_*` tools.** All `chrome_*` tools now honor the agent harness `AbortSignal`, so pressing Esc aborts in-flight bridge calls (including the long-polling `chrome_wait_for`) immediately instead of waiting out the full `timeoutMs`.
+
 ## 0.15.19 — 2026-05-14
 
 - **Simpler package description.** README hero and npm/pi.dev description now use the same concise authorization-focused sentence.

package/extensions/chrome-profile-bridge/browser-extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Pi Chrome Connector",
-  "version": "0.15.19",
+  "version": "0.15.22",
   "description": "Lets Pi control tabs in Chrome via a local connector at 127.0.0.1.",
   "permissions": [
     "tabs",

package/extensions/chrome-profile-bridge/browser-extension/service_worker.js

@@ -966,6 +966,24 @@ if (chrome.webNavigation && chrome.webNavigation.onCommitted) {
   });
 }
 
+// Always inject early console/network capture at document_start on every navigation.
+// Catches console messages, errors, and network requests that fire during page load,
+// before chrome_snapshot or chrome_evaluate install the instrumentation normally.
+// The function installEarlyCapture sets __piChromeWrapped flags so the post-hoc
+// installPiChromeInstrumentation() call is idempotent.
+if (chrome.webNavigation && chrome.webNavigation.onCommitted) {
+  chrome.webNavigation.onCommitted.addListener((details) => {
+    if (details.frameId !== 0) return;
+    chrome.scripting.executeScript({
+      target: { tabId: details.tabId, frameIds: [0] },
+      world: "MAIN",
+      injectImmediately: true,
+      func: installEarlyCapture,
+      args: [],
+    }).catch(() => undefined);
+  });
+}
+
 async function bringToFront(tab) {
   await chrome.windows.update(tab.windowId, { focused: true });
   await chrome.tabs.update(tab.id, { active: true });
@@ -1310,6 +1328,141 @@ function installPiChromeInstrumentation() {
   }
 }
 
+// Early-capture version of installPiChromeInstrumentation, designed to be injected
+// at document_start via webNavigation.onCommitted. Wraps console, fetch, and XHR
+// before the page's own JavaScript runs, so page-load errors are captured.
+// Sets __piChromeWrapped flags so the post-hoc installPiChromeInstrumentation()
+// sees them and skips (idempotent).
+// NOTE: This function is self-contained — it does NOT close over any outer scope
+// because it gets serialized by chrome.scripting.executeScript({func: ...}).
+function installEarlyCapture() {
+  if (window.__piChromeEarlyCaptureInstalled) return;
+  window.__piChromeEarlyCaptureInstalled = true;
+  var state = window.__PI_CHROME_STATE__;
+  if (!state) {
+    state = {
+      nextElementUid: 1,
+      elements: {},
+      console: [],
+      network: [],
+      nextRequestId: 1,
+      instrumentationInstalled: false,
+    };
+    window.__PI_CHROME_STATE__ = state;
+  }
+  function pushConsole(level, args) {
+    state.console.push({
+      id: state.console.length + 1,
+      level: level,
+      timestamp: Date.now(),
+      url: location.href,
+      args: Array.from(args).map(function(arg) {
+        try {
+          if (typeof arg === "string") return arg;
+          if (arg instanceof Error) return { name: arg.name, message: arg.message, stack: arg.stack };
+          return JSON.parse(JSON.stringify(arg));
+        } catch (e) {
+          return String(arg);
+        }
+      }),
+    });
+    if (state.console.length > 500) state.console.splice(0, state.console.length - 500);
+  }
+  for (var i = 0; i < 5; i++) {
+    var levels = ["debug", "log", "info", "warn", "error"];
+    var level = levels[i];
+    var original = console[level];
+    if (typeof original !== "function" || original.__piChromeWrapped) continue;
+    var wrapped = function(lvl, orig) {
+      return function() {
+        pushConsole(lvl, arguments);
+        return orig.apply(this, arguments);
+      };
+    }(level, original);
+    wrapped.__piChromeWrapped = true;
+    console[level] = wrapped;
+  }
+  window.addEventListener("error", function(event) {
+    pushConsole("pageerror", [event.message, event.filename + ":" + event.lineno + ":" + event.colno]);
+  });
+  window.addEventListener("unhandledrejection", function(event) {
+    pushConsole("unhandledrejection", [event.reason]);
+  });
+  var trimBody = function(text) {
+    return typeof text === "string" && text.length > 200000 ? text.slice(0, 200000) + "\n[truncated " + (text.length - 200000) + " chars]" : text;
+  };
+  var record = function(entry) {
+    state.network.push(entry);
+    if (state.network.length > 1000) state.network.splice(0, state.network.length - 1000);
+    return entry;
+  };
+  if (window.fetch && !window.fetch.__piChromeWrapped) {
+    var originalFetch = window.fetch.bind(window);
+    var wrappedFetch = async function() {
+      var args = [];
+      for (var k = 0; k < arguments.length; k++) args.push(arguments[k]);
+      var id = "req-" + state.nextRequestId++;
+      var startedAt = Date.now();
+      var input = args[0];
+      var init = args[1] || {};
+      var url = typeof input === "string" ? input : (input ? input.url : "");
+      var method = (init.method || (input ? input.method : null) || "GET").toUpperCase();
+      var entry = record({ id: id, type: "fetch", method: method, url: String(url || ""), startedAt: startedAt, pageUrl: location.href, status: "pending" });
+      try {
+        var response = await originalFetch.apply(window, args);
+        entry.status = response.status;
+        entry.statusText = response.statusText;
+        entry.ok = response.ok;
+        entry.responseUrl = response.url;
+        entry.durationMs = Date.now() - startedAt;
+        entry.responseHeaders = Array.from(response.headers.entries());
+        response.clone().text().then(function(text) {
+          entry.responseBody = trimBody(text);
+          entry.responseBodyTruncated = typeof text === "string" && text.length > 200000;
+        }).catch(function(error) { entry.responseBodyError = error ? error.message : String(error); });
+        return response;
+      } catch (error) {
+        entry.error = error ? error.message : String(error);
+        entry.durationMs = Date.now() - startedAt;
+        throw error;
+      }
+    };
+    wrappedFetch.__piChromeWrapped = true;
+    window.fetch = wrappedFetch;
+  }
+  if (window.XMLHttpRequest && !XMLHttpRequest.prototype.open.__piChromeWrapped) {
+    var originalOpen = XMLHttpRequest.prototype.open;
+    var originalSend = XMLHttpRequest.prototype.send;
+    XMLHttpRequest.prototype.open = function(method, url) {
+      this.__piChromeRequest = { method: String(method || "GET").toUpperCase(), url: String(url || "") };
+      return originalOpen.apply(this, arguments);
+    };
+    XMLHttpRequest.prototype.open.__piChromeWrapped = true;
+    XMLHttpRequest.prototype.send = function(body) {
+      var id = "req-" + state.nextRequestId++;
+      var startedAt = Date.now();
+      var info = this.__piChromeRequest || {};
+      var entry = record({ id: id, type: "xhr", method: info.method || "GET", url: info.url || "", startedAt: startedAt, pageUrl: location.href, status: "pending" });
+      this.addEventListener("loadend", function() {
+        entry.status = this.status;
+        entry.statusText = this.statusText;
+        entry.responseUrl = this.responseURL;
+        entry.durationMs = Date.now() - startedAt;
+        try { entry.responseHeadersText = this.getAllResponseHeaders(); } catch (e) {}
+        try {
+          if (typeof this.responseText === "string") {
+            entry.responseBody = trimBody(this.responseText);
+            entry.responseBodyTruncated = this.responseText.length > 200000;
+          }
+        } catch (error) { entry.responseBodyError = error ? error.message : String(error); }
+      });
+      this.addEventListener("error", function() { entry.error = "XMLHttpRequest error"; entry.durationMs = Date.now() - startedAt; });
+      return originalSend.apply(this, arguments);
+    };
+  }
+  state.instrumentationInstalled = true;
+}
+
 function snapshotPage(maxElements, containingText, roleFilter, nearUid) {
   installPiChromeInstrumentation();
   const unique = (selector) => {

package/extensions/chrome-profile-bridge/index.ts

@@ -237,32 +237,58 @@ class ChromeProfileBridge {
 		this.mode = undefined;
 	}
 
-	send(action: string, params: Record<string, unknown>, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<unknown> {
-		if (this.mode === "client") return this.sendViaOwner(action, params, timeoutMs);
-		return this.sendLocal(action, params, timeoutMs);
+	send(action: string, params: Record<string, unknown>, timeoutMs = DEFAULT_TIMEOUT_MS, signal?: AbortSignal): Promise<unknown> {
+		if (this.mode === "client") return this.sendViaOwner(action, params, timeoutMs, signal);
+		return this.sendLocal(action, params, timeoutMs, signal);
 	}
 
-	private sendLocal(action: string, params: Record<string, unknown>, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<unknown> {
+	private sendLocal(action: string, params: Record<string, unknown>, timeoutMs = DEFAULT_TIMEOUT_MS, signal?: AbortSignal): Promise<unknown> {
 		const id = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 		const command = { id, action, params };
 		return new Promise((resolveCommand, rejectCommand) => {
+			if (signal?.aborted) {
+				rejectCommand(new Error("Chrome command aborted"));
+				return;
+			}
+			const cleanupAbort = () => {
+				if (signal) signal.removeEventListener("abort", onAbort);
+			};
+			const onAbort = () => {
+				clearTimeout(timer);
+				this.pending.delete(id);
+				this.queue = this.queue.filter((queued) => queued.id !== id);
+				cleanupAbort();
+				rejectCommand(new Error("Chrome command aborted"));
+			};
 			const timer = setTimeout(() => {
 				this.pending.delete(id);
 				this.queue = this.queue.filter((queued) => queued.id !== id);
+				cleanupAbort();
 				rejectCommand(
 					new Error(
 						`Timed out waiting for Chrome extension after ${timeoutMs}ms. Run /chrome onboard, then load the bundled browser-extension folder in your normal Chrome profile.`,
 					),
 				);
 			}, timeoutMs);
-			this.pending.set(id, { command, resolve: resolveCommand, reject: rejectCommand, timer });
+			this.pending.set(id, {
+				command,
+				resolve: (value) => { cleanupAbort(); resolveCommand(value); },
+				reject: (err) => { cleanupAbort(); rejectCommand(err); },
+				timer,
+			});
+			if (signal) signal.addEventListener("abort", onAbort, { once: true });
 			this.enqueue(command);
 		});
 	}
 
-	private async sendViaOwner(action: string, params: Record<string, unknown>, timeoutMs: number): Promise<unknown> {
+	private async sendViaOwner(action: string, params: Record<string, unknown>, timeoutMs: number, signal?: AbortSignal): Promise<unknown> {
 		const controller = new AbortController();
 		const timer = setTimeout(() => controller.abort(), timeoutMs + 2_000);
+		const forwardAbort = () => controller.abort();
+		if (signal) {
+			if (signal.aborted) controller.abort();
+			else signal.addEventListener("abort", forwardAbort, { once: true });
+		}
 		try {
 			const response = await fetch(`${this.url}/command`, {
 				method: "POST",
@@ -280,11 +306,13 @@ class ChromeProfileBridge {
 			return payload.result;
 		} catch (error) {
 			if ((error as Error).name === "AbortError") {
+				if (signal?.aborted) throw new Error("Chrome command aborted");
 				throw new Error(`Timed out waiting for shared Chrome bridge owner after ${timeoutMs}ms`);
 			}
 			throw error;
 		} finally {
 			clearTimeout(timer);
+			if (signal) signal.removeEventListener("abort", forwardAbort);
 		}
 	}
 
@@ -419,8 +447,9 @@ function StringEnum<T extends readonly [string, ...string[]]>(values: T) {
 }
 
 export default function (pi: ExtensionAPI): void {
+	const instanceToken = Symbol("pi-chrome-instance");
 	const globalState = globalThis as typeof globalThis & {
-		[PI_CHROME_GLOBAL_KEY]?: { version: string; root: string };
+		[PI_CHROME_GLOBAL_KEY]?: { version: string; root: string; token: symbol };
 	};
 	const alreadyLoaded = globalState[PI_CHROME_GLOBAL_KEY];
 	if (alreadyLoaded) {
@@ -429,11 +458,12 @@ export default function (pi: ExtensionAPI): void {
 		);
 		return;
 	}
-	globalState[PI_CHROME_GLOBAL_KEY] = { version: PI_CHROME_VERSION, root: extensionRoot() };
+	globalState[PI_CHROME_GLOBAL_KEY] = { version: PI_CHROME_VERSION, root: extensionRoot(), token: instanceToken };
 
 	const bridge = new ChromeProfileBridge(DEFAULT_HOST, DEFAULT_PORT);
 	let backgroundDefault = false;
 	let chromeAuthorizedUntil: number | "indefinite" | undefined;
+	let chromeToolsRegistered = false;
 
 	const authSummary = (): string => {
 		if (chromeAuthorizedUntil === "indefinite") return "authorized indefinitely";
@@ -457,9 +487,17 @@ export default function (pi: ExtensionAPI): void {
 		}
 	};
 
-	const authorizedBridgeSend = (action: string, params: Record<string, unknown>, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<unknown> => {
+	const updateChromeStatus = (ctx: ExtensionContext): void => {
+		if (chromeControlAuthorized()) {
+			ctx.ui.setStatus("chrome", ctx.ui.theme.fg("success", "●") + " Chrome Bridge");
+		} else {
+			ctx.ui.setStatus("chrome", undefined);
+		}
+	};
+
+	const authorizedBridgeSend = (action: string, params: Record<string, unknown>, timeoutMs = DEFAULT_TIMEOUT_MS, signal?: AbortSignal): Promise<unknown> => {
 		requireChromeControlAuthorized();
-		return bridge.send(action, params, timeoutMs);
+		return bridge.send(action, params, timeoutMs, signal);
 	};
 
 	// Translate the public `background` parameter (default false = visible/foreground) into the
@@ -478,21 +516,20 @@ export default function (pi: ExtensionAPI): void {
 
 	pi.on("session_start", async (_event, ctx) => {
 		await bridge.start();
-		const status = bridge.status();
-		ctx.ui.setStatus("chrome", `Chrome bridge :${DEFAULT_PORT}`);
-		ctx.ui.notify(
-			status.mode === "client"
-				? `pi-chrome connected (sharing the Chrome connection an earlier pi session opened). Run /chrome authorize before using chrome_* tools.`
-				: `pi-chrome is ready and waiting for the Chrome companion to connect. Run /chrome onboard to install it, then /chrome authorize to allow chrome_* tools.`,
-			"info",
-		);
+		updateChromeStatus(ctx);
 	});
 
 	pi.on("session_shutdown", () => {
 		bridge.stop();
+		if (globalState[PI_CHROME_GLOBAL_KEY]?.token === instanceToken) {
+			delete globalState[PI_CHROME_GLOBAL_KEY];
+		}
 	});
 
 	pi.on("before_agent_start", (event) => {
+		if (!chromeToolsRegistered || !chromeControlAuthorized()) {
+			return { systemPrompt: event.systemPrompt };
+		}
 		const primer = `
 <chrome-profile-bridge>
 Chrome control is available through the chrome_* tools via a companion Chrome extension installed in the user's normal Chrome profile. Tools target the existing signed-in profile: no remote-debug port, no throwaway profile.
@@ -616,8 +653,10 @@ Usage rules:
 			ctx.ui.notify("Chrome control remains locked.", "info");
 			return;
 		}
+		registerChromeTools(pi);
 		chromeAuthorizedUntil = until;
 		ctx.ui.notify(`Chrome control authorized for ${label}.`, "info");
+		updateChromeStatus(ctx);
 	};
 
 	const parseAuthorizeArg = (arg: string): { label: string; until: number | "indefinite" } | undefined => {
@@ -640,6 +679,7 @@ Usage rules:
 	const revokeHandler = (ctx: ExtensionContext) => {
 		chromeAuthorizedUntil = undefined;
 		ctx.ui.notify("Chrome control locked. Run /chrome authorize to allow chrome_* tools again.", "info");
+		updateChromeStatus(ctx);
 	};
 
 	const onboardHandler = async (ctx: ExtensionContext) => {
@@ -816,6 +856,10 @@ Usage rules:
 		},
 	});
 
+	function registerChromeTools(pi: ExtensionAPI): void {
+		if (chromeToolsRegistered) return;
+		chromeToolsRegistered = true;
+
 	pi.registerTool({
 		name: "chrome_launch",
 		label: "Chrome Bridge Setup",
@@ -829,9 +873,9 @@ Usage rules:
 			useDefaultProfile: Type.Optional(Type.Boolean({ description: "Ignored; existing-profile access comes from the companion Chrome extension." })),
 			headless: Type.Optional(Type.Boolean({ description: "Ignored." })),
 		}),
-		async execute(_id, params, _signal, _onUpdate, ctx): Promise<ToolTextResult> {
+		async execute(_id, params, signal, _onUpdate, ctx): Promise<ToolTextResult> {
 			if (params.url && bridge.connected) {
-				const result = await authorizedBridgeSend("tab.new", { url: params.url }, DEFAULT_TIMEOUT_MS);
+				const result = await authorizedBridgeSend("tab.new", { url: params.url }, DEFAULT_TIMEOUT_MS, signal);
 				return { content: [{ type: "text", text: `Chrome bridge connected; opened ${params.url}` }], details: { status: bridge.status(), result } };
 			}
 			return {
@@ -865,8 +909,8 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const result = await authorizedBridgeSend(`tab.${params.action}`, params, DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const result = await authorizedBridgeSend(`tab.${params.action}`, params, DEFAULT_TIMEOUT_MS, signal);
 			if (params.action === "list") {
 				const tabs = result as Array<{ id: number; title: string; url: string; active: boolean; windowId: number }>;
 				const text = tabs.map((tab) => `${tab.id}\t${tab.active ? "*" : " "}\t${tab.title || "(untitled)"}\t${tab.url}`).join("\n") || "No tabs.";
@@ -896,11 +940,12 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
+		async execute(_id, params, signal): Promise<ToolTextResult> {
 			const snapshot = await authorizedBridgeSend(
 				"page.snapshot",
 				withBackground({ ...params, maxElements: params.maxElements ?? MAX_ELEMENTS }),
 				DEFAULT_TIMEOUT_MS,
+				signal,
 			);
 			return { content: [{ type: "text", text: truncateText(safeJson(snapshot)) }], details: { snapshot } };
 		},
@@ -926,8 +971,8 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const result = await authorizedBridgeSend("page.navigate", withBackground(params), (params.timeoutMs ?? 15_000) + 2_000);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const result = await authorizedBridgeSend("page.navigate", withBackground(params), (params.timeoutMs ?? 15_000) + 2_000, signal);
 			return { content: [{ type: "text", text: `Navigated to ${params.url}${params.initScript ? " (with initScript)" : ""}` }], details: { result: result as Json } };
 		},
 	});
@@ -950,8 +995,8 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const value = await authorizedBridgeSend("page.evaluate", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const value = await authorizedBridgeSend("page.evaluate", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			const text = value === undefined
 				? "undefined"
 				: typeof value === "string"
@@ -983,8 +1028,8 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const raw = await authorizedBridgeSend("page.click", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const raw = await authorizedBridgeSend("page.click", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			const result = (params.includeSnapshot ? (raw as { result: unknown }).result : raw) as Json;
 			const summary = summarizeActionResult(result);
 			const target = params.uid ?? params.selector ?? `${params.x},${params.y}`;
@@ -1015,8 +1060,8 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const raw = await authorizedBridgeSend("page.type", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const raw = await authorizedBridgeSend("page.type", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			const result = (params.includeSnapshot ? (raw as { result: unknown }).result : raw) as Json;
 			const summary = summarizeActionResult(result);
 			const into = params.uid || params.selector ? ` into ${params.uid ?? params.selector}` : "";
@@ -1047,8 +1092,8 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const raw = await authorizedBridgeSend("page.fill", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const raw = await authorizedBridgeSend("page.fill", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			const result = (params.includeSnapshot ? (raw as { result: unknown }).result : raw) as Json;
 			const summary = summarizeActionResult(result);
 			const into = params.uid || params.selector ? ` into ${params.uid ?? params.selector}` : "";
@@ -1082,8 +1127,8 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const raw = await authorizedBridgeSend("page.key", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const raw = await authorizedBridgeSend("page.key", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			const result = (params.includeSnapshot ? (raw as { result: unknown }).result : raw) as Json;
 			const summary = summarizeActionResult(result);
 			const base = `Pressed ${params.key}.`;
@@ -1107,8 +1152,8 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const result = await authorizedBridgeSend("page.waitFor", params, (params.timeoutMs ?? 10_000) + 2_000);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const result = await authorizedBridgeSend("page.waitFor", params, (params.timeoutMs ?? 10_000) + 2_000, signal);
 			return { content: [{ type: "text", text: `Observed ${params.kind}: ${params.value}` }], details: { result: result as Json } };
 		},
 	});
@@ -1128,8 +1173,8 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const result = await authorizedBridgeSend("page.console.list", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const result = await authorizedBridgeSend("page.console.list", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			return { content: [{ type: "text", text: truncateText(safeJson(result)) }], details: { result: result as Json } };
 		},
 	});
@@ -1150,8 +1195,8 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const result = await authorizedBridgeSend("page.network.list", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const result = await authorizedBridgeSend("page.network.list", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			return { content: [{ type: "text", text: truncateText(safeJson(result)) }], details: { result: result as Json } };
 		},
 	});
@@ -1170,8 +1215,8 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const result = await authorizedBridgeSend("page.network.get", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const result = await authorizedBridgeSend("page.network.get", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			return { content: [{ type: "text", text: truncateText(safeJson(result)) }], details: { result: result as Json } };
 		},
 	});
@@ -1196,12 +1241,12 @@ Usage rules:
 			host: Type.Optional(Type.String()),
 			port: Type.Optional(Type.Number()),
 		}),
-		async execute(_id, params, _signal, _onUpdate, ctx: ExtensionContext): Promise<ToolTextResult> {
+		async execute(_id, params, signal, _onUpdate, ctx: ExtensionContext): Promise<ToolTextResult> {
 			const format = params.format ?? "png";
 			const cwd = workspaceCwd(ctx);
 			const defaultPath = join(cwd, ".pi", "chrome-screenshots", `${new Date().toISOString().replace(/[:.]/g, "-")}.${format}`);
 			const outputPath = params.path ? resolve(cwd, params.path) : defaultPath;
-			const result = (await authorizedBridgeSend("page.screenshot", withBackground(params), params.fullPage ? 120_000 : DEFAULT_TIMEOUT_MS)) as {
+			const result = (await authorizedBridgeSend("page.screenshot", withBackground(params), params.fullPage ? 120_000 : DEFAULT_TIMEOUT_MS, signal)) as {
 				dataUrl?: string;
 				tab?: unknown;
 				fullPage?: boolean;
@@ -1250,8 +1295,8 @@ Usage rules:
 			titleIncludes: Type.Optional(Type.String()),
 			background: Type.Optional(Type.Boolean()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const result = await authorizedBridgeSend("page.hover", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const result = await authorizedBridgeSend("page.hover", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			return { content: [{ type: "text", text: `Hovered ${params.uid ?? params.selector ?? `${params.x},${params.y}`}` }], details: { result: result as Json } };
 		},
 	});
@@ -1276,8 +1321,8 @@ Usage rules:
 			titleIncludes: Type.Optional(Type.String()),
 			background: Type.Optional(Type.Boolean()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const result = await authorizedBridgeSend("page.drag", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const result = await authorizedBridgeSend("page.drag", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			return { content: [{ type: "text", text: `Dragged from ${params.fromUid ?? params.fromSelector} to ${params.toUid ?? params.toSelector}` }], details: { result: result as Json } };
 		},
 	});
@@ -1298,8 +1343,8 @@ Usage rules:
 			titleIncludes: Type.Optional(Type.String()),
 			background: Type.Optional(Type.Boolean()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const result = await authorizedBridgeSend("page.tap", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const result = await authorizedBridgeSend("page.tap", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			const target = params.uid ?? params.selector ?? `${params.x},${params.y}`;
 			return { content: [{ type: "text", text: `Tapped ${target} (touch)` }], details: { result: result as Json } };
 		},
@@ -1321,8 +1366,8 @@ Usage rules:
 			titleIncludes: Type.Optional(Type.String()),
 			background: Type.Optional(Type.Boolean()),
 		}),
-		async execute(_id, params): Promise<ToolTextResult> {
-			const result = await authorizedBridgeSend("page.scroll", withBackground(params), DEFAULT_TIMEOUT_MS);
+		async execute(_id, params, signal): Promise<ToolTextResult> {
+			const result = await authorizedBridgeSend("page.scroll", withBackground(params), DEFAULT_TIMEOUT_MS, signal);
 			return { content: [{ type: "text", text: `Scrolled dy=${params.deltaY ?? 0} dx=${params.deltaX ?? 0}` }], details: { result: result as Json } };
 		},
 	});
@@ -1341,11 +1386,13 @@ Usage rules:
 			titleIncludes: Type.Optional(Type.String()),
 			background: Type.Optional(Type.Boolean()),
 		}),
-		async execute(_id, params, _signal, _onUpdate, ctx): Promise<ToolTextResult> {
+		async execute(_id, params, signal, _onUpdate, ctx): Promise<ToolTextResult> {
 			const cwd = workspaceCwd(ctx);
 			const paths = params.paths.map((p) => resolve(cwd, p));
-			const result = await authorizedBridgeSend("page.upload", withBackground({ ...params, paths }), DEFAULT_TIMEOUT_MS);
+			const result = await authorizedBridgeSend("page.upload", withBackground({ ...params, paths }), DEFAULT_TIMEOUT_MS, signal);
 			return { content: [{ type: "text", text: `Uploaded ${paths.length} file(s) to ${params.uid ?? params.selector}` }], details: { result: result as Json } };
 		},
 	});
+	}
+
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-chrome",
-	"version": "0.15.19",
+	"version": "0.15.22",
 	"scripts": {
 		"version": "node scripts/sync-manifest-version.js",
 		"prepublishOnly": "node scripts/sync-manifest-version.js"