@tiens.nguyen/gu-cli 1.0.806 → 1.0.807

package/gu-repl.mjs

@@ -144,6 +144,7 @@ import { readSkillSource, sourceLabel, SKILL_SOURCE_KEY } from "./skill-source.m
 import { codingBannerLabel, isOllamaCloudUrl, SECRET_KEY_HINT } from "./coding-key-prompt.mjs";
 import { questionEchoText, thoughtPrintSeq } from "./terminal-layout.mjs";
 import { globalPrefixOf } from "./install-path.mjs";
+import { firstGuOnPath, pathGuMismatch, guOnPathIsCurrent, updateAttemptRecord, repeatUpdateNotice } from "./update-verify.mjs";
 import { embedNotice, embedState } from "./embed-model-command.mjs";
 import {
   MODELFALLBACK_PREFIX, fallbackAfterTurn, fallbackHistoryLine, fallbackNotice, keyMissingNotice,
@@ -1107,12 +1108,21 @@ const contentWrite = (raw, chunk, enc, cb) => {
   // Any real output commits a held question first (see pendingEcho above).
   if (_uiDepth === 0 && pendingEcho !== null) flushPendingEcho();
   if (_uiDepth === 0 && (typeof chunk === "string" || Buffer.isBuffer(chunk))) {
+    // #113 NEVER PULL A READER DOWN. If the user has scrolled back to read history, new output
+    // (the model thinking, a tool's lines) is RECORDED but not drawn, and the view stays on the
+    // same lines: the offset grows by the rows just added, so "↓ jump to bottom · N lines below"
+    // counts up instead. Only the user brings the view home — typing, Enter, End, or a click on
+    // the jump line. At the live tail (offset 0) output follows the bottom exactly as before.
+    const holdView = barPinned() && scrolledBack();
+    const rowsBefore = holdView ? screenRows().length : 0;
     transcript.append(String(chunk), { followCursor: !zoneTookOver });
-    // ALWAYS FOLLOW THE BOTTOM. New output means there is something newer to see, so a view
-    // that was scrolled back comes home first and the line lands where the user is looking.
-    // Scrolling up is therefore the ONLY way to leave the live tail — which is exactly when the
-    // "jump to bottom" line appears, and it disappears again the moment output arrives.
-    if (scrolledBack()) jumpToBottom();
+    if (holdView) {
+      scrollOffset += Math.max(0, screenRows().length - rowsBefore);
+      paintBar(); // the jump line's "N lines below" changed; the history on screen did not
+      if (typeof enc === "function") enc();
+      else if (typeof cb === "function") cb();
+      return true;
+    }
   }
   if (_uiDepth === 0 && barPinned()) {
     // Content belongs in the scrolling area, not where the caret is parked.
@@ -2441,11 +2451,26 @@ async function refreshCliToken() {
 }
 const TOKEN_TICK_MS = 60 * 60 * 1000;
 
+// The last in-app CLI update attempt (task #21): lets the next start say WHY an update did not
+// take effect instead of offering the very same update again, forever.
+const UPDATE_ATTEMPT_FILE = join(homedir(), ".gonext", "last-cli-update.json");
+function readUpdateAttempt() {
+  try { return JSON.parse(readFileSync(UPDATE_ATTEMPT_FILE, "utf8")); } catch { return null; }
+}
+function saveUpdateAttempt(rec) {
+  try { mkdirSync(dirname(UPDATE_ATTEMPT_FILE), { recursive: true }); writeFileSync(UPDATE_ATTEMPT_FILE, JSON.stringify(rec, null, 2)); } catch { /* best effort */ }
+}
+
 let cliNoticeShown = false;
 function announceCliUpdate() {
   if (cliNoticeShown || !availableUpdates.cli) return;
   if (following) return; // a turn owns the transcript — try again at the next prompt
-  const lines = updateNotice({ cli: availableUpdates.cli, running: REPL_VERSION });
+  let lines = [];
+  try {
+    lines = repeatUpdateNotice({ last: readUpdateAttempt(), cli: availableUpdates.cli, running: REPL_VERSION,
+                                 onPath: firstGuOnPath({ PATH: process.env.PATH }), home: homedir(), env: process.env });
+  } catch { lines = []; }
+  if (!lines.length) lines = updateNotice({ cli: availableUpdates.cli, running: REPL_VERSION });
   if (!lines.length) return;
   cliNoticeShown = true;
   console.log("");
@@ -2539,12 +2564,20 @@ async function runUpdate() {
         }
         const failed = describeInstallFailure(r);
         if (failed) throw new Error(failed);
+        const onPath = firstGuOnPath({ PATH: process.env.PATH });
         // npm exiting 0 is not the outcome: read the version now on disk in THIS install.
         let onDisk = "";
         try { onDisk = JSON.parse(readFileSync(join(DIR, "package.json"), "utf8")).version ?? ""; } catch { /* unreadable: skip the check */ }
         const short = installedVersionShortfall(onDisk, cli);
-        if (short) throw new Error(short);
+        // nvm-windows: `nvm use` in ANY terminal re-points C:\nvm4w\nodejs, so npm may have updated the
+        // now-active Node's copy instead of this one. What counts is the gu the next `gu` starts.
+        if (short && !guOnPathIsCurrent({ wanted: cli, onPath })) throw new Error(short);
+        // …and THIS install is not necessarily the gu the next `gu` starts (task #21): another copy
+        // earlier on PATH (e.g. a Homebrew Cellar bin dir from ~/.zshrc) keeps running the old one.
+        const mismatch = pathGuMismatch({ wanted: cli, installedDir: DIR, onPath, env: process.env });
+        if (mismatch) throw new Error(mismatch);
       });
+      saveUpdateAttempt(updateAttemptRecord({ version: cli, running: REPL_VERSION, ok: true }));
       // NOT "updated" — the files changed, THIS process did not. Claiming otherwise is the one
       // way this feature could lie to someone.
       console.log(accent(` ✓ gu ${cli} installed`) +
@@ -2552,7 +2585,13 @@ async function runUpdate() {
       availableUpdates = { ...availableUpdates, cli: "", any: Boolean(availableUpdates.api) };
     }
   } catch (e) {
-    console.log(red(`   update failed: ${e?.message ?? e}\n`));
+    if (pick === "cli") {
+      saveUpdateAttempt(updateAttemptRecord({ version: cli, running: REPL_VERSION, ok: false, reason: e?.message ?? String(e) }));
+      console.log(red(`   ✗ Update NOT successful — gu is still ${REPL_VERSION}`));
+      console.log(red(`     ${e?.message ?? e}\n`));
+    } else {
+      console.log(red(`   update failed: ${e?.message ?? e}\n`));
+    }
   }
   paintBar();
 }
@@ -2644,7 +2683,9 @@ const tokenLineText = () => {
     dim(" · ") +
     accent(`↓ out ${fmtTokens(lastTurnOutputTokens)}`)
   );
-  const total = dim(" · ") + dim("total ") + accent(`↓ ${fmtTokens(Math.max(globalOutputTokens, lastTurnTotalOutput))}`);
+  // #112: the lifetime "total ↓ N" is no longer shown on the bar (the user's call) — hidden, not
+  // deleted: globalOutputTokens is still tracked and still feeds /tokens reset.
+  const total = "";
   // #323: what the last turn's prompt cost, LAST on the row after a "|" — "~" when the cached share
   // was assumed; "no price" when the model has none (never a misleading "| $0"). It survives a
   // narrow window: "total ↓" is dropped before it is (tokenRowWithPrice).
@@ -7829,6 +7870,13 @@ async function applyTransferDoc(value, opts = {}) {
  * bar and /model kept showing the old coder), and the "no embed model" / "no agent model"
  * warnings. /model already does this after a change; applying a preset must too.
  */
+function seedDefaultCoder(p) {
+  // The ONE place the account-default coder fields are read (startup + after a preset apply).
+  // Anything that wants THIS folder's coder uses sessionCodingModel / activeCoderName() instead.
+  if (p?.codingModelId) defaultCodingModel = p.codingModelId;
+  if (p?.codingBaseURL) defaultCodingUrl = p.codingBaseURL;
+}
+
 async function refreshAfterPresetApply(value, codingDefault, result) {
   try {
     // The preset's coder IS the account default now — a folder pick would shadow it.
@@ -7843,9 +7891,9 @@ async function refreshAfterPresetApply(value, codingDefault, result) {
     // What the API now answers with is authoritative — read it back rather than assume.
     const probe = await fetchAgentPayload([{ role: "user", content: "ping" }]).catch(() => null);
     const p = probe?.payload ?? {};
-    if (p.codingModelId) defaultCodingModel = p.codingModelId;
-    if (p.codingBaseURL) defaultCodingUrl = p.codingBaseURL;
-    activeCoderWhere = whereOfActiveCoder(probe?.codingChoices ?? p.codingChoices, sessionCodingModel);
+    seedDefaultCoder(p);
+    // codingChoices lives on the envelope, never inside payload.
+    activeCoderWhere = whereOfActiveCoder(probe?.codingChoices, sessionCodingModel);
     if (value?.agentModel?.name || p.agentMissing === false) agentMissing = false;
     else if (p.agentMissing === true) agentMissing = true;
     if (probe?.payload) noModelAtAll = nothingToAnswerWith(p);
@@ -12876,8 +12924,7 @@ async function main() {
     // Remember the default coder id for the token footer's global-total label, and the
     // default backend's coding URL so the GLOBAL output-token total is keyed to it (task
     // #125) when no /model override is active.
-    if (p.codingModelId) defaultCodingModel = p.codingModelId;
-    if (p.codingBaseURL) defaultCodingUrl = p.codingBaseURL;
+    seedDefaultCoder(p);
     // Task #14: seed the bottom warnings from the AUTHORITATIVE payload. `agentMissing` is set
     // by the API when no agent model is configured (and it fell back to the coding model);
     // `ragEnabled` false means no embed model was chosen. Boot may have already set these from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.806",
+  "version": "1.0.807",
   "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",
@@ -115,6 +115,7 @@
     "add-server.mjs",
     "powershell-alias.mjs",
     "install-path.mjs",
+    "update-verify.mjs",
     "skills.mjs",
     "skill-source.mjs",
     "step-group.mjs",

package/update-verify.mjs

@@ -0,0 +1,194 @@
+/**
+ * Did the gu update REALLY take effect? (task #21)
+ *
+ * Seen on a real Mac: `~/.zshrc` put /opt/homebrew/Cellar/node/<v>/bin first on PATH, so `gu`
+ * started the Cellar copy (1.0.797) while `npm install -g` wrote /opt/homebrew/lib/node_modules
+ * (1.0.806). The updater said "✓ installed", the next `gu` was still 1.0.797, and it asked again —
+ * forever. npm exiting 0 and the files in ONE prefix being new proves nothing about the gu the
+ * user's shell will start. So:
+ *   · firstGuOnPath   — the gu the next `gu` will actually run (first on PATH) and its version;
+ *   · pathGuMismatch  — the sentence to show when that gu is older than what we installed;
+ *   · attempt memory  — remember the last update, so the next start reports WHY instead of
+ *                       offering the same update again as if nothing had happened.
+ *
+ * ALL THREE PLATFORMS (follow-up: "make sure this won't happen on Ubuntu or Windows 11"):
+ *   · macOS / Ubuntu: `<prefix>/bin/gu` is a SYMLINK to `<prefix>/lib/node_modules/@tiens.nguyen/
+ *     gu-cli/gu-repl.mjs` — apt/NodeSource node (prefix /usr), nvm (~/.nvm/versions/node/<v>),
+ *     Homebrew, a user prefix (~/.npm-global). Realpath tells us the package and its prefix.
+ *     Ubuntu's usual failure is EACCES on the root-owned /usr prefix → the fix needs `sudo`.
+ *   · Windows: PATH is `;`-separated, case-insensitive, and the shims (gu.cmd / gu.ps1 / gu) are
+ *     small scripts, NOT symlinks — they sit directly in the prefix next to
+ *     `<prefix>\node_modules\@tiens.nguyen\gu-cli`. Its usual failure is EPERM/EBUSY because the
+ *     running gu's files are locked → the fix is "close every gu window first".
+ * Pure (fs + platform injected) so every branch is testable on any OS.
+ */
+import { existsSync, realpathSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+const PKG = "@tiens.nguyen/gu-cli";
+const pathFor = (platform) => (platform === "win32" ? path.win32 : path.posix);
+
+/** Numeric compare of x.y.z (pre-release suffix ignored). <0, 0, >0; NaN parts → 0. */
+export function compareVersions(a = "", b = "") {
+  const p = (v) => String(v ?? "").split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
+  const x = p(a), y = p(b);
+  for (let i = 0; i < Math.max(x.length, y.length); i++) {
+    const d = (x[i] ?? 0) - (y[i] ?? 0);
+    if (d) return d;
+  }
+  return 0;
+}
+
+const realFs = {
+  exists: (p) => existsSync(p),
+  realpath: (p) => realpathSync(p),
+  readVersion: (dir) => {
+    try { return JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8")).version ?? ""; } catch { return ""; }
+  },
+};
+
+/** Windows shim names, in the order cmd.exe / PowerShell would pick them. */
+const WIN_SHIMS = ["gu.exe", "gu.cmd", "gu.bat", "gu.ps1", "gu"];
+
+/**
+ * The first `gu` on PATH → { bin, dir, version, prefix } or null.
+ * `dir` is the package folder the bin resolves to; `prefix` the npm prefix owning it ("" if none).
+ */
+export function firstGuOnPath({ PATH = "", platform = process.platform, fs = realFs } = {}) {
+  const P = pathFor(platform);
+  const win = platform === "win32";
+  const dirs = String(PATH).split(win ? ";" : ":").map((d) => d.trim().replace(/^"(.*)"$/, "$1")).filter(Boolean);
+  for (const d of dirs) {
+    if (win) {
+      const shim = WIN_SHIMS.map((n) => P.join(d, n)).find((b) => fs.exists(b));
+      if (!shim) continue;
+      // npm's Windows layout: shims in <prefix>, package in <prefix>\node_modules\@tiens.nguyen\gu-cli.
+      const dir = P.join(d, "node_modules", "@tiens.nguyen", "gu-cli");
+      const version = fs.readVersion(dir);
+      // nvm-windows: d is a JUNCTION (C:\nvm4w\nodejs → %LOCALAPPDATA%\nvm\v22.x). The running gu's
+      // own folder is the resolved target, so keep both spellings to compare against.
+      let realDir = dir;
+      try { realDir = (version && fs.realpath(dir)) || dir; } catch { /* keep dir */ }
+      return { bin: shim, dir, realDir, version, prefix: version ? d : "" };
+    }
+    const bin = P.join(d, "gu");
+    if (!fs.exists(bin)) continue;
+    let real;
+    try { real = fs.realpath(bin); } catch { continue; }
+    const dir = P.dirname(real);
+    const m = /^(.*)\/lib\/node_modules\/@tiens\.nguyen\/gu-cli$/.exec(dir);
+    return { bin, dir, realDir: dir, version: fs.readVersion(dir), prefix: m ? (m[1] || "/") : "" };
+  }
+  return null;
+}
+
+/** EACCES / EPERM: the prefix is not writable by this user (root-owned /usr on Ubuntu). */
+const isPermission = (reason) => /\b(EACCES|permission denied)\b/i.test(String(reason ?? ""));
+/** EPERM / EBUSY on Windows: the running gu's files are locked. */
+const isLocked = (reason) => /\b(EPERM|EBUSY|operation not permitted|resource busy)\b/i.test(String(reason ?? ""));
+
+/**
+ * The command that puts the latest gu into the prefix owning the gu on PATH.
+ * `reason` (the last npm failure) picks the platform's fix: `sudo` for EACCES on Linux/macOS when
+ * the prefix is outside the user's home (never for nvm / ~/.npm-global — sudo there makes it worse).
+ */
+export function fixCommandFor(onPath, { platform = process.platform, reason = "", home = "" } = {}) {
+  const win = platform === "win32";
+  const base = `npm install -g ${PKG}@latest`;
+  const bad = win ? /["%`\n]/ : /["$`\\\n]/;
+  const cmd = onPath?.prefix && !bad.test(onPath.prefix) ? `${base} --prefix "${onPath.prefix}"` : base;
+  if (!win && isPermission(reason)) {
+    const inHome = home && onPath?.prefix && (onPath.prefix === home || onPath.prefix.startsWith(home + "/"));
+    if (!inHome) return `sudo ${cmd}`;
+  }
+  return cmd;
+}
+
+/**
+ * Is this gu from nvm-windows? Its PATH folder is %NVM_SYMLINK% (C:\nvm4w\nodejs by default), a
+ * junction into %NVM_HOME%\v<version>. Two things differ from a normal install: every Node version
+ * has its OWN global packages (gu included), and `nvm use` re-points that junction for EVERY open
+ * terminal at once — so switching Node makes a different (or missing) gu start next time.
+ */
+export function isNvmWindows(onPath, env = {}) {
+  if (!onPath) return false;
+  const norm = (s) => String(s ?? "").toLowerCase().replace(/\//g, "\\").replace(/\\+$/, "");
+  const s = `${norm(onPath.bin)}\n${norm(onPath.realDir)}`;
+  const link = norm(env.NVM_SYMLINK), home = norm(env.NVM_HOME);
+  return Boolean((link && s.includes(link + "\\")) || (home && s.includes(home + "\\")) ||
+                 /\\nvm4w\\|\\nvm\\v\d/.test(s));
+}
+
+const NVM_NOTE = "nvm-windows keeps a separate gu for each Node version, and `nvm use` switches EVERY terminal — " +
+  "after switching Node, install gu again for that version.";
+
+/** What to do after running the fix command, per platform. */
+export function fixFollowUp({ platform = process.platform, reason = "", nvm = false } = {}) {
+  if (platform === "win32") {
+    const base = isLocked(reason) || !reason
+      ? "Close EVERY gu window first (Windows can't replace files in use), run that in a new terminal, then start gu again."
+      : "Run that in a new terminal (close gu first), then start gu again.";
+    return nvm ? `${base} ${NVM_NOTE}` : base;
+  }
+  return "Run that in a terminal, then start gu again.";
+}
+
+const sameDir = (a, b, platform) =>
+  platform === "win32" ? String(a).toLowerCase().replace(/[\\/]+$/, "") === String(b).toLowerCase().replace(/[\\/]+$/, "")
+                       : a === b;
+
+/**
+ * After an install into `installedDir`: will the next `gu` start `wanted` (or newer)?
+ * → null when yes (or unknowable), otherwise the reason + the exact fix.
+ */
+/** Will the next `gu` start `wanted` or newer? (What an update is really for.) */
+export function guOnPathIsCurrent({ wanted = "", onPath = null } = {}) {
+  return Boolean(wanted && onPath?.version && compareVersions(onPath.version, wanted) >= 0);
+}
+
+export function pathGuMismatch({ wanted = "", installedDir = "", onPath = null, platform = process.platform, env = {} } = {}) {
+  if (!wanted || !onPath || !onPath.version) return null;
+  if (compareVersions(onPath.version, wanted) >= 0) return null;
+  const elsewhere = installedDir && !sameDir(installedDir, onPath.dir, platform) &&
+                    !sameDir(installedDir, onPath.realDir ?? onPath.dir, platform);
+  const where = elsewhere ? `installed to ${installedDir}, but ` : "";
+  const profile = platform !== "win32"
+    ? "remove the older folder from PATH in your shell profile"
+    : isNvmWindows(onPath, env)
+      ? `run \`nvm use\` for the Node version you updated gu in. ${NVM_NOTE}`
+      : "remove the older folder from Path in Settings › System › About › Advanced system settings › Environment Variables";
+  return `${where}the gu on your PATH is ${onPath.bin} (v${onPath.version}) — the next \`gu\` would still be ` +
+    `v${onPath.version}. Fix: ${fixCommandFor(onPath, { platform })}  (or ${profile})`;
+}
+
+/** The record saved after an update attempt. */
+export function updateAttemptRecord({ version = "", running = "", ok = false, reason = "", at = Date.now() } = {}) {
+  return { version, running, ok: Boolean(ok), reason: String(reason ?? ""), at };
+}
+
+/**
+ * At startup, an update `cli` is available while `running` is old. If we ALREADY tried exactly
+ * this update from exactly this version, offering it again is the loop the user hit — say what
+ * happened instead. → notice lines like updateNotice ([] = nothing remembered, show the normal one).
+ */
+export function repeatUpdateNotice({ last = null, cli = "", running = "", onPath = null,
+                                     platform = process.platform, home = "", env = {} } = {}) {
+  if (!last || !cli || !running) return [];
+  if (last.version !== cli || last.running !== running) return [];
+  if (compareVersions(running, cli) >= 0) return [];
+  const head = last.ok
+    ? `gu ${cli} was installed, but this gu is still ${running} — the update did NOT take effect`
+    : `gu ${cli} update did NOT succeed last time`;
+  const why = last.ok
+    ? (onPath && onPath.version && compareVersions(onPath.version, cli) < 0
+        ? `the gu on your PATH is ${onPath.bin} (v${onPath.version}), a different copy from the one updated`
+        : "a different gu copy than the one updated is starting")
+    : (last.reason || "unknown error");
+  const reason = last.ok ? "" : last.reason;
+  return [
+    { kind: "head", text: head },
+    { kind: "note", text: `Reason: ${why}` },
+    { kind: "cmd", text: fixCommandFor(onPath, { platform, reason, home }) },
+    { kind: "note", text: fixFollowUp({ platform, reason, nvm: platform === "win32" && isNvmWindows(onPath, env) }) },
+  ];
+}