@tiens.nguyen/gu-cli 1.0.862 → 1.0.864

package/README.md

@@ -9,9 +9,13 @@ gu            # open the REPL in the current folder
 ```
 
 The package installs three commands: `gu` (the terminal REPL), `gu-cli` and `gu-local-worker`
-(the same worker CLI). Requires Node.js 18 or newer. The install runs `fix-path` for you; if
-npm's global bin folder is not on your PATH afterwards, run `npx @tiens.nguyen/gu-cli fix-path`
-(works even when `gu-cli` itself is not found, e.g. when npm skipped the install script).
+(the same worker CLI). Requires Node.js 18 or newer. The install tries to put npm's global bin
+folder on your PATH, but npm 11 skips install scripts it was not told to allow (it prints
+"install scripts not yet covered by allowScripts"). If `gu` is "command not found" afterwards, run
+`npx @tiens.nguyen/gu-cli fix-path` (works even when `gu-cli` itself is not found). `gu-cli fix-path`
+also finds what an old install left behind - broken `gu` links, a second gu from another npm, a
+shell-profile PATH line pinned to a versioned Homebrew folder - and asks before fixing each
+(`--check` only reports). `gu support` sends the support team a request with gu's logs attached.
 On Windows, PowerShell's built-in `gu` alias (Get-Unique) shadows this CLI — run
 `gu-cli fix-powershell` to drop it.
 

package/cli-token.mjs

@@ -238,6 +238,19 @@ export function shortToken(token) {
   return t.length <= 24 ? t : `${t.slice(0, 16)}…${t.slice(-6)}`;
 }
 
+/**
+ * The ONE short yellow line for "there is no token to offer" (#222). The caller's `why` (a licence
+ * rule's full sentence) is cut to its first sentence; with none, what the trial lookup said.
+ */
+export function noTokenShort({ why = "", trial = {}, dev = null } = {}) {
+  const first = (t) => String(t).trim().split(/(?<=[.!?])\s+/)[0].trim();
+  if (why) return first(why);
+  if (trial.why === "used" && trial.endedAt) return `Free trial ended ${shortDate(trial.endedAt)} — a gu token is needed.`;
+  if (trial.why === "unreachable") return "Can't reach the gu service right now.";
+  if (/^http-\d+$/.test(String(trial.why ?? "")) || trial.why === "bad-response") return "The gu service gave no free trial right now.";
+  return "This computer needs a gu token to start the agent.";
+}
+
 /**
  * THE TOKEN QUESTION, WITH THE TRIAL AS ITS DEFAULT (#305/#76, placed by #314).
  *
@@ -275,6 +288,8 @@ export async function promptForToken({
   why = "",
   // #209: the block is the computer LIMIT (not a missing/expired plan) — a Pro token is not the way out.
   overLimit = false,
+  // #219: with overLimit, the ONE short yellow line (the long `why` is shown only on request).
+  short = "",
   // #315: a saved token must also be ENTITLED on this computer. `accept(token)` → { ok } | { ok:false, reason }
   // — the REPL renews it from this computer (to learn its free time) and runs the licence rule.
   accept = null,
@@ -283,7 +298,10 @@ export async function promptForToken({
   const dev = device === undefined ? await trialDevice().catch(() => null) : device;
   const getOne = `For a free token for 1 computer, log in at ${accountUrl} and create one — or buy Pro there for more computers.`;
   let trial, trialOk, shown, hint;
+  let details = []; // #219/#222: the detail, printed only when the person asks ("?" or an empty Enter)
+  let compactShort = ""; // #222: the ONE yellow line when there is no default token to offer
   const offer = async () => {
+    details = [];
     trial = dev ? await claim({ hostedBase, device: dev }) : { ok: false, why: "no-device" };
     trialOk = Boolean(trial.ok && verifyCliToken(trial.token, publicKeyB64).ok);
     shown = trialOk ? shortToken(trial.token) : "";
@@ -305,12 +323,16 @@ export async function promptForToken({
         ];
     if (why) {
       const pricingUrl = `${String(site).replace(/^https?:\/\//, "")}/pricing`;
+      if (overLimit) {
+        details = [
+          why,
+          `Remove the computers you no longer use at ${accountUrl}, then start gu again — or Pro allows more computers: ${pricingUrl}`,
+          `Think this is wrong? ${SUPPORT_EMAIL}`,
+          required ? "/exit or Ctrl+C quits gu." : "Enter to skip for now.",
+        ];
+      }
       hint = overLimit
-        ? [
-            `Remove the computers you no longer use at ${accountUrl}, then start gu again — or Pro allows more computers: ${pricingUrl}`,
-            `Think this is wrong? ${SUPPORT_EMAIL}`,
-            required ? "/exit or Ctrl+C quits gu." : "Enter to skip for now.",
-          ]
+        ? [] // #219: one yellow line only — the rest is behind "?"
         : [
         // The reason (the title) already says what happened; a "trial ended on <date>" line beside it is
         // noise — and wrong for a computer that went straight to a free account and never had one.
@@ -319,9 +341,18 @@ export async function promptForToken({
         ...(trialOk ? [] : ["Paste a Pro token here, then Enter."]),
           ];
     }
+    // #222: NO DEFAULT TOKEN to offer (trial ended, nothing yet, service unreachable): the same
+    // advice used to be said three times — the banner, a title, and 3-4 yellow lines under the
+    // prompt. Now ONE yellow line; everything else is behind "?" (or an empty Enter).
+    compactShort = "";
+    if (!trialOk && !overLimit) {
+      compactShort = noTokenShort({ why, trial, dev });
+      details = [...(why ? [why] : []), ...hint.filter((l) => !why || l !== why)];
+      hint = [];
+    }
   };
   await offer();
-  log(why || "This computer needs a gu token before the agent can start — one time only.", "title");
+  log(overLimit && why ? `${short || why} Type ? for details.` : compactShort ? `${compactShort} Type ? for details.` : why || "This computer needs a gu token before the agent can start — one time only.", "title");
   const entitled = async (token) => {
     if (!accept) return true;
     const r = await accept(token).catch(() => ({ ok: true })); // unknown = soft, like every other check here
@@ -334,6 +365,14 @@ export async function promptForToken({
     // A way OUT of a required question (task #17): "/exit" is not a token, and treating it as one
     // ("That token was not saved…" and the same question again) left no way to leave gu at all.
     if (/^\/(exit|quit)$/i.test(typed)) return { ok: false, why: "quit" };
+    // An empty Enter with no default is also "try again": the service may be back, the trial may exist now (#222).
+    if (!typed && required && !trialOk && !overLimit) await offer();
+    // #219: the over-limit detail, on request only — "?" or an empty Enter, then the same question again.
+    if (details.length && (typed === "?" || (!typed && required))) {
+      for (const l of details) log(l, "info");
+      if (!required) round--; // "?" does not use up one of the two tries
+      continue;
+    }
     if (!typed) {
       if (!required) return { ok: false, why: "skipped" };
       if (!trialOk) await offer(); // no default: maybe the service is back, or the trial exists now
@@ -754,6 +793,8 @@ export function enforcementDecision({ token, publicKeyB64, now = new Date(), sit
       enforced: true,
       allowed: false,
       reason: "over-limit",
+      // #219: the ONE short line shown first (the long `why` is the detail, shown on request).
+      short: `${planName(p.plan)} allows ${computers(p.deviceLimit)}; this account is on ${p.activeDevices}.`,
       why:
         `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}.`,

package/client-expert-run.mjs

@@ -324,15 +324,18 @@ export async function ensureNativeMongoMac(ask, mongo, { log = (l) => console.lo
   // a yes to something unseen. These are exactly the lines a yes runs.
   log(dim(installing ? "\n  It is not installed here. This installs it (Homebrew):\n" : "\n  It is installed but not running. This starts it:\n"));
   for (const s of steps) log(`    brew ${s.join(" ")}`);
+  // How long and how big, BEFORE the yes (#221): the install took minutes and pulled a second Node
+  // and a dozen libraries, with nothing said about it up front.
+  if (installing) log(dim("\n  This downloads a few hundred MB and takes a few minutes — Homebrew may also\n  add or update some of its own libraries (a Node, OpenSSL…) that MongoDB's tools need."));
   log("");
   const yes = await readYesNo(ask, installing ? "  Install MongoDB now? [Y/n]: " : "  Start MongoDB now? [Y/n]: ", true, log);
   if (!yes) {
     log(dim(`\n  Not ${installing ? "installed" : "started"} — run the commands above yourself.`));
     return { ok: false, explained: true };
   }
-  log("\n  " + bold(installing ? "Installing MongoDB Community" : "Starting MongoDB") + dim("   Homebrew, a minute or two"));
+  log("\n  " + bold(installing ? "Installing MongoDB Community" : "Starting MongoDB") + dim(installing ? "   Homebrew, a few minutes" : "   Homebrew"));
   const done = await mn.runBrewSteps(brew, steps, {
-    onLine: (l) => l.length < 200 && log(dim("    " + l)),
+    onLine: (l) => l.length < 200 && mn.brewLineWorthShowing(l) && log(dim("    " + l)),
   });
   if (!done) {
     log("\n  " + red("✗ ") + "Homebrew did not finish — the lines above say why.");
@@ -771,6 +774,19 @@ export async function readYesNo(ask, prompt, defaultYes, say = (l) => console.lo
   return defaultYes;
 }
 
+/**
+ * Does setup still need to ASK whose MongoDB this is? (#221) → "custom" | "default" | "forced" | "ask".
+ * A resumed run reuses what an earlier run was told: custom credentials (kept as a uri), or a yes
+ * to the default empty pair (kept as mongoCredsConfirmed — it used to be forgotten, so an
+ * interrupted setup asked the same question again). A uri forced through the environment is deliberate.
+ */
+export function mongoCredsDecision(state = {}, env = process.env) {
+  if (typeof state.localMongoUri === "string" && state.localMongoUri) return "custom";
+  if (state.mongoCredsConfirmed === true) return "default";
+  if (env.GONEXT_LOCAL_MONGO_URI) return "forced";
+  return "ask";
+}
+
 export async function askMongoCredentials(ask, askSecret = null) {
   const { host, port } = mongoHostPort(LOCAL_MONGO_URI);
   console.log(dim(`  MongoDB is answering at ${host}:${port}.`));
@@ -1167,12 +1183,13 @@ export async function runClientExpertSetup({
   // A uri already in state — a resumed run — is reused silently, like every other answered
   // question, and a URI forced via GONEXT_LOCAL_MONGO_URI is taken as deliberate.
   let mongoUri = LOCAL_MONGO_URI;
-  if (typeof state.localMongoUri === "string" && state.localMongoUri) {
+  const credsDecision = mongoCredsDecision(state);
+  if (credsDecision === "custom") {
     mongoUri = state.localMongoUri;
     if (mongoUri !== LOCAL_MONGO_URI) {
       console.log(dim("  using the MongoDB credentials from the previous run"));
     }
-  } else if (!process.env.GONEXT_LOCAL_MONGO_URI) {
+  } else if (credsDecision === "ask") {
     const credsChoice = await askMongoCredentials(ask, askSecret);
     if (credsChoice.exit) {
       console.log("\n  " + dim("No working MongoDB credentials — setup stops here."));
@@ -1184,9 +1201,7 @@ export async function runClientExpertSetup({
       return { complete: false, stoppedAt: "mongo" };
     }
     mongoUri = credsChoice.uri;
-    if (credsChoice.custom) {
-      state = { ...state, localMongoUri: mongoUri };
-    }
+    state = credsChoice.custom ? { ...state, localMongoUri: mongoUri } : { ...state, mongoCredsConfirmed: true };
   }
   state = recordStep(state, "mongo", "done");
   await saveState(state);

package/env-check.mjs

@@ -0,0 +1,228 @@
+/**
+ * What is wrong with gu's footprint on THIS machine's PATH (#221) — found on a Mac that was
+ * "uninstalled" and reinstalled:
+ *
+ *   · a second gu from ANOTHER npm (Homebrew's, beside nvm's) survived the uninstall and kept
+ *     answering `which gu` — two copies, two versions, no hint which one runs;
+ *   · `gu`/`gu-cli` links whose package was removed (broken) are left in a bin folder;
+ *   · the shell profile's PATH block was written with a VERSIONED Homebrew path
+ *     (…/Cellar/node/26.10.0_1/bin), which stops existing at the next `brew upgrade node`.
+ *
+ * Pure of prompts: this file looks and fixes ONE thing at a time; `gu-cli fix-path` asks. Everything
+ * takes `pathDirs` / `home`, so the tests run on a temp folder.
+ */
+import { existsSync, lstatSync, readFileSync, readlinkSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+
+export const GU_BIN_NAMES = ["gu", "gu-cli"];
+export const RC_BEGIN = "# >>> gu-cli PATH >>>";
+export const RC_END = "# <<< gu-cli PATH <<<";
+const PACKAGE_MARK = "@tiens.nguyen/gu-cli";
+
+/**
+ * A Homebrew Cellar path names ONE version of node and disappears when it is upgraded; the same
+ * folder is reachable as <brew prefix>/bin for good. Anything else is returned as it was.
+ *   /opt/homebrew/Cellar/node/26.10.0_1/bin → /opt/homebrew/bin
+ */
+export function stableBinDir(binDir) {
+  const m = /^(.*)\/Cellar\/[^/]+\/[^/]+\/bin\/?$/.exec(String(binDir ?? ""));
+  return m ? join(m[1] || "/", "bin") : String(binDir ?? "");
+}
+
+const isGuTarget = (t) => String(t).includes(PACKAGE_MARK) || /gu-cli[\\/](gu-repl|gu-cli)\.mjs$/.test(String(t));
+
+/**
+ * Every gu / gu-cli launcher in the PATH folders (POSIX symlinks, what npm makes).
+ * → [{ dir, name, path, target, broken, pkgDir }]  (`pkgDir` = the package folder it points into, when it works)
+ */
+export function scanGuLinks({ pathDirs = [] } = {}) {
+  const out = [];
+  const seen = new Set();
+  for (const dir of pathDirs) {
+    if (!dir || seen.has(dir)) continue;
+    seen.add(dir);
+    for (const name of GU_BIN_NAMES) {
+      const path = join(dir, name);
+      let st;
+      try {
+        st = lstatSync(path);
+      } catch {
+        continue;
+      }
+      if (!st.isSymbolicLink()) continue;
+      let target = "";
+      try {
+        target = readlinkSync(path);
+      } catch {
+        continue;
+      }
+      const abs = isAbsolute(target) ? target : resolve(dir, target);
+      if (!isGuTarget(abs)) continue; // somebody else's `gu` is none of our business
+      let real = "";
+      try {
+        real = realpathSync(path);
+      } catch {
+        /* broken */
+      }
+      out.push({ dir, name, path, target: abs, broken: !real, pkgDir: real ? dirname(real) : "" });
+    }
+  }
+  return out;
+}
+
+/** The npm prefix a package folder belongs to: <prefix>/lib/node_modules/@tiens.nguyen/gu-cli → <prefix>. */
+export function prefixOfPackageDir(pkgDir) {
+  const m = /^(.*)\/lib\/node_modules\/@tiens\.nguyen\/gu-cli$/.exec(String(pkgDir ?? ""));
+  return m ? m[1] || "/" : "";
+}
+
+/**
+ * Working gu installs other than `here` (the one running this).
+ * → [{ pkgDir, prefix, links: [path] }]
+ */
+export function otherGuCopies(links, here = "") {
+  const mine = here ? safeReal(here) : "";
+  const byPkg = new Map();
+  for (const l of links) {
+    if (l.broken || !l.pkgDir) continue;
+    if (mine && safeReal(l.pkgDir) === mine) continue;
+    const e = byPkg.get(l.pkgDir) ?? { pkgDir: l.pkgDir, prefix: prefixOfPackageDir(l.pkgDir), links: [] };
+    e.links.push(l.path);
+    byPkg.set(l.pkgDir, e);
+  }
+  return [...byPkg.values()];
+}
+
+function safeReal(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return resolve(p);
+  }
+}
+
+/**
+ * The gu block in a shell profile, read. → { has, binDir, versioned, missing }
+ *   versioned = the path names a Homebrew Cellar version (breaks on upgrade)
+ *   missing   = the folder it adds is not there any more
+ */
+export function readRcBlock(text, { exists = existsSync } = {}) {
+  const s = String(text ?? "");
+  const a = s.indexOf(RC_BEGIN);
+  const b = s.indexOf(RC_END);
+  if (a < 0 || b < a) return { has: false, binDir: "", versioned: false, missing: false };
+  const m = /export PATH="([^"$]+?):\$PATH"/.exec(s.slice(a, b));
+  const binDir = m ? m[1] : "";
+  return { has: true, binDir, versioned: Boolean(binDir) && stableBinDir(binDir) !== binDir, missing: Boolean(binDir) && !exists(binDir) };
+}
+
+/** The block, rewritten to add `binDir` instead (everything outside the markers untouched). */
+export function rewriteRcBlock(text, binDir) {
+  const s = String(text ?? "");
+  const a = s.indexOf(RC_BEGIN);
+  const b = s.indexOf(RC_END);
+  if (a < 0 || b < a) return s;
+  const end = b + RC_END.length;
+  const block = `${RC_BEGIN}\n# npm's global bin dir was not on PATH; added by @tiens.nguyen/gu-cli.\nexport PATH="${binDir}:$PATH"\n${RC_END}`;
+  return s.slice(0, a) + block + s.slice(end);
+}
+
+export const RC_FILES = [".zshrc", ".bashrc", ".bash_profile", ".profile"];
+
+/**
+ * Everything found, as findings the caller can print and (when `fix`) apply:
+ *   { id, text, fix?: { kind: "remove-link" | "rewrite-rc" | "uninstall-copy", … , label } }
+ */
+export function checkEnvironment({ pathDirs = [], home = "", here = "", exists = existsSync } = {}) {
+  const findings = [];
+  const links = scanGuLinks({ pathDirs });
+  for (const l of links.filter((x) => x.broken)) {
+    findings.push({
+      id: "broken-link",
+      text: `${l.path} points to a gu that is no longer installed.`,
+      fix: { kind: "remove-link", path: l.path, label: `remove ${l.path}` },
+    });
+  }
+  for (const c of otherGuCopies(links, here)) {
+    let version = "?";
+    try {
+      version = JSON.parse(readFileSync(join(c.pkgDir, "package.json"), "utf8")).version;
+    } catch {
+      /* shown as ? */
+    }
+    findings.push({
+      id: "second-copy",
+      text: `A second gu (${version}) is installed at ${c.pkgDir} — which one runs depends on PATH order.`,
+      fix: c.prefix ? { kind: "uninstall-copy", prefix: c.prefix, label: `npm uninstall -g ${PACKAGE_MARK} --prefix ${c.prefix}` } : undefined,
+    });
+  }
+  for (const f of RC_FILES) {
+    const file = join(home, f);
+    let text = "";
+    try {
+      text = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const rc = readRcBlock(text, { exists });
+    if (!rc.has) continue;
+    if (rc.versioned) {
+      const stable = stableBinDir(rc.binDir);
+      findings.push({
+        id: "versioned-path",
+        text: `${file} adds ${rc.binDir}, a Homebrew version folder that goes away on \`brew upgrade\`${rc.missing ? " (it already has — gu is not on PATH from there)" : ""}.`,
+        fix: { kind: "rewrite-rc", file, binDir: stable, label: `change it to ${stable}` },
+      });
+    } else if (rc.missing) {
+      findings.push({ id: "missing-path", text: `${file} adds ${rc.binDir}, which does not exist.` });
+    }
+  }
+  return findings;
+}
+
+/** Apply one finding's fix. → { ok, why } — never throws. */
+export function applyFix(fix, { run = null } = {}) {
+  try {
+    if (fix.kind === "remove-link") {
+      rmSync(fix.path, { force: true });
+      return { ok: !lstatOk(fix.path), why: "" };
+    }
+    if (fix.kind === "rewrite-rc") {
+      const text = readFileSync(fix.file, "utf8");
+      writeFileSync(fix.file, rewriteRcBlock(text, fix.binDir));
+      return { ok: true, why: "" };
+    }
+    if (fix.kind === "uninstall-copy") {
+      if (!run) return { ok: false, why: "no runner" };
+      const r = run("npm", ["uninstall", "-g", PACKAGE_MARK, "--prefix", fix.prefix]);
+      return { ok: r.status === 0, why: r.status === 0 ? "" : String(r.stderr || r.error || `exit ${r.status}`).trim().slice(0, 200) };
+    }
+  } catch (e) {
+    return { ok: false, why: e?.message || String(e) };
+  }
+  return { ok: false, why: "unknown fix" };
+}
+
+function lstatOk(p) {
+  try {
+    lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * One line for gu's start when gu runs but its own npm folder is NOT on PATH (#221). npm 11 no
+ * longer runs install scripts it was not told to allow, so the postinstall that adds the folder
+ * may never have run: gu was started by its full path (or npx) and the next terminal will say
+ * "gu: command not found". The line gives the command, by full path since `gu-cli` is not found either.
+ * → "" when there is nothing to say (on PATH, not a global install, Windows, or CI).
+ */
+export function pathNoticeLine({ prefix = "", pathEnv = "", platform = process.platform, ci = false } = {}) {
+  if (!prefix || platform === "win32" || ci) return "";
+  const binDir = join(prefix, "bin");
+  const dirs = String(pathEnv).split(":");
+  if (dirs.includes(binDir) || dirs.includes(stableBinDir(binDir))) return "";
+  return `${binDir} is not on your PATH, so a new terminal will not find \`gu\`. Fix it: ${join(binDir, "gu-cli")} fix-path`;
+}