@tiens.nguyen/gu-cli 1.0.796 → 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/package.json

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