pi-chrome 0.14.0 → 0.14.2

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

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Pi Chrome Connector",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "description": "Lets Pi control tabs in Chrome via a local connector at 127.0.0.1.",
   "permissions": ["tabs", "scripting", "storage", "activeTab", "alarms", "webNavigation", "debugger"],
   "host_permissions": ["<all_urls>", "http://127.0.0.1:17318/*"],

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

@@ -60,6 +60,13 @@ async function maybeUpgradeToTrusted(kind, params, syntheticResult, trustedFn) {
   }
 }
 
+// Last few attach failures, kept for /chrome doctor + trusted.debug diagnostics.
+const attachDebugLog = [];
+function recordAttachEvent(entry) {
+  attachDebugLog.push({ ...entry, t: Date.now() });
+  if (attachDebugLog.length > 20) attachDebugLog.shift();
+}
+
 async function attachDebugger(tabId) {
   if (!chrome.debugger) throw new Error("chrome.debugger API unavailable; reload the extension to grant the new permission");
   if (attachedTabs.has(tabId)) {
@@ -67,28 +74,75 @@ async function attachDebugger(tabId) {
     entry.detachAt = Date.now() + TRUSTED_IDLE_DETACH_MS;
     return entry;
   }
+  // Before each attach, force-detach any stale CDP target this extension owns on the tab.
+  // Chrome sometimes keeps a half-dead session around (extension reload mid-attach, etc.) and
+  // surfaces it as "Cannot access a chrome-extension://" on the next attach attempt.
   try {
-    await chrome.debugger.attach({ tabId }, CDP_VERSION);
-  } catch (error) {
-    // Chrome occasionally rejects attach with "Cannot access a chrome-extension:// URL of
-    // different extension" right after a navigation, even when the target tab's URL is a
-    // normal page. Wait a tick, verify the tab is on a non-privileged URL, and retry once.
-    const msg = String(error?.message || error);
+    const targets = await new Promise((resolve) => chrome.debugger.getTargets((t) => resolve(t || [])));
+    for (const tgt of targets) {
+      if (tgt.tabId === tabId && tgt.attached) {
+        recordAttachEvent({ kind: "stale-target-found", tabId, target: { id: tgt.id, type: tgt.type, url: tgt.url, extensionId: tgt.extensionId } });
+        try { await chrome.debugger.detach({ tabId }); } catch {}
+        await sleep(80);
+        break;
+      }
+    }
+  } catch {}
+  const attemptAttach = async () => {
+    try {
+      await chrome.debugger.attach({ tabId }, CDP_VERSION);
+      return null;
+    } catch (error) {
+      return error;
+    }
+  };
+  let err = await attemptAttach();
+  if (err) {
+    const msg = String(err?.message || err);
     const transient = /Cannot access a chrome-extension|Cannot access contents of|No tab with id|Debugger is not attached|Another debugger|Target closed/i.test(msg);
-    if (!transient) throw error;
+    const tabSnapshot = await chrome.tabs.get(tabId).catch(() => null);
+    recordAttachEvent({ kind: "attach-failed", tabId, message: msg, tabUrl: tabSnapshot?.url, transient });
+    if (!transient) throw err;
+    if (!tabSnapshot || (tabSnapshot.url || "").startsWith("chrome://") || (tabSnapshot.url || "").startsWith("chrome-extension://")) {
+      throw new Error(`Chrome can't attach the debugger to this tab (${tabSnapshot?.url ?? "unknown"}). Open a normal http(s) tab and try again.`);
+    }
     await sleep(180);
-    const tab = await chrome.tabs.get(tabId).catch(() => null);
-    if (!tab || (tab.url || "").startsWith("chrome://") || (tab.url || "").startsWith("chrome-extension://")) {
-      throw new Error(`Chrome can't attach the debugger to this tab (${tab?.url ?? "unknown"}). Open a normal http(s) tab and try again.`);
+    err = await attemptAttach();
+    if (err) {
+      recordAttachEvent({ kind: "attach-retry-failed", tabId, message: String(err.message || err), tabUrl: tabSnapshot?.url });
+      // One more try after a longer settle. Some Chrome builds need ~500ms after a navigation
+      // for content-script registration on the tab to drain before chrome.debugger.attach
+      // will accept the target.
+      await sleep(500);
+      err = await attemptAttach();
+      if (err) {
+        recordAttachEvent({ kind: "attach-retry2-failed", tabId, message: String(err.message || err), tabUrl: tabSnapshot?.url });
+        throw err;
+      }
     }
-    await chrome.debugger.attach({ tabId }, CDP_VERSION);
   }
+  recordAttachEvent({ kind: "attached", tabId });
   // Seed pointer in a plausible "just left the address bar" location.
   const entry = { detachAt: Date.now() + TRUSTED_IDLE_DETACH_MS, pointer: { x: 120 + Math.random() * 200, y: 80 + Math.random() * 120 } };
   attachedTabs.set(tabId, entry);
   return entry;
 }
 
+async function trustedDebug(params) {
+  const tab = params?.targetId ? await chrome.tabs.get(Number(params.targetId)).catch(() => null) : null;
+  let targets = [];
+  try { targets = await new Promise((resolve) => chrome.debugger.getTargets((t) => resolve(t || []))); } catch {}
+  return {
+    extensionVersion: chrome.runtime.getManifest().version,
+    extensionId: chrome.runtime.id,
+    trustedMode: TRUSTED_MODE,
+    attachedTabs: Array.from(attachedTabs.keys()),
+    requestedTab: tab ? { id: tab.id, url: tab.url, status: tab.status, title: tab.title } : null,
+    cdpTargets: targets,
+    recentAttachEvents: attachDebugLog.slice(),
+  };
+}
+
 async function detachDebugger(tabId) {
   if (!attachedTabs.has(tabId)) return;
   attachedTabs.delete(tabId);
@@ -131,12 +185,72 @@ function cdpRaw(tabId, method, params) {
 // chrome.debugger.attach can stay cached in attachedTabs even after Chrome killed
 // the session (tab nav, devtools opened/closed, etc). Recover by detaching the
 // stale entry and re-attaching, then retry the command once.
+// Find foreign chrome-extension targets currently anchored to the tab. Password managers,
+// autofill helpers, and other input-attached extensions create type:"other" CDP targets
+// whose URL is chrome-extension://<otherId>/...  When that target is in focus, CDP refuses
+// our Input.dispatchMouseEvent calls with "Cannot access a chrome-extension:// URL of
+// different extension" — surfacing a cryptic error to the user.
+async function findForeignExtensionTargets() {
+  try {
+    const targets = await new Promise((resolve) => chrome.debugger.getTargets((t) => resolve(t || [])));
+    return targets.filter((t) => {
+      const url = String(t.url || "");
+      if (!url.startsWith("chrome-extension://")) return false;
+      if (t.extensionId === chrome.runtime.id) return false;
+      return true;
+    });
+  } catch {
+    return [];
+  }
+}
+
+function extractForeignExtId(targets) {
+  for (const t of targets) {
+    if (t.extensionId && t.extensionId !== chrome.runtime.id) return t.extensionId;
+    const m = String(t.url || "").match(/chrome-extension:\/\/([a-p]+)\//);
+    if (m && m[1] !== chrome.runtime.id) return m[1];
+  }
+  return null;
+}
+
+async function dismissOverlayViaEscape(tabId) {
+  // Esc routes through key dispatcher (target-by-focus), not by mouse coordinates, so it
+  // works even when a foreign chrome-extension popup is intercepting pointer events.
+  try {
+    await cdpRaw(tabId, "Input.dispatchKeyEvent", { type: "keyDown", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27 });
+    await cdpRaw(tabId, "Input.dispatchKeyEvent", { type: "keyUp", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27 });
+    await sleep(120);
+  } catch {}
+}
+
 async function cdp(tabId, method, params) {
   try {
     return await cdpRaw(tabId, method, params);
   } catch (error) {
     const msg = String(error?.message || error);
     const isStale = /Debugger is not attached|Detached while|Target closed|No tab with id/i.test(msg);
+    const isForeignExtBlock = /Cannot access a chrome-extension:\/\/ URL of different extension/i.test(msg);
+    if (isForeignExtBlock && /Input\./.test(method)) {
+      // Foreign chrome-extension popup (autofill, password manager) is hijacking input.
+      // Try once: dismiss via Esc, then retry.
+      const before = await findForeignExtensionTargets();
+      recordAttachEvent({ kind: "foreign-ext-detected", tabId, method, foreignExtId: extractForeignExtId(before), targetCount: before.length });
+      await dismissOverlayViaEscape(tabId);
+      try {
+        return await cdpRaw(tabId, method, params);
+      } catch (retryErr) {
+        const retryMsg = String(retryErr?.message || retryErr);
+        if (/Cannot access a chrome-extension:\/\/ URL of different extension/i.test(retryMsg)) {
+          const after = await findForeignExtensionTargets();
+          const id = extractForeignExtId(after) || extractForeignExtId(before) || "unknown";
+          throw new Error(
+            `Another Chrome extension (${id}) has an input overlay on this page (e.g. a password manager / autofill popup). \n` +
+            `pi-chrome tried to dismiss it with Escape but it reappeared. Disable that extension on this page, focus the field via Tab instead of clicking, or run /chrome quiet off so the agent uses synthetic input here.`,
+          );
+        }
+        throw retryErr;
+      }
+    }
     if (!isStale) throw error;
     attachedTabs.delete(tabId);
     await chrome.debugger.attach({ tabId }, CDP_VERSION).catch(() => undefined);
@@ -639,6 +753,8 @@ async function dispatch(action, params) {
       return setTrustedMode(params.mode);
     case "trusted.status":
       return trustedStatus();
+    case "trusted.debug":
+      return trustedDebug(params);
     case "page.console.list":
       return executeInTab(params, listConsoleMessages, [params.clear === true]);
     case "page.network.list":

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

@@ -1,6 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
-import { StringEnum } from "@earendil-works/pi-ai";
 import { Container, type SettingItem, SettingsList, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { existsSync, readFileSync, statSync } from "node:fs";
@@ -381,6 +380,10 @@ const tabActionValues = ["list", "new", "activate", "close", "version"] as const
 const imageFormatValues = ["png", "jpeg"] as const;
 const waitForValues = ["selector", "expression"] as const;
 
+function StringEnum<T extends readonly [string, ...string[]]>(values: T) {
+	return Type.Union(values.map((value) => Type.Literal(value)) as [ReturnType<typeof Type.Literal>, ...ReturnType<typeof Type.Literal>[]]);
+}
+
 export default function (pi: ExtensionAPI): void {
 	const globalState = globalThis as typeof globalThis & {
 		[PI_CHROME_GLOBAL_KEY]?: { version: string; root: string };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-chrome",
-	"version": "0.14.0",
+	"version": "0.14.2",
 	"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",
@@ -24,8 +24,15 @@
 		]
 	},
 	"peerDependencies": {
-		"@earendil-works/pi-ai": "*",
 		"@earendil-works/pi-coding-agent": "*",
 		"typebox": "*"
+	},
+	"peerDependenciesMeta": {
+		"@earendil-works/pi-coding-agent": {
+			"optional": true
+		},
+		"typebox": {
+			"optional": true
+		}
 	}
 }