@tiens.nguyen/gu-cli 1.0.796 → 1.0.798

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.796",
+  "version": "1.0.798",
   "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/terminal-layout.mjs

@@ -1950,6 +1950,55 @@ export function describeInstallFailure({ status = 0, stderr = "", error = null }
  */
 export const CLI_UPDATE_SHELL_COMMAND = `${CLI_INSTALL_COMMAND} --prefer-online`;
 
+/**
+ * WHERE the update installs, so it lands on the gu that is RUNNING (task #16 follow-up).
+ *
+ * A bare `npm install -g` uses whichever npm is first on PATH — which, with nvm AND Homebrew (or
+ * several nvm versions) installed, is often not the npm that owns this gu. The install then
+ * "succeeds" into the OTHER prefix and the next `gu` still starts the old version. So:
+ *   · `--prefix <prefix>` — the global prefix THIS package lives under (globalPrefixOf), when
+ *     the caller found one (a checkout / npm link has none, and keeps the plain command);
+ *   · the running node's bin dir goes first on PATH, so `npm` is the one that matches this node.
+ * POSIX only: Windows resolves npm.cmd through the shell and keeps its own prefix rules.
+ * → { command, env, prefix }
+ */
+export function cliUpdatePlan({ prefix = "", execPath = "", platform = process.platform, env = {} } = {}) {
+  const posix = platform !== "win32";
+  let command = CLI_UPDATE_SHELL_COMMAND;
+  let usedPrefix = "";
+  // A prefix with shell metacharacters is not worth quoting cleverly: fall back to the plain command.
+  if (posix && prefix && !/["$`\\\n]/.test(prefix)) {
+    command += ` --prefix "${prefix}"`;
+    usedPrefix = prefix;
+  }
+  let nextEnv = { ...env };
+  if (posix && execPath && execPath.includes("/")) {
+    const bin = execPath.slice(0, execPath.lastIndexOf("/")) || "/";
+    nextEnv.PATH = env.PATH ? `${bin}:${env.PATH}` : bin;
+  }
+  return { command, env: nextEnv, prefix: usedPrefix };
+}
+
+/**
+ * npm exited 0 — but is the gu on disk really the version we meant to install?
+ * → null when fine (or unknowable), otherwise the sentence to show. Compares numeric parts, so a
+ * NEWER version published in between is fine; only an installed version OLDER than wanted fails.
+ */
+export function installedVersionShortfall(installed = "", wanted = "") {
+  const parse = (v) => String(v ?? "").split("-")[0].split(".").map((n) => parseInt(n, 10));
+  const a = parse(installed), b = parse(wanted);
+  if (!installed || !wanted || a.some(Number.isNaN) || b.some(Number.isNaN)) return null;
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const x = a[i] ?? 0, y = b[i] ?? 0;
+    if (x > y) return null;
+    if (x < y) {
+      return `npm finished, but the gu on disk is still ${installed} (wanted ${wanted}) — ` +
+        "run `npm install -g @tiens.nguyen/gu-cli@latest` in a terminal, then restart gu.";
+    }
+  }
+  return null;
+}
+
 /**
  * Did the install fail only because npm has not caught up with a JUST-published version?
  * (ETARGET / notarget — "No matching version found".) Worth one retry after a short wait, and