@tiens.nguyen/gu-cli 1.0.857 → 1.0.859

package/client-expert-run.mjs

@@ -887,7 +887,10 @@ export async function downloadApiPackage(manifest, { onProgress = () => {} } = {
   const tmpTar = join(staging, "package.tar.gz");
   await writeFile(tmpTar, bytes);
   onProgress(`unpacking ${bytes.length} bytes…`);
-  await run("tar", ["xzf", tmpTar, "-C", staging]);
+  // RELATIVE NAMES, run from inside the staging dir. GNU tar (Git Bash / MSYS on Windows, often first
+  // on PATH) reads "C:\\x\\package.tar.gz" as host:file and tries to reach a machine called "C", which
+  // ends in "gzip: stdin: unexpected end of file". A path with no drive letter works for GNU and bsdtar.
+  await run("tar", ["xzf", "package.tar.gz", "-C", "."], { cwd: staging });
   await rm(tmpTar, { force: true });
   await rm(dir, { recursive: true, force: true });
   await mkdir(join(homedir(), ".gonext", "api"), { recursive: true });

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

@@ -586,7 +586,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 +3694,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.
@@ -10733,7 +10733,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;
@@ -10870,7 +10870,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 +10891,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,7 +10937,7 @@ 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,
@@ -10956,7 +10956,7 @@ 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;

package/package.json

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

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