@tiens.nguyen/gu-cli 1.0.797 → 1.0.798

package/gu-repl.mjs

@@ -81,6 +81,8 @@ import {
   updateRestartNote,
   describeInstallFailure,
   CLI_UPDATE_SHELL_COMMAND,
+  cliUpdatePlan,
+  installedVersionShortfall,
   isFreshPublishMiss,
   freshPublishNote,
   lazyModuleNames,
@@ -139,6 +141,7 @@ import { readHooks } from "./hooks-config.mjs";
 import { readSkillSource, sourceLabel, SKILL_SOURCE_KEY } from "./skill-source.mjs";
 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 { embedNotice, embedState } from "./embed-model-command.mjs";
 import {
   MODELFALLBACK_PREFIX, fallbackAfterTurn, fallbackHistoryLine, fallbackNotice, keyMissingNotice,
@@ -2503,8 +2506,11 @@ async function runUpdate() {
         // stderr is captured rather than discarded so the reason can be shown. npm puts the
         // useful line (EPERM, EACCES, ETARGET) there, and "it failed" without it leaves the
         // user with nothing to act on — sudo and "close gu first" are different fixes.
-        const install = () => spawnSync(CLI_UPDATE_SHELL_COMMAND,
-                                        { stdio: ["ignore", "ignore", "pipe"], shell: true, encoding: "utf8" });
+        // Install into the prefix of the gu that is RUNNING, with the npm that matches this node —
+        // not whichever npm happens to be first on PATH (that one may own a different copy).
+        const plan = cliUpdatePlan({ prefix: globalPrefixOf(DIR), execPath: process.execPath, env: process.env });
+        const install = () => spawnSync(plan.command,
+                                        { stdio: ["ignore", "ignore", "pipe"], shell: true, encoding: "utf8", env: plan.env });
         let r = install();
         // JUST PUBLISHED: the update check sees a new version the moment it lands, npm's cache and
         // CDN a few minutes later — ETARGET in between. Wait once and retry before calling it a
@@ -2516,6 +2522,11 @@ async function runUpdate() {
         }
         const failed = describeInstallFailure(r);
         if (failed) throw new Error(failed);
+        // 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);
       });
       // NOT "updated" — the files changed, THIS process did not. Claiming otherwise is the one
       // way this feature could lie to someone.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.797",
+  "version": "1.0.798",
   "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",

package/terminal-layout.mjs

@@ -1950,6 +1950,55 @@ export function describeInstallFailure({ status = 0, stderr = "", error = null }
  */
 export const CLI_UPDATE_SHELL_COMMAND = `${CLI_INSTALL_COMMAND} --prefer-online`;
 
+/**
+ * WHERE the update installs, so it lands on the gu that is RUNNING (task #16 follow-up).
+ *
+ * A bare `npm install -g` uses whichever npm is first on PATH — which, with nvm AND Homebrew (or
+ * several nvm versions) installed, is often not the npm that owns this gu. The install then
+ * "succeeds" into the OTHER prefix and the next `gu` still starts the old version. So:
+ *   · `--prefix <prefix>` — the global prefix THIS package lives under (globalPrefixOf), when
+ *     the caller found one (a checkout / npm link has none, and keeps the plain command);
+ *   · the running node's bin dir goes first on PATH, so `npm` is the one that matches this node.
+ * POSIX only: Windows resolves npm.cmd through the shell and keeps its own prefix rules.
+ * → { command, env, prefix }
+ */
+export function cliUpdatePlan({ prefix = "", execPath = "", platform = process.platform, env = {} } = {}) {
+  const posix = platform !== "win32";
+  let command = CLI_UPDATE_SHELL_COMMAND;
+  let usedPrefix = "";
+  // A prefix with shell metacharacters is not worth quoting cleverly: fall back to the plain command.
+  if (posix && prefix && !/["$`\\\n]/.test(prefix)) {
+    command += ` --prefix "${prefix}"`;
+    usedPrefix = prefix;
+  }
+  let nextEnv = { ...env };
+  if (posix && execPath && execPath.includes("/")) {
+    const bin = execPath.slice(0, execPath.lastIndexOf("/")) || "/";
+    nextEnv.PATH = env.PATH ? `${bin}:${env.PATH}` : bin;
+  }
+  return { command, env: nextEnv, prefix: usedPrefix };
+}
+
+/**
+ * npm exited 0 — but is the gu on disk really the version we meant to install?
+ * → null when fine (or unknowable), otherwise the sentence to show. Compares numeric parts, so a
+ * NEWER version published in between is fine; only an installed version OLDER than wanted fails.
+ */
+export function installedVersionShortfall(installed = "", wanted = "") {
+  const parse = (v) => String(v ?? "").split("-")[0].split(".").map((n) => parseInt(n, 10));
+  const a = parse(installed), b = parse(wanted);
+  if (!installed || !wanted || a.some(Number.isNaN) || b.some(Number.isNaN)) return null;
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const x = a[i] ?? 0, y = b[i] ?? 0;
+    if (x > y) return null;
+    if (x < y) {
+      return `npm finished, but the gu on disk is still ${installed} (wanted ${wanted}) — ` +
+        "run `npm install -g @tiens.nguyen/gu-cli@latest` in a terminal, then restart gu.";
+    }
+  }
+  return null;
+}
+
 /**
  * Did the install fail only because npm has not caught up with a JUST-published version?
  * (ETARGET / notarget — "No matching version found".) Worth one retry after a short wait, and