@tiens.nguyen/gu-cli 1.0.858 → 1.0.860

package/command-allow.mjs

@@ -0,0 +1,35 @@
+// "Yes, always in this folder" for the destructive-command question (GH #215).
+// The agent reads the same file (gonext_agent_chat._cmd_allowed_in) before it asks. Only the SOFT
+// question ("a destructive command ...") can be skipped by it - sudo, the denylist and deletes
+// outside the project are never covered by it.
+import { readFileSync, writeFileSync, mkdirSync, realpathSync } from "node:fs";
+import { dirname, join, sep } from "node:path";
+import { homedir } from "node:os";
+
+export const commandAllowPath = () => process.env.GU_COMMAND_ALLOW || join(homedir(), ".gonext", "command-allow.json");
+const real = (p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+};
+export function commandAllowList() {
+  try {
+    const f = JSON.parse(readFileSync(commandAllowPath(), "utf8")).folders;
+    return Array.isArray(f) ? f : [];
+  } catch {
+    return [];
+  }
+}
+/** Is `folder` on the list, or inside a folder that is (a project covers its subfolders)? */
+export function commandAllowedIn(folder) {
+  const f = real(folder);
+  return commandAllowList().some((r) => f === r || f.startsWith(r.replace(/[\\/]+$/, "") + sep));
+}
+export function commandAllowIn(folder, allow = true) {
+  const f = real(folder);
+  const folders = [...commandAllowList().filter((x) => x !== f), ...(allow ? [f] : [])];
+  mkdirSync(dirname(commandAllowPath()), { recursive: true });
+  writeFileSync(commandAllowPath(), JSON.stringify({ folders }, null, 2));
+}

package/gonext_agent_chat.py

@@ -7971,8 +7971,19 @@ def _ws_shell_command_risk(scan, denyset, wd="", allowset=None, roots=None):
             return (None, None, f"it runs text as code ({a[0]})")
         if "$" in a[0] or "`" in a[0]:
             return (None, None, f"the program to run is only known at run time ({a[0][:40]})")
+    # `cd sub && rm -rf x`: judge a delete from the folder the shell will be in when it runs.
+    cwds, cur = {}, wd
+    for c in top:
+        a = c["argv"]
+        if a and a[0] == "cd" and len(a) >= 2 and c["sep"] not in ("|", "|&"):
+            cur = os.path.normpath(os.path.join(cur or os.getcwd(),
+                                                os.path.expanduser(_shell_path_to_native(a[1]))))
+        cwds[id(c)] = cur
     for c in every:
-        if _WS_DESTRUCTIVE_RE.search(" ".join(c["argv"])) and not _agent_created_owns_delete(c["argv"], wd):
+        here = cwds.get(id(c), wd)
+        if (_WS_DESTRUCTIVE_RE.search(" ".join(c["argv"]))
+                and not _agent_created_owns_delete(c["argv"], wd)
+                and not _ws_delete_inside_only(c["argv"], here, roots)):
             return (None, None, "a destructive command (deletes files / wipes disk / powers off)")
     return (None, None, None)
 
@@ -8905,6 +8916,42 @@ def _ws_is_inside(path, roots):
     return any(path == r or path.startswith(r.rstrip(os.sep) + os.sep) for r in roots)
 
 
+def _ws_delete_inside_only(argv, wd, roots=None):
+    """True when `argv` is an rm/rmdir/unlink whose EVERY target is inside a registered project
+    (the user's own build output, node_modules, scratch files...) - deleting those is the normal
+    work of a project, so the destructive question is not asked. Still asks for: the project root
+    itself, its .git folder, a path only known at run time ($VAR, `cmd`), anything outside."""
+    if not argv:
+        return False
+    runner = os.path.basename(argv[0]).lower()
+    if runner.endswith(".exe"):
+        runner = runner[:-4]
+    if runner not in ("rm", "rmdir", "unlink"):
+        return False
+    targets = _ws_delete_targets(argv)
+    if not targets:
+        return False
+    ws = [os.path.realpath(r["path"]) for r in (_WS_ROOTS if roots is None else roots) if r.get("path")]
+    if not ws:
+        return False
+    for t in targets:
+        if "$" in t or "`" in t:
+            return False
+        if any(ch in t for ch in "*?[") and os.path.basename(t).startswith("."):
+            return False  # `.*` would also match .git
+        p = os.path.expanduser(_shell_path_to_native(t))
+        try:
+            p = os.path.realpath(p if os.path.isabs(p) else os.path.join(wd or os.getcwd(), p))
+        except OSError:
+            return False
+        home = next((r for r in ws if _ws_is_inside(p, [r])), None)
+        if home is None or p == home:
+            return False
+        if os.path.relpath(p, home).split(os.sep)[0] == ".git":
+            return False
+    return True
+
+
 def _ws_delete_outside_reason(argv, wd, roots=None):
     """Why this delete needs the user's yes, or None when every target is inside a workspace or
     the temp folder. Paths are resolved from `wd`, with ~ expanded and symlinks followed."""
@@ -9015,6 +9062,29 @@ def _with_attribution(argv, settings):
     return argv, ""
 
 
+# GH #215: "Yes, always in this folder" for the SOFT destructive question. ~/.gonext/command-allow.json
+# ({"folders": [...]}) is written by the terminal (command-allow.mjs). It never covers a hard reason
+# (sudo, denylist, delete outside the project) - those keep asking.
+_CMD_ALLOW_ASK = "a destructive command"
+
+
+def _cmd_allow_path():
+    return os.environ.get("GU_COMMAND_ALLOW") or os.path.join(os.path.expanduser("~"), ".gonext", "command-allow.json")
+
+
+def _cmd_allowed_in(folder):
+    """Is `folder` on the always-allow list, or inside a folder that is?"""
+    if not folder:
+        return False
+    try:
+        with open(_cmd_allow_path(), encoding="utf-8") as f:
+            folders = json.load(f).get("folders") or []
+        real = os.path.realpath(folder)
+        return any(isinstance(r, str) and _ws_is_inside(real, [r]) for r in folders)
+    except (OSError, ValueError, AttributeError):
+        return False
+
+
 def _ws_command_risk(command, argv, denyset, wd=""):
     """Classify a command for the run policy. Returns (hard_reason, ask_reason), either
     None when N/A:
@@ -9037,7 +9107,8 @@ def _ws_command_risk(command, argv, denyset, wd=""):
     outside = _ws_delete_outside_reason(argv, wd)
     if outside:
         return (outside, outside)
-    if _WS_DESTRUCTIVE_RE.search(cmd) and not _agent_created_owns_delete(argv, wd):
+    if (_WS_DESTRUCTIVE_RE.search(cmd) and not _agent_created_owns_delete(argv, wd)
+            and not _ws_delete_inside_only(argv, wd)):
         return (None, "a destructive command (deletes files / wipes disk / powers off)")
     return (None, None)
 
@@ -15709,6 +15780,13 @@ def run_agent_chat(cfg):
                            f"Needs {_priv} → cannot run here ({_ws_access_line(_facts)})"})
                     _last_obs["text"] = msg
                     return msg
+                # GH #215: the user said "Yes, always in this folder" to the destructive question.
+                if (_ask_reason and not _hard_reason and _ask_reason.startswith(_CMD_ALLOW_ASK)
+                        and _cmd_allowed_in(wd or _WS_ACTIVE or _default_ws_root())):
+                    # accept-edits OFF still confirms every command, so only the destructive
+                    # question is dropped, not that one.
+                    _ask_reason = None if _accept_edits else (
+                        "accept edits is off, so every command is confirmed first")
                 if _ask_reason:
                     if _priv and _facts:
                         _ask_reason += f" — {_facts['why']}"

package/gu-cli.mjs

@@ -139,6 +139,7 @@ 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 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
@@ -1235,6 +1236,16 @@ if (args[0] === "fix-powershell") {
   process.exit(0);
 }
 
+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);
+}
+
 if (args[0] === "clear" || args[0] === "reset") {
   const cs = await import("./clear-state.mjs");
   const scratchOnly = args.includes("--scratch");

package/gu-repl.mjs

@@ -140,6 +140,7 @@ import {
 import { completedFlush, splitLiveStream } from "./completed-flush.mjs";
 import { isScaffoldStep, isGroupableStep, stepGroupMark, stepGroupRows, relativizePaths } from "./step-group.mjs";
 import { clearLogsNoticeText } from "./clear-logs.mjs";
+import { commandAllowIn, commandAllowedIn } from "./command-allow.mjs";
 import { allowIn, allowedIn, bridgeCommand, browserReport, bridgeStatus, extensionDir, findDevInstalls, helpInstall, installExtensionFiles, installSteps, localLeftovers, openExtensionsPage, removeLocalFiles, STORE_URL, stopBridge } from "./browser-command.mjs";
 import { commandLogFile, killShell, logTail, markAnnounced, readShells, recapQuestion, runningShells, shellsToRecap, statusText as shellStatusText, renderShellDetails, shellPanelRows, shellPickerLabel, shellState, shellsNotice } from "./shell-details.mjs";
 import { discoverSkills, matchSkillCommand } from "./skills.mjs";
@@ -586,7 +587,7 @@ const argv = process.argv.slice(2);
 // process.argv and exits inside its own subcommand branch, before it ever starts polling.
 const CLI_SUBCOMMANDS = [
   "status", "start", "stop", "restart", "logs", "doctor", "login", "set", "rag",
-  "clear", "reset", "api", "token-usage", "tokens", "token", "full-log", "mcp", "hooks",
+  "clear", "reset", "api", "token-usage", "tokens", "token", "full-log", "mcp", "hooks", "support",
 ];
 // `gu logz` USED TO START THE REPL (task #181). Silently: an unrecognised word was not in
 // the list, so it fell through to "no subcommand given" and a full agent session opened in that
@@ -3694,7 +3695,7 @@ const paintThoughtRows = (block, hovered, collapsed = block.collapsed) => {
   if (block.kind === "command") {
     // #204: the Allow prompt's command — wrapped under its own indent, long ones collapsed.
     const paint = (row) => (hovered ? hoverThought(row) : dim(row));
-    return commandBlockRows(block.text, { width: commandWidth(), collapsed, maxRows: COMMAND_COLLAPSED_ROWS }).map(paint);
+    return commandBlockRows(block.text, { width: commandWidth(), indent: GUTTER, collapsed, maxRows: COMMAND_COLLAPSED_ROWS }).map(paint);
   }
   if (block.kind === "steps") {
     // Activity (look-ups, finished commands): dim, like a ✓ row; bright while hovered.
@@ -10699,6 +10700,9 @@ let approvalOpenedOver = null;
 let approvalDeadline = 0;
 let listDeadline = 0;
 let listTimeoutIndex = -1;
+/** How long a command approval ("Allow running this command?") waits before it answers No by itself.
+ *  GH #214: was 170 s; under 30 s so an absent user does not stall the turn. The python side waits 180 s. */
+const COMMAND_APPROVAL_MS = 25000;
 /** "2:49" above a minute, "45s" below; never negative. */
 function countdownLabel(msLeft) {
   const s = Math.max(0, Math.ceil(msLeft / 1000));
@@ -10733,7 +10737,7 @@ function printApprovalCommand(shown, { toggle = true } = {}) {
   const canToggle = toggle && barPinned();
   const block = { kind: "command", from: 0, to: 0, text: shown, collapsed: canToggle };
   const painted = paintThoughtRows(block, false);
-  process.stdout.write("\n" + yellow("⚠ Allow running this command?") + "\n" + painted.join("\n") + "\n");
+  process.stdout.write("\n" + markLine(yellow("⚠")) + yellow("Allow running this command?") + "\n" + painted.join("\n") + "\n");
   if (!canToggle || !blockCanToggle(block)) return null;
   block.to = transcript.dropped() + transcript.length() - 2;
   block.from = block.to - painted.length + 1;
@@ -10774,7 +10778,7 @@ function onApprovalKey(key) {
   // Ctrl+C is delivered via readline "SIGINT" (onInterrupt), which also denies — see there.
 }
 // Show the picker and resolve to the user's choice. Non-TTY (piped) can't pick → deny
-// (safe). Auto-denies after ~170s so an absent user never hangs the turn (and stays
+// (safe). A command approval auto-denies after COMMAND_APPROVAL_MS (25s, GH #214) so an absent user never hangs the turn (well
 // under the python side's 180s wait); Enter is instant since Yes is preselected.
 // The command carries a "__MAXSTEP__::<message>" sentinel when it's the step-budget
 // continue prompt (task #80) rather than a risky-command approval. That case shows a
@@ -10870,7 +10874,7 @@ async function approvalPrompt(command) {
     if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
     process.stdout.write(
       "\n" + yellow("🌐 Allow gu to use a web browser?") + dim("  (no answer in ~3 min = Yes, this time)") + "\n" +
-        indentBlock(`It wants to: ${what || "open a page"}`, { paint: dim }) + "\n" +
+        indentBlock(`It wants to: ${what || "open a page"}`, { indent: GUTTER, paint: dim }) + "\n" +
         dim("  In your Chrome if the gu extension is there, else in gu's own Chrome window.") + "\n"
     );
     // "Yes, this time" is THE default (#380, GitHub #167): highlighted, so Enter allows it once, and
@@ -10891,8 +10895,8 @@ async function approvalPrompt(command) {
     const [server = "", tool = "", preview = ""] = command.slice(MCPTOOL_PREFIX.length).split("\t");
     if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
     process.stdout.write(
-      "\n" + yellow(`⚙ Allow the MCP tool ${server}/${tool}?`) + dim("  (no answer in ~3 min = No)") + "\n" +
-        (preview ? indentBlock(preview, { paint: dim }) + "\n" : "")
+      "\n" + markLine(yellow("⚙")) + yellow(`Allow the MCP tool ${server}/${tool}?`) + dim("  (no answer in ~3 min = No)") + "\n" +
+        (preview ? indentBlock(preview, { indent: GUTTER, paint: dim }) + "\n" : "")
     );
     const idx = await pickFromList(
       ["Yes", `Yes, and always allow ${server}/${tool}`, `Yes, and always allow every ${server} tool`, "No"],
@@ -10937,11 +10941,11 @@ async function approvalPrompt(command) {
   // "yes" must never cover those.
   if (process.stdin.isTTY && editMode === "manual" && why.startsWith("accept edits is off")) {
     printApprovalCommand(shown, { toggle: false }); // a list picker follows — shown whole, wrapped (#204)
-    process.stdout.write(indentBlock(why, { paint: dim }) + "\n");
+    process.stdout.write(indentBlock(why, { indent: GUTTER, paint: dim }) + "\n");
     const idx = await pickFromList(
       ["Yes", "Yes for all later ones (turns accept edits on)", "No"],
       0,
-      { timeoutMs: 170000, timeoutIndex: 2 }
+      { timeoutMs: COMMAND_APPROVAL_MS, timeoutIndex: 2 }
     );
     if (idx === 1 && editMode === "manual") {
       switchEditMode();
@@ -10949,6 +10953,27 @@ async function approvalPrompt(command) {
     }
     return { allow: idx === 0 || idx === 1, dontAsk: false };
   }
+  // GH #215 — "Yes, always in this folder". ONLY for the soft "a destructive command" question
+  // (the reason text comes from _ws_command_risk in gonext_agent_chat.py). sudo, the denylist and
+  // deletes outside the project give a different reason, so they keep the plain Yes/No below.
+  if (process.stdin.isTTY && why.startsWith("a destructive command")) {
+    printApprovalCommand(shown, { toggle: false }); // a list picker follows — shown whole, wrapped
+    process.stdout.write(indentBlock(why, { indent: GUTTER, paint: dim }) + "\n");
+    const idx = await pickFromList(
+      ["Yes", "Yes, always in this folder", "No"],
+      0,
+      { timeoutMs: COMMAND_APPROVAL_MS, timeoutIndex: 2 }
+    );
+    if (idx === 1) {
+      try {
+        commandAllowIn(resolve(process.cwd()), true);
+        process.stdout.write(dim("  (won't ask about destructive commands in this folder again — /command forget undoes it)\n"));
+      } catch (e) {
+        process.stdout.write(yellow(`  could not save that (${e?.message || e}) — allowed this once\n`));
+      }
+    }
+    return { allow: idx === 0 || idx === 1, dontAsk: false };
+  }
   const allow = await new Promise((resolve) => {
     if (!process.stdin.isTTY) {
       process.stdout.write("\n" + GUTTER + dim(`(approval needed for: ${shown}${why ? ` — ${why}` : ""} — no interactive terminal, skipping)`) + "\n");
@@ -10956,13 +10981,13 @@ async function approvalPrompt(command) {
       return;
     }
     approvalCommandBlock = printApprovalCommand(shown);
-    if (why) process.stdout.write(indentBlock(why, { paint: dim }) + "\n");
+    if (why) process.stdout.write(indentBlock(why, { indent: GUTTER, paint: dim }) + "\n");
     approvalSel = 0;
     approvalResolve = resolve;
     approvalActive = true;
-    approvalDeadline = Date.now() + 170000;
+    approvalDeadline = Date.now() + COMMAND_APPROVAL_MS;
     drawApprovalOptions(false);
-    const t = setTimeout(() => finishApproval(false, true), 170000);
+    const t = setTimeout(() => finishApproval(false, true), COMMAND_APPROVAL_MS);
     // #135: redraw the two option rows once a second so the countdown on "No" ticks down.
     const tick = setInterval(() => {
       if (approvalActive) drawApprovalOptions(true);
@@ -14564,6 +14589,17 @@ async function main() {
       paintBar();
       continue;
     }
+    if (line === "/command forget" || line === "/command status") {
+      const here = resolve(process.cwd());
+      if (line === "/command forget") commandAllowIn(here, false);
+      console.log("\n" + GUTTER + (line === "/command forget"
+        ? accent("✓ gu asks again before a destructive command in this folder.")
+        : (commandAllowedIn(here)
+          ? accent("Destructive commands run without asking in this folder.") + dim(" (/command forget undoes it)")
+          : dim("gu asks before a destructive command in this folder."))) + "\n");
+      paintBar();
+      continue;
+    }
     if (line === "/model") {
       await chooseModel();
       await refreshNoModelAtAll(); // #188: a coding model may have just been set → drop its row

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.858",
+  "version": "1.0.860",
   "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",
@@ -88,6 +88,7 @@
     "poll-errors.mjs",
     "node-version.mjs",
     "clear-state.mjs",
+    "support-report.mjs",
     "clear-logs.mjs",
     "platform-tools.mjs",
     "job-pools.mjs",
@@ -130,6 +131,7 @@
     "proc-identity.mjs",
     "win-path.mjs",
     "browser-command.mjs",
+    "command-allow.mjs",
     "browser-bridge.mjs",
     "browser-chrome.mjs",
     "browser-extension/manifest.json",

package/support-report.mjs

@@ -0,0 +1,161 @@
+/**
+ * `gu support` — one redacted report a customer can send to the support team.
+ *
+ * Written after a fresh Ubuntu install got no free token and no clue why (#17): the cause (an empty
+ * /etc/machine-id, so no trial request was ever made) was invisible from the customer's side. This
+ * collects what support would otherwise ask for one question at a time: version and OS, the machine
+ * id (present or not, NEVER its value), whether the gu service answers, the token state, the local
+ * API and MongoDB, and the tail of the logs.
+ *
+ * NOTHING SECRET LEAVES: tokens, worker keys, passwords in URLs and key=value secrets are masked
+ * before anything is printed or written. It does not claim a trial or change any file but its own report.
+ * Everything with a side effect on the outside is injectable so the tests run offline.
+ */
+import { readFile, readdir, stat, writeFile, mkdir } from "node:fs/promises";
+import { homedir, platform as osPlatform, release, arch } from "node:os";
+import { join } from "node:path";
+import { redactSecrets } from "./proxy-config.mjs";
+
+export const SUPPORT_REPORT_FILE = "support-report.txt";
+export const SUPPORT_LOGS = ["worker.log", "local-api.log", "model.log", "embed.log"];
+
+/** Mask tokens, keys, passwords and URL credentials in any text. */
+export function redactReport(text) {
+  return redactSecrets(String(text ?? ""))
+    .replace(/\bgu1\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, "gu1.***")
+    .replace(/\b(sk|pk|ghp|gho|xox[abp])[-_][A-Za-z0-9_-]{12,}/g, "$1-***")
+    .replace(/(["']?[A-Za-z_]*(?:key|token|secret|password|passwd)[A-Za-z_]*["']?\s*[:=]\s*["']?)([^\s"',}]{6,})/gi, "$1***")
+    .replace(/(Authorization:\s*Bearer\s+)\S+/gi, "$1***");
+}
+
+const lastLines = (text, n) => String(text ?? "").split(/\r?\n/).filter((l, i, a) => l || i < a.length - 1).slice(-n);
+
+async function fileInfo(path) {
+  try {
+    const s = await stat(path);
+    return { size: s.size, mtime: s.mtime.toISOString() };
+  } catch {
+    return null;
+  }
+}
+
+/** → the report as an array of lines (already redacted). Never throws. */
+export async function buildSupportReport({
+  home = homedir(),
+  version = "unknown",
+  platform = osPlatform(),
+  env = process.env,
+  now = new Date(),
+  logLines = 40,
+  fetchImpl = fetch,
+  token = null, // the cli-token module, injectable
+  api = null,   // the client-expert-api module, injectable
+  run = null,   // the client-expert-run module, injectable
+} = {}) {
+  const dir = join(home, ".gonext");
+  const out = [];
+  const section = (t) => out.push("", `== ${t} ==`);
+  const line = (l) => out.push(l);
+  const safe = async (label, fn) => {
+    try {
+      await fn();
+    } catch (e) {
+      line(`${label}: could not check (${e?.message || e})`);
+    }
+  };
+
+  line(`gu support report — ${now.toISOString()}`);
+  line("Secrets are masked. Send this file to the support team.");
+
+  section("This computer");
+  line(`gu ${version}   node ${process.version}`);
+  line(`os ${platform} ${release()} ${arch()}`);
+
+  const ct = token ?? (await import("./cli-token.mjs"));
+
+  section("Machine id (the free trial needs one)");
+  await safe("machine id", async () => {
+    const id = await ct.osMachineId({ platform });
+    if (id) line(`OK — the operating system gives this computer an id (${id.length} characters; not shown).`);
+    else {
+      line("MISSING — no operating-system machine id, so gu makes NO free-trial request.");
+      if (platform === "linux") line("  /etc/machine-id is empty or absent. Fix: sudo systemd-machine-id-setup   (then run gu again)");
+    }
+  });
+
+  section("gu service (free token, account)");
+  const site = ct.siteUrl(env);
+  await safe("site", async () => {
+    try {
+      const res = await fetchImpl(site, { method: "GET", signal: AbortSignal.timeout(8000) });
+      line(`${site} → HTTP ${res.status}`);
+    } catch (err) {
+      line(`${site} → cannot be reached: ${ct.netErrorDetail(err, 8000)}`);
+    }
+  });
+  const workerEnv = await readFile(join(dir, "worker.env"), "utf8").catch(() => null);
+  if (workerEnv === null) line("worker.env: absent (not signed in / Local mode)");
+  else {
+    const keys = workerEnv.split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("#") && l.includes("=")).map((l) => l.split("=")[0].trim());
+    line(`worker.env: present, settings: ${keys.join(", ") || "(none)"}`);
+    const base = /^GONEXT_API_BASE=(.*)$/m.exec(workerEnv)?.[1]?.trim();
+    if (base) line(`API base: ${base}`);
+  }
+
+  section("Token");
+  await safe("token", async () => {
+    const st = await ct.readState(dir);
+    if (!st.token) line("No token saved.");
+    else {
+      const pk = ct.publicKey(env);
+      const check = ct.verifyCliToken(st.token, pk);
+      line(check.ok ? "A token is saved and valid." : `A token is saved but not valid here: ${check.why}`);
+    }
+    if (st.lastAttemptAt) line(`last automatic fetch: ${st.lastAttemptAt}${st.lastAttemptWhy ? ` — failed: ${st.lastAttemptWhy}` : ""}`);
+  });
+
+  section("Local API and MongoDB");
+  await safe("local api", async () => {
+    const ce = api ?? (await import("./client-expert-api.mjs"));
+    const probe = await ce.probeLocalApi();
+    line(probe.ok ? `API up on ${ce.LOCAL_API_BASE}${probe.body?.version ? ` (running ${probe.body.version})` : ""}` : `API not usable: ${probe.why}`);
+    const uri = ce.localMongoUri({ env, home });
+    line(`MongoDB uri: ${redactSecrets(uri)}`);
+    try {
+      const r = run ?? (await import("./client-expert-run.mjs"));
+      const down = await r.localMongoDown(uri);
+      line(down ? `MongoDB does NOT answer at ${down}` : "MongoDB answers.");
+    } catch (e) {
+      line(`MongoDB: could not check (${e?.message || e})`);
+    }
+  });
+
+  section("Files in ~/.gonext");
+  await safe("files", async () => {
+    const names = (await readdir(dir).catch(() => [])).sort();
+    if (!names.length) line("(folder is empty or absent — a totally fresh install)");
+    for (const n of names) {
+      const info = await fileInfo(join(dir, n));
+      if (info) line(`${n}  ${info.size} bytes  ${info.mtime}`);
+    }
+  });
+
+  for (const name of SUPPORT_LOGS) {
+    const text = await readFile(join(dir, name), "utf8").catch(() => null);
+    if (text === null) continue;
+    section(`${name} (last ${logLines} lines)`);
+    for (const l of lastLines(text, logLines)) line(l);
+  }
+
+  return out.map(redactReport);
+}
+
+/** Build, write ~/.gonext/support-report.txt (owner-only) and return { lines, file }. */
+export async function writeSupportReport(opts = {}) {
+  const home = opts.home ?? homedir();
+  const lines = await buildSupportReport(opts);
+  const file = join(home, ".gonext", SUPPORT_REPORT_FILE);
+  await mkdir(join(home, ".gonext"), { recursive: true });
+  await writeFile(file, lines.join("\n") + "\n", { encoding: "utf8", mode: 0o600 });
+  return { lines, file };
+}