@tiens.nguyen/gu-cli 1.0.791 → 1.0.792

package/clear-logs.mjs

@@ -0,0 +1,352 @@
+/**
+ * "clear logs" (#329) — what is taking the disk under ~/.gonext, and a way to give it back.
+ *
+ * Asked for after this Mac's disk filled three times in one day and took the local MongoDB down
+ * with it (#328). A click on the notice row's "clear logs" (or /clear-logs) DELETES NOTHING at
+ * first: it measures, shows the logs beside the two things that are actually big — the RAG indexes
+ * and the downloaded API versions — with a total, and then asks about each of the three.
+ *
+ * THREE DIFFERENT KINDS OF "CLEAR", because losing each costs something different:
+ *
+ *   logs  nothing. But the worker and the local API hold their log OPEN: a deleted open file frees
+ *         no space on macOS/Linux until the holder closes it (and the holder keeps writing into
+ *         the unlinked file), and on Windows the delete fails outright. So the live "<name>.log"
+ *         is TRUNCATED IN PLACE and only rotations and finished run-logs are deleted — the same
+ *         rule rotateIfLarge (log-policy.mjs) already lives by.
+ *   rag   minutes of embedding per folder: an index is rebuilt the next time its folder is used.
+ *   api   nothing, PROVIDED the version in use stays. One folder per installed version, none ever
+ *         removed; deleting the running one would break every open terminal's turn. So "clear
+ *         api" only ever means the OLDER versions.
+ *
+ * SELECTED BY AN EXPLICIT LIST, never by a "*.log*" / "*.jsonl" sweep of the home: sessions/archive
+ * is conversation history (#278) and rag/ shards are also .jsonl. Anything not named here is not
+ * touched, whatever the answers.
+ *
+ * Everything takes `home` so the tests run against a real temp folder, not this machine's.
+ */
+import { readdir, readFile, rm, rmdir, stat, truncate, unlink } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pickUsableVersion, compareVersions } from "./version-check.mjs";
+
+/** The logs gu writes at the top of its home. `<name>` is live; `<name>.N` are its rotations. */
+export const LIVE_LOGS = ["worker.log", "local-api.log", "model.log", "embed.log"];
+/** Folders that hold nothing but finished log files. */
+export const LOG_DIRS = ["run-logs", "logs"];
+/** The link appears once the logs pass this — below it the row stays quiet. */
+export const LOGS_NOTICE_BYTES = 50 * 1024 * 1024;
+
+const guHome = (home = homedir()) => join(home, ".gonext");
+
+/** "740 KB", "15 MB", "4.9 GB" — two significant figures, the way `du -h` reads. */
+export function humanSize(bytes) {
+  const n = Math.max(0, Number(bytes) || 0);
+  const units = [["GB", 1024 ** 3], ["MB", 1024 ** 2], ["KB", 1024]];
+  for (const [unit, size] of units) {
+    if (n < size) continue;
+    const v = n / size;
+    // 9.96 would print as "10.0" with one decimal — let it round up to the integer form instead.
+    return `${v < 9.95 ? v.toFixed(1) : Math.round(v)} ${unit}`;
+  }
+  return `${Math.round(n)} B`;
+}
+
+const plural = (n, one, many = one + "s") => `${n} ${n === 1 ? one : many}`;
+
+/**
+ * What a file takes ON DISK — its blocks, which is what clearing gives back and what `du` reports.
+ * The byte length undercounts thousands of small files (an API version read as 85 MB here against
+ * du's 120 MB). Windows reports no blocks; the length is the best there is.
+ */
+const onDisk = (s) => (s.blocks > 0 ? s.blocks * 512 : s.size);
+
+async function fileSize(p) {
+  try {
+    const s = await stat(p);
+    return s.isFile() ? onDisk(s) : -1;
+  } catch {
+    return -1;
+  }
+}
+
+/** Bytes under a folder. Children are walked together: an API version is thousands of files. */
+async function dirSize(p) {
+  let entries;
+  try {
+    entries = await readdir(p, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  const sizes = await Promise.all(
+    entries.map(async (e) => {
+      const full = join(p, e.name);
+      if (e.isDirectory()) return dirSize(full);
+      if (e.isSymbolicLink()) return 0; // never followed: a link out of the home is not ours to count
+      try {
+        return onDisk(await stat(full));
+      } catch {
+        return 0;
+      }
+    })
+  );
+  return sizes.reduce((a, b) => a + b, 0);
+}
+
+/**
+ * The logs: each live file and its rotations by name, each log folder as a count.
+ * → { items: [{ name, bytes, kind: "live" | "rotation" | "dir", files?, paths? }], bytes, files }
+ */
+export async function surveyLogs({ home = homedir() } = {}) {
+  const root = guHome(home);
+  let names = [];
+  try {
+    names = await readdir(root);
+  } catch {
+    /* no home yet — nothing to report */
+  }
+  const items = [];
+  for (const live of LIVE_LOGS) {
+    const bytes = await fileSize(join(root, live));
+    if (bytes >= 0) items.push({ name: live, bytes, kind: "live", path: join(root, live) });
+    const rotations = names
+      .filter((n) => n.startsWith(live + ".") && /^\d+$/.test(n.slice(live.length + 1)))
+      .sort((a, b) => Number(a.slice(live.length + 1)) - Number(b.slice(live.length + 1)));
+    for (const r of rotations) {
+      const b = await fileSize(join(root, r));
+      if (b >= 0) items.push({ name: r, bytes: b, kind: "rotation", path: join(root, r) });
+    }
+  }
+  for (const dir of LOG_DIRS) {
+    let files = [];
+    try {
+      files = (await readdir(join(root, dir), { withFileTypes: true })).filter(
+        (e) => e.isFile() && /\.log(\.\d+)?$/.test(e.name)
+      );
+    } catch {
+      continue;
+    }
+    const paths = files.map((e) => join(root, dir, e.name));
+    let bytes = 0;
+    for (const p of paths) bytes += Math.max(0, await fileSize(p));
+    if (paths.length) items.push({ name: dir, bytes, kind: "dir", files: paths.length, paths });
+  }
+  return {
+    items,
+    bytes: items.reduce((n, i) => n + i.bytes, 0),
+    files: items.reduce((n, i) => n + (i.kind === "dir" ? i.files : 1), 0),
+  };
+}
+
+/**
+ * Every local index: ~/.gonext/rag/<folder hash>/<source hash>/. The hashes say nothing to a
+ * person, so the name comes from the manifest the agent wrote (`sourceUrl`). `missing` = that
+ * source was a folder on this machine and is gone — the index can never be used again.
+ */
+export async function surveyRag({ home = homedir() } = {}) {
+  const root = join(guHome(home), "rag");
+  const indexes = [];
+  let folders = [];
+  try {
+    folders = (await readdir(root, { withFileTypes: true })).filter((e) => e.isDirectory());
+  } catch {
+    return { indexes, bytes: 0 };
+  }
+  for (const f of folders) {
+    let sources = [];
+    try {
+      sources = (await readdir(join(root, f.name), { withFileTypes: true })).filter((e) => e.isDirectory());
+    } catch {
+      continue;
+    }
+    for (const s of sources) {
+      const dir = join(root, f.name, s.name);
+      let source = "";
+      try {
+        source = String(JSON.parse(await readFile(join(dir, "manifest.json"), "utf8"))?.sourceUrl ?? "");
+      } catch {
+        /* no manifest — an interrupted index; still counted, still clearable */
+      }
+      const isPath = source.startsWith("/") || /^[A-Za-z]:[\\/]/.test(source);
+      indexes.push({
+        dir,
+        parent: join(root, f.name),
+        source,
+        label: source ? source.replace(/[\\/]+$/, "").split(/[\\/]/).pop() || source : `${s.name.slice(0, 8)}…`,
+        missing: isPath && !existsSync(source),
+        bytes: await dirSize(dir),
+      });
+    }
+  }
+  indexes.sort((a, b) => b.bytes - a.bytes);
+  return { indexes, bytes: indexes.reduce((n, i) => n + i.bytes, 0) };
+}
+
+/**
+ * The installed API versions, and which must stay.
+ *
+ * KEPT: the version answering on the port right now (`runningVersion`, from /api/health), the one
+ * `gu-cli api start` would pick (newest that has its dependencies — #181), and the newest folder
+ * even when it is not runnable yet (an upgrade in progress). Everything else is "old".
+ */
+export async function surveyApi({ home = homedir(), runningVersion = "" } = {}) {
+  const root = join(guHome(home), "api");
+  let names = [];
+  try {
+    names = (await readdir(root, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return { versions: [], bytes: 0, oldBytes: 0, old: [], inUse: "" };
+  }
+  names.sort((a, b) => compareVersions(a, b));
+  const usable = pickUsableVersion(names, (v) => existsSync(join(root, v, "node_modules", "mongodb", "package.json")));
+  const running = names.includes(runningVersion) ? runningVersion : "";
+  const keep = new Set([running, usable, names[names.length - 1]].filter(Boolean));
+  const sizes = await Promise.all(names.map((v) => dirSize(join(root, v))));
+  const versions = names.map((version, i) => ({ version, dir: join(root, version), bytes: sizes[i], keep: keep.has(version) }));
+  const old = versions.filter((v) => !v.keep);
+  return {
+    versions,
+    old,
+    bytes: versions.reduce((n, v) => n + v.bytes, 0),
+    oldBytes: old.reduce((n, v) => n + v.bytes, 0),
+    inUse: running || usable || "",
+  };
+}
+
+/** All three, measured together. */
+export async function surveyDisk({ home = homedir(), runningVersion = "" } = {}) {
+  const [logs, rag, api] = await Promise.all([surveyLogs({ home }), surveyRag({ home }), surveyApi({ home, runningVersion })]);
+  return { logs, rag, api, total: logs.bytes + rag.bytes + api.bytes };
+}
+
+/** Lay `parts` out after `lead`, breaking only between parts; later rows start at `indent`. */
+function wrapParts(lead, parts, width, { sep = " · ", indent = lead.length } = {}) {
+  const pad = " ".repeat(indent);
+  const rows = [];
+  let cur = lead;
+  let empty = true;
+  for (const part of parts) {
+    if (!empty && cur.length + sep.length + part.length > width) {
+      rows.push(cur);
+      cur = pad + part;
+    } else {
+      cur += (empty ? "" : sep) + part;
+    }
+    empty = false;
+  }
+  rows.push(cur.trimEnd());
+  // a single part longer than the row is cut, never wrapped — a wrapped row moves everything under it
+  return rows.map((r) => (r.length > width ? r.slice(0, Math.max(1, width - 1)) + "…" : r));
+}
+
+/**
+ * What the click shows before it asks anything: the logs with their files, RAG and API with what
+ * they are, and the total. Plain text rows that fit `width` — the caller paints and indents them.
+ * A part that is not on this machine (no api/ outside Local mode) has no row.
+ */
+export function summaryRows(survey, { width = 76, top = 3 } = {}) {
+  const w = Math.max(30, width | 0);
+  const { logs, rag, api } = survey;
+  const parts = [
+    { name: "Logs", bytes: logs.bytes, detail: logs.items.map((i) => i.kind === "dir"
+      ? `${i.name} ${plural(i.files, "file")} ${humanSize(i.bytes)}`
+      : `${i.name} ${humanSize(i.bytes)}`), none: "none" },
+  ];
+  if (rag.indexes.length) {
+    const shown = rag.indexes.slice(0, top);
+    const rest = rag.indexes.slice(top);
+    const detail = shown.map((i) => `${i.label} ${humanSize(i.bytes)}`);
+    if (rest.length) detail.push(`${rest.length} more ${humanSize(rest.reduce((n, i) => n + i.bytes, 0))}`);
+    parts.push({ name: "RAG", bytes: rag.bytes, intro: plural(rag.indexes.length, "folder index", "folder indexes") + ":", detail });
+  }
+  if (api.versions.length) {
+    const detail = [plural(api.versions.length, "version")];
+    if (api.inUse) detail.push(`${api.inUse} in use`);
+    if (api.old.length) detail.push(`${plural(api.old.length, "older one")} ${humanSize(api.oldBytes)}`);
+    parts.push({ name: "API", bytes: api.bytes, detail });
+  }
+  const nameW = Math.max(5, ...parts.map((p) => p.name.length));
+  const sizeW = Math.max(humanSize(survey.total).length, ...parts.map((p) => humanSize(p.bytes).length));
+  const lead = (name, bytes) => `${name.padEnd(nameW)}  ${humanSize(bytes).padStart(sizeW)}  `;
+  const rows = [];
+  for (const p of parts) {
+    const head = lead(p.name, p.bytes);
+    // "22 folder indexes:" introduces the list — the list wraps under the first index, the
+    // other parts under their own first word
+    rows.push(...wrapParts(head + (p.intro ? p.intro + " " : ""), p.detail.length ? p.detail : [p.none ?? ""], w, { indent: head.length }));
+  }
+  rows.push(lead("Total", survey.total).trimEnd());
+  return rows;
+}
+
+/**
+ * Clear the logs `surveyLogs` found: truncate the live ones, delete rotations and log folders'
+ * files. → { freed, truncated, deleted, failed: [name] } — `freed` is what really went, so a file
+ * Windows refused to let go of is reported, not counted.
+ */
+export async function clearLogs(logs) {
+  const out = { freed: 0, truncated: 0, deleted: 0, failed: [] };
+  for (const item of logs?.items ?? []) {
+    if (item.kind === "live") {
+      try {
+        const before = Math.max(0, await fileSize(item.path));
+        await truncate(item.path, 0);
+        out.freed += before;
+        out.truncated += 1;
+      } catch {
+        out.failed.push(item.name);
+      }
+      continue;
+    }
+    for (const p of item.kind === "dir" ? item.paths : [item.path]) {
+      try {
+        const before = Math.max(0, await fileSize(p));
+        await unlink(p);
+        out.freed += before;
+        out.deleted += 1;
+      } catch (e) {
+        if (e?.code === "ENOENT") continue; // pruned meanwhile — gone is what was wanted
+        if (!out.failed.includes(item.name)) out.failed.push(item.name);
+      }
+    }
+  }
+  return out;
+}
+
+/** Remove the given indexes (surveyRag's rows). An emptied folder-hash directory goes with them. */
+export async function clearRagIndexes(indexes) {
+  const out = { freed: 0, removed: 0, failed: [] };
+  for (const idx of indexes ?? []) {
+    try {
+      await rm(idx.dir, { recursive: true, force: true });
+      out.freed += idx.bytes;
+      out.removed += 1;
+      await rmdir(idx.parent).catch(() => {}); // only succeeds when nothing else lives there
+    } catch {
+      out.failed.push(idx.label);
+    }
+  }
+  return out;
+}
+
+/** Remove the OLD API versions (surveyApi's `old`). A row marked keep is refused, whoever asks. */
+export async function clearOldApiVersions(versions) {
+  const out = { freed: 0, removed: 0, failed: [] };
+  for (const v of versions ?? []) {
+    if (v.keep) continue;
+    try {
+      await rm(v.dir, { recursive: true, force: true });
+      out.freed += v.bytes;
+      out.removed += 1;
+    } catch {
+      out.failed.push(v.version);
+    }
+  }
+  return out;
+}
+
+/** The notice-row item's text, or "" while the logs are too small to be worth a row. */
+export function clearLogsNoticeText(logBytes, { threshold = LOGS_NOTICE_BYTES } = {}) {
+  const n = Number(logBytes) || 0;
+  return n >= threshold ? `clear logs · ${humanSize(n)} (click)` : "";
+}

package/gu-repl.mjs

@@ -128,6 +128,7 @@ import {
 } from "./terminal-layout.mjs";
 import { completedFlush, splitLiveStream } from "./completed-flush.mjs";
 import { isScaffoldStep, isGroupableStep, stepGroupRows, relativizePaths } from "./step-group.mjs";
+import { clearLogsNoticeText } from "./clear-logs.mjs";
 import { discoverSkills, matchSkillCommand } from "./skills.mjs";
 import { appendNew, archivePathFor, archivedWorkspaceKey, markReset, seedArchive } from "./conversation-archive.mjs";
 import { addAllowRule, listServers as listMcpServers } from "./mcp-config.mjs";
@@ -891,6 +892,7 @@ const COMMANDS = [
   { name: "/use-presets", usage: "/use-presets [name]", desc: "pick a saved preset and apply it — shows what changes, backs up your setup, asks first" },
   { name: "/doctor", desc: "check every configured model ANSWERS — especially the embedder, which a turn only reaches after several steps" },
   { name: "/tokens", desc: "break down the last prompt sent to the coding model — how much of it was RAG" },
+  { name: "/clear-logs", desc: "show what gu's logs, RAG indexes and old API versions take on disk, then ask what to clear — the logs first" },
   { name: "/prices", usage: "/prices [update]", desc: "the price table and the cache table, and what the last turn and this session cost — \"update\" applies gu's newest published tables" },
   // ONE name, /new (user, #278). /reset and /clear still work (HIDDEN_COMMANDS) for habit and
   // for Claude Code users — not to be confused with `gu clear` in a shell, which wipes gu's state.
@@ -1462,6 +1464,11 @@ function applyClick({ row, col }) {
     void runPricesUpdate();
     return;
   }
+  if (logsRowTarget && row === updateRowAbs &&
+      col - 1 >= logsRowTarget.from && col - 1 < logsRowTarget.to) {
+    void runClearLogs();
+    return;
+  }
   if (agentsRowTarget && row === updateRowAbs &&
       col - 1 >= agentsRowTarget.from && col - 1 < agentsRowTarget.to) {
     void showOtherAgents(); // async now — it offers stop / switch-to (task #211)
@@ -2680,6 +2687,9 @@ function zoneNotice(width) {
   if (tokenNotice?.text) items.push({ key: "token", paint: tokenNotice.urgent ? yellow : dim, text: tokenNotice.text });
   const agents = agentsIndicator(otherAgents);
   if (agents) items.push({ key: "agents", clickable: true, paint: accent, text: `${agents} running (click)` });
+  // LAST, so it is the first to give way on a narrow window: housekeeping, never urgent (#329).
+  const logs = clearLogsNoticeText(logsBytes);
+  if (logs) items.push({ key: "logs", clickable: true, paint: dim, text: logs });
   return noticeRow(items, { width, gutter: GUTTER });
 }
 
@@ -2760,6 +2770,7 @@ function frozenZone() {
   updateRowTarget = notice?.spans.update ?? null;
   agentsRowTarget = notice?.spans.agents ?? null;
   pricesRowTarget = notice?.spans.prices ?? null;
+  logsRowTarget = notice?.spans.logs ?? null;
   jumpSpan = notice?.spans.jump ?? null;
   return { ...zone, rows, statusRows: sep, noticeRow: Boolean(notice) };
 }
@@ -2829,7 +2840,7 @@ function paintBar() {
   // THE NOTICE ROW is the one directly above the separator (#318) — never the separator itself.
   const noticeAbs = zone.noticeRow ? sepAbs - 1 : 0;
   jumpRowTarget = scrolledBack() && jumpSpan ? { row: noticeAbs, ...jumpSpan } : null;
-  updateRowAbs = updateRowTarget || agentsRowTarget || pricesRowTarget ? noticeAbs : 0;
+  updateRowAbs = updateRowTarget || agentsRowTarget || pricesRowTarget || logsRowTarget ? noticeAbs : 0;
   // preserveCaret:false — the save slot holds the OUTPUT position (see regionUi), and the caret
   // is parked on the input line right after, so there is nothing to preserve here.
   ui(
@@ -2991,6 +3002,8 @@ let updateRowAbs = 0;
 let agentsRowTarget = null;
 // …and "new prices updated <date>" (#323).
 let pricesRowTarget = null;
+// …and "clear logs · 175 MB" (#329), shown only once the logs are worth a row.
+let logsRowTarget = null;
 // A terminal left with a scrolling region is a broken shell — a hard guarantee, like the
 // bracketed-paste and mouse-reporting teardowns.
 process.on("exit", () => {
@@ -7071,6 +7084,16 @@ function writePresetFile(pr, file, name, parsed) {
     const v = pr.validatePresetFile(JSON.stringify(out));
     console.log(GUTTER + `Preset "${name}" saved to ${file}:`);
     if (v.ok && v.full) for (const l of pr.fullPresetSummary(v.value, v.codingDefault)) console.log(GUTTER + dim(l));
+    // SAY WHAT IS ACTUALLY IN IT (reported 2026-10-02). This line used to read "It CONTAINS API
+    // keys" under a summary that said "no key" four times: the pasted text held key NAMES only, and
+    // the person carried the file to another machine believing the keys were inside.
+    const n = pr.presetKeyCounts(out);
+    if (!n.withValue) {
+      console.log(GUTTER + yellow("It contains NO API keys") + dim(n.nameOnly ? ` — only the names of ${n.nameOnly}. Using it will ask you to paste each one.` : "."));
+      console.log(GUTTER + dim("To carry keys: on the computer that HAS them run /open-presets and copy (keys included)."));
+      return;
+    }
+    if (n.nameOnly) console.log(GUTTER + yellow(`${n.nameOnly} of its keys ${n.nameOnly === 1 ? "is" : "are"} a name only`) + dim(" — their values are not in the file."));
   } else {
     writeFileSync(file, JSON.stringify(pr.buildPreset({ name, preset: parsed.preset, host: hostname() }), null, 2) + "\n", { mode: 0o600 });
     console.log(GUTTER + `Preset "${name}" saved to ${file}`);
@@ -7879,6 +7902,128 @@ async function runPricesUpdate() {
   }
 }
 
+// ---------------------------------------------------------------------------------------------
+// "CLEAR LOGS" (#329): a quiet item at the right of the notice row once gu's logs are worth a row,
+// and /clear-logs for where there is no mouse. A click deletes nothing: it MEASURES — the logs,
+// and beside them the two things that are actually big, the RAG indexes and the downloaded API
+// versions — shows that with a total, then asks about each. What each "clear" may and may not
+// touch is decided in clear-logs.mjs; this is the terminal half only.
+// ---------------------------------------------------------------------------------------------
+let logsBytes = 0; // what the notice shows; only the logs are measured for it (a handful of stats)
+let clearLogsBusy = false;
+
+async function refreshLogsSize() {
+  try {
+    const { surveyLogs } = await import("./clear-logs.mjs");
+    const was = clearLogsNoticeText(logsBytes);
+    logsBytes = (await surveyLogs()).bytes;
+    if (clearLogsNoticeText(logsBytes) !== was && barPinned()) paintBar();
+  } catch {
+    /* a housekeeping notice is never worth an error */
+  }
+}
+
+async function runClearLogs() {
+  // ONE AT A TIME, and never over a turn or another picker — reached from a fire-and-forget click
+  // (see showOtherAgents for what a second picker over the first one does).
+  if (clearLogsBusy || listPickerActive || approvalActive || following) return;
+  clearLogsBusy = true;
+  try {
+    const cl = await import("./clear-logs.mjs");
+    const { LOCAL_API_PORT } = await import("./client-expert-api.mjs");
+    const width = Math.max(20, process.stdout.columns || 80);
+    console.log("\n" + GUTTER + dim("Measuring ~/.gonext…"));
+    // Which API version is ANSWERING decides what "old" means — ask it, do not infer it.
+    const runningVersion = await fetch(`http://127.0.0.1:${LOCAL_API_PORT}/api/health`, { signal: AbortSignal.timeout(2000) })
+      .then((r) => r.json())
+      .then((j) => String(j?.version ?? ""))
+      .catch(() => "");
+    const survey = await cl.surveyDisk({ runningVersion });
+    console.log("");
+    for (const row of cl.summaryRows(survey, { width: width - GUTTER.length - 1 })) {
+      console.log(GUTTER + (row.startsWith("Total") ? bold(row) : row));
+    }
+    const freed = [];
+    // A question never wraps: at 80 columns over SSH the picker hint goes on a row of its own.
+    const question = (q) => {
+      const hint = `(${PICK_HINT}):`;
+      console.log("");
+      if (2 + q.length + 2 + hint.length < width) console.log(dim(`  ${q}  ${hint}`));
+      else console.log(dim(`  ${q}\n  ${hint}`));
+    };
+    const cancelled = () => {
+      console.log(dim(`  (stopped — nothing ${freed.length ? "further " : ""}removed)\n`));
+      paintBar();
+    };
+
+    // 1. THE LOGS — what was asked for, so Yes is the first row.
+    if (survey.logs.bytes > 0) {
+      question(`Clear the logs — ${cl.humanSize(survey.logs.bytes)}?`);
+      const go = await pickFromList(["Yes — clear the logs" + dim("  · the worker and the API keep running"), "No"], 0);
+      if (go < 0) return cancelled();
+      if (go === 0) {
+        const r = await cl.clearLogs(survey.logs);
+        freed.push({ what: "logs", ...r });
+        console.log(GUTTER + accent(`✓ logs cleared — ${cl.humanSize(r.freed)} freed`) +
+          (r.failed.length ? yellow(`  (still in use, left alone: ${r.failed.join(", ")})`) : ""));
+      } else {
+        console.log(GUTTER + dim("logs kept"));
+      }
+    } else {
+      console.log("\n" + GUTTER + dim("No logs to clear."));
+    }
+
+    // 2. RAG — costs a re-index, so No is the first row.
+    if (survey.rag.indexes.length) {
+      const gone = survey.rag.indexes.filter((i) => i.missing);
+      const goneBytes = gone.reduce((n, i) => n + i.bytes, 0);
+      const choices = [{ id: "no", label: "No — keep them" }];
+      if (gone.length && gone.length < survey.rag.indexes.length) {
+        choices.push({ id: "gone", label: `Only the ${gone.length} whose folder no longer exists — ${cl.humanSize(goneBytes)}` });
+      }
+      choices.push({ id: "all", label: `Yes — all ${survey.rag.indexes.length}` + dim("  · a folder is indexed again when it is next used") });
+      question(`Also clear the RAG indexes — ${cl.humanSize(survey.rag.bytes)}?`);
+      const pick = await pickFromList(choices.map((c) => c.label), 0);
+      if (pick < 0) return cancelled();
+      if (choices[pick].id !== "no") {
+        const r = await cl.clearRagIndexes(choices[pick].id === "gone" ? gone : survey.rag.indexes);
+        freed.push({ what: "rag", ...r });
+        console.log(GUTTER + accent(`✓ ${r.removed} RAG index${r.removed === 1 ? "" : "es"} cleared — ${cl.humanSize(r.freed)} freed`) +
+          (r.failed.length ? yellow(`  (could not remove: ${r.failed.join(", ")})`) : ""));
+      } else {
+        console.log(GUTTER + dim("RAG indexes kept"));
+      }
+    }
+
+    // 3. THE API — only ever the OLDER versions; the one in use is not on offer.
+    if (survey.api.old.length) {
+      const n = survey.api.old.length;
+      question(`Also remove the ${n} older API version${n === 1 ? "" : "s"} — ${cl.humanSize(survey.api.oldBytes)}?`);
+      const go = await pickFromList(["No — keep them", `Yes — remove the ${n} older one${n === 1 ? "" : "s"}` +
+        dim(survey.api.inUse ? `  · ${survey.api.inUse}, the one in use, stays` : "")], 0);
+      if (go < 0) return cancelled();
+      if (go === 1) {
+        console.log(GUTTER + dim("Removing…"));
+        const r = await cl.clearOldApiVersions(survey.api.old);
+        freed.push({ what: "api", ...r });
+        console.log(GUTTER + accent(`✓ ${r.removed} older API version${r.removed === 1 ? "" : "s"} removed — ${cl.humanSize(r.freed)} freed`) +
+          (r.failed.length ? yellow(`  (could not remove: ${r.failed.join(", ")})`) : ""));
+      } else {
+        console.log(GUTTER + dim("older API versions kept"));
+      }
+    }
+
+    const total = freed.reduce((n, f) => n + f.freed, 0);
+    console.log("\n" + GUTTER + (freed.length ? bold(`${cl.humanSize(total)} freed in all.`) : dim("Nothing removed.")) + "\n");
+  } catch (e) {
+    console.log(GUTTER + red(`couldn't finish — ${e?.message ?? e}`) + "\n");
+  } finally {
+    clearLogsBusy = false;
+    await refreshLogsSize();
+    if (barPinned()) paintBar();
+  }
+}
+
 /**
  * `/embed-model` — switch the RAG embedder, the embed server, or the embed key (task #169).
  *
@@ -12844,6 +12989,8 @@ async function main() {
   // #323: gu's newest published price + cache tables — same cadence, same silent failure.
   void refreshPriceUpdate();
   setInterval(() => void refreshPriceUpdate(), UPDATE_CHECK_MS).unref();
+  void refreshLogsSize();
+  setInterval(() => void refreshLogsSize(), UPDATE_CHECK_MS).unref();
   // The gu token (#232): same arrangement — background, never delays the prompt, unref'd.
   startupTokenRefresh = refreshCliToken();
   setInterval(() => void refreshCliToken(), TOKEN_TICK_MS).unref();
@@ -13304,6 +13451,10 @@ async function main() {
       await runPricesCommand(line);
       continue;
     }
+    if (line === "/clear-logs") {
+      await runClearLogs();
+      continue;
+    }
     if (line === "/tokens") {
       // Task #142: WHERE the last request's prompt went. The bar answers "how much is RAG";
       // this answers "and what displaced it", which is the part that tells you whether RAG is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.791",
+  "version": "1.0.792",
   "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",
@@ -77,6 +77,7 @@
     "poll-errors.mjs",
     "node-version.mjs",
     "clear-state.mjs",
+    "clear-logs.mjs",
     "platform-tools.mjs",
     "job-pools.mjs",
     "agent-stop.mjs",

package/preset-apply.mjs

@@ -18,7 +18,7 @@
  */
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { buildFullPreset, keysToApply } from "./presets-transfer.mjs";
+import { buildFullPreset, keysToApply, keyHiddenInName, shownKeyName } from "./presets-transfer.mjs";
 import { planLoad, toSettingsPatch } from "./settings-transfer.mjs";
 import { existingBackendRows, providerRowForUrl } from "./coding-provider-setup.mjs";
 
@@ -86,7 +86,7 @@ export async function applyTransfer(value, { api, io, fromLine = "", carriesSecr
     : plan.lines;
   for (const l of lines) say(l);
   if (summary && plan.replaces) say(`replaces the ${plan.replaces} coding provider${plan.replaces === 1 ? "" : "s"} on this account.`);
-  for (const w of warnings) say("⚠ " + w, "warn");
+  for (const w of new Set(warnings)) say("⚠ " + w, "warn");
   if (carriesSecrets) say("this file contains API keys in plain text — delete it when you are done.", "warn");
   const go = String((await io.ask("apply this? [y/N] ")) ?? "").trim().toLowerCase();
   if (go !== "y" && go !== "yes") {
@@ -116,22 +116,32 @@ export async function applyTransfer(value, { api, io, fromLine = "", carriesSecr
   const rows = existingBackendRows(fresh);
   const { add, kept } = keysToApply(value, { currentKeys: keys, rows, missing: plan.missingKeys });
   for (const k of kept) {
-    say(`kept your existing key ${k.name} for ${k.backendUrl} (the preset's copy was not used).`);
+    say(`kept your existing key ${shownKeyName(k)} for ${k.backendUrl} (the preset's copy was not used).`);
     if (k.default && k.rowId && k.existingId && !(await api.setDefaultKey(k.rowId, k.existingId))) {
       say(`could not make ${k.name} the default for ${k.backendUrl} — pick it in /model with ctrl+k.`, "err");
     }
   }
-  for (const k of add) {
-    const where = k.backendUrl ? ` for ${k.backendUrl}` : "";
-    const typed = k.key || String((await io.ask(`key "${k.name}"${k.tail ? ` (…${k.tail})` : ""}${where} — paste it, or Enter to skip: `)) ?? "").trim();
+  for (const k0 of add) {
+    const where = k0.backendUrl ? ` for ${k0.backendUrl}` : "";
+    // A NAME THAT IS THE KEY ITSELF (see keyHiddenInName): use it as the value it always was, and
+    // give the key a real name — its server — so the secret stops being printed as a label.
+    const hidden = k0.key ? "" : keyHiddenInName(k0);
+    let hostName = "";
+    try {
+      hostName = new URL(k0.backendUrl).hostname;
+    } catch { /* no server — keep a neutral name */ }
+    const k = hidden ? { ...k0, key: hidden, name: hostName || "key" } : k0;
+    const shown = shownKeyName(k0);
+    if (hidden) say(`the key named ${shown}${where} IS the key — using it, saved as "${k.name}".`);
+    const typed = k.key || String((await io.ask(`key "${shown}"${k.tail ? ` (…${k.tail})` : ""}${where} — paste it, or Enter to skip: `)) ?? "").trim();
     if (!typed) {
-      say(`skipped ${k.name} — add it later with ctrl+k.`);
+      say(`skipped ${shown}${where} — its value is not in the preset; add it later with ctrl+k.`);
       continue;
     }
     const id = await api.addKey(k.name, typed, k.rowId);
     if (!id) {
       out.failed.push(k.name);
-      say(`could not add ${k.name}${where} — add it in /model with ctrl+k.`, "err");
+      say(`could not add ${shown}${where} — add it in /model with ctrl+k.`, "err");
       continue;
     }
     out.added.push(k.name);

package/presets-transfer.mjs

@@ -337,7 +337,12 @@ export function validateFullPreset(doc) {
     }
   }
   const noKey = v.backends.filter((b) => !v.keys.some((k) => k.key && sameServer(k.backendUrl, b.url)));
-  for (const b of noKey) warnings.push(`${b.url} has no key in the preset — it keeps whatever key this machine has for it (or none).`);
+  for (const b of noKey) {
+    const named = v.keys.some((k) => !k.key && sameServer(k.backendUrl, b.url));
+    warnings.push(named
+      ? `${b.url}: the preset names its key but does not carry the value — you will be asked to paste it.`
+      : `${b.url} has no key in the preset — it keeps whatever key this machine has for it (or none).`);
+  }
   // THE DEFAULT CODER must be a server and model the preset itself sets up.
   const cd = doc.codingDefault && typeof doc.codingDefault === "object" ? doc.codingDefault : {};
   if (cd.url !== undefined && cd.url !== "" && !isHttpUrl(cd.url)) {
@@ -404,6 +409,35 @@ const mask = (k) => {
   return v.length <= 8 ? "…" + v.slice(-2) : `${v.startsWith("sk-") ? "sk-" : v.slice(0, 3)}…${v.slice(-4)}`;
 };
 
+/**
+ * IS THIS KEY'S *NAME* ACTUALLY THE KEY? (reported 2026-10-02) → the key, or "".
+ * A key pasted into the NAME question is stored as a name, and from then on it is printed in full
+ * wherever a name is shown ("skipped sk-E8Iv…3E66 — add it later") and travels in every names-only
+ * export — while its value is asked for again. The tail settles it: a name that is key-shaped AND
+ * ends in the recorded last four characters is the key.
+ */
+export function keyHiddenInName(k) {
+  const name = clean(k?.name);
+  const tail = clean(k?.tail);
+  if (name.length < 20 || /\s/.test(name) || keyProblem(name)) return "";
+  if (tail ? !name.endsWith(tail) : !/^(sk|pk|rk|xai|gsk|ghp|hf)[-_]/i.test(name)) return "";
+  return name;
+}
+
+/** A key NAME as it may be shown: a name that is itself a key is masked like one. */
+export function shownKeyName(k) {
+  const name = clean(typeof k === "string" ? k : k?.name);
+  const secret = keyHiddenInName(typeof k === "string" ? { name } : k);
+  return secret ? `${mask(secret)} (a key saved as its own name)` : name;
+}
+
+/** How many of a preset's keys carry a VALUE, and how many are only a name. */
+export function presetKeyCounts(v) {
+  const keys = Array.isArray(v?.keys) ? v.keys : [];
+  const withValue = keys.filter((k) => k.key).length;
+  return { withValue, nameOnly: keys.length - withValue };
+}
+
 /** The whole preset with every key MASKED — what is printed; the file / the copy keep the real keys. */
 export function maskedFullPreset(doc) {
   return { ...doc, keys: (Array.isArray(doc?.keys) ? doc.keys : []).map((k) => ({ ...k, ...(k.key ? { key: mask(k.key) } : {}) })) };
@@ -414,8 +448,15 @@ export function fullPresetSummary(v, codingDefault) {
   const lines = [];
   for (const b of v.backends) {
     const models = [...new Set([b.defaultModel, ...(b.models ?? [])].filter(Boolean))];
-    const key = v.keys.find((k) => k.backendUrl && ensureV1Root(k.backendUrl).toLowerCase() === ensureV1Root(b.url).toLowerCase());
-    lines.push(`  ${b.url}  ${models.join(", ") || "(no models)"}${key?.key ? `  · key ${key.name} ${mask(key.key)}` : "  · no key"}`);
+    const mine = v.keys.filter((k) => k.backendUrl && ensureV1Root(k.backendUrl).toLowerCase() === ensureV1Root(b.url).toLowerCase());
+    const key = mine.find((k) => k.key);
+    // "no key" was printed for a server whose key the preset NAMES but does not carry — the same
+    // words as a server with no key at all, so a names-only preset read as an empty one.
+    const named = mine.filter((k) => !k.key).map((k) => `${shownKeyName(k)}${k.tail && !keyHiddenInName(k) ? ` …${k.tail}` : ""}`);
+    const tell = key?.key
+      ? `  · key ${shownKeyName(key)} ${mask(key.key)}`
+      : named.length ? `  · key NAME only (${named.join(", ")}) — the value is not in this preset` : "  · no key";
+    lines.push(`  ${b.url}  ${models.join(", ") || "(no models)"}${tell}`);
   }
   if (codingDefault?.url || codingDefault?.model) lines.push(`coding model: ${codingDefault.model || "?"} at ${codingDefault.url || "?"}`);
   return lines;

package/settings-transfer.mjs

@@ -344,7 +344,7 @@ export function planLoad(file, current = {}) {
   }
   if (missingKeys.length) {
     lines.push(`${missingKeys.length} API key${missingKeys.length === 1 ? "" : "s"} this account does not have — gu will ask for ${missingKeys.length === 1 ? "it" : "them"} after:`);
-    for (const k of missingKeys) lines.push(`  ${k.name}${k.tail ? ` (…${k.tail})` : ""}${k.backendUrl ? ` for ${k.backendUrl}` : ""}`);
+    for (const k of missingKeys) lines.push(`  ${listedKeyName(k)}${k.tail ? ` (…${k.tail})` : ""}${k.backendUrl ? ` for ${k.backendUrl}` : ""}`);
   }
   // The account default is NOT in the file and is not touched — said out loud, because someone
   // loading "their models" onto a machine reasonably expects the coder to change too.
@@ -352,6 +352,19 @@ export function planLoad(file, current = {}) {
   return { lines, missingKeys, replaces: currentRows.length, adds: file.backends.length };
 }
 
+/**
+ * A key NAME as this list may print it. A key typed into the name question is stored AS the name,
+ * and the full secret was then printed here (reported 2026-10-02). A key-shaped name ending in the
+ * key's recorded tail is masked. (presets-transfer.mjs keyHiddenInName is the same rule, with the
+ * stricter key checks it has; it imports this module, so the rule cannot be shared the other way.)
+ */
+function listedKeyName(k) {
+  const name = String(k?.name ?? "").trim();
+  const tail = String(k?.tail ?? "").trim();
+  if (name.length >= 20 && !/\s/.test(name) && tail && name.endsWith(tail)) return `${name.slice(0, 3)}… (a key saved as its own name)`;
+  return name;
+}
+
 /**
  * The POST body for /api/worker/settings. Only fields a worker key may write.
  *