@tiens.nguyen/gu-cli 1.0.833 → 1.0.834

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.833",
+  "version": "1.0.834",
   "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",
@@ -125,6 +125,13 @@
     "skills.mjs",
     "skill-source.mjs",
     "shell-details.mjs",
+    "browser-command.mjs",
+    "browser-bridge.mjs",
+    "browser-extension/manifest.json",
+    "browser-extension/background.js",
+    "browser-extension/popup.html",
+    "browser-extension/popup.js",
+    "browser-extension/icons/",
     "step-group.mjs",
     "mcp-config.mjs",
     "mcp-command.mjs",
@@ -136,6 +143,7 @@
     "gu_mcp.py",
     "gu_skills.py",
     "gu_test_digest.py",
+    "gu_browser.py",
     "gu_hooks.py",
     "prompt_scaffold_check.py",
     "gonext_transcribe.py",

package/shell-details.mjs

@@ -11,9 +11,9 @@
 // read from the same two facts the agent uses: is the process group alive, and has the shell
 // written its exit file.
 
-import { existsSync, openSync, readSync, closeSync, fstatSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, openSync, readSync, closeSync, fstatSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { isAbsolute, join, normalize } from "node:path";
+import { basename, dirname, isAbsolute, join, normalize } from "node:path";
 import { spawnSync } from "node:child_process";
 
 export const shellsPath = (home = homedir()) => join(home, ".gonext", "shells.json");
@@ -63,7 +63,7 @@ export function shellState(rec, { alive, exit, now = Date.now() / 1000 } = {}) {
   if (live && !ex && !rec?.killed) return { state: "running", code: null, runtime: Math.max(0, now - started), ended: now };
   const ended = Number(rec?.ended) || ex?.at || now;
   const state = rec?.killed ? "killed" : !ex ? "ended" : ex.code === 0 ? "exited" : "failed";
-  return { state, code: ex ? ex.code : null, runtime: Math.max(0, ended - started), ended };
+  return { state, code: ex ? ex.code : null, runtime: Math.max(0, ended - started), ended, by: String(rec?.killed_by ?? "") };
 }
 
 /** 7m 2s — Claude Code's spelling. */
@@ -79,7 +79,10 @@ export function fmtRuntime(seconds) {
 export function statusText(st) {
   if (st.state === "running") return "running";
   if (st.state === "exited" || st.state === "failed") return `exited ${st.code}`;
-  return st.state === "killed" ? "killed" : "ended (exit code unknown)";
+  // Who stopped it (#362/#143): a bare "killed" read as a crash when the agent had stopped its own
+  // search on purpose.
+  if (st.state === "killed") return st.by ? `killed — stopped by ${st.by}` : "killed";
+  return "ended (exit code unknown)";
 }
 
 /**
@@ -250,8 +253,59 @@ export async function killShell(rec, { path = shellsPath(), platform = process.p
   const mine = shells.find((s) => String(s.id) === String(rec.id));
   if (!mine || readExit(mine)) return; // it finished on its own first: keep the real exit code
   mine.killed = true;
+  mine.killed_by = "you (Stop it in Shell details)";
+  mine.announced = true; // you stopped it — no recap turn for it
   mine.ended = Date.now() / 1000;
   const tmp = `${path}.${process.pid}.tmp`;
   writeFileSync(tmp, JSON.stringify({ shells }, null, 2));
   renameSync(tmp, path);
 }
+
+/**
+ * Shells whose ending the agent has not heard about (#362) — Claude Code tells its model when a
+ * background command completes; gu's terminal starts a short recap turn for these. Only this
+ * folder's shells (shells.json is shared by every project), only ones that ended while this
+ * terminal was open, never one the agent already read (`seen`) or was told about (`announced`),
+ * and never one you stopped yourself.
+ */
+export function shellsToRecap(entries, { cwd = process.cwd(), since = 0 } = {}) {
+  // The nearest folder that still exists, resolved (macOS: /var → /private/var), plus the rest —
+  // a build may have deleted the folder it ran in.
+  const real = (p) => {
+    const raw = String(p ?? "");
+    if (!raw) return raw;
+    try { return realpathSync(raw); } catch { /* gone */ }
+    const up = dirname(raw);
+    return up === raw ? raw : join(real(up), basename(raw));
+  };
+  const base = real(cwd).replace(/\/+$/, "");
+  const under = (wd) => {
+    const w = real(wd);
+    return w === base || w.startsWith(base + "/");
+  };
+  return entries
+    .filter(({ rec, st }) => st.state !== "running" && st.state !== "killed" && !rec.seen && !rec.announced
+      && st.ended >= since && under(rec.workdir))
+    .map((e) => e.rec);
+}
+
+/** Mark these shells announced in shells.json, so neither the agent nor another terminal repeats it. */
+export function markAnnounced(ids, { path = shellsPath() } = {}) {
+  const shells = readShells(path);
+  let n = 0;
+  for (const s of shells) if (ids.includes(String(s.id)) && !s.announced) { s.announced = true; n++; }
+  if (!n) return 0;
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify({ shells }, null, 2));
+  renameSync(tmp, path);
+  return n;
+}
+
+/** The recap question the terminal asks for finished shells. */
+export function recapQuestion(entries) {
+  const parts = entries.map(({ rec, st }) =>
+    `shell ${rec.id} ${statusText(st)} after ${fmtRuntime(st.runtime)} (${String(rec.command ?? "").replace(/\s+/g, " ").trim().slice(0, 120)})`);
+  const ids = entries.map(({ rec }) => `shell_output('${rec.id}')`).join(", ");
+  return `[gu: background ${entries.length === 1 ? "shell" : "shells"} finished — ${parts.join("; ")}] `
+    + `Read the result with ${ids}, tell me briefly what happened, and continue with the next step if the task needs one.`;
+}