@tiens.nguyen/gu-cli 1.0.833 → 1.0.835

package/shell-details.mjs

@@ -11,10 +11,13 @@
 // 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";
+import { procStart } from "./proc-identity.mjs";
+
+export { procStart };
 
 export const shellsPath = (home = homedir()) => join(home, ".gonext", "shells.json");
 
@@ -40,10 +43,39 @@ export function readExit(rec) {
   }
 }
 
-/** Is the shell's process group (POSIX) or process (Windows) still there? */
-export function isAlive(rec, platform = process.platform) {
+// A SAVED PGID IS ONLY OURS WHILE ITS LEADER IS THE PROCESS WE STARTED (#373, GitHub #154) — the
+// same rule as the agent's _ws_group_owner. shells.json outlives its commands; after a reboot or a
+// crash the id goes to the next program (VS Code is its own group leader), and "a group with that
+// id exists" read as running and offered "Stop it" on someone else's app. The record's start time
+// is the proof: the process whose pid == the pgid must have started then (± START_SLACK_S). With
+// no such process, members left in the group are still ours — an id in use is never reused.
+export const START_SLACK_S = 5;
+
+/** The record's start (epoch s): `started`, else the older "YYYY-MM-DD HH:MM:SS" `started_at`. */
+function recordStarted(rec) {
+  const n = Number(rec?.started);
+  if (rec?.started != null && Number.isFinite(n)) return n;
+  const m = String(rec?.started_at ?? "").match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
+  return m ? new Date(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6]).getTime() / 1000 : null;
+}
+
+/** "ours" | "leader-gone" | "other" (the id now belongs to another program) | "unknown". */
+export function groupOwner(rec, { platform = process.platform, startOf = procStart } = {}) {
+  if (platform === "win32") return "ours";
+  const pgid = Number(rec?.pgid || rec?.pid || 0);
+  if (!pgid) return "unknown";
+  const leader = startOf(pgid);
+  if (leader === null) return "leader-gone";
+  const started = recordStarted(rec);
+  if (!Number.isFinite(leader) || started == null) return "unknown";
+  return Math.abs(leader - started) <= START_SLACK_S ? "ours" : "other";
+}
+
+/** Is the shell's process group (POSIX) or process (Windows) still there — and still ours? */
+export function isAlive(rec, platform = process.platform, { startOf = procStart } = {}) {
   const pid = Number(rec?.pgid || rec?.pid || 0);
   if (!pid) return false;
+  if (groupOwner(rec, { platform, startOf }) === "other") return false;
   try {
     process.kill(platform === "win32" ? pid : -pid, 0);
     return true;
@@ -63,7 +95,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 +111,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)";
 }
 
 /**
@@ -234,15 +269,17 @@ export function shellPickerLabel(rec, st, width = 80) {
  * Stop a shell's whole group and record that it was killed — the record is what the agent reads
  * next turn, so "killed" must not later read as "ended (exit code unknown)".
  */
-export async function killShell(rec, { path = shellsPath(), platform = process.platform } = {}) {
+export async function killShell(rec, { path = shellsPath(), platform = process.platform, startOf = procStart } = {}) {
   const pid = Number(rec?.pgid || rec?.pid || 0);
-  if (pid && isAlive(rec, platform)) {
+  // Only a group that is provably the one gu started is signalled — never "unknown", never "other".
+  const ours = ["ours", "leader-gone"].includes(groupOwner(rec, { platform, startOf }));
+  if (pid && ours && isAlive(rec, platform, { startOf })) {
     if (platform === "win32") {
       spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
     } else {
       try { process.kill(-pid, "SIGTERM"); } catch { /* gone already */ }
-      for (let i = 0; i < 10 && isAlive(rec, platform); i++) await new Promise((r) => setTimeout(r, 100));
-      if (isAlive(rec, platform)) try { process.kill(-pid, "SIGKILL"); } catch { /* gone */ }
+      for (let i = 0; i < 10 && isAlive(rec, platform, { startOf }); i++) await new Promise((r) => setTimeout(r, 100));
+      if (isAlive(rec, platform, { startOf })) try { process.kill(-pid, "SIGKILL"); } catch { /* gone */ }
     }
   }
   if (!existsSync(path)) return;
@@ -250,8 +287,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.`;
+}

package/terminal-layout.mjs

@@ -1148,6 +1148,7 @@ export function trimWords(text, limit) {
 // grey ✗ with dim text. Judged by the LAST segment of a chain/pipeline (its exit status is
 // the one reported): `ps aux | grep foo` and `cd src && rg Foo` are both look-ups.
 const SEARCH_CMDS = new Set([
+  // platform-ok: names to recognise in a command the agent ran — nothing here runs them.
   "grep", "egrep", "fgrep", "zgrep", "rg", "ag", "ack", "pgrep", "which", "whereis", "lsof",
 ]);
 export function isSoftFailCommand(cmd) {