@tiens.nguyen/gu-cli 1.0.838 → 1.0.840

package/browser-chrome.mjs

@@ -0,0 +1,244 @@
+// gu's OWN Chrome window (task #369, GitHub #150) — the browser tool with nothing to install.
+//
+// Chrome lets no program turn on Developer mode or load an unpacked extension, so without the
+// gu extension the bridge starts a Chrome of its own: a normal, visible window on a separate
+// profile (~/.gonext/browser-profile), started with its DevTools port open, and drives it over the
+// DevTools protocol — the same protocol the extension uses through chrome.debugger, through the
+// same actions.js. Nothing in the user's own Chrome is touched; the agent asks the user before it
+// is first used (gu_browser.py).
+//
+// The profile is gu's alone: the user's logins are not in it (sign in there once if a test needs
+// it — it is kept). Chrome 136+ refuses a DevTools port on the default profile anyway.
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { WebSocket } from "undici";
+import { enableDomains, forgetTab, onCdpEvent, runAction } from "./browser-extension/actions.js";
+
+export const profileDir = () => process.env.GU_BROWSER_PROFILE || join(homedir(), ".gonext", "browser-profile");
+
+/** The Chrome to start: GU_BROWSER_CHROME, else Chrome / Chromium / Edge / Brave where they install. */
+export function findChrome(platform = process.platform, env = process.env, exists = existsSync) {
+  if (env.GU_BROWSER_CHROME) return exists(env.GU_BROWSER_CHROME) ? env.GU_BROWSER_CHROME : "";
+  let list = [];
+  if (platform === "darwin") {
+    list = ["Google Chrome", "Chromium", "Microsoft Edge", "Brave Browser"].map((n) => `/Applications/${n}.app/Contents/MacOS/${n}`);
+  } else if (platform === "win32") {
+    const roots = [env.PROGRAMFILES, env["PROGRAMFILES(X86)"], env.LOCALAPPDATA].filter(Boolean);
+    list = roots.flatMap((r) => [join(r, "Google", "Chrome", "Application", "chrome.exe"), join(r, "Microsoft", "Edge", "Application", "msedge.exe"), join(r, "BraveSoftware", "Brave-Browser", "Application", "brave.exe")]);
+  } else {
+    list = ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge", "brave-browser"]
+      .flatMap((n) => (env.PATH || "/usr/bin:/usr/local/bin").split(":").map((d) => join(d, n)));
+  }
+  return list.find((p) => exists(p)) || "";
+}
+
+/** DevToolsActivePort: line 1 the port, line 2 the browser's WebSocket path. */
+export function readActivePort(dir) {
+  try {
+    const [port, path] = readFileSync(join(dir, "DevToolsActivePort"), "utf8").trim().split("\n");
+    return Number(port) > 0 && path ? { port: Number(port), path: path.trim() } : null;
+  } catch {
+    return null;
+  }
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export class OwnChrome {
+  constructor({ dir = profileDir(), chrome = findChrome(), headless = process.env.GU_BROWSER_HEADLESS === "1", log = () => {} } = {}) {
+    Object.assign(this, { dir, chrome, headless, log });
+    this.ws = null;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.sessions = new Map(); // targetId → sessionId
+    this.targetOf = new Map(); // sessionId → targetId
+    this.current = null;
+    this.launched = false;
+    // Main frames between "started loading" and "stopped loading". During a navigation the OLD
+    // document still says readyState "complete", so that alone cannot tell a page has moved on.
+    this.loading = new Set();
+  }
+
+  get running() {
+    return Boolean(this.ws && this.ws.readyState === WebSocket.OPEN);
+  }
+
+  // ── the DevTools connection ──
+  send(method, params = {}, sessionId) {
+    return new Promise((resolve, reject) => {
+      if (!this.running) return reject(new Error("gu's Chrome window is not running"));
+      const id = this.nextId++;
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out`));
+      }, 30000);
+      this.pending.set(id, { resolve, reject, timer });
+      this.ws.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
+    });
+  }
+
+  async connect(ap) {
+    const ws = new WebSocket(`ws://127.0.0.1:${ap.port}${ap.path}`);
+    await new Promise((resolve, reject) => {
+      ws.onopen = resolve;
+      ws.onerror = () => reject(new Error("cannot reach Chrome's DevTools port"));
+    });
+    this.ws = ws;
+    ws.onmessage = (ev) => this.onMessage(JSON.parse(String(ev.data)));
+    ws.onclose = () => {
+      if (this.ws !== ws) return;
+      this.ws = null; // the user closed the window: the next command starts it again
+      for (const p of this.pending.values()) {
+        clearTimeout(p.timer);
+        p.reject(new Error("gu's Chrome window was closed"));
+      }
+      this.pending.clear();
+      this.sessions.clear();
+      this.targetOf.clear();
+      this.current = null;
+    };
+    await this.send("Target.setDiscoverTargets", { discover: true });
+  }
+
+  onMessage(m) {
+    if (m.id !== undefined) {
+      const p = this.pending.get(m.id);
+      if (!p) return;
+      this.pending.delete(m.id);
+      clearTimeout(p.timer);
+      if (m.error) p.reject(new Error(m.error.message || "DevTools error"));
+      else p.resolve(m.result || {});
+      return;
+    }
+    if (m.method === "Target.targetCreated") {
+      // A page gu's tab opened (target=_blank, window.open) becomes the current one.
+      const t = m.params.targetInfo;
+      if (t.type === "page" && t.openerId && t.openerId === this.current) this.current = t.targetId;
+    } else if (m.method === "Target.targetDestroyed" || m.method === "Target.detachedFromTarget") {
+      const id = m.params.targetId || this.targetOf.get(m.params.sessionId);
+      if (id) {
+        const s = this.sessions.get(id);
+        this.sessions.delete(id);
+        if (s) this.targetOf.delete(s);
+        if (m.method === "Target.targetDestroyed") forgetTab(id);
+        if (this.current === id && m.method === "Target.targetDestroyed") this.current = null;
+      }
+    } else if (m.sessionId && this.targetOf.has(m.sessionId)) {
+      const id = this.targetOf.get(m.sessionId);
+      // A tab's main frame has the tab's own id.
+      if (m.method === "Page.frameStartedLoading" && m.params.frameId === id) this.loading.add(id);
+      else if (m.method === "Page.frameStoppedLoading" && m.params.frameId === id) this.loading.delete(id);
+      onCdpEvent(id, m.method, m.params || {}, this.cdp);
+    }
+  }
+
+  /** Connect to gu's Chrome, starting it if it is not running. */
+  async ensure() {
+    if (this.running) return;
+    let ap = readActivePort(this.dir);
+    if (ap) {
+      try {
+        await this.connect(ap); // still running from an earlier bridge
+        return;
+      } catch {
+        /* stale file */
+      }
+    }
+    if (!this.chrome) throw new Error("no Chrome, Chromium, Edge or Brave found on this computer (set GU_BROWSER_CHROME to one)");
+    mkdirSync(this.dir, { recursive: true });
+    rmSync(join(this.dir, "DevToolsActivePort"), { force: true });
+    const args = [`--user-data-dir=${this.dir}`, "--remote-debugging-port=0", "--no-first-run", "--no-default-browser-check", "--window-size=1280,900", ...(this.headless ? ["--headless=new"] : []), "about:blank"];
+    spawn(this.chrome, args, { detached: true, stdio: "ignore" }).unref();
+    this.log(`started gu's Chrome window (${this.chrome})`);
+    this.launched = true;
+    const end = Date.now() + 20000;
+    while (Date.now() < end) {
+      await sleep(150);
+      ap = readActivePort(this.dir);
+      if (!ap) continue;
+      try {
+        await this.connect(ap);
+        return;
+      } catch {
+        /* not listening yet */
+      }
+    }
+    throw new Error("gu's Chrome window did not start");
+  }
+
+  // ── the host actions.js runs on ──
+  cdp = (targetId, method, params = {}) => this.send(method, params, this.sessions.get(targetId));
+
+  async pages() {
+    const { targetInfos } = await this.send("Target.getTargets");
+    return targetInfos.filter((t) => t.type === "page" && !/^(devtools|chrome-extension):/.test(t.url));
+  }
+
+  host() {
+    return {
+      // gu's own window is not an extension: no store rules, so the agent's js action runs here.
+      runsJs: true,
+      cdp: this.cdp,
+      attach: async (id) => {
+        if (this.sessions.has(id)) return;
+        const { sessionId } = await this.send("Target.attachToTarget", { targetId: id, flatten: true });
+        this.sessions.set(id, sessionId);
+        this.targetOf.set(sessionId, id);
+        await enableDomains(this.cdp, id);
+      },
+      open: async (url, newTab) => {
+        const pages = await this.pages();
+        const reuse = newTab ? null : pages.find((t) => t.targetId === this.current) || pages[0];
+        // A new tab starts blank and is navigated once attached, so its load events are seen.
+        const id = reuse ? reuse.targetId : (await this.send("Target.createTarget", { url: "about:blank" })).targetId;
+        await this.host().attach(id);
+        this.loading.add(id);
+        await this.cdp(id, "Page.navigate", { url });
+        this.current = id;
+        await this.send("Target.activateTarget", { targetId: id }).catch(() => {});
+        return id;
+      },
+      tabs: async () => (await this.pages()).map((t) => ({ id: t.targetId, title: t.title, url: t.url, current: t.targetId === this.current })),
+      switchTo: async (id) => {
+        if (!(await this.pages()).some((t) => t.targetId === id)) return false;
+        this.current = id;
+        await this.send("Target.activateTarget", { targetId: id }).catch(() => {});
+        return true;
+      },
+      current: async () => {
+        const pages = await this.pages();
+        const t = pages.find((p) => p.targetId === this.current) || pages[pages.length - 1];
+        if (!t) throw new Error('gu has no tab open yet — use action "open" with a url first');
+        this.current = t.targetId;
+        return t.targetId;
+      },
+      info: async (id) => {
+        const t = (await this.pages()).find((p) => p.targetId === id);
+        if (!t) return null;
+        let status = "loading";
+        if (this.sessions.has(id) && !this.loading.has(id)) {
+          const r = await Promise.race([this.cdp(id, "Runtime.evaluate", { expression: "document.readyState", returnByValue: true }).catch(() => null), sleep(2000)]);
+          if (r?.result?.value === "complete") status = "complete";
+        }
+        return { url: t.url, title: t.title, status };
+      },
+      activate: (id) => this.send("Target.activateTarget", { targetId: id }).catch(() => {}),
+      close: (id) => this.send("Target.closeTarget", { targetId: id }),
+    };
+  }
+
+  async run(cmd) {
+    await this.ensure();
+    return runAction(cmd, this.host());
+  }
+
+  /** Close gu's window (tests, and /browser cleanup). */
+  async quit() {
+    if (!this.running) return;
+    await this.send("Browser.close").catch(() => {});
+    this.ws?.close();
+    this.ws = null;
+  }
+}

package/browser-command.mjs

@@ -47,6 +47,34 @@ async function status(st, waitMs = 0) {
 
 // → { running, connected, version }. Starts the bridge when it is not running, so an extension
 // installed a moment from now has something to connect to.
+/**
+ * The error a bridge that died on start left in its log, in one line — or "" (#381, GitHub #170).
+ * Same reading as gu_browser.bridge_error: gu 1.0.838 shipped without browser-chrome.mjs, and a
+ * bridge that cannot start was shown as "nothing to install" / "no Chrome".
+ */
+export function bridgeError(logText) {
+  let lines = String(logText || "").split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].includes("listening on 127.0.0.1")) {
+      lines = lines.slice(i + 1);
+      break;
+    }
+  }
+  const hits = lines.filter((l) => /Cannot find (?:module|package)|ERR_[A-Z_]+|\b\w*Error\b:|cannot listen|EADDRINUSE|EACCES/.test(l));
+  if (!hits.length) return "";
+  const line = hits.find((l) => l.includes("Cannot find")) ?? hits[hits.length - 1];
+  return line.replace(/\s+/g, " ").slice(0, 240);
+}
+
+function bridgeLogTail(maxBytes = 16000) {
+  try {
+    const text = readFileSync(join(dataDir(), "browser-bridge.log"), "utf8");
+    return text.slice(-maxBytes);
+  } catch {
+    return "";
+  }
+}
+
 export async function bridgeStatus({ start = true, waitMs = 1500 } = {}) {
   let st = readState();
   try {
@@ -57,10 +85,13 @@ export async function bridgeStatus({ start = true, waitMs = 1500 } = {}) {
   if (!start) return { running: false, connected: false };
   mkdirSync(dataDir(), { recursive: true });
   const log = openSync(join(dataDir(), "browser-bridge.log"), "a");
-  spawn(process.execPath, [join(HERE, "browser-bridge.mjs")], { detached: true, stdio: ["ignore", log, log] }).unref();
+  const child = spawn(process.execPath, [join(HERE, "browser-bridge.mjs")], { detached: true, stdio: ["ignore", log, log] });
+  let died = false;
+  child.once("exit", () => { died = true; });
+  child.unref();
   closeSync(log);
   const end = Date.now() + 5000;
-  while (Date.now() < end) {
+  while (Date.now() < end && !died) {
     await new Promise((r) => setTimeout(r, 150));
     st = readState();
     if (!st) continue;
@@ -70,11 +101,14 @@ export async function bridgeStatus({ start = true, waitMs = 1500 } = {}) {
       /* not listening yet */
     }
   }
-  return { running: false, connected: false };
+  return { running: false, connected: false, error: bridgeError(bridgeLogTail()) || "it did not start" };
 }
 
 // The Chrome Web Store page of the gu extension, once published (#149/#150). Empty until then.
-export const STORE_URL = process.env.GU_BROWSER_STORE_URL || "";
+// The published listing (#385, GitHub #175) — live since 2026-10-16, gu browser 1.0.4. The env var
+// still overrides it (a staging listing, or "" to fall back to the developer steps).
+export const PUBLISHED_STORE_URL = "https://chromewebstore.google.com/detail/gu-browser/ldfcjapmdbgdkdhlbdkbkiankneabagj";
+export const STORE_URL = process.env.GU_BROWSER_STORE_URL ?? PUBLISHED_STORE_URL;
 
 // "Always allow the browser in this folder" (#150) — the agent reads the same file
 // (gu_browser.allowed_in) before it asks.
@@ -106,7 +140,16 @@ export function allowIn(folder, allow = true) {
   writeFileSync(allowPath(), JSON.stringify({ folders }, null, 2));
 }
 
-export function browserReport({ connected, version, installType, refused = [] }, { allowed = false } = {}) {
+export function browserReport({ connected, version, installType, refused = [], running = true, error = "" }, { allowed = false, storeUrl = STORE_URL, storeInstalled = false } = {}) {
+  // The bridge itself would not start (#170): that is gu's fault, and says so — not "nothing to install".
+  if (!running && error) {
+    return [
+      `⚠ gu's browser bridge did not start: ${error}`,
+      "⚠ This is a problem in gu, not in Chrome — no browser needs installing.",
+      "Update gu: npm install -g @tiens.nguyen/gu-cli@latest — then restart gu.",
+      "The bridge's log: ~/.gonext/browser-bridge.log",
+    ];
+  }
   // Two copies installed (the store one next to a developer one): the bridge kept one (#148).
   const twoCopies = refused.length
     ? [`⚠ A second gu extension (${refused.map((r) => r.id).join(", ")}) tried to connect and was`,
@@ -130,9 +173,15 @@ export function browserReport({ connected, version, installType, refused = [] },
     "Nothing to install. When the agent needs a browser it asks you first, then",
     "opens gu's own Chrome window (a separate profile — not signed in to your",
     "accounts) and works in it with a real mouse and keyboard.",
-    STORE_URL
-      ? `To let it use YOUR Chrome (your logins, a tab you share): ${STORE_URL}`
-      : "To let it use YOUR Chrome (your logins, a tab you share): /browser install",
+    // The link on a row of its own (#385): the published one is longer than a row beside the text.
+    // #386: which step is missing — added but not connected, or not added at all.
+    ...(storeUrl && storeInstalled
+      ? ["The gu extension is added to Chrome but not connected: keep Chrome open (it",
+        "connects within 30 s) — /browser install waits for it."]
+      : storeUrl
+        ? ["To let it use YOUR Chrome (your logins, a tab you share), add the gu",
+          "extension — /browser install guides you through it:", `  ${storeUrl}`]
+        : ["To let it use YOUR Chrome (your logins, a tab you share): /browser install"]),
     here,
     ...twoCopies,
   ];
@@ -140,9 +189,10 @@ export function browserReport({ connected, version, installType, refused = [] },
 
 // /browser install — the extension, for the user's own Chrome. The store page when there is one;
 // until then the developer way (Developer mode → Load unpacked).
-export function installSteps(folder, platform = process.platform) {
-  if (STORE_URL) {
-    return [`Open ${STORE_URL} in Chrome and click "Add to Chrome".`, "Then type /browser — it should say connected."];
+export function installSteps(folder, platform = process.platform, storeUrl = STORE_URL) {
+  if (storeUrl) {
+    return ["Add the gu extension from the Chrome Web Store — click \"Add to Chrome\":", `  ${storeUrl}`,
+      "Then type /browser — it should say connected."];
   }
   const pick = platform === "darwin"
     ? ["     In the file dialog press ⌘⇧G, paste the folder (it is on your", "     clipboard) and press Enter."]
@@ -171,6 +221,23 @@ export function openExtensionsPage(platform = process.platform) {
   }
 }
 
+/** Open the store listing (#385): Chrome on macOS when it is there, else the default browser. */
+export function openStorePage(url = STORE_URL, platform = process.platform) {
+  if (!url || process.env.GU_NO_OPEN_APPS) return false;
+  try {
+    const [cmd, args] =
+      platform === "darwin"
+        ? ["open", existsSync("/Applications/Google Chrome.app") ? ["-a", "Google Chrome", url] : [url]]
+        : platform === "win32"
+          ? ["explorer.exe", [url]]
+          : ["xdg-open", [url]];
+    spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // macOS: put the folder on the clipboard and open the extensions page, so step 3 is a paste.
 export function helpInstall(folder, platform = process.platform) {
   if (platform !== "darwin" || process.env.GU_NO_OPEN_APPS) return false;
@@ -257,6 +324,86 @@ export function findDevInstalls({ roots = browserRoots(), extDir = extensionDir(
   return found;
 }
 
+// THE PUBLISHED EXTENSION, FOUND IN CHROME'S OWN RECORDS (#386, GitHub #176). Its ID is fixed by the
+// store (the last part of the store URL), so a profile has it when its preferences list that ID
+// from anywhere but an unpacked folder. Disabled is told apart: it is installed but cannot connect.
+export const STORE_EXTENSION_ID = "ldfcjapmdbgdkdhlbdkbkiankneabagj";
+
+export function findStoreInstalls({ roots = browserRoots(), id = STORE_EXTENSION_ID } = {}) {
+  const found = [];
+  for (const { browser, dir } of roots) {
+    let profiles = [];
+    try {
+      profiles = readdirSync(dir).filter((p) => p === "Default" || /^Profile \d+$/.test(p));
+    } catch {
+      continue;
+    }
+    for (const profile of profiles) {
+      for (const file of ["Secure Preferences", "Preferences"]) {
+        let e;
+        try {
+          e = JSON.parse(readFileSync(join(dir, profile, file), "utf8"))?.extensions?.settings?.[id];
+        } catch {
+          continue;
+        }
+        if (!e || UNPACKED.has(e.location)) continue;
+        const reasons = Array.isArray(e.disable_reasons) ? e.disable_reasons.length : Number(e.disable_reasons) || 0;
+        found.push({ browser, profile, id, disabled: e.state === 0 || reasons > 0 });
+        break;
+      }
+    }
+  }
+  return found;
+}
+
+/**
+ * Where the install stands, and what to tell the user — PURE, so every stage can be tested.
+ * → { stage, lines }: "remove-dev" (a developer copy would block the store one, #148), "add" (not
+ * in Chrome yet), "enable" (added but switched off), "connect" (added, not connected yet), "done".
+ */
+export function installStage({ dev = [], store = [], status = {}, storeUrl = STORE_URL } = {}) {
+  if (status.connected && status.installType === "normal") {
+    return { stage: "done", lines: [`✓ gu browser is connected (Chrome Web Store, v${status.version ?? "?"}).`] };
+  }
+  if (dev.length) {
+    return {
+      stage: "remove-dev",
+      lines: [
+        "1. First remove the developer copy of gu browser — only one can connect.",
+        "   In chrome://extensions (gu opened it), click Remove on this one:",
+        ...dev.map((d) => `     ${d.browser} · ${d.profile} · ID ${d.id}`),
+        "   Waiting for it to be removed…",
+      ],
+    };
+  }
+  if (!store.length) {
+    return {
+      stage: "add",
+      lines: [
+        "1. Add gu browser to Chrome: on its store page, click \"Add to Chrome\".",
+        `   ${storeUrl}`,
+        "   (gu opened the page for you.) Waiting for it to be added…",
+      ],
+    };
+  }
+  if (store.every((s) => s.disabled)) {
+    return {
+      stage: "enable",
+      lines: [
+        "2. gu browser is added but switched off. In chrome://extensions, turn it on.",
+        "   Waiting for it to be turned on…",
+      ],
+    };
+  }
+  return {
+    stage: "connect",
+    lines: [
+      "2. gu browser is added. Waiting for it to connect to gu…",
+      "   Keep Chrome open — it connects within 30 s, or click its icon → Connect now.",
+    ],
+  };
+}
+
 // gu's own leftovers of the developer install, in ~/.gonext.
 export function localLeftovers() {
   return [extensionDir(), statePath(), seenPath(), logPath()].filter((p) => existsSync(p));

package/gonext_agent_chat.py

@@ -8771,6 +8771,25 @@ def _ws_delete_targets(argv):
         runner = runner[:-4]
     if runner in _WS_DELETE_RUNNERS:
         return [a for a in argv[1:] if a and not a.startswith("-") and a != "--"]
+    if runner in ("mv", "move"):
+        # A MOVE REMOVES ITS SOURCE (#381, GitHub #171), measured: `mv '/Applications/Google
+        # Chrome.app' /tmp/Google-Chrome-old.app` ran without a question while the same with rm
+        # would have asked. The sources are every operand but the destination — or, with
+        # -t DIR / --target-directory=DIR, every operand.
+        ops, target_given, skip = [], False, False
+        for a in argv[1:]:
+            if skip:
+                skip = False
+                continue
+            if a in ("-t", "--target-directory"):
+                target_given, skip = True, True
+                continue
+            if a.startswith("--target-directory="):
+                target_given = True
+                continue
+            if a and not a.startswith("-") and a != "--":
+                ops.append(a)
+        return ops if target_given else ops[:-1]
     if runner == "find" and any(a in ("-delete",) for a in argv[1:]):
         # `find <paths…> <expression>`: the paths come before the first expression token.
         out = []
@@ -8805,7 +8824,8 @@ def _ws_delete_outside_reason(argv, wd, roots=None):
             outside.append(t)
     if not outside:
         return None
-    return ("it deletes files OUTSIDE the project (" + ", ".join(outside[:3])
+    verb = "moves" if os.path.basename(argv[0]).lower() in ("mv", "move") else "deletes"
+    return (f"it {verb} files OUTSIDE the project (" + ", ".join(outside[:3])
             + (" …" if len(outside) > 3 else "") + ")")
 
 
@@ -16101,7 +16121,9 @@ def run_agent_chat(cfg):
                     _emit({"type": "step", "text": "Using gu's own Chrome window" if where == "chrome"
                            else "Using your Chrome (gu extension)"})
                 if not_connected:
-                    _emit({"type": "step", "text": "⚠ No browser gu can use — /browser shows why"})
+                    _emit({"type": "step", "text": ("⚠ gu's browser bridge failed to start — /browser shows why"
+                                                   if str(res).startswith(_gb.BRIDGE_FAILED)
+                                                   else "⚠ No browser gu can use — /browser shows why")})
                     msg = _gb.install_text(str(res))
                 elif not ok:
                     msg = f"Error: browser {a} failed: {res}"

package/gu-repl.mjs

@@ -137,9 +137,9 @@ import {
   trimWords,
 } from "./terminal-layout.mjs";
 import { completedFlush, splitLiveStream } from "./completed-flush.mjs";
-import { isScaffoldStep, isGroupableStep, stepGroupRows, relativizePaths } from "./step-group.mjs";
+import { isScaffoldStep, isGroupableStep, stepGroupMark, stepGroupRows, relativizePaths } from "./step-group.mjs";
 import { clearLogsNoticeText } from "./clear-logs.mjs";
-import { allowIn, allowedIn, bridgeCommand, browserReport, bridgeStatus, extensionDir, findDevInstalls, helpInstall, installExtensionFiles, installSteps, localLeftovers, openExtensionsPage, removeLocalFiles, STORE_URL, stopBridge } from "./browser-command.mjs";
+import { allowIn, allowedIn, bridgeCommand, browserReport, bridgeStatus, extensionDir, findDevInstalls, helpInstall, installExtensionFiles, installSteps, localLeftovers, findStoreInstalls, installStage, openExtensionsPage, openStorePage, removeLocalFiles, STORE_URL, stopBridge } from "./browser-command.mjs";
 import { commandLogFile, killShell, logTail, markAnnounced, readShells, recapQuestion, shellsToRecap, statusText as shellStatusText, renderShellDetails, shellPanelRows, shellPickerLabel, shellState, shellsNotice } from "./shell-details.mjs";
 import { discoverSkills, matchSkillCommand } from "./skills.mjs";
 import { appendNew, archivePathFor, archivedWorkspaceKey, markReset, seedArchive } from "./conversation-archive.mjs";
@@ -420,6 +420,8 @@ const bold = paint(1);
 // toward white (no bold/underline/anchor) so it subtly signals "hovered" without looking like
 // a link. 97 = bright white.
 const hoverThought = (s) => `\x1b[97m${s}\x1b[0m`;
+// A thought at rest: the terminal's own text colour (#383) — no longer dim.
+const thoughtText = (s) => s;
 
 // The worker's "still thinking" heartbeat lines look like "Caffeinating… (90s)" — we
 // SWALLOW them from the terminal (the local ticker below drives progress instead), and
@@ -563,7 +565,10 @@ const BULLET_STYLE = {
   // A look-up (grep/pgrep/rg…) that found nothing: not an error — a dim grey ✗, dim text.
   soft: { mark: CROSS, markColor: dim, textColor: dim },
   ok: { mark: CHECK, markColor: accent, textColor: dim },
-  info: { mark: BULLET, markColor: dim, textColor: dim },
+  // #383 (GitHub #173): a "●" row that stands alone is the agent saying something — a warning, a
+  // wait for approval — so its text is white. Look-ups and finished commands are activity and go
+  // into the dim counted group instead (step-group.mjs); they never reach this style.
+  info: { mark: BULLET, markColor: dim, textColor: brightText },
 };
 const classifyBullet = (text) => BULLET_STYLE[bulletKind(text)];
 
@@ -1985,9 +1990,9 @@ rl.on("line", (l) => {
   // Enter ends any drag: if a release was lost (focus left the window mid-drag) the highlight
   // would otherwise stay painted over text nobody is selecting — see endDrag.
   endDrag();
-  // A list picker owns the keyboard (its Enter resolves via the keypress handler) — never
-  // let that Enter submit a stray empty line into the command loop.
-  if (listPickerActive) {
+  // A list picker — or a panel in the input box's place (#384) — owns the keyboard (its Enter
+  // resolves via the keypress handler): never let that Enter submit a stray empty line.
+  if (listPickerActive || zonePanel) {
     rl.line = "";
     rl.cursor = 0;
     return;
@@ -2985,8 +2990,42 @@ function zoneNotice(width) {
  * carries — off the line being typed (INPUT_HEAD_ROWS). All of it lives below the scrolling region, so all of it stays put — including
  * what the user is typing, which is why gu renders that line itself (see inputZoneRows).
  */
+// A PANEL IN PLACE OF THE INPUT BOX (#384, GitHub #174) — Claude Code's Shell details. While one
+// is open it owns the bottom zone from the separator down: the input box, the notice row and the
+// bar give way to it, a turn's live status (if any) stays above it, and Esc gives the zone back.
+// `rows(width, maxRows)` → the panel's rows (it may use fewer); `onKey(key)` → true when handled.
+let zonePanel = null;
+
+function openZonePanel(panel) {
+  closeZonePanel();
+  zonePanel = { ...panel, timer: panel.refreshMs ? setInterval(() => paintBar(), panel.refreshMs) : null };
+  paintBar();
+}
+
+function closeZonePanel() {
+  if (!zonePanel) return;
+  if (zonePanel.timer) clearInterval(zonePanel.timer);
+  const done = zonePanel.onClose;
+  zonePanel = null;
+  paintBar();
+  if (done) done();
+}
+
 function frozenZone() {
   const width = Math.max(20, process.stdout.columns || 80);
+  if (zonePanel) {
+    const status = footerActive ? [] : [...pendingEchoRows(), ...liveStatusRows];
+    // At least four rows of conversation stay visible, as with a tall input (maxInputRows).
+    const room = Math.max(3, viewportRows() - status.length - 2 - 4);
+    let body = [];
+    try { body = zonePanel.rows(width, room) || []; } catch { body = []; }
+    const rule = dim("─".repeat(width));
+    const rows = status.concat([rule], body.slice(0, room).map((r) => clipVisible(r, width - 1)), [rule]);
+    return {
+      rows, statusRows: status.length, noticeRow: false, headRows: 1, rowCount: 1,
+      caretRow: 0, caretCol: 1, offsetAt: () => 0,
+    };
+  }
   // The status rows sit at the TOP of the zone — directly under the transcript, which is
   // visually where the block already appeared, so nothing jumps. Everything below is unchanged.
   //
@@ -3596,12 +3635,18 @@ const hoverCtl = createHoverController({
  * that is the one place they are told apart.
  */
 const paintThoughtRows = (block, hovered, collapsed = block.collapsed) => {
-  const paint = (r) => (hovered ? hoverThought(r) : dim(r));
   if (block.kind === "steps") {
+    // Activity (look-ups, finished commands): dim, like a ✓ row; bright while hovered.
+    const paint = (r) => (hovered ? hoverThought(r) : dim(r));
+    const ok = stepGroupMark(block.items) === "ok";
     return stepGroupRows(block.items, { width: thoughtWidth(), collapsed }).map(
-      (r) => (r.head ? markLine(dim(BULLET)) : GUTTER) + paint(r.text)
+      (r) => (r.head ? markLine(ok ? accent(CHECK) : dim(BULLET)) : GUTTER) + paint(r.text)
     );
   }
+  // THE AGENT'S OWN WORDS ARE WHITE (#383, GitHub #173) — what it found, what it will do next.
+  // They were grey scaffolding (#148), as dim as the commands, and the user missed them; now
+  // only activity recedes. Hover still lifts the block to bright white, the cue it can open.
+  const paint = (r) => (hovered ? hoverThought(r) : thoughtText(r));
   const rows = thoughtBlockRows(block.prose, {
     width: thoughtWidth(),
     collapsed,
@@ -3615,7 +3660,7 @@ const thoughtWidth = () =>
   Math.max(24, (process.stdout.columns || 80) - GUTTER.length - 1);
 
 /**
- * Print one step's reasoning into the transcript, collapsed, in grey (task #148).
+ * Print one step's reasoning into the transcript, collapsed — in the normal text colour since #383 (grey before, task #148).
  *
  * Grey and collapsed for the same reason: this is ON by default, so it has to stay scaffolding.
  * Progress recedes and the answer is the only full-bright thing on screen — a page of bright
@@ -3656,7 +3701,7 @@ function printThoughtBlock(raw, before, { gap = false } = {}) {
       lines: THOUGHT_COLLAPSED_LINES,
     });
     const rowsBeforeMerge = screenRows().length;
-    const newEnd = transcript.replaceRange(prev.from, prev.to, grown.map((r) => GUTTER + dim(r)));
+    const newEnd = transcript.replaceRange(prev.from, prev.to, grown.map((r) => GUTTER + thoughtText(r)));
     if (newEnd !== null) {
       prev.prose = merged;
       prev.to = newEnd;
@@ -3675,7 +3720,7 @@ function printThoughtBlock(raw, before, { gap = false } = {}) {
   // as its error text. A thought is printed when its step's reasoning ends, BEFORE that step's
   // tools report: it introduces what comes next, it does not belong to the row above. Only for a
   // NEW block — a continuation is merged into the previous one above and never gets here.
-  process.stdout.write(thoughtPrintSeq(rows.map((r) => GUTTER + dim(r)), { gap }));
+  process.stdout.write(thoughtPrintSeq(rows.map((r) => GUTTER + thoughtText(r)), { gap }));
   // Record where it landed. The blank is above `from`, so the block is still exactly its rows. Measured AFTER the write so a trim during it cannot skew the
   // range: the last completed line is length-2 (the final entry is the still-open line).
   const endAbs = transcript.dropped() + transcript.length() - 2;
@@ -4474,6 +4519,15 @@ if (process.stdin.isTTY) {
     // #247: the restored question was erased (Backspace, Ctrl+U, a picker taking the line) — it
     // is let go, exactly as with Ctrl+C, so the next message does not REPLACE it in history.
     if (prefillFor && (listPickerActive || restoredQuestionLetGo(rl.line, key))) prefillFor = null;
+    // A panel holds the input box's place (#384): its keys, and nothing reaches the line.
+    if (zonePanel) {
+      if (key && (key.name === "escape" || (key.ctrl && key.name === "c"))) closeZonePanel();
+      else if (zonePanel.onKey) zonePanel.onKey(key, _ch);
+      rl.line = "";
+      rl.cursor = 0;
+      rl.historyIndex = -1;
+      return;
+    }
     // An arrow-key list picker (/server) is up → ↑/↓ move the highlight, Enter chooses.
     if (listPickerActive) {
       onListKey(key);
@@ -9566,30 +9620,100 @@ function printShellDetails(rec) {
 // /browser (#363): the extension's connection, else how to install it.
 async function showBrowser() {
   const st = await bridgeStatus().catch(() => ({ running: false, connected: false }));
-  const lines = browserReport(st, { allowed: allowedIn(resolve(process.cwd())) });
+  const lines = browserReport(st, { allowed: allowedIn(resolve(process.cwd())), storeInstalled: findStoreInstalls().length > 0 });
   console.log("");
   for (const [i, l] of lines.entries()) console.log(GUTTER + (i === 0 && st.connected ? accent(l) : l.startsWith("⚠") ? yellow(l) : dim(l)));
   console.log("");
   paintBar();
 }
 
-// /browser install (#150): the extension, for the agent to use YOUR Chrome. Optional — gu's own
-// window needs nothing. The store page once published; until then the developer way.
+// /browser install (#150; guided since #386, GitHub #176): the published extension, for the agent to
+// use YOUR Chrome — the way Claude Code sets up its Chrome extension. gu walks it through to the end:
+// a developer copy is removed first (it would block the store one, #148), then the store page is
+// opened, and the panel in place of the input box (#384) shows each stage live until the store copy
+// is CONNECTED — or Esc stops waiting. gu's own window still needs none of this.
 async function browserInstall() {
-  let folder = extensionDir();
+  if (listPickerActive || approvalActive) return;
+  const done = (line) => {
+    console.log("\n" + GUTTER + line + "\n");
+    paintBar();
+  };
   if (!STORE_URL) {
+    // No published listing configured (GU_BROWSER_STORE_URL=""): the developer way, as before.
+    let folder = extensionDir();
     try {
       folder = installExtensionFiles();
     } catch (e) {
       console.log(GUTTER + yellow(`could not copy the extension to ${folder}: ${e.message}`));
     }
+    await bridgeStatus().catch(() => null);
+    console.log("");
+    for (const l of installSteps(folder, process.platform, "")) console.log(GUTTER + dim(l));
+    if (helpInstall(folder)) console.log(GUTTER + dim("(Opened chrome://extensions and copied the folder to your clipboard.)"));
+    console.log("");
+    paintBar();
+    return;
   }
-  await bridgeStatus().catch(() => null); // running, so a fresh install has something to connect to
-  console.log("");
-  for (const l of installSteps(folder)) console.log(GUTTER + dim(l));
-  if (STORE_URL ? openExtensionsPage() : helpInstall(folder)) console.log(GUTTER + dim(STORE_URL ? "(Opened Chrome.)" : "(Opened chrome://extensions and copied the folder to your clipboard.)"));
-  console.log("");
-  paintBar();
+  let status = await bridgeStatus().catch(() => ({ running: false, connected: false }));
+  const opened = new Set();
+  const state = () => {
+    const st = installStage({ dev: findDevInstalls(), store: findStoreInstalls(), status });
+    // Open the page each stage needs, once.
+    if (st.stage === "remove-dev" && !opened.has("ext")) { opened.add("ext"); openExtensionsPage(); }
+    if (st.stage === "add" && !opened.has("store")) { opened.add("store"); openStorePage(); }
+    if (st.stage === "enable" && !opened.has("ext2")) { opened.add("ext2"); openExtensionsPage(); }
+    return st;
+  };
+  let st = state();
+  if (st.stage === "done") return done(accent(st.lines[0]));
+  if (!barPinned()) {
+    // No zone to wait in: say what to do once.
+    console.log("");
+    for (const l of st.lines) console.log(GUTTER + dim(l));
+    console.log(GUTTER + dim("Then type /browser — it should say connected.") + "\n");
+    paintBar();
+    return;
+  }
+  let polling = false;
+  const poll = setInterval(async () => {
+    if (polling) return;
+    polling = true;
+    try {
+      status = await bridgeStatus({ waitMs: 0 }).catch(() => status);
+      st = state();
+      if (st.stage === "done") {
+        clearInterval(poll);
+        closeZonePanel();
+        done(accent(st.lines[0]) + dim("  The agent can use your Chrome now."));
+      }
+    } finally {
+      polling = false;
+    }
+  }, 2000);
+  openZonePanel({
+    refreshMs: 1000,
+    rows: (width) => {
+      // A row the panel would clip is WRAPPED instead: the store link is 84 characters, and a link
+      // cut short at 80 columns cannot be copied.
+      const room = Math.max(20, width - 1 - GUTTER.length);
+      const wrap = (l) => {
+        const out = [];
+        for (let rest = l; rest.length; rest = rest.slice(room)) out.push(rest.slice(0, room));
+        return out.length ? out : [""];
+      };
+      return [
+        GUTTER + bold(accent("Install gu browser")) + dim("  — so the agent can use your own Chrome"),
+        "",
+        ...st.lines.flatMap((l) => wrap(/https?:\/\//.test(l) ? l.trim() : l).map((r) => GUTTER + (/^\d\./.test(l) ? r : dim(r)))),
+        "",
+        GUTTER + dim("Esc to stop waiting · /browser install picks up where you left off"),
+      ];
+    },
+    onClose: () => {
+      clearInterval(poll);
+      if (st.stage !== "done") done(dim("(stopped waiting — /browser install picks up where you left off)"));
+    },
+  });
 }
 
 // /browser cleanup (#145, #147): remove the developer (unpacked) install so the Chrome Web Store
@@ -9668,52 +9792,57 @@ async function showShells() {
     }
   }
   const rec = entries[pick].rec;
-  // During a turn a picker would fight the turn for the keyboard: the details are printed instead.
-  if (following) {
-    printShellDetails(rec);
-    refreshShells();
-    paintBar();
+  // IN PLACE OF THE INPUT BOX (#384, GitHub #174), the way Claude Code shows it: from the top of
+  // the bottom zone, live, until Esc — which gives the input box and the "N shell(s)" link back.
+  // Nothing goes into the scrollback, and it works during a turn too: it holds two keys (Esc, s)
+  // and swallows the rest, as a picker does. The shell keeps running when it closes.
+  shellsViewed.add(String(rec.id));
+  if (!barPinned()) {
+    printShellDetails(rec); // no zone to draw in (a short window, piped output): print, as before
     return;
   }
-  // AT THE BOTTOM, ABOVE THE BAR, LIVE; Esc closes (#376, GitHub #157) — Claude Code's Shell
-  // details. Nothing goes into the scrollback: the panel and its choices are one block that the
-  // picker wipes when it closes. Its height is fixed when it opens (what the screen allows, at most
-  // the details plus 15 output lines) and it redraws once a second, so a build's runtime and
-  // newest output move while you watch.
-  shellsViewed.add(String(rec.id));
-  const panel = (rowsWanted) => {
+  let note = "";
+  const rowsFor = (width, room) => {
     const st = shellState(rec);
-    let output = logTail(rec.log, { lines: 40 });
+    let output = logTail(rec.log, { lines: 60 });
     let outputFrom = "";
     if (!output.length) {
       const lf = commandLogFile(rec.command, rec.workdir);
       if (lf) {
-        output = logTail(lf, { lines: 40 });
+        output = logTail(lf, { lines: 60 });
         outputFrom = lf.startsWith(String(rec.workdir || "\0") + "/") ? lf.slice(String(rec.workdir).length + 1) : lf;
       }
     }
+    const footer = note || (st.state === "running" ? "Esc to close · s to stop it" : "Esc to close");
+    // As tall as it needs — its own detail rows (a long command wraps to 4), up to 15 output
+    // lines and the footer — never taller than the room.
+    const headRows = renderShellDetails({ rec, st, output: [], outputFrom, width: width - 1, gutter: GUTTER }).length - 1;
+    const want = Math.min(room, headRows + Math.max(1, Math.min(15, output.length)) + 1);
     return shellPanelRows({
-      rec, st, output, outputFrom, width: Math.max(20, process.stdout.columns || 80) - 1, gutter: GUTTER, rows: rowsWanted,
-      footer: "Esc to close",
+      rec, st, output, outputFrom, width: width - 1, gutter: GUTTER, rows: want, footer,
       style: { title: (t) => bold(accent(t)), label: bold, running: accent, ok: accent, bad: red, dim },
     });
   };
-  const running = shellState(rec).state === "running";
-  const actions = running
-    ? [{ id: "kill", label: "Stop it", note: "kills the command and everything it started" }, { id: "close", label: "Close" }]
-    : [{ id: "close", label: "Close" }];
-  const headerRows = Math.max(8, Math.min(24, viewportHeight() - 3 - actions.length));
-  const act = await pickFromList(
-    actions.map((a) => a.label + (a.note ? dim(`  · ${a.note}`) : "")),
-    actions.length - 1, // Close: Enter on its own never stops a build
-    { header: panel, headerRows, refreshMs: 1000 },
-  );
-  if (act >= 0 && actions[act].id === "kill") {
-    await killShell(rec);
-    console.log(GUTTER + accent(`✓ stopped shell ${rec.id}`) + dim(" — the agent sees it as killed next turn.\n"));
-  }
-  refreshShells();
-  paintBar();
+  openZonePanel({
+    rows: rowsFor,
+    refreshMs: 1000,
+    onKey: (key) => {
+      if (key?.name === "s" && !key.ctrl && !key.meta && shellState(rec).state === "running") {
+        note = "stopping…";
+        paintBar();
+        killShell(rec).then(() => {
+          note = "";
+          console.log(GUTTER + accent(`✓ stopped shell ${rec.id}`) + dim(" — the agent sees it as killed next turn."));
+          refreshShells();
+          paintBar();
+        });
+      }
+    },
+    onClose: () => {
+      refreshShells();
+      paintBar();
+    },
+  });
 }
 async function refreshOtherAgents() {
   if (!barPinned() || following) return;
@@ -10699,11 +10828,18 @@ async function approvalPrompt(command) {
     const [folder = "", what = ""] = command.slice(BROWSER_PREFIX.length).split("\t");
     if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
     process.stdout.write(
-      "\n" + yellow("🌐 Allow gu to use a web browser?") + dim("  (no answer in ~3 min = No)") + "\n" +
+      "\n" + yellow("🌐 Allow gu to use a web browser?") + dim("  (no answer in ~3 min = Yes, this time)") + "\n" +
         dim(`  It wants to: ${what || "open a page"}`) + "\n" +
-        dim("  In your Chrome if the gu extension is there, else in gu's own Chrome window.") + "\n"
+        dim("  In your Chrome if the gu extension is there, else in gu's own Chrome window.") + "\n" +
+        // #386: the way to "your Chrome", said where the question is asked.
+        (STORE_URL && !findStoreInstalls().length
+          ? dim("  To use your own Chrome (your logins): /browser install adds the gu extension.") + "\n"
+          : "")
     );
-    const idx = await pickFromList(["Yes, this time", "Yes, always in this folder", "No"], 0, { timeoutMs: 170000, timeoutIndex: 2 });
+    // "Yes, this time" is THE default (#380, GitHub #167): highlighted, so Enter allows it once, and
+    // also what an unanswered question becomes — the countdown used to sit on "No", which read as
+    // the default. Remembering the folder is never automatic; it takes an explicit choice.
+    const idx = await pickFromList(["Yes, this time", "Yes, always in this folder", "No"], 0, { timeoutMs: 170000, timeoutIndex: 0 });
     if (idx === 1) {
       try {
         allowIn(folder || resolve(process.cwd()), true);
@@ -12391,17 +12527,14 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   /** Is the open group still followed by nothing but thought blocks? */
   const stepGroupStillOpen = () => {
     if (!stepGroup || !barPinned() || scrolledBack()) return false;
-    let end = stepGroup.to;
-    const at = thoughtBlocks.indexOf(stepGroup);
-    if (at < 0) return false; // dropped from the registry (it is capped): no longer ours to rewrite
-    for (let i = at + 1; i < thoughtBlocks.length; i++) {
-      // Directly under, or under the ONE blank a thought now opens with (#344) — the look-up
-      // group must stay open across it, or every thought would start a new counted row.
-      const step = thoughtBlocks[i].from - end;
-      if (step !== 1 && step !== 2) return false;
-      end = thoughtBlocks[i].to;
-    }
-    return end === transcriptTail();
+    if (thoughtBlocks.indexOf(stepGroup) < 0) return false; // dropped from the registry (it is capped)
+    // ONLY WHILE IT IS THE LAST THING ON SCREEN (#383, GitHub #173). It used to stay open across
+    // the agent's notes, so a look-up made AFTER a note was counted in the row ABOVE it. With
+    // finished commands joining groups and notes now white — the part the user reads — that put
+    // activity above the note that came before it ("Chrome opened but the log still shows…" under
+    // commands it had not seen yet). A note closes the group; the next activity starts a new one
+    // below it, so the history reads in order: activity, note, activity, note.
+    return stepGroup.to === transcriptTail();
   };
   const addLookupStep = (text) => {
     if (stepGroupStillOpen()) {

package/gu_browser.py

@@ -8,6 +8,7 @@ model reads. No model or smolagents import here — it is tested on its own.
 
 import base64
 import json
+import re
 import os
 import shutil
 import subprocess
@@ -71,7 +72,9 @@ def install_extension_files():
 
 # The Chrome Web Store page of the gu extension, once it is published (#149/#150). Until then the
 # extension is the developer path only — and nobody needs it: gu's own Chrome window works without.
-STORE_URL = os.environ.get("GU_BROWSER_STORE_URL", "")
+# The published Chrome Web Store listing (#385, GitHub #175); the env var still overrides it.
+PUBLISHED_STORE_URL = "https://chromewebstore.google.com/detail/gu-browser/ldfcjapmdbgdkdhlbdkbkiankneabagj"
+STORE_URL = os.environ.get("GU_BROWSER_STORE_URL", PUBLISHED_STORE_URL)
 
 
 def allow_path():
@@ -122,8 +125,45 @@ def last_seen():
         return {}
 
 
+BRIDGE_FAILED = "the gu browser bridge did not start"
+
+
+def bridge_error(log_text):
+    """The error a bridge that died on start left in its log — the last one, in one line — or "".
+    gu 1.0.838 shipped without browser-chrome.mjs: the bridge died with ERR_MODULE_NOT_FOUND, and
+    the agent was told "no Chrome" and reinstalled a Chrome that was fine (#381, GitHub #170)."""
+    lines = [l.strip() for l in (log_text or "").splitlines() if l.strip()]
+    # Only what came after the last successful start counts.
+    for i in range(len(lines) - 1, -1, -1):
+        if "listening on 127.0.0.1" in lines[i]:
+            lines = lines[i + 1:]
+            break
+    pat = re.compile(r"Cannot find (?:module|package)|ERR_[A-Z_]+|\b\w*Error\b:|cannot listen|EADDRINUSE|EACCES")
+    hits = [l for l in lines if pat.search(l)]
+    if not hits:
+        return ""
+    line = hits[-1] if "Cannot find" not in " ".join(hits) else next(l for l in hits if "Cannot find" in l)
+    return re.sub(r"\s+", " ", line)[:240]
+
+
+def bridge_log_tail(max_bytes=16000):
+    try:
+        with open(os.path.join(data_dir(), "browser-bridge.log"), "rb") as f:
+            f.seek(0, 2)
+            f.seek(max(0, f.tell() - max_bytes))
+            return f.read().decode("utf-8", "replace")
+    except OSError:
+        return ""
+
+
 def install_text(reason="not connected"):
     """What the model is told when the extension is not there: stop and ask the user."""
+    if str(reason).startswith(BRIDGE_FAILED):
+        # A fault in gu itself — never "install Chrome" (#170): the agent took that literally.
+        return (f"BROWSER NOT AVAILABLE — {reason}. This is a problem in gu's own browser bridge, NOT a "
+                "missing or broken Chrome: do NOT install, reinstall, move or delete any browser. STOP "
+                "and tell the user, with that error: update gu (npm install -g @tiens.nguyen/gu-cli@latest), "
+                "restart it, and ask again; the bridge's log is ~/.gonext/browser-bridge.log.")
     if last_seen().get("installType") == "normal":
         # The Chrome Web Store copy is installed: never point at the developer folder again (#145).
         return (f"BROWSER NOT AVAILABLE ({reason}): the gu Chrome extension (Chrome Web Store) is "
@@ -174,13 +214,15 @@ def _start_bridge(log=None):
     logf = open(os.path.join(data_dir(), "browser-bridge.log"), "ab")
     kw = {"start_new_session": True} if os.name != "nt" else {
         "creationflags": getattr(subprocess, "DETACHED_PROCESS", 0) | getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)}
-    subprocess.Popen([_node(), BRIDGE], stdin=subprocess.DEVNULL, stdout=logf, stderr=logf,
-                     env=dict(os.environ), **kw)
+    proc = subprocess.Popen([_node(), BRIDGE], stdin=subprocess.DEVNULL, stdout=logf, stderr=logf,
+                            env=dict(os.environ), **kw)
     logf.close()
     if log:
         log("browser: started the bridge")
     end = time.time() + 6
     while time.time() < end:
+        if proc.poll() is not None:  # it died: no point waiting the full 6 s (#170)
+            return None
         st = _read_state()
         if st:
             try:
@@ -206,7 +248,8 @@ def connect(wait=True, log=None, on_wait=None, own=False):
         st = _start_bridge(log)
         started = True
         if not st:
-            return None, "the gu browser bridge did not start (is node installed?)"
+            err = bridge_error(bridge_log_tail())
+            return None, f"{BRIDGE_FAILED}: {err}" if err else f"{BRIDGE_FAILED} (is node installed?)"
     # A Chrome extension's worker sleeps; its alarm wakes it to reconnect within 30 s. Wait that
     # long only when an extension has connected before — otherwise it is most likely not installed.
     seen = os.path.exists(seen_path())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.838",
+  "version": "1.0.840",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -129,6 +129,7 @@
     "win-path.mjs",
     "browser-command.mjs",
     "browser-bridge.mjs",
+    "browser-chrome.mjs",
     "browser-extension/manifest.json",
     "browser-extension/background.js",
     "browser-extension/actions.js",

package/step-group.mjs

@@ -42,11 +42,24 @@ export function stepLabel(text) {
   return /^[A-Za-z][A-Za-z0-9 _.\-/]*$/.test(label) ? label : "";
 }
 
-/** Does this step join a group? `kind` is bulletKind()'s: only neutral ("info") steps do. */
+// A COMMAND THAT FINISHED joins the group too (#383, GitHub #173): a turn that checks eight tools
+// printed eight "✓ Command finished → …" rows in a column. They are activity, like the look-ups —
+// one counted row, a click from the commands. A FAILED command never joins: it is the row to see.
+const COMMAND_DONE = /^Command finished → /;
+export const isCommandStep = (text) => COMMAND_DONE.test(String(text ?? "").trim());
+
+/** Does this step join a group? `kind` is bulletKind()'s: neutral look-ups, and finished commands. */
 export function isGroupableStep(text, kind) {
+  if (kind === "ok") return isCommandStep(text);
   return kind === "info" && !isScaffoldStep(text) && stepLabel(text) !== "";
 }
 
+/** The group's marker: ✓ when every step in it is a finished command, else the neutral ●. */
+export function stepGroupMark(items) {
+  const list = items ?? [];
+  return list.length && list.every(isCommandStep) ? "ok" : "info";
+}
+
 // "Searching code" reads as work in progress; a finished group is said in the past. Only the first
 // word changes, and only when it is one of these — anything else is shown as the agent wrote it.
 const PAST = {
@@ -68,7 +81,9 @@ export function stepGroupSummary(items) {
     const label = stepLabel(it) || String(it ?? "").trim();
     counts.set(label, (counts.get(label) ?? 0) + 1);
   }
-  return [...counts].map(([label, n]) => pastLabel(label) + (n > 1 ? ` ${n}×` : "")).join(" · ");
+  return [...counts]
+    .map(([label, n]) => (label === "Command finished" ? `ran ${n} command${n > 1 ? "s" : ""}` : pastLabel(label) + (n > 1 ? ` ${n}×` : "")))
+    .join(" · ");
 }
 
 function wrapWords(text, width) {