@tiens.nguyen/gu-cli 1.0.795 → 1.0.797

package/log-level.mjs

@@ -0,0 +1,193 @@
+/**
+ * HOW MUCH THIS MACHINE LOGS (task #352) — almost nothing, unless a `gu --log` run is open.
+ *
+ * The owner's rule (2026-10-04): "reduce logs to super minimum — only log like currently if the
+ * user does `gu --log`; minimum is only if something starts, something stops, or an error occurs",
+ * and "--log is per run".
+ *
+ * Measured on the Mac it was asked for: nearly every line of worker.log was the agent's per-step
+ * narration relayed by the worker — "=== MODEL REQUEST", "step N ← model output", "heartbeat:
+ * model call in flight" — about 150 lines a turn, none of which say that anything went wrong.
+ *
+ * TWO LEVELS:
+ *   · "minimal" (the default) — a line when something STARTS (the worker, a job), one when it
+ *     STOPS (how it ended, how long it took), and every ERROR or warning. Nothing per step, per
+ *     request, per heartbeat.
+ *   · "detail" — exactly what was logged before this existed (the account's profile, "production"
+ *     or "full", see log-policy.mjs). On only while a `gu --log` terminal is open.
+ *
+ * PER RUN, AND THE WORKER OUTLIVES THE RUN. The terminal that was started with --log writes a
+ * LEASE — a small file holding its pid. The worker reads it; a lease whose process is gone is no
+ * lease. So closing that terminal, or killing it, puts the machine back at minimal with nothing
+ * to switch off and no setting left behind.
+ */
+import { readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { readFileSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const LEASE_FILE = join(homedir(), ".gonext", "log-detail.json");
+
+/** Is that process still running? (signal 0 asks without sending anything.) */
+export function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    // EPERM: it exists, it is just not ours to signal.
+    return e?.code === "EPERM";
+  }
+}
+
+/** What a lease file's text says: the pid of the `gu --log` run, or 0 when it is not a lease. */
+export function leasePid(text) {
+  try {
+    const pid = JSON.parse(String(text ?? ""))?.pid;
+    return Number.isInteger(pid) && pid > 1 ? pid : 0;
+  } catch {
+    return 0;
+  }
+}
+
+/** The level a lease's text selects: "detail" only while its process is alive. Pure given `alive`. */
+export function levelFor(leaseText, alive = pidAlive) {
+  const pid = leasePid(leaseText);
+  return pid && alive(pid) ? "detail" : "minimal";
+}
+
+/** The level right now. Synchronous and never throws: it sits on the path of every log line. */
+export function currentLevel({ file = LEASE_FILE, alive = pidAlive } = {}) {
+  try {
+    return levelFor(readFileSync(file, "utf8"), alive);
+  } catch {
+    return "minimal"; // no lease file
+  }
+}
+
+/** `gu --log` started: take the lease for this run. */
+export async function takeLease({ file = LEASE_FILE, pid = process.pid, now = new Date() } = {}) {
+  const tmp = `${file}.${pid}.tmp`;
+  await writeFile(tmp, JSON.stringify({ pid, since: now.toISOString() }) + "\n", "utf8");
+  await rename(tmp, file);
+}
+
+/** That run is ending: give the lease back — but only if it is still OURS (a later --log run may hold it). */
+export async function releaseLease({ file = LEASE_FILE, pid = process.pid } = {}) {
+  try {
+    if (leasePid(await readFile(file, "utf8")) === pid) await unlink(file);
+  } catch {
+    /* nothing to release */
+  }
+}
+
+/** The same, for an "exit" handler — which may only do synchronous work. */
+export function releaseLeaseSync({ file = LEASE_FILE, pid = process.pid } = {}) {
+  try {
+    if (leasePid(readFileSync(file, "utf8")) === pid) unlinkSync(file);
+  } catch {
+    /* nothing to release */
+  }
+}
+
+// What is kept at "minimal". Two lists, read as: is this line about a START or a STOP, or does it
+// say something went WRONG? Everything else is narration.
+//
+// LIFECYCLE — the worker and each job, coming and going.
+const LIFECYCLE = [
+  /\[gu-worker\] gu-cli v/, // the worker started, and which version wrote this log
+  /\[gu-worker\] daemon (started|RUNNING|stopped)/,
+  /\[gu-worker\] (started|completed|cancelled|stopped|stopping|shutting down)\b/,
+  /\[gu-worker\] log (level|profile):/,
+  /\bAPI listening on\b/,
+  /\[mongo\] (connected|disconnected)/,
+];
+// TROUBLE — written to be generous: a line kept by mistake costs a line; a dropped error costs
+// the afternoon it takes to find out why a turn failed.
+const TROUBLE =
+  /\b(error|errors|errored|fail|failed|failure|fatal|exception|traceback|panic|refused|unreachable|unavailable|overloaded|denied|forbidden|unauthori[sz]ed|invalid|rejected|aborted|killed|crash(ed)?|timed out|timeout|not found|cannot|can't|could ?n[o']t|couldn't|unable|warning|warn|degrad\w*|fall(ing|s)? back|fell back|fallback|skipped|lost)\b|✗|⚠|HTTP [45]\d\d|status[= ][45]\d\d/i;
+// System error codes — ENOENT, ECONNRESET, EPERM, ETIMEDOUT. CASE-SENSITIVE and on its own: under
+// the /i above it matched every word starting with "e" ("earlier", "exact", "explicit"), which
+// kept half the narration. Measured on a real worker.log before this line was split out.
+const ERRNO = /\bE[A-Z]{4,}\b/;
+
+/** Does a line survive at the minimal level? Pure. */
+export function keepAtMinimal(line) {
+  const text = String(line ?? "");
+  if (!text.trim()) return false;
+  if (LIFECYCLE.some((re) => re.test(text))) return true;
+  return TROUBLE.test(text) || ERRNO.test(text);
+}
+
+/**
+ * Filter what the process prints, a LINE at a time, while `level()` says "minimal".
+ *
+ * worker.log IS this process's stdout/stderr (the launcher appends them to the file), so this is
+ * the one place every line passes through — the worker's own and the agent's relayed ones — which
+ * is why the rule lives here and not at 300 call sites.
+ *
+ *   · stdout: a line is written only if keepAtMinimal says so. A chunk may hold several lines or
+ *     end mid-line, so text is held until its newline arrives.
+ *   · stderr: everything passes. console.error / console.warn are errors and warnings by intent,
+ *     and a Node stack trace must arrive whole.
+ *
+ * Install it AFTER the timestamps (log-policy.mjs installTimestamps): each wrapper wraps the
+ * stream as it finds it, so the last one installed is the first a line meets — the filter decides,
+ * and only a kept line goes on to be stamped. Returns an undo.
+ */
+export function installLevelFilter(level, { out = process.stdout } = {}) {
+  const write = out.write.bind(out);
+  let held = "";
+  let dropped = 0;
+  out.write = (chunk, encoding, cb) => {
+    const done = typeof encoding === "function" ? encoding : cb;
+    if ((typeof chunk !== "string" && !Buffer.isBuffer(chunk)) || level() !== "minimal") {
+      if (held) {
+        // The level just rose mid-line: what was held belongs to the detailed log.
+        const h = held;
+        held = "";
+        write(h);
+      }
+      return write(chunk, encoding, cb);
+    }
+    held += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
+    let keep = "";
+    let at;
+    while ((at = held.indexOf("\n")) !== -1) {
+      const line = held.slice(0, at);
+      held = held.slice(at + 1);
+      if (keepAtMinimal(line)) keep += line + "\n";
+      else dropped++;
+    }
+    // A runaway line with no newline must not grow in memory for ever.
+    if (held.length > 65536) held = held.slice(-4096);
+    if (keep) return write(keep, undefined, done);
+    if (typeof done === "function") done();
+    return true;
+  };
+  const undo = () => {
+    out.write = write;
+  };
+  /** Lines dropped since the last call — for the "stopped" line, so a quiet log says it was quiet on purpose. */
+  undo.takeDropped = () => {
+    const n = dropped;
+    dropped = 0;
+    return n;
+  };
+  return undo;
+}
+
+/** run-logs/ at minimal: the last day's, at most 20 files (production keeps 7 days / 200). */
+export const MINIMAL_RUN_LOGS = { maxAgeMs: 86_400_000, maxFiles: 20 };
+
+/** The profile an agent run is told to log at: "minimal", or the account's own while --log is open. */
+export function agentLogProfile(level, accountProfile) {
+  return level === "detail" ? accountProfile || "full" : "minimal";
+}
+
+/** One line for `gu status` and the worker's log. */
+export function levelLine(level) {
+  return level === "detail"
+    ? "log level: detail — a `gu --log` terminal is open; back to minimal when it closes"
+    : "log level: minimal — starts, stops and errors only (`gu --log` for the detail)";
+}

package/model-prices.mjs

@@ -177,6 +177,33 @@ export function turnCost({ input = 0, cached = 0, cacheReported = false, firstIn
 }
 
 /** "$1.23", "$0.123", "$0.0042"; "~" in front when the cached share was assumed. */
+/**
+ * WHAT THE BAR SAYS ABOUT THE LAST TURN'S COST (task #349).
+ *
+ * Reported: "price and cost is not shown on this gu terminal on this Mac." The coder there was a
+ * self-hosted Ollama model, which is in no price table — and for a model with no price the bar
+ * showed NOTHING, by design ("never a misleading | $0"). Right about the $0, wrong about the
+ * silence: a missing figure looked like a broken feature. So the three cases are told apart:
+ *
+ *   a price was found      → { kind: "cost", text: "$0.334" | "~$0.334" }
+ *   the turn's model has none → { kind: "none", text: "no price" }   — never "$0": it is not free,
+ *                                                                     it is not priced
+ *   no turn has run yet    → null (there is nothing to say)
+ *
+ * `last` is the terminal's lastTurnCost: { usd, estimated } or { usd: null, model, host }.
+ */
+export function costSegment(last) {
+  if (!last) return null;
+  if (last.usd == null) return { kind: "none", text: "no price" };
+  return { kind: "cost", text: formatUsd(last.usd, { estimated: last.estimated === true }) };
+}
+
+/** The line /prices prints when the coder in use has no price — why, and that nothing is broken. */
+export function noPriceLine({ model = "", host = "" } = {}) {
+  const what = `${model || "the coder"}${host ? ` at ${host}` : ""}`;
+  return `no price for ${what} — its turns show "no price" on the bar instead of a cost. The table prices hosted providers; a model on your own server has none.`;
+}
+
 export function formatUsd(usd, { estimated = false } = {}) {
   if (!Number.isFinite(usd)) return "";
   const v = Math.max(0, usd);

package/model-setup-ui.mjs

@@ -1,7 +1,7 @@
 /**
  * THE WAY OUT OF THE MODEL QUESTIONS, and the key question that follows a typed server (#301).
  *
- * Reported: at "Agent + embedding server [https://ollama1.gomarsic.cc]:" there was no visible way
+ * Reported: at "Agent + embedding server [https://ollama1.getmarsic.cc]:" there was no visible way
  * to NOT choose. Enter takes the default server; a decline existed ("n", "no", "skip", "-") but no
  * prompt said so, and one hint even claimed "press Enter with no address to skip", which was the
  * opposite of what Enter does. Some people want no model setup at all and to load a saved preset.

package/ollama-setup.mjs

@@ -1,7 +1,7 @@
 /**
  * Pointing a Client Expert machine at ITS OWN Ollama box (task #220).
  *
- * Setup used to seed https://ollama1.gomarsic.cc and three model names, so anyone whose box is
+ * Setup used to seed https://ollama1.getmarsic.cc and three model names, so anyone whose box is
  * somewhere else — a company LAN, http://192.168.1.40:11434, their own dnsname — had to know to
  * override environment variables they had never heard of. This module is the pure half of asking
  * instead: normalise whatever URL they type, and turn the list that box actually reports into the
@@ -180,8 +180,8 @@ export function describeNotReady(host, missing) {
  *   192.168.1.40:11434           → http://192.168.1.40:11434/v1
  *   ollama.local                 → http://ollama.local:11434/v1
  *   http://box:11434/v1          → http://box:11434/v1
- *   https://ollama1.gomarsic.cc  → https://ollama1.gomarsic.cc/v1
- *   https://ollama1.gomarsic.cc/v1/ → https://ollama1.gomarsic.cc/v1
+ *   https://ollama1.getmarsic.cc  → https://ollama1.getmarsic.cc/v1
+ *   https://ollama1.getmarsic.cc/v1/ → https://ollama1.getmarsic.cc/v1
  *
  * TWO DEFAULTS, AND THEY ARE NOT SYMMETRICAL:
  *
@@ -243,7 +243,7 @@ export function normalizeOllamaUrl(raw) {
  * Every address a bare hostname could reasonably mean, in the order worth trying.
  *
  * ONE GUESS IS NOT ENOUGH, and this was found by typing a real hostname at a real prompt:
- * `ollama2.gomarsic.cc` became `http://ollama2.gomarsic.cc:11434` and timed out, because that
+ * `ollama2.getmarsic.cc` became `http://ollama2.getmarsic.cc:11434` and timed out, because that
  * box is behind a reverse proxy on HTTPS:443 — exactly like ollama1. The single default is
  * right for a LAN box and wrong for a public name, and the reader has no way to know which
  * assumption we made beyond a timeout that looks like their server is down.
@@ -390,7 +390,7 @@ export async function localOllamaDefault(fallbackUrl, fetchTags, { log } = {}) {
  *
  * DISPLAY ONLY. Every settings field in gu stores the /v1 base, because that is the
  * OpenAI-compatible endpoint the API actually calls; nothing about what is SAVED changes here.
- * What changes is what we show: a default of "https://ollama1.gomarsic.cc/v1" reads as an
+ * What changes is what we show: a default of "https://ollama1.getmarsic.cc/v1" reads as an
  * instruction, and the reader is left wondering whether their own address needs the suffix too
  * (reported 2026-09-04: "it makes user confused if he/she should input v1 to the url").
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.795",
+  "version": "1.0.797",
   "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",
@@ -76,6 +76,7 @@
     "device-login.mjs",
     "daemon-control.mjs",
     "log-policy.mjs",
+    "log-level.mjs",
     "full-log-command.mjs",
     "poll-errors.mjs",
     "node-version.mjs",

package/proxy-config.mjs

@@ -126,8 +126,8 @@ export function isLoopbackUrl(url) {
 /**
  * The origin (scheme + host + port) of a URL, which is what "the same endpoint" means here.
  *
- * A configured model is https://ollama1.gomarsic.cc/v1 while the actual call is
- * https://ollama1.gomarsic.cc/v1/chat/completions — comparing full URLs would match neither, and
+ * A configured model is https://ollama1.getmarsic.cc/v1 while the actual call is
+ * https://ollama1.getmarsic.cc/v1/chat/completions — comparing full URLs would match neither, and
  * comparing hostnames alone would proxy a DIFFERENT service that happens to share the host.
  * Origin is the level that means "this endpoint", and URL normalizes the default port for us.
  */
@@ -141,7 +141,7 @@ export function originOf(url) {
 
 /**
  * The three model endpoints, read from the settings row rather than hardcoded — the user can
- * change any of them at any time (/model, the web app), and a hardcoded ollama1.gomarsic.cc
+ * change any of them at any time (/model, the web app), and a hardcoded ollama1.getmarsic.cc
  * would keep proxying an endpoint they have already moved away from.
  */
 export function modelOrigins(settings = {}) {

package/terminal-hover.mjs

@@ -63,10 +63,38 @@ export function applyToggleShift(blocks, block, newEnd) {
  *   write(seq)          → put bytes on screen.
  *   afterPaint()        → put the caret back where the user is typing.
  */
+/**
+ * DOES A CLICK ON THIS BLOCK CHANGE ANYTHING? (task #350) — the ONE question hover and click
+ * both ask.
+ *
+ * Reported: "hover an item and it becomes whiter; some items, you click and nothing expands — so
+ * the user is confused. Only allow hover to turn white if it is expandable." A highlight is a
+ * promise that a click does something. Every thought and every look-up row made that promise;
+ * a short thought that is already shown whole could not keep it.
+ *
+ * A block has two forms, collapsed and expanded. It can be toggled exactly when they are not the
+ * same rows — which answers every case without a list of kinds:
+ *   · a long thought, collapsed       → different rows → highlight, click expands
+ *   · the same thought, expanded      → different rows → highlight, click collapses
+ *   · a thought that fits as it is    → identical rows → no highlight, click does nothing
+ *   · one look-up that fits its row   → identical rows → no highlight
+ * …and it follows the WINDOW: the rows are laid out for the current width, so a thought that
+ * fits at 160 columns and is cut at 80 is expandable at 80 only.
+ */
+export function rowsDiffer(collapsedRows, expandedRows) {
+  const a = collapsedRows ?? [];
+  const b = expandedRows ?? [];
+  if (a.length !== b.length) return true;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return true;
+  return false;
+}
+
 export function createHoverController({
   pinned = () => true,
   transcriptRows = () => 1,
   blockAtRow = () => null,
+  // #350: may this block be highlighted — i.e. would a click on it change anything?
+  canToggle = () => true,
   paintRows = () => [],
   replaceRange = () => null,
   repaintSeq = () => "",
@@ -101,7 +129,10 @@ export function createHoverController({
     if (key === lastKey) return false;
     lastKey = key;
 
-    const block = blockAtRow(row);
+    // ONLY WHAT A CLICK WOULD CHANGE (#350). A block that is already shown whole is treated as
+    // no block at all: nothing lights up, and whatever was lit before is put back.
+    const under = blockAtRow(row);
+    const block = under && canToggle(under) ? under : null;
     if (block === hovered) return false;
     const previous = hovered;
     hovered = block;

package/terminal-layout.mjs

@@ -528,6 +528,61 @@ export function buildFooterRows({
   ];
 }
 
+/**
+ * A SUBMITTED QUESTION, LAID OUT FOR THE TRANSCRIPT (task #348): every row at the column where
+ * the first one's text starts — after ">> ".
+ *
+ * Reported with a screenshot: a pasted question of many lines was echoed as ">> Build the first
+ * playable…" and then every other line hard against the left edge. The echo was the prompt plus
+ * the text exactly as typed, so only the first line had anything in front of it; a long line was
+ * left for the terminal to soft-wrap, back to column 0 as well.
+ *
+ * → rows WITHOUT the prompt: the caller puts ">> " before the first and `indent` spaces before
+ * the rest. Blank lines stay empty (no trailing spaces). A line's own leading spaces are kept —
+ * pasted code and nested lists keep their shape — and its wrapped rows start under its first
+ * word. A word longer than the row is cut rather than left to overflow.
+ */
+export function questionEchoRows(text, { width = 80, indent = 3 } = {}) {
+  const rows = [];
+  for (const line of String(text ?? "").replace(/\r/g, "").split("\n")) {
+    if (line.trim() === "") {
+      rows.push("");
+      continue;
+    }
+    const lead = /^[ \t]*/.exec(line)[0].replace(/\t/g, "  ");
+    const avail = Math.max(8, (width || 80) - 1 - indent - visibleLen(lead));
+    let cur = "";
+    for (let word of line.trim().split(/\s+/)) {
+      while (visibleLen(word) > avail) {
+        if (cur) {
+          rows.push(lead + cur);
+          cur = "";
+        }
+        const head = clipVisible(word, avail);
+        rows.push(lead + head);
+        word = word.slice(head.length);
+      }
+      if (!word) continue;
+      const next = cur ? `${cur} ${word}` : word;
+      if (visibleLen(next) <= avail) cur = next;
+      else {
+        rows.push(lead + cur);
+        cur = word;
+      }
+    }
+    if (cur) rows.push(lead + cur);
+  }
+  return rows;
+}
+
+/** The echo itself: ">> " on the first row, the same width of spaces on every other. */
+export function questionEchoText(text, { width = 80, prompt = ">> ", paintPrompt = (s) => s } = {}) {
+  const indent = visibleLen(prompt);
+  const rows = questionEchoRows(text, { width, indent });
+  if (rows.length === 0) return paintPrompt(prompt);
+  return rows.map((r, i) => (i === 0 ? paintPrompt(prompt) + r : r === "" ? "" : " ".repeat(indent) + r)).join("\n");
+}
+
 /**
  * The bytes that print a NEW thought block into the transcript (task #344): its painted rows,
  * with ONE empty line above when the row above is not already blank (`gap`).