pi-chrome 0.13.0 → 0.14.1

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

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Pi Chrome Connector",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "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);
@@ -639,6 +693,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,5 +1,7 @@
 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";
 import { mkdir, writeFile } from "node:fs/promises";
@@ -679,6 +681,81 @@ Usage rules:
 		ctx.ui.notify(await statusSummary(), "info");
 	};
 
+	// Interactive dialog: each row is a setting whose value cycles with Space/Enter. Enter on
+	// the last value also saves; Esc / 'q' closes. The description below changes with the
+	// current value so users always see what the active setting means.
+	const openSettingsDialog = async (ctx: ExtensionContext): Promise<void> => {
+		// Read current click mode (might fail if extension permission missing).
+		let clicksMode: string = "auto";
+		let permissionGranted = false;
+		try {
+			const t = (await bridge.send("trusted.status", {}, 5_000)) as { mode?: string; permissionGranted?: boolean };
+			clicksMode = t.mode ?? "auto";
+			permissionGranted = !!t.permissionGranted;
+		} catch {}
+
+		const clicksItem: SettingItem = {
+			id: "clicks",
+			label: "Click realism",
+			currentValue: clicksMode,
+			values: ["auto", "on", "off"],
+			description: permissionGranted
+				? (CLICKS_DESC[clicksMode] ?? "")
+				: "Real-looking clicks unavailable: reload the Chrome extension in chrome://extensions and accept the new permission prompt.",
+		};
+		const quietItem: SettingItem = {
+			id: "quiet",
+			label: "Quiet mode",
+			currentValue: backgroundDefault ? "on" : "off",
+			values: ["on", "off"],
+			description: QUIET_DESC[backgroundDefault ? "on" : "off"] ?? "",
+		};
+		const items: SettingItem[] = [clicksItem, quietItem];
+
+		await ctx.ui.custom<void>((_tui, theme, _kb, done) => {
+			const container = new Container();
+			container.addChild(new Text(theme.fg("accent", theme.bold("pi-chrome settings")), 1, 1));
+			container.addChild(new Text(theme.fg("muted", "\u2191\u2193 navigate · space/enter cycle · esc close"), 1, 0));
+
+			let list: SettingsList;
+			list = new SettingsList(
+				items,
+				Math.min(items.length + 2, 8),
+				getSettingsListTheme(),
+				(id, newValue) => {
+					if (id === "clicks") {
+						if (!permissionGranted) {
+							ctx.ui.notify("Click mode locked: reload the Chrome extension first.", "warning");
+							// Revert by snapping back to the previous value.
+							list.updateValue("clicks", clicksItem.currentValue);
+							return;
+						}
+						// Mutate description so the help text matches the new value.
+						clicksItem.currentValue = newValue;
+						clicksItem.description = CLICKS_DESC[newValue] ?? "";
+						list.invalidate();
+						void bridge.send("trusted.mode", { mode: newValue }, 5_000).catch((err) => {
+							ctx.ui.notify(`Couldn't switch click mode: ${(err as Error).message}`, "warning");
+						});
+					} else if (id === "quiet") {
+						backgroundDefault = newValue === "on";
+						quietItem.currentValue = newValue;
+						quietItem.description = QUIET_DESC[newValue] ?? "";
+						list.invalidate();
+					}
+				},
+				() => done(undefined),
+			);
+			container.addChild(list);
+
+			return {
+				render: (w) => container.render(w),
+				invalidate: () => container.invalidate(),
+				handleInput: (data: string) => list.handleInput(data),
+			};
+		});
+	};
+
 	pi.registerCommand("chrome", {
 		description:
 			"All pi-chrome controls in one place.\n  /chrome status   — one-line snapshot of connection + current modes.\n  /chrome doctor   — full health check.\n  /chrome onboard  — install the Chrome companion extension.\n  /chrome clicks [auto|off|on|status]  — how realistic should pi-chrome's clicks be.\n  /chrome quiet  [on|off|status|toggle] — whether Chrome pops to the front when pi-chrome acts.\nRun with no arguments for an interactive picker that shows current state.",
@@ -727,32 +804,7 @@ Usage rules:
 		handler: async (args, ctx) => {
 			const tokens = (args || "").trim().split(/\s+/).filter(Boolean);
 			if (tokens.length === 0) {
-				const header = await statusSummary();
-				// Compute next-cycle targets so the picker labels describe the toggle action.
-				let clicksNow = "?";
-				try {
-					const t = (await bridge.send("trusted.status", {}, 3_000)) as { mode?: string };
-					clicksNow = t.mode ?? "?";
-				} catch {}
-				const clicksNext = (() => {
-					const idx = CLICKS_CYCLE.indexOf(clicksNow as typeof CLICKS_CYCLE[number]);
-					return idx >= 0 ? CLICKS_CYCLE[(idx + 1) % CLICKS_CYCLE.length] : "auto";
-				})();
-				const quietNow = backgroundDefault ? "on" : "off";
-				const quietNext = backgroundDefault ? "off" : "on";
-				const picked = await ctx.ui.select(`pi-chrome — ${header}`, [
-					`status — print the line above (so you can copy it).`,
-					`doctor — full health check; explains anything broken.`,
-					`onboard — install the Chrome companion extension (first-time setup).`,
-					`clicks: ${clicksNow} → switch to ${clicksNext} — ${CLICKS_DESC[clicksNext] ?? ""}`,
-					`quiet: ${quietNow} → switch to ${quietNext} — ${QUIET_DESC[quietNext] ?? ""}`,
-				]);
-				if (!picked) return;
-				if (picked.startsWith("status")) return statusHandler(ctx);
-				if (picked.startsWith("doctor")) return doctorHandler(ctx);
-				if (picked.startsWith("onboard")) return onboardHandler(ctx);
-				if (picked.startsWith("clicks")) return trustedHandler(ctx, ""); // cycles
-				if (picked.startsWith("quiet")) return backgroundHandler(ctx, ""); // toggles
+				await openSettingsDialog(ctx);
 				return;
 			}
 			const [head, ...rest] = tokens;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-chrome",
-	"version": "0.13.0",
+	"version": "0.14.1",
 	"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",