@tiens.nguyen/gu-cli 1.0.730 → 1.0.731

package/full-log-command.mjs

@@ -0,0 +1,219 @@
+/**
+ * `gu full-log on|off|status [account]` and `/full-log` in the terminal (task #250) — ONE code path.
+ *
+ * An administrator turns "Enable Full Log" (#249) on or off for an account from a terminal. The
+ * command asks for an ADMIN TOKEN first — minted on the web admin page (Admin → Full Log → Create
+ * CLI token), 15 minutes, one use — and sends it to this machine's own API, which (hosted) decides
+ * or (Client Expert) forwards to the hosted API. The ordinary gu CLI token cannot do this: every
+ * account has one.
+ *
+ * THE TOKEN IS A SECRET HERE TOO: typed masked, never echoed, never printed, never logged, never
+ * saved. It lives in one local variable for one request.
+ *
+ * `status` for THIS machine's account needs no token (reading your own setting is harmless, and
+ * the worker reads it every 5 minutes anyway). Another account's status needs one.
+ */
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export const USAGE = "gu full-log on|off|status [email or account id]";
+/** The daemon's minute tick sees this and re-reads the policy at once (see gu-cli.mjs startLogPolicy). */
+export const REFRESH_FLAG = join(homedir(), ".gonext", "log-policy.refresh");
+export const TOKEN_PROMPT = "Admin token (Admin → Full Log → Create CLI token), hidden:";
+
+/** → { action: "on"|"off"|"status", account? } | { error } */
+export function parseFullLogArgs(words) {
+  const w = (words ?? []).map((s) => String(s).trim()).filter(Boolean);
+  const action = (w[0] ?? "status").toLowerCase();
+  if (!["on", "off", "status"].includes(action)) return { error: `unknown "${w[0]}" — ${USAGE}` };
+  if (w.length > 2) return { error: `too many words — ${USAGE}` };
+  return w[1] ? { action, account: w[1] } : { action };
+}
+
+const onOff = (b) => (b ? "ON" : "OFF");
+
+/** Tell a running worker on this machine to re-read its policy now, instead of within 5 minutes. */
+export async function requestLocalRefresh(file = REFRESH_FLAG) {
+  try {
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, new Date().toISOString() + "\n", "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(res) {
+  return (await res.json().catch(() => null)) ?? {};
+}
+
+/**
+ * Run it. `askSecret(label)` → the typed token ("" = cancelled). `print(line)` writes one line.
+ * → an exit code: 0 done, 1 refused / failed, 2 usage.
+ */
+export async function runFullLog({
+  action,
+  account,
+  apiBase,
+  workerKey,
+  askSecret,
+  print = (l) => console.log(l),
+  fetchImpl = fetch,
+  requestRefresh = requestLocalRefresh,
+}) {
+  const base = String(apiBase ?? "").trim().replace(/\/+$/, "");
+  const key = String(workerKey ?? "").trim();
+  if (!base || !key) {
+    print("This computer is not signed in to gu yet — run `gu login` first.");
+    return 1;
+  }
+  const who = account ? account : "this computer's account";
+
+  // Your own status: no token.
+  if (action === "status" && !account) {
+    let res;
+    try {
+      res = await fetchImpl(`${base}/api/worker/log-policy`, {
+        headers: { "X-Worker-Key": key },
+        signal: AbortSignal.timeout(10_000),
+      });
+    } catch {
+      print(`Could not reach ${base} — try again in a moment.`);
+      return 1;
+    }
+    const body = await readJson(res);
+    if (res.status === 404) {
+      print("Full Log is not available on this gu service yet — this computer keeps full logs until it is.");
+      return 0;
+    }
+    if (!res.ok || typeof body.fullLog !== "boolean") {
+      print(`Could not read the log setting: ${body.error ?? `HTTP ${res.status}`}.`);
+      return 1;
+    }
+    print(
+      body.fullLog
+        ? "Full Log: ON for this computer's account — its logs include what was asked and answered."
+        : "Full Log: OFF for this computer's account — its logs carry no conversation content (the default)."
+    );
+    print(`To change it (administrators): ${USAGE.replace("on|off|status", "on|off")}`);
+    return 0;
+  }
+
+  let token = "";
+  try {
+    token = String((await askSecret(TOKEN_PROMPT)) ?? "").trim();
+  } catch {
+    token = "";
+  }
+  if (!token) {
+    print("No token entered — nothing changed.");
+    return 1;
+  }
+
+  const body = action === "status" ? { account } : { account, fullLog: action === "on" };
+  let res;
+  try {
+    res = await fetchImpl(`${base}/api/worker/log-policy/admin`, {
+      method: "POST",
+      headers: { "X-Worker-Key": key, Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(20_000),
+    });
+  } catch {
+    print(`Could not reach ${base} — nothing changed.`);
+    return 1;
+  } finally {
+    token = ""; // one request, then gone
+  }
+  const a = await readJson(res);
+  if (!res.ok) {
+    if (res.status === 404 && typeof a.error !== "string") {
+      print("This computer's gu service does not support `gu full-log` yet — it needs an update. Nothing changed.");
+    } else {
+      const why = a.error ?? `HTTP ${res.status}`;
+      const tail = action === "status" || /nothing (was )?changed/i.test(why) ? "" : " Nothing changed.";
+      print(`${res.status >= 500 ? "Failed" : "Refused"}: ${why}${tail}`);
+    }
+    return 1;
+  }
+  const name = a.email ? `${a.email} (${a.userId})` : a.self ? `this computer's account (${a.userId})` : String(a.userId ?? who);
+  if (action === "status") {
+    print(`Full Log: ${onOff(a.fullLog)} for ${name}.`);
+    if (a.lastChange) {
+      const lc = a.lastChange;
+      print(`Last changed ${String(lc.at).replace("T", " ").slice(0, 16)} UTC by ${lc.by}${lc.via === "cli" ? " from the CLI" : ""}.`);
+    }
+    return 0;
+  }
+  print(
+    a.changed
+      ? `Full Log ${onOff(a.fullLog)} for ${name} — it was ${onOff(a.previous)}.`
+      : `Full Log was already ${onOff(a.fullLog)} for ${name} — nothing changed (recorded).`
+  );
+  if (a.self) {
+    await requestRefresh();
+    print("This computer picks it up within a minute; the account's other computers within 5 minutes.");
+  } else {
+    print("That account's computers pick it up within 5 minutes.");
+  }
+  return 0;
+}
+
+/**
+ * A masked line from a plain terminal (no REPL) — `gu full-log` in a shell. A bullet per
+ * character, nothing of the value on screen; Ctrl+C / Ctrl+D cancel (→ ""). Piped stdin (a
+ * script: `printf '%s\n' "$TOKEN" | gu full-log on`) reads the first line, echoing nothing.
+ */
+export function readHiddenLine(label, { input = process.stdin, output = process.stderr } = {}) {
+  return new Promise((resolve) => {
+    output.write(label + " ");
+    if (!input.isTTY) {
+      let buf = "";
+      const onData = (d) => {
+        buf += d.toString("utf8");
+        const nl = buf.indexOf("\n");
+        if (nl >= 0) finish(buf.slice(0, nl));
+      };
+      const onEnd = () => finish(buf);
+      const finish = (v) => {
+        input.off("data", onData);
+        input.off("end", onEnd);
+        input.pause();
+        output.write("\n");
+        resolve(v.replace(/\r$/, "").trim());
+      };
+      input.on("data", onData);
+      input.on("end", onEnd);
+      input.resume();
+      return;
+    }
+    let value = "";
+    input.setRawMode(true);
+    input.resume();
+    const done = (v) => {
+      input.off("data", onData);
+      input.setRawMode(false);
+      input.pause();
+      output.write("\n");
+      resolve(v);
+    };
+    const onData = (d) => {
+      for (const ch of d.toString("utf8")) {
+        if (ch === "\r" || ch === "\n") return done(value.trim());
+        if (ch === "\u0003" || ch === "\u0004") return done("");
+        if (ch === "\u007f" || ch === "\b") {
+          if (value) {
+            value = value.slice(0, -1);
+            output.write("\b \b");
+          }
+          continue;
+        }
+        if (ch < " ") continue; // other control bytes: ignored, never stored
+        value += ch;
+        output.write("•");
+      }
+    };
+    input.on("data", onData);
+  });
+}

package/gu-cli.mjs

@@ -15,7 +15,7 @@ import { requireSupportedNode } from "./node-version.mjs";
 // The brand accent, shared with the REPL — see accent.mjs.
 import { accent } from "./accent.mjs";
 requireSupportedNode();
-import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { execFile as execFileCallback, spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { createTaskPool, createFolderQueue } from "./job-pools.mjs";
@@ -76,6 +76,9 @@ gu-cli
 Usage:
   gu-cli
   gu-cli login [--api-base <url>]   # browser sign-in → writes ~/.gonext/worker.env
+  gu-cli full-log on|off|status [account] # administrators: Enable Full Log for an account (asks for
+                                           # an admin token from the web admin page first); status
+                                           # alone shows this computer's account, no token needed
   gu-cli token [<token>]                   # show this computer's gu token, or save one pasted from
                                                #   the Account page (Client Expert machines)
   gu-cli set <workerKey> [--api-base <url>]
@@ -220,6 +223,24 @@ if (args[0] === "token") {
   process.exit(0);
 }
 
+if (args[0] === "full-log") {
+  // #250. An administrator switches Enable Full Log (#249) from a terminal — after typing an admin
+  // token minted on the web admin page. Same code as /full-log in the terminal UI.
+  const fl = await import("./full-log-command.mjs");
+  const parsed = fl.parseFullLogArgs(args.slice(1));
+  if (parsed.error) {
+    console.error(parsed.error);
+    process.exit(2);
+  }
+  const code = await fl.runFullLog({
+    ...parsed,
+    apiBase: process.env.GONEXT_API_BASE,
+    workerKey: process.env.GONEXT_WORKER_KEY,
+    askSecret: (label) => fl.readHiddenLine(label),
+  });
+  process.exit(code);
+}
+
 if (args[0] === "login") {
   // Task #127, Phase 1: browser device-pairing → writes worker.env. `--api-base` overrides
   // which API to pair against (defaults to the production API).
@@ -5067,10 +5088,13 @@ async function startLogPolicy() {
     };
     await housekeep();
     let ticks = 0;
+    const { REFRESH_FLAG } = await import("./full-log-command.mjs");
     setInterval(() => {
       ticks++;
       void (async () => {
-        if (ticks % Math.round(lp.REFRESH_MS / 60_000) === 0) await logPolicy.refresh();
+        // `gu full-log` just changed this machine's account (#250): re-read now, not in 5 minutes.
+        const asked = await unlink(REFRESH_FLAG).then(() => true, () => false);
+        if (asked || ticks % Math.round(lp.REFRESH_MS / 60_000) === 0) await logPolicy.refresh();
         await housekeep();
       })().catch(() => {});
     }, 60_000).unref();

package/gu-repl.mjs

@@ -532,7 +532,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",
+  "clear", "reset", "api", "token-usage", "tokens", "token", "full-log",
 ];
 // `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
@@ -806,6 +806,7 @@ const COMMANDS = [
   { name: "/load-settings", usage: "/load-settings [name|path]", desc: "read that file back on another machine — picks from the settings files in your home folder, asks before it replaces anything" },
   { 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: "/full-log", usage: "/full-log [on|off|status] [account]", desc: "administrators: Enable Full Log for an account — asks for an admin token from the web admin page first" },
   { name: "/help", desc: "list these commands" },
   { name: "/exit", aliases: ["/quit"], desc: "quit" },
 ];
@@ -7085,6 +7086,28 @@ async function runS3Command(line) {
   await runTest({});
 }
 
+/**
+ * /full-log (#250) — the same code as `gu full-log`. The admin token goes through askSecret: masked
+ * in the frozen row, dropped from readline history, never echoed (#191).
+ */
+async function runFullLogCommand(line) {
+  const fl = await import("./full-log-command.mjs");
+  const parsed = fl.parseFullLogArgs(line.split(/\s+/).slice(1));
+  if (parsed.error) {
+    console.log(red(parsed.error) + "\n");
+    return;
+  }
+  // A cancelled token prompt (Esc / Ctrl+C) reads as "no token entered" inside runFullLog.
+  await fl.runFullLog({
+    ...parsed,
+    apiBase,
+    workerKey,
+    askSecret: (label) => askSecret(`  ${label}`),
+    print: (l) => console.log(gutterLines(l)),
+  });
+  console.log("");
+}
+
 async function runProxyCommand(line) {
   const cmd = await import("./proxy-command.mjs");
   const store = await import("./proxy-store.mjs");
@@ -11065,6 +11088,10 @@ async function main() {
       await saveSession(cwd, history); // remember the pick for this folder
       continue;
     }
+    if (line === "/full-log" || line.startsWith("/full-log ")) {
+      await runFullLogCommand(line);
+      continue;
+    }
     if (line === "/proxy" || line.startsWith("/proxy ")) {
       await runProxyCommand(line);
       continue;

package/package.json

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