pi-chrome 0.6.0 → 0.7.0

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

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Pi Existing Chrome Profile Bridge",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Lets Pi control tabs in this existing Chrome profile via a local bridge at 127.0.0.1.",
   "permissions": ["tabs", "scripting", "storage", "activeTab", "alarms"],
   "host_permissions": ["<all_urls>", "http://127.0.0.1:17318/*"],

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

@@ -111,11 +111,19 @@ async function dispatch(action, params) {
     case "page.evaluate":
       return executeInTab(params, evaluateExpression, [params.expression, params.awaitPromise !== false]);
     case "page.click":
-      return executeInTab(params, clickPage, [params.selector ?? null, params.x ?? null, params.y ?? null]);
+      return executeActionInTab(params, clickPage, [params.selector ?? null, params.uid ?? null, params.x ?? null, params.y ?? null]);
     case "page.type":
-      return executeInTab(params, typeIntoPage, [params.selector ?? null, params.text || "", Boolean(params.pressEnter)]);
+      return executeActionInTab(params, typeIntoPage, [params.selector ?? null, params.uid ?? null, params.text || "", Boolean(params.pressEnter)]);
+    case "page.fill":
+      return executeActionInTab(params, fillPage, [params.selector ?? null, params.uid ?? null, params.text || "", params.submit === true]);
     case "page.key":
-      return executeInTab(params, pressKeyInPage, [params.key]);
+      return executeActionInTab(params, pressKeyInPage, [params.key]);
+    case "page.console.list":
+      return executeInTab(params, listConsoleMessages, [params.clear === true]);
+    case "page.network.list":
+      return executeInTab(params, listNetworkRequests, [params.includePreservedRequests === true, params.clear === true]);
+    case "page.network.get":
+      return executeInTab(params, getNetworkRequest, [params.requestId]);
     case "page.waitFor":
       return executeInTab(params, waitForPage, [params.kind, params.value, params.timeoutMs || 10000, params.intervalMs || 250]);
     case "page.navigate": {
@@ -193,13 +201,49 @@ async function getTabByParams(params) {
 async function executeInTab(params, func, args) {
   const tab = await getTabByParams(params);
   if (params.foreground) await bringToFront(tab);
+  const helperSource = [
+    getPiChromeState,
+    rememberElement,
+    elementBySelectorOrUid,
+    installPiChromeInstrumentation,
+    resolvePoint,
+    dispatchInputEvents,
+    setNativeValue,
+    normalizeKey,
+  ].map((helper) => helper.toString()).join("\n");
   const results = await chrome.scripting.executeScript({
     target: { tabId: tab.id },
     world: "MAIN",
-    func,
-    args,
+    func: async (helperSource, source, invocationArgs) => {
+      try {
+        (0, eval)(helperSource);
+        const injected = (0, eval)(`(${source})`);
+        return { ok: true, value: await injected(...invocationArgs) };
+      } catch (error) {
+        return { ok: false, error: error?.stack || error?.message || String(error) };
+      }
+    },
+    args: [helperSource, func.toString(), args],
   });
-  return results?.[0]?.result;
+  const first = results?.[0];
+  if (first?.error) {
+    const message = typeof first.error === "string" ? first.error : (first.error.message || JSON.stringify(first.error));
+    throw new Error(message);
+  }
+  const envelope = first?.result;
+  if (envelope && typeof envelope === "object" && envelope.ok === false) {
+    throw new Error(envelope.error || "Chrome page script failed");
+  }
+  return envelope?.value;
+}
+
+async function executeActionInTab(params, func, args) {
+  const result = await executeInTab(params, func, args);
+  if (params.includeSnapshot) {
+    const snapshot = await executeInTab({ ...params, foreground: false }, snapshotPage, [params.maxElements || 80]);
+    return { result, snapshot };
+  }
+  return result;
 }
 
 async function bringToFront(tab) {
@@ -224,7 +268,147 @@ function waitForTabComplete(tabId, timeoutMs) {
   });
 }
 
+function getPiChromeState() {
+  const state = window.__PI_CHROME_STATE__ || {
+    nextElementUid: 1,
+    elements: {},
+    console: [],
+    network: [],
+    nextRequestId: 1,
+    instrumentationInstalled: false,
+  };
+  window.__PI_CHROME_STATE__ = state;
+  return state;
+}
+
+function rememberElement(element) {
+  const state = getPiChromeState();
+  if (!element.__piChromeUid) element.__piChromeUid = "el-" + state.nextElementUid++;
+  state.elements[element.__piChromeUid] = element;
+  return element.__piChromeUid;
+}
+
+function elementBySelectorOrUid(selector, uid) {
+  if (uid) {
+    const element = getPiChromeState().elements[uid];
+    if (!element || !element.isConnected) throw new Error(`No live element for uid: ${uid}. Take a fresh chrome_snapshot.`);
+    return element;
+  }
+  if (selector) {
+    const element = document.querySelector(selector);
+    if (!element) throw new Error(`No element matches selector: ${selector}`);
+    return element;
+  }
+  return null;
+}
+
+function installPiChromeInstrumentation() {
+  const state = getPiChromeState();
+  if (state.instrumentationInstalled) return;
+  state.instrumentationInstalled = true;
+  const pushConsole = (level, args) => {
+    state.console.push({
+      id: state.console.length + 1,
+      level,
+      timestamp: Date.now(),
+      url: location.href,
+      args: Array.from(args).map((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 {
+          return String(arg);
+        }
+      }),
+    });
+    if (state.console.length > 500) state.console.splice(0, state.console.length - 500);
+  };
+  for (const level of ["debug", "log", "info", "warn", "error"]){
+    const original = console[level];
+    if (typeof original !== "function" || original.__piChromeWrapped) continue;
+    const wrapped = function(...args) {
+      pushConsole(level, args);
+      return original.apply(this, args);
+    };
+    wrapped.__piChromeWrapped = true;
+    console[level] = wrapped;
+  }
+  window.addEventListener("error", (event) => pushConsole("pageerror", [event.message, event.filename + ":" + event.lineno + ":" + event.colno]));
+  window.addEventListener("unhandledrejection", (event) => pushConsole("unhandledrejection", [event.reason]));
+
+  const trimBody = (text) => typeof text === "string" && text.length > 200000 ? text.slice(0, 200000) + `\n[truncated ${text.length - 200000} chars]` : text;
+  const record = (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) {
+    const originalFetch = window.fetch.bind(window);
+    const wrappedFetch = async (...args) => {
+      const id = "req-" + state.nextRequestId++;
+      const startedAt = Date.now();
+      const input = args[0];
+      const init = args[1] || {};
+      const url = typeof input === "string" ? input : input?.url;
+      const method = (init.method || input?.method || "GET").toUpperCase();
+      const entry = record({ id, type: "fetch", method, url: String(url || ""), startedAt, pageUrl: location.href, status: "pending" });
+      try {
+        const response = await originalFetch(...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((text) => {
+          entry.responseBody = trimBody(text);
+          entry.responseBodyTruncated = typeof text === "string" && text.length > 200000;
+        }).catch((error) => { entry.responseBodyError = error?.message || String(error); });
+        return response;
+      } catch (error) {
+        entry.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) {
+    const originalOpen = XMLHttpRequest.prototype.open;
+    const originalSend = XMLHttpRequest.prototype.send;
+    XMLHttpRequest.prototype.open = function(method, url, ...rest) {
+      this.__piChromeRequest = { method: String(method || "GET").toUpperCase(), url: String(url || "") };
+      return originalOpen.call(this, method, url, ...rest);
+    };
+    XMLHttpRequest.prototype.open.__piChromeWrapped = true;
+    XMLHttpRequest.prototype.send = function(body) {
+      const id = "req-" + state.nextRequestId++;
+      const startedAt = Date.now();
+      const info = this.__piChromeRequest || {};
+      const entry = record({ id, type: "xhr", method: info.method || "GET", url: info.url || "", startedAt, pageUrl: location.href, status: "pending" });
+      this.addEventListener("loadend", () => {
+        entry.status = this.status;
+        entry.statusText = this.statusText;
+        entry.responseUrl = this.responseURL;
+        entry.durationMs = Date.now() - startedAt;
+        try { entry.responseHeadersText = this.getAllResponseHeaders(); } catch {}
+        try {
+          if (typeof this.responseText === "string") {
+            entry.responseBody = trimBody(this.responseText);
+            entry.responseBodyTruncated = this.responseText.length > 200000;
+          }
+        } catch (error) { entry.responseBodyError = error?.message || String(error); }
+      });
+      this.addEventListener("error", () => { entry.error = "XMLHttpRequest error"; entry.durationMs = Date.now() - startedAt; });
+      return originalSend.call(this, body);
+    };
+  }
+}
+
 function snapshotPage(maxElements) {
+  installPiChromeInstrumentation();
   const unique = (selector) => {
     try { return document.querySelectorAll(selector).length === 1; } catch { return false; }
   };
@@ -269,6 +453,7 @@ function snapshotPage(maxElements) {
     const rect = element.getBoundingClientRect();
     return {
       index,
+      uid: rememberElement(element),
       tag: element.tagName.toLowerCase(),
       selector: selectorFor(element),
       label: labelFor(element),
@@ -289,61 +474,123 @@ function snapshotPage(maxElements) {
 }
 
 async function evaluateExpression(expression, awaitPromise) {
+  installPiChromeInstrumentation();
   const indirectEval = (0, eval);
   const value = indirectEval(expression);
   return awaitPromise && value && typeof value.then === "function" ? await value : value;
 }
 
-function resolvePoint(selector, x, y) {
-  if (selector) {
-    const element = document.querySelector(selector);
-    if (!element) throw new Error(`No element matches selector: ${selector}`);
+function resolvePoint(selector, uid, x, y) {
+  const element = elementBySelectorOrUid(selector, uid);
+  if (element) {
     element.scrollIntoView({ block: "center", inline: "center", behavior: "instant" });
     const rect = element.getBoundingClientRect();
     return { element, x: rect.left + rect.width / 2, y: rect.top + rect.height / 2, rect };
   }
-  if (typeof x !== "number" || typeof y !== "number") throw new Error("Provide selector or x/y");
+  if (typeof x !== "number" || typeof y !== "number") throw new Error("Provide selector, uid, or x/y");
   return { element: document.elementFromPoint(x, y), x, y, rect: undefined };
 }
 
-function clickPage(selector, x, y) {
-  const point = resolvePoint(selector, x, y);
+function clickPage(selector, uid, x, y) {
+  const point = resolvePoint(selector, uid, x, y);
   if (!point.element) throw new Error("No element at click point");
   for (const type of ["pointerdown", "mousedown", "pointerup", "mouseup", "click"]) {
     point.element.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, view: window, clientX: point.x, clientY: point.y, button: 0 }));
   }
-  return { x: point.x, y: point.y, selector, tag: point.element.tagName };
+  return { x: point.x, y: point.y, selector, uid, tag: point.element.tagName };
 }
 
-function typeIntoPage(selector, text, pressEnter) {
-  let element = selector ? document.querySelector(selector) : document.activeElement;
-  if (!element) throw new Error(selector ? `No element matches selector: ${selector}` : "No active element");
+function dispatchInputEvents(element, data, inputType = "insertText") {
+  element.dispatchEvent(new InputEvent("beforeinput", { bubbles: true, cancelable: true, inputType, data }));
+  element.dispatchEvent(new InputEvent("input", { bubbles: true, inputType, data }));
+  element.dispatchEvent(new Event("change", { bubbles: true }));
+}
+
+function setNativeValue(element, value) {
+  const prototype = element instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+  const descriptor = Object.getOwnPropertyDescriptor(prototype, "value");
+  if (descriptor?.set) descriptor.set.call(element, value);
+  else element.value = value;
+}
+
+function typeIntoPage(selector, uid, text, pressEnter) {
+  installPiChromeInstrumentation();
+  let element = elementBySelectorOrUid(selector, uid) || document.activeElement;
+  if (!element) throw new Error(selector || uid ? `No element for ${selector || uid}` : "No active element");
   element.focus();
   if (element.isContentEditable) {
     document.execCommand("insertText", false, text);
   } else if ("value" in element) {
     const start = element.selectionStart ?? element.value.length;
     const end = element.selectionEnd ?? element.value.length;
-    element.value = element.value.slice(0, start) + text + element.value.slice(end);
+    setNativeValue(element, element.value.slice(0, start) + text + element.value.slice(end));
     element.selectionStart = element.selectionEnd = start + text.length;
-    element.dispatchEvent(new InputEvent("input", { bubbles: true, inputType: "insertText", data: text }));
-    element.dispatchEvent(new Event("change", { bubbles: true }));
+    dispatchInputEvents(element, text, "insertText");
   } else {
     throw new Error("Focused element is not text-editable");
   }
   if (pressEnter) pressKeyInPage("Enter");
-  return { selector, length: text.length, pressEnter };
+  return { selector, uid, length: text.length, pressEnter };
+}
+
+function fillPage(selector, uid, text, submit) {
+  installPiChromeInstrumentation();
+  let element = elementBySelectorOrUid(selector, uid) || document.activeElement;
+  if (!element) throw new Error(selector || uid ? `No element for ${selector || uid}` : "No active element");
+  element.focus();
+  if (element.isContentEditable) {
+    element.textContent = "";
+    document.execCommand("insertText", false, text);
+  } else if ("value" in element) {
+    setNativeValue(element, text);
+    const length = String(text).length;
+    try { element.selectionStart = element.selectionEnd = length; } catch {}
+    dispatchInputEvents(element, text, "insertReplacementText");
+  } else {
+    throw new Error("Focused element is not text-editable");
+  }
+  if (submit) pressKeyInPage("Enter");
+  return { selector, uid, length: String(text).length, submit };
 }
 
 function pressKeyInPage(key) {
-  const target = document.activeElement || document.body;
   const normalized = normalizeKey(key);
+  const target = document.activeElement || document.body;
   target.dispatchEvent(new KeyboardEvent("keydown", { key: normalized, bubbles: true, cancelable: true }));
   target.dispatchEvent(new KeyboardEvent("keyup", { key: normalized, bubbles: true, cancelable: true }));
-  if (normalized === "Enter" && target instanceof HTMLFormElement) target.requestSubmit();
+  if (normalized === "Enter") {
+    const form = target.closest?.("form");
+    if (form) form.requestSubmit?.();
+  }
   return { key: normalized };
 }
 
+function listConsoleMessages(clear) {
+  installPiChromeInstrumentation();
+  const state = getPiChromeState();
+  const messages = state.console.slice();
+  if (clear) state.console = [];
+  return { messages, count: messages.length };
+}
+
+function listNetworkRequests(includePreservedRequests, clear) {
+  installPiChromeInstrumentation();
+  const state = getPiChromeState();
+  const currentUrl = location.href;
+  const requests = state.network
+    .filter((request) => includePreservedRequests || request.pageUrl === currentUrl)
+    .map(({ responseBody, ...summary }) => ({ ...summary, hasResponseBody: responseBody !== undefined }));
+  if (clear) state.network = [];
+  return { requests, count: requests.length, note: "Captures fetch/XHR after instrumentation is installed (snapshot/evaluate/network/console tools install it). Browser-initiated document/static asset requests are not captured." };
+}
+
+function getNetworkRequest(requestId) {
+  installPiChromeInstrumentation();
+  const request = getPiChromeState().network.find((entry) => entry.id === requestId);
+  if (!request) throw new Error(`No network request with id ${requestId}`);
+  return request;
+}
+
 async function waitForPage(kind, value, timeoutMs, intervalMs) {
   const started = Date.now();
   while (Date.now() - started < timeoutMs) {

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

@@ -46,7 +46,7 @@ type BridgeResult = {
 	error?: string;
 };
 
-const PI_CHROME_VERSION = "0.6.0";
+const PI_CHROME_VERSION = "0.7.0";
 const DEFAULT_HOST = process.env.PI_CHROME_BRIDGE_HOST ?? "127.0.0.1";
 const DEFAULT_PORT = Number(process.env.PI_CHROME_BRIDGE_PORT ?? "17318");
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -376,7 +376,7 @@ export default function (pi: ExtensionAPI): void {
 <chrome-profile-bridge>
 Chrome control is available through the chrome_* tools via a companion Chrome extension installed in the user's normal Chrome profile.
 This is not CDP: it can use the user's existing Chrome windows and authenticated sessions after the user loads the companion browser extension.
-If chrome_* tools time out, ask the user to run /chrome-onboard, then load the bundled browser-extension folder in chrome://extensions. Prefer chrome_snapshot before clicking/typing. Avoid destructive actions unless explicitly requested. By default chrome_* tools focus Chrome and activate the target tab so the user can watch the agent work. The user can switch to silent/background mode for the whole session via /chrome-background; you can also pass background=true on a single tool call when the user explicitly wants the action to be silent (for example, scraping while they keep working in another app).
+If chrome_* tools time out, ask the user to run /chrome-onboard, then load the bundled browser-extension folder in chrome://extensions. Prefer chrome_snapshot before clicking/typing; use stable element uids from snapshots with chrome_click/chrome_type when available. For form work, use includeSnapshot=true on actions to verify in one round trip. Avoid destructive actions unless explicitly requested. By default chrome_* tools focus Chrome and activate the target tab so the user can watch the agent work. The user can switch to silent/background mode for the whole session via /chrome-background; you can also pass background=true on a single tool call when the user explicitly wants the action to be silent (for example, scraping while they keep working in another app).
 </chrome-profile-bridge>`;
 		return { systemPrompt: event.systemPrompt + primer };
 	});
@@ -390,13 +390,17 @@ If chrome_* tools time out, ask the user to run /chrome-onboard, then load the b
 			const status = bridge.status();
 			lines.push(`• Local bridge: mode=${status.mode}, url=${status.url}`);
 			try {
+				const started = Date.now();
 				const version = (await bridge.send("tab.version", {}, 35_000)) as {
 					extensionId?: string;
 					extensionVersion?: string;
+					bridgeUrl?: string;
 				};
+				const latencyMs = Date.now() - started;
 				if (version.extensionId)
-					lines.push(`✓ Companion Chrome extension responding (ID: ${version.extensionId}, ext v${version.extensionVersion ?? "unknown"})`);
-				else lines.push("✓ Companion Chrome extension responding (no extension ID reported)");
+					lines.push(`✓ Companion Chrome extension responding (ID: ${version.extensionId}, ext v${version.extensionVersion ?? "unknown"}, latency ${latencyMs}ms)`);
+				else lines.push(`✓ Companion Chrome extension responding (no extension ID reported, latency ${latencyMs}ms)`);
+				if (version.bridgeUrl) lines.push(`• Extension polling: ${version.bridgeUrl}`);
 				if (version.extensionVersion && version.extensionVersion !== PI_CHROME_VERSION) {
 					lines.push(
 						`⚠ Extension version (${version.extensionVersion}) differs from pi-chrome (${PI_CHROME_VERSION}). Reload "Pi Existing Chrome Profile Bridge" in chrome://extensions to pick up the latest service worker.`,
@@ -529,7 +533,7 @@ If chrome_* tools time out, ask the user to run /chrome-onboard, then load the b
 		name: "chrome_snapshot",
 		label: "Chrome Snapshot",
 		description:
-			"Inspect a page in the user's existing Chrome profile: title, URL, visible body text, viewport, and clickable/focusable elements with CSS selectors. Brings Chrome to the foreground by default so the user can watch; pass background=true to inspect silently.",
+			"Inspect a page in the user's existing Chrome profile: title, URL, visible body text, viewport, and clickable/focusable elements with stable uids plus CSS selectors. Brings Chrome to the foreground by default so the user can watch; pass background=true to inspect silently.",
 		promptSnippet: "Inspect the current Chrome page and get CSS selectors for browser automation.",
 		parameters: Type.Object({
 			targetId: Type.Optional(Type.String()),
@@ -606,12 +610,15 @@ If chrome_* tools time out, ask the user to run /chrome-onboard, then load the b
 		name: "chrome_click",
 		label: "Chrome Click",
 		description:
-			"Click a CSS selector or viewport coordinate in an existing Chrome tab through the companion extension. The click is dispatched as a synthetic DOM event; by default Chrome is focused so the user can watch, pass background=true to click silently.",
-		promptSnippet: "Click page elements in Chrome by selector or viewport coordinate.",
+			"Click a snapshot uid, CSS selector, or viewport coordinate in an existing Chrome tab through the companion extension. The click is dispatched as a synthetic DOM event; by default Chrome is focused so the user can watch, pass background=true to click silently. Pass includeSnapshot=true to return a fresh snapshot after the click.",
+		promptSnippet: "Click page elements in Chrome by snapshot uid, selector, or viewport coordinate.",
 		parameters: Type.Object({
-			selector: Type.Optional(Type.String({ description: "CSS selector to click. Prefer selectors from chrome_snapshot." })),
-			x: Type.Optional(Type.Number({ description: "Viewport x coordinate if selector is omitted." })),
-			y: Type.Optional(Type.Number({ description: "Viewport y coordinate if selector is omitted." })),
+			uid: Type.Optional(Type.String({ description: "Stable element uid from chrome_snapshot. Prefer uid over selector after taking a snapshot." })),
+			selector: Type.Optional(Type.String({ description: "CSS selector to click. Prefer uid from chrome_snapshot when available." })),
+			x: Type.Optional(Type.Number({ description: "Viewport x coordinate if uid/selector is omitted." })),
+			y: Type.Optional(Type.Number({ description: "Viewport y coordinate if uid/selector is omitted." })),
+			includeSnapshot: Type.Optional(Type.Boolean({ description: "If true, include a fresh chrome_snapshot result after the click." })),
+			maxElements: Type.Optional(Type.Number({ default: MAX_ELEMENTS, description: "Max elements in the included snapshot." })),
 			targetId: Type.Optional(Type.String()),
 			urlIncludes: Type.Optional(Type.String()),
 			titleIncludes: Type.Optional(Type.String()),
@@ -623,7 +630,7 @@ If chrome_* tools time out, ask the user to run /chrome-onboard, then load the b
 		}),
 		async execute(_id, params): Promise<ToolTextResult> {
 			const result = await bridge.send("page.click", withBackground(params), DEFAULT_TIMEOUT_MS);
-			return { content: [{ type: "text", text: `Clicked ${params.selector ?? `${params.x},${params.y}`}` }], details: { result: result as Json } };
+			return { content: [{ type: "text", text: `Clicked ${params.uid ?? params.selector ?? `${params.x},${params.y}`}` }], details: { result: result as Json } };
 		},
 	});
 
@@ -631,11 +638,14 @@ If chrome_* tools time out, ask the user to run /chrome-onboard, then load the b
 		name: "chrome_type",
 		label: "Chrome Type",
 		description:
-			"Focus an optional CSS selector, then type text into an existing Chrome tab through the companion extension. By default focuses Chrome and activates the tab so the user can watch; pass background=true to type silently.",
-		promptSnippet: "Type text into Chrome, optionally focusing a selector first.",
+			"Focus an optional snapshot uid or CSS selector, then type text into an existing Chrome tab through the companion extension. By default focuses Chrome and activates the tab so the user can watch; pass background=true to type silently. Pass includeSnapshot=true to return a fresh snapshot after typing.",
+		promptSnippet: "Type text into Chrome, optionally focusing a snapshot uid or selector first.",
 		parameters: Type.Object({
 			text: Type.String(),
+			uid: Type.Optional(Type.String({ description: "Stable element uid from chrome_snapshot." })),
 			selector: Type.Optional(Type.String({ description: "CSS selector to focus before typing." })),
+			includeSnapshot: Type.Optional(Type.Boolean({ description: "If true, include a fresh chrome_snapshot result after typing." })),
+			maxElements: Type.Optional(Type.Number({ default: MAX_ELEMENTS, description: "Max elements in the included snapshot." })),
 			pressEnter: Type.Optional(Type.Boolean()),
 			targetId: Type.Optional(Type.String()),
 			urlIncludes: Type.Optional(Type.String()),
@@ -648,7 +658,35 @@ If chrome_* tools time out, ask the user to run /chrome-onboard, then load the b
 		}),
 		async execute(_id, params): Promise<ToolTextResult> {
 			const result = await bridge.send("page.type", withBackground(params), DEFAULT_TIMEOUT_MS);
-			return { content: [{ type: "text", text: `Typed ${params.text.length} character(s)${params.selector ? ` into ${params.selector}` : ""}.` }], details: { result: result as Json } };
+			return { content: [{ type: "text", text: `Typed ${params.text.length} character(s)${params.uid || params.selector ? ` into ${params.uid ?? params.selector}` : ""}.` }], details: { result: result as Json } };
+		},
+	});
+
+	pi.registerTool({
+		name: "chrome_fill",
+		label: "Chrome Fill",
+		description:
+			"Set the full value of a text input, textarea, or contenteditable element using framework-aware native value setters and input/change events. Accepts a snapshot uid or CSS selector. Pass includeSnapshot=true to verify after filling.",
+		promptSnippet: "Fill a Chrome form field by snapshot uid or selector, optionally returning a fresh snapshot.",
+		parameters: Type.Object({
+			text: Type.String(),
+			uid: Type.Optional(Type.String({ description: "Stable element uid from chrome_snapshot." })),
+			selector: Type.Optional(Type.String({ description: "CSS selector to fill if uid is omitted." })),
+			submit: Type.Optional(Type.Boolean({ description: "If true, press Enter after filling." })),
+			includeSnapshot: Type.Optional(Type.Boolean({ description: "If true, include a fresh chrome_snapshot result after filling." })),
+			maxElements: Type.Optional(Type.Number({ default: MAX_ELEMENTS, description: "Max elements in the included snapshot." })),
+			targetId: Type.Optional(Type.String()),
+			urlIncludes: Type.Optional(Type.String()),
+			titleIncludes: Type.Optional(Type.String()),
+			background: Type.Optional(
+				Type.Boolean({ description: "If true, fill silently without focusing Chrome. Default false." }),
+			),
+			host: Type.Optional(Type.String()),
+			port: Type.Optional(Type.Number()),
+		}),
+		async execute(_id, params): Promise<ToolTextResult> {
+			const result = await bridge.send("page.fill", withBackground(params), DEFAULT_TIMEOUT_MS);
+			return { content: [{ type: "text", text: `Filled ${params.text.length} character(s)${params.uid || params.selector ? ` into ${params.uid ?? params.selector}` : ""}.` }], details: { result: result as Json } };
 		},
 	});
 
@@ -656,10 +694,12 @@ If chrome_* tools time out, ask the user to run /chrome-onboard, then load the b
 		name: "chrome_key",
 		label: "Chrome Key",
 		description:
-			"Send a keyboard key to an existing Chrome tab (Enter, Escape, Tab, Backspace, Delete, ArrowUp/Down/Left/Right, or one character). By default focuses Chrome and activates the tab so the user can watch; pass background=true to send the key silently.",
+			"Send a keyboard key to an existing Chrome tab (Enter, Escape, Tab, Backspace, Delete, ArrowUp/Down/Left/Right, or one character). By default focuses Chrome and activates the tab so the user can watch; pass background=true to send the key silently. Pass includeSnapshot=true to verify after the keypress.",
 		promptSnippet: "Press keys in Chrome through the companion extension.",
 		parameters: Type.Object({
 			key: Type.String(),
+			includeSnapshot: Type.Optional(Type.Boolean({ description: "If true, include a fresh chrome_snapshot result after the keypress." })),
+			maxElements: Type.Optional(Type.Number({ default: MAX_ELEMENTS, description: "Max elements in the included snapshot." })),
 			targetId: Type.Optional(Type.String()),
 			urlIncludes: Type.Optional(Type.String()),
 			titleIncludes: Type.Optional(Type.String()),
@@ -697,6 +737,69 @@ If chrome_* tools time out, ask the user to run /chrome-onboard, then load the b
 		},
 	});
 
+	pi.registerTool({
+		name: "chrome_list_console_messages",
+		label: "Chrome Console Messages",
+		description:
+			"List console messages captured in the page by the companion extension. Capture starts after any chrome_snapshot, chrome_evaluate, chrome_list_console_messages, or chrome_list_network_requests call installs page instrumentation.",
+		promptSnippet: "List captured console messages from the active Chrome page.",
+		parameters: Type.Object({
+			clear: Type.Optional(Type.Boolean({ description: "Clear the captured console log after reading." })),
+			targetId: Type.Optional(Type.String()),
+			urlIncludes: Type.Optional(Type.String()),
+			titleIncludes: Type.Optional(Type.String()),
+			background: Type.Optional(Type.Boolean({ description: "If true, run silently without focusing Chrome. Default false." })),
+			host: Type.Optional(Type.String()),
+			port: Type.Optional(Type.Number()),
+		}),
+		async execute(_id, params): Promise<ToolTextResult> {
+			const result = await bridge.send("page.console.list", withBackground(params), DEFAULT_TIMEOUT_MS);
+			return { content: [{ type: "text", text: truncateText(safeJson(result)) }], details: { result: result as Json } };
+		},
+	});
+
+	pi.registerTool({
+		name: "chrome_list_network_requests",
+		label: "Chrome Network Requests",
+		description:
+			"List fetch/XMLHttpRequest activity captured in the page by the companion extension. Capture starts after instrumentation is installed by snapshot/evaluate/network/console tools; browser document/static asset requests are not captured. Use includePreservedRequests=true to keep requests from earlier same-tab navigations that were captured before navigation.",
+		promptSnippet: "List captured XHR/fetch requests from the active Chrome page before doing DOM-heavy debugging.",
+		parameters: Type.Object({
+			includePreservedRequests: Type.Optional(Type.Boolean({ description: "Include captured requests from earlier locations in the same tab/session." })),
+			clear: Type.Optional(Type.Boolean({ description: "Clear the captured request log after reading." })),
+			targetId: Type.Optional(Type.String()),
+			urlIncludes: Type.Optional(Type.String()),
+			titleIncludes: Type.Optional(Type.String()),
+			background: Type.Optional(Type.Boolean({ description: "If true, run silently without focusing Chrome. Default false." })),
+			host: Type.Optional(Type.String()),
+			port: Type.Optional(Type.Number()),
+		}),
+		async execute(_id, params): Promise<ToolTextResult> {
+			const result = await bridge.send("page.network.list", withBackground(params), DEFAULT_TIMEOUT_MS);
+			return { content: [{ type: "text", text: truncateText(safeJson(result)) }], details: { result: result as Json } };
+		},
+	});
+
+	pi.registerTool({
+		name: "chrome_get_network_request",
+		label: "Chrome Network Request",
+		description: "Retrieve one captured fetch/XMLHttpRequest entry, including response body when available, by requestId from chrome_list_network_requests.",
+		promptSnippet: "Fetch captured request details and response body by requestId.",
+		parameters: Type.Object({
+			requestId: Type.String({ description: "Request id returned by chrome_list_network_requests." }),
+			targetId: Type.Optional(Type.String()),
+			urlIncludes: Type.Optional(Type.String()),
+			titleIncludes: Type.Optional(Type.String()),
+			background: Type.Optional(Type.Boolean({ description: "If true, run silently without focusing Chrome. Default false." })),
+			host: Type.Optional(Type.String()),
+			port: Type.Optional(Type.Number()),
+		}),
+		async execute(_id, params): Promise<ToolTextResult> {
+			const result = await bridge.send("page.network.get", withBackground(params), DEFAULT_TIMEOUT_MS);
+			return { content: [{ type: "text", text: truncateText(safeJson(result)) }], details: { result: result as Json } };
+		},
+	});
+
 	pi.registerTool({
 		name: "chrome_screenshot",
 		label: "Chrome Screenshot",

package/package.json

@@ -1,31 +1,31 @@
 {
-  "name": "pi-chrome",
-  "version": "0.6.0",
-  "description": "Drive your existing logged-in Chrome from Pi \u2014 no re-login, no throwaway profile, watch the agent work in real time (or toggle quiet background mode).",
-  "keywords": [
-    "pi-package",
-    "pi-extension",
-    "chrome",
-    "browser",
-    "automation",
-    "authenticated-session",
-    "real-profile",
-    "web-debugging"
-  ],
-  "license": "MIT",
-  "type": "commonjs",
-  "files": [
-    "extensions",
-    "README.md"
-  ],
-  "pi": {
-    "extensions": [
-      "./extensions/chrome-profile-bridge/index.ts"
-    ]
-  },
-  "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "typebox": "*"
-  }
+	"name": "pi-chrome",
+	"version": "0.7.0",
+	"description": "Drive your existing logged-in Chrome from Pi — no re-login, no throwaway profile, watch the agent work in real time (or toggle quiet background mode).",
+	"keywords": [
+		"pi-package",
+		"pi-extension",
+		"chrome",
+		"browser",
+		"automation",
+		"authenticated-session",
+		"real-profile",
+		"web-debugging"
+	],
+	"license": "MIT",
+	"type": "commonjs",
+	"files": [
+		"extensions",
+		"README.md"
+	],
+	"pi": {
+		"extensions": [
+			"./extensions/chrome-profile-bridge/index.ts"
+		]
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"typebox": "*"
+	}
 }