pi-chrome 0.15.20 → 0.15.23

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable user-facing changes to `pi-chrome`.
 
+## 0.15.23 — 2026-05-16
+
+- **Attribution.** The 0.15.22 features below are pulled from Dani Bednarski's fork (`DaniBedz/pi-chrome`). Thank you, Dani.
+
+## 0.15.22 — 2026-05-16
+
+Features in this release are pulled from Dani Bednarski's fork (`DaniBedz/pi-chrome`). Thank you, Dani.
+
+- **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`.

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

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Pi Chrome Connector",
-  "version": "0.15.20",
+  "version": "0.15.23",
   "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

@@ -463,6 +463,7 @@ export default function (pi: ExtensionAPI): void {
 	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";
@@ -486,6 +487,14 @@ export default function (pi: ExtensionAPI): void {
 		}
 	};
 
+	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, signal);
@@ -507,14 +516,7 @@ 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", () => {
@@ -525,6 +527,9 @@ export default function (pi: ExtensionAPI): void {
 	});
 
 	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.
@@ -648,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 => {
@@ -672,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) => {
@@ -848,6 +856,10 @@ Usage rules:
 		},
 	});
 
+	function registerChromeTools(pi: ExtensionAPI): void {
+		if (chromeToolsRegistered) return;
+		chromeToolsRegistered = true;
+
 	pi.registerTool({
 		name: "chrome_launch",
 		label: "Chrome Bridge Setup",
@@ -1381,4 +1393,6 @@ Usage rules:
 			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.20",
+	"version": "0.15.23",
 	"scripts": {
 		"version": "node scripts/sync-manifest-version.js",
 		"prepublishOnly": "node scripts/sync-manifest-version.js"