@tiens.nguyen/gu-cli 1.0.863 → 1.0.865

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).
  *
@@ -285,8 +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: the over-limit detail, printed only when the person asks ("?" or an empty Enter)
+  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) : "";
@@ -326,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(overLimit && why ? `${short || why} Type ? for details.` : 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
@@ -341,6 +365,8 @@ 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");

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`;
+}

package/gu-cli.mjs

@@ -139,7 +139,8 @@ Usage:
   gu-cli workspace revert [runId]          # undo an agent run's file edits from its backups
   gu-cli mongo migrate-from-docker         # macOS: move a Docker MongoDB to native (Homebrew)
   gu-cli clear [--scratch|--keep-history] [--yes]  # back to a fresh machine (asks first)
-  gu-cli support                           # write a masked health report for the support team
+  gu-cli support                           # send the support team a request with gu's logs (masked) attached
+  gu-cli support --no-send                 # only make the logs zip (~/.gonext/support/) to email yourself
   gu-cli fix-path [--check]                # put npm's global folder on PATH (Windows: check, then ask)
                                                #   (what the install does, if npm skipped it)
   gu-cli fix-powershell [--check]          # Windows: drop PowerShell's built-in \`gu\` alias
@@ -1111,14 +1112,45 @@ if (args[0] === "fix-path") {
   // #94: under `npx @tiens.nguyen/gu-cli fix-path` this file runs from npx's cache; fixPathPrefix
   // then falls back to npm's global prefix when gu is installed there.
   const prefix = fixPathPrefix({ here });
+  // #221: besides the PATH line, look for what an old or second install left behind — broken
+  // `gu` links, a second copy from another npm, a profile line pinned to a versioned Homebrew
+  // folder. Each is explained and asked about; `--check` only reports.
+  const scanEnvironment = async () => {
+    const { checkEnvironment, applyFix } = await import("./env-check.mjs");
+    const { homedir } = await import("node:os");
+    const findings = checkEnvironment({ pathDirs: (process.env.PATH || "").split(":"), home: homedir(), here });
+    if (!findings.length) return;
+    console.log("\n  Also found:");
+    const { spawnSync } = await import("node:child_process");
+    let rl = null;
+    const check = args.includes("--check") || !process.stdin.isTTY;
+    for (const f of findings) {
+      console.log(`  • ${f.text}`);
+      if (!f.fix || check) {
+        if (f.fix) console.log(`    Fix: ${f.fix.label}   (run \`gu-cli fix-path\` in a terminal to be asked)`);
+        continue;
+      }
+      rl ??= (await import("node:readline/promises")).createInterface({ input: process.stdin, output: process.stdout });
+      // Removing another gu install is the one that costs something: default No.
+      const dflt = f.fix.kind === "uninstall-copy" ? "N" : "Y";
+      const a = (await rl.question(`    ${f.fix.label}? [${dflt === "Y" ? "Y/n" : "y/N"}] `)).trim().toLowerCase();
+      if (!(a === "y" || a === "yes" || (a === "" && dflt === "Y"))) continue;
+      const r = applyFix(f.fix, { run: (cmd, a2) => spawnSync(cmd, a2, { encoding: "utf8" }) });
+      console.log(r.ok ? "    Done." : `    Could not: ${r.why}`);
+    }
+    rl?.close();
+  };
   if (!prefix) {
     console.log(`  gu is not installed globally with npm (${here}) — there is no PATH to fix.`);
     console.log("  Install it with: npm install -g @tiens.nguyen/gu-cli");
+    await scanEnvironment();
     process.exit(0);
   }
+  const { stableBinDir } = await import("./env-check.mjs");
   const binDir = join(prefix, "bin");
-  if ((process.env.PATH || "").split(":").includes(binDir)) {
+  if ((process.env.PATH || "").split(":").some((d) => d === binDir || d === stableBinDir(binDir))) {
     console.log(`  Nothing to fix — ${binDir} is already on PATH.`);
+    await scanEnvironment();
     process.exit(0);
   }
   const { spawnSync } = await import("node:child_process");
@@ -1143,9 +1175,10 @@ if (args[0] === "fix-path") {
     if (has) console.log(`  Your shell profile already adds ${binDir} to PATH — open a new terminal.`);
     else {
       console.log(`  ${binDir} is not on your PATH and was not added to a shell profile. Add this line to it:`);
-      console.log(`  export PATH="${binDir}:$PATH"`);
+      console.log(`  export PATH="${stableBinDir(binDir)}:$PATH"`);
     }
   }
+  await scanEnvironment();
   process.exit(r.status ?? 0);
 }
 
@@ -1253,13 +1286,17 @@ if (args[0] === "fix-powershell") {
 }
 
 if (args[0] === "support") {
-  // One redacted report for the support team (see support-report.mjs). Changes nothing but its own file.
-  const sr = await import("./support-report.mjs");
-  const { lines, file } = await sr.writeSupportReport({ version: WORKER_VERSION });
-  for (const l of lines) console.log(l);
-  console.log("");
-  console.log(`  Saved to ${file} — send that file (or this text) to the support team. Secrets are masked.`);
-  process.exit(0);
+  // #220: the masked logs + health report as one zip, shown, then sent to the support team with a
+  // reference back (support-command.mjs). `--report` is the old text-only report.
+  const { runSupportCommand } = await import("./support-command.mjs");
+  let rl = null;
+  const ask = async (q) => {
+    rl ??= (await import("node:readline/promises")).createInterface({ input: process.stdin, output: process.stdout });
+    return rl.question(q).catch(() => "");
+  };
+  const code = await runSupportCommand({ args: args.slice(1), version: WORKER_VERSION, ask });
+  rl?.close();
+  process.exit(code);
 }
 
 if (args[0] === "clear" || args[0] === "reset") {