@tiens.nguyen/gu-cli 1.0.727 → 1.0.728

package/cli-token.mjs

@@ -291,7 +291,11 @@ export function barNotice({ token, publicKeyB64, mode, now = new Date(), attempt
     if (Number.isInteger(p.activeDevices) && p.activeDevices > p.deviceLimit) {
       return {
         kind: "over-limit",
-        text: `gu is active on ${p.activeDevices} devices — ${p.plan === "pro" ? "Pro" : "Free"} covers ${p.deviceLimit}`,
+        // PLAIN WORDS (asked: "make it simple to understand"). It read "gu is active on 4 devices —
+        // Free covers 1", which leaves the reader to work out that "active" means "used gu in the
+        // last 30 days" and "covers" means "the plan allows". Kept short: the bar drops it entirely
+        // when it does not fit the terminal's width.
+        text: `${planName(p.plan)} allows ${computers(p.deviceLimit)} — you've used gu on ${p.activeDevices} this month`,
       };
     }
     const age = now.getTime() - Date.parse(p.issuedAt);
@@ -305,6 +309,11 @@ export function barNotice({ token, publicKeyB64, mode, now = new Date(), attempt
     : { kind: "stale", text: "Sign in to keep getting gu updates — run gu login" };
 }
 
+/** "Free plan" / "Pro plan" — the name a person uses. */
+const planName = (plan) => (plan === "pro" ? "Pro plan" : "Free plan");
+/** "1 computer" / "4 computers" — "computer", not "device": a device is also a phone. */
+const computers = (n) => `${n} ${n === 1 ? "computer" : "computers"}`;
+
 /** What `gu token` prints about a valid token — plain lines, no colour, for the command to style. */
 export function tokenSummary(payload, now = new Date()) {
   const lines = [];
@@ -317,7 +326,7 @@ export function tokenSummary(payload, now = new Date()) {
   }
   if (Number.isInteger(payload.activeDevices)) {
     const n = payload.activeDevices;
-    lines.push(`Active on ${n} ${n === 1 ? "device" : "devices"} in the last 30 days — ${payload.plan === "pro" ? "Pro" : "Free"} covers ${payload.deviceLimit}.`);
+    lines.push(`Used on ${computers(n)} in the last 30 days — the ${planName(payload.plan)} allows ${payload.deviceLimit}.`);
   }
   lines.push(`Issued ${shortDate(payload.issuedAt)}.`);
   return lines;
@@ -370,8 +379,8 @@ export function enforcementDecision({ token, publicKeyB64, now = new Date(), sit
       enforced: true,
       allowed: false,
       why:
-        `This account is active on ${p.activeDevices} devices and Pro covers ${p.deviceLimit}. ` +
-        `Sign out of one, or remove it at ${accountUrl}.`,
+        `This account has used gu on ${computers(p.activeDevices)} in the last 30 days, and the ` +
+        `${planName(p.plan)} allows ${p.deviceLimit}. Sign out of one, or remove it at ${accountUrl}.`,
     };
   }
   return { enforced: true, allowed: true, why: "" };

package/gu-cli.mjs

@@ -679,7 +679,6 @@ const currentApiVersion = async () => {
     // machine that was already paired, i.e. every machine that could need an upgrade, had no
     // path to one. A published API fix reached nobody.
     const run = await import("./client-expert-run.mjs");
-    const { isNewer } = await import("./version-check.mjs");
     const running = await currentVersion();
 
     // TOP UP THE SEEDED SETTINGS FIRST, AND UNCONDITIONALLY.
@@ -719,8 +718,19 @@ const currentApiVersion = async () => {
     const dir = run.apiInstallDir(manifest.version);
     const depsIn = await ce.apiDepsInstalled(dir);
     const present = (await run.probeApiInstall(manifest.version)).installed;
-    if (!isNewer(manifest.version, running) && depsIn) {
-      console.log(`\n  Already on ${running} — nothing newer published.\n`);
+    // DECIDED FROM WHAT IS RUNNING, not only what is on disk (see upgradePlan). A build already
+    // downloaded but never started used to answer "Already on 1.0.161 — nothing newer published"
+    // and leave yesterday's 1.0.153 process serving. Reported from the startup scaffold line.
+    const { upgradePlan } = await import("./version-check.mjs");
+    const liveVersion = String((await ce.probeLocalApi()).body?.version ?? "").trim();
+    const plan = upgradePlan({
+      published: manifest.version,
+      installed: running,
+      running: liveVersion,
+      ready: present && depsIn,
+    });
+    if (plan.action === "none") {
+      console.log(`\n  ${plan.say}\n`);
       process.exit(0);
     }
     // A version already on disk but unusable is a RESUME, not an upgrade — someone whose
@@ -730,12 +740,12 @@ const currentApiVersion = async () => {
     // Caught by running it: "Finishing an interrupted install of 1.0.30" on a box going
     // cleanly from 1.0.29.
     console.log(
-      present && !depsIn
+      plan.action === "install" && present && !depsIn
         ? `\n  Finishing an interrupted install of ${manifest.version}`
-        : `\n  Upgrading the API: ${running || "none"} → ${manifest.version}`
+        : `\n  ${plan.say}`
     );
     try {
-      if (!present || !depsIn) {
+      if (plan.action === "install" && (!present || !depsIn)) {
         await run.downloadApiPackage(manifest, { onProgress: (l) => console.log(`    ${l}`) });
         await ce.installApiDeps(dir, {
           onLine: (l) => l && l.length < 160 && console.log(`    ${l}`),
@@ -760,12 +770,19 @@ const currentApiVersion = async () => {
     console.log(`  Starting ${version}…`);
     await ce.startLocalApi({ apiDir: run.apiInstallDir(version) });
     const health = await ce.waitForApi({});
+    // "An API answers" is not "the NEW API answers": an old process that never stopped answers
+    // too, and this line once reported the new version while the old one kept serving.
+    const serving = String((await ce.probeLocalApi()).body?.version ?? "").trim();
+    const wrong = health.ok && Boolean(serving) && serving !== version;
     console.log(
-      health.ok
-        ? `  API is up on ${ce.LOCAL_API_BASE} (${version})\n`
-        : `  API did not come up: ${health.why}\n  Log: ${ce.API_LOG_FILE}\n`
+      !health.ok
+        ? `  API did not come up: ${health.why}\n  Log: ${ce.API_LOG_FILE}\n`
+        : wrong
+          ? `  ${serving} is still the one answering on ${ce.LOCAL_API_BASE}, not ${version}.\n` +
+            `  Stop it (gu-cli api stop), then: gu-cli api start\n`
+          : `  API is up on ${ce.LOCAL_API_BASE} (${serving || version})\n`
     );
-    process.exit(health.ok ? 0 : 1);
+    process.exit(health.ok && !wrong ? 0 : 1);
   }
 
   if (sub === "stop") {

package/package.json

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

@@ -70,3 +70,37 @@ export function updatesAvailable({ cliRunning, cliLatest, apiRunning, apiLatest
   const api = isNewer(apiLatest, apiRunning) ? String(apiLatest) : "";
   return { cli, api, any: Boolean(cli || api) };
 }
+
+/**
+ * WHAT `gu api upgrade` SHOULD DO — decided from the version that is RUNNING, not only the one on
+ * disk. Pure, so every case is tested.
+ *
+ * REPORTED: the startup line said "your local gu API is older than this gu — run gu api upgrade",
+ * and upgrading did nothing. 1.0.161 was already downloaded (by the in-app updater), so the old
+ * check compared "published 1.0.161" with "installed 1.0.161", answered "Already on 1.0.161 —
+ * nothing newer published" and exited — while a process started the day before from 1.0.153 kept
+ * serving. `gu api status` had learnt this difference long ago; `upgrade` had not.
+ *
+ *   published — the manifest's version     installed — the newest usable build on disk
+ *   running   — what /api/health reports ("" when the API is down or too old to say)
+ *   ready     — `installed` has its dependencies (a runnable install)
+ * Returns { action: "none" | "install" | "restart", say }:
+ *   install → download/finish the published build, then restart onto it;
+ *   restart → nothing to download, but the running process is not the installed build.
+ */
+export function upgradePlan({ published = "", installed = "", running = "", ready = false } = {}) {
+  const target = published && (!installed || isNewer(published, installed)) ? published : installed;
+  if (target === published && published && (!ready || installed !== published)) {
+    return { action: "install", say: `Upgrading the API: ${running || installed || "none"} → ${published}` };
+  }
+  if (running && (running === target || isNewer(running, target))) {
+    // Running something at least as new as anything here — never "restart" onto an older build.
+    return { action: "none", say: `Already on ${running} — nothing newer published.` };
+  }
+  return {
+    action: "restart",
+    say: running
+      ? `${target} is installed but ${running} is still running — restarting onto ${target}`
+      : `Starting ${target}`,
+  };
+}