@tiens.nguyen/gu-cli 1.0.739 → 1.0.741

package/hooks-config.mjs

@@ -0,0 +1,172 @@
+/**
+ * HOOKS — commands gu runs at fixed moments of a turn (task #270). Where they are set, and which
+ * ones a turn gets.
+ *
+ *   ~/.gonext/settings.json            yours, every folder
+ *   <project>/.gonext/settings.json    this project's — run only once you approve them here
+ *
+ *   { "hooks": { "<event>": [ { "matcher": "edit_file|create_file",
+ *                               "hooks": [ { "type": "command", "command": "python3",
+ *                                            "args": ["/path/hook.py"], "timeout": 30 } ] } ] } }
+ *
+ * gu's OWN event names — onStart, onAsk, onToolDone, onTurnEnd — and gu's own tool names in
+ * matchers (edit_file, grep_repo, mcp__<server>__<tool>). Claude Code's names (SessionStart, …) are
+ * recognised only to say what to write instead: a hook filed under a name gu never fires would
+ * otherwise fail in silence.
+ *
+ * A PROJECT'S HOOKS ARE COMMANDS THAT CAME WITH THE REPOSITORY, so they never run until you approve
+ * them for that folder — and the approval is of their exact content (a hash): an edited hooks
+ * block needs approving again. The approval lives in YOUR settings file, never the project's.
+ *
+ * THE SESSION. onStart fires on the first turn of a gu session. The terminal writes a new session
+ * id into the folder's session file when it starts (and on /reset); sessionForTurn reads it back so
+ * the agent can tell "new session" from "next turn" with nothing added to the API.
+ */
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+export const HOOK_EVENTS = ["onStart", "onAsk", "onToolDone", "onTurnEnd"];
+/** Claude Code's names → gu's. Only used to tell the user what to rename. */
+export const CLAUDE_EVENT_NAMES = {
+  SessionStart: "onStart",
+  UserPromptSubmit: "onAsk",
+  PostToolUse: "onToolDone",
+  Stop: "onTurnEnd",
+};
+
+export const userSettingsPath = (home = homedir()) => join(home, ".gonext", "settings.json");
+export const projectSettingsPath = (cwd) => join(cwd, ".gonext", "settings.json");
+
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+
+function readJson(file) {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return { data: null };
+  }
+  try {
+    const data = JSON.parse(text);
+    return isObj(data) ? { data } : { data: null, error: "not a JSON object" };
+  } catch (e) {
+    return { data: null, error: `not valid JSON (${e.message})` };
+  }
+}
+
+/** A settings file's hooks, cleaned: only gu events, only command hooks. → { hooks, warnings } */
+export function cleanHooks(raw, where) {
+  const hooks = {};
+  const warnings = [];
+  if (!isObj(raw)) return { hooks, warnings };
+  for (const [event, groups] of Object.entries(raw)) {
+    if (!HOOK_EVENTS.includes(event)) {
+      const gu = CLAUDE_EVENT_NAMES[event];
+      warnings.push(
+        gu
+          ? `${where}: "${event}" is Claude Code's name — gu calls it "${gu}". Skipped until renamed.`
+          : `${where}: "${event}" is not a gu hook event (${HOOK_EVENTS.join(", ")}). Skipped.`
+      );
+      continue;
+    }
+    const kept = [];
+    for (const g of Array.isArray(groups) ? groups : []) {
+      if (!isObj(g)) continue;
+      const hs = (Array.isArray(g.hooks) ? g.hooks : [])
+        .filter((h) => isObj(h) && (h.type ?? "command") === "command" && String(h.command ?? "").trim())
+        .map((h) => ({
+          type: "command",
+          command: String(h.command),
+          ...(Array.isArray(h.args) ? { args: h.args.map(String) } : {}),
+          ...(Number.isFinite(h.timeout) && h.timeout > 0 ? { timeout: h.timeout } : {}),
+          ...(isObj(h.env) ? { env: Object.fromEntries(Object.entries(h.env).map(([k, v]) => [k, String(v)])) } : {}),
+        }));
+      if (hs.length) kept.push({ matcher: String(g.matcher ?? ""), hooks: hs });
+    }
+    if (kept.length) hooks[event] = kept;
+  }
+  return { hooks, warnings };
+}
+
+/** The exact content being approved — any edit changes it. */
+export function hooksFingerprint(hooks) {
+  return createHash("sha256").update(JSON.stringify(hooks ?? {})).digest("hex").slice(0, 16);
+}
+
+/** → { user, project, projectApproved, projectPending, warnings } */
+export function readHooks({ cwd, home = homedir() } = {}) {
+  const warnings = [];
+  const u = readJson(userSettingsPath(home));
+  if (u.error) warnings.push(`${userSettingsPath(home)} is ${u.error} — its hooks are skipped`);
+  const user = cleanHooks(u.data?.hooks, "~/.gonext/settings.json");
+  warnings.push(...user.warnings);
+  let project = { hooks: {}, warnings: [] };
+  let projectApproved = false;
+  if (cwd && resolve(projectSettingsPath(cwd)) !== resolve(userSettingsPath(home))) {
+    const p = readJson(projectSettingsPath(cwd));
+    if (p.error) warnings.push(`${projectSettingsPath(cwd)} is ${p.error} — its hooks are skipped`);
+    project = cleanHooks(p.data?.hooks, ".gonext/settings.json");
+    warnings.push(...project.warnings);
+    const approved = u.data?.approvedProjectHooks?.[resolve(cwd)];
+    projectApproved = Object.keys(project.hooks).length > 0 && approved === hooksFingerprint(project.hooks);
+  }
+  const hasProject = Object.keys(project.hooks).length > 0;
+  return {
+    user: user.hooks,
+    project: project.hooks,
+    projectApproved,
+    projectPending: hasProject && !projectApproved,
+    warnings,
+  };
+}
+
+/** What one turn runs: yours first, then the project's when approved. */
+export function hooksForTurn({ cwd, home = homedir() } = {}) {
+  const r = readHooks({ cwd, home });
+  const out = {};
+  for (const ev of HOOK_EVENTS) {
+    const groups = [...(r.user[ev] ?? []), ...(r.projectApproved ? r.project[ev] ?? [] : [])];
+    if (groups.length) out[ev] = groups;
+  }
+  return out;
+}
+
+/** Approve (or withdraw) this folder's hooks, as they are right now. */
+export function approveProjectHooks({ cwd, home = homedir(), approve = true }) {
+  const r = readHooks({ cwd, home });
+  const file = userSettingsPath(home);
+  const { data, error } = readJson(file);
+  if (error) throw new Error(`${file} is ${error} — fix or remove it first`);
+  const raw = data ?? {};
+  raw.approvedProjectHooks = isObj(raw.approvedProjectHooks) ? raw.approvedProjectHooks : {};
+  if (approve) raw.approvedProjectHooks[resolve(cwd)] = hooksFingerprint(r.project);
+  else delete raw.approvedProjectHooks[resolve(cwd)];
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmp, JSON.stringify(raw, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  renameSync(tmp, file);
+  return r.project;
+}
+
+/* ---------------------------------------------------------------- the session ------------ */
+
+/** The terminal's per-folder session file — the same name gu-repl.mjs uses. */
+export function sessionFileFor(cwd, home = homedir()) {
+  const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 32);
+  return join(home, ".gonext", "sessions", `${hash}.json`);
+}
+
+/** → { id, startedAt } | null. null = no terminal session (the web, or an older terminal). */
+export function sessionForTurn(cwd, home = homedir()) {
+  if (!cwd) return null;
+  const { data } = readJson(sessionFileFor(cwd, home));
+  const id = data?.hookSessionId;
+  return typeof id === "string" && id ? { id, startedAt: String(data.hookSessionStartedAt ?? "") } : null;
+}
+
+/** Describe one hook for a list: the command and its args, as one line. */
+export function describeHook(h) {
+  return [h.command, ...(h.args ?? [])].map((w) => (/\s/.test(w) ? JSON.stringify(w) : w)).join(" ");
+}

package/mcp-command.mjs

@@ -0,0 +1,324 @@
+/**
+ * `gu mcp …` and `/mcp …` — ONE code path (task #269).
+ *
+ *   list                      every server, whether it connects, how many tools (the default)
+ *   tools <name>              that server's tools
+ *   add …                     `claude mcp add`'s shape; `/mcp add` alone asks step by step
+ *   remove <name>             from your ~/.gonext/mcp.json
+ *   enable|disable <name>     keep it configured, stop starting it
+ *   approve|unapprove <name>  a project's .mcp.json server, for this folder
+ *   allow <name> [tool]       its tools run without asking (all, or one)
+ *   disallow <name>           back to asking
+ *   reconnect <name>          test it again now
+ *
+ * "Connected" is decided by the same Python client the agent uses (gu_mcp.py probe), so this
+ * screen cannot say yes to a server the agent then fails to start.
+ */
+import { spawn } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolvePython } from "./platform-tools.mjs";
+import {
+  ADD_USAGE,
+  addAllowRule,
+  addServer,
+  approveProjectServer,
+  describeServer,
+  listServers,
+  parseAddArgs,
+  readUserConfig,
+  removeAllowRules,
+  removeServer,
+  setDisabled,
+  userConfigPath,
+  SERVER_NAME_RE,
+} from "./mcp-config.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const MCP_SUBCOMMANDS = [
+  "list", "tools", "add", "remove", "enable", "disable", "approve", "unapprove", "allow", "disallow", "reconnect",
+];
+export const MCP_USAGE = `gu mcp [${MCP_SUBCOMMANDS.join("|")}] …`;
+
+/**
+ * Probe servers with the agent's own client. → { [name]: { ok, ms, tools?, error? } }
+ * A probe that cannot run at all (no python) reports that for every server rather than throwing.
+ */
+export async function probeServers(servers, { cwd, timeoutS = 20 } = {}) {
+  if (!servers.length) return {};
+  const py = await resolvePython();
+  const req = JSON.stringify({
+    servers: servers.map(({ name, command, args, env }) => ({ name, command, args, env })),
+    cwd,
+    timeout: timeoutS,
+  });
+  return await new Promise((resolveP) => {
+    let out = "";
+    let err = "";
+    let child;
+    const fail = (why) => resolveP(Object.fromEntries(servers.map((s) => [s.name, { ok: false, error: why }])));
+    try {
+      child = spawn(py.cmd, [...py.args, join(HERE, "gu_mcp.py"), "probe"], { stdio: ["pipe", "pipe", "pipe"] });
+    } catch (e) {
+      fail(`could not run python: ${e.message}`);
+      return;
+    }
+    const timer = setTimeout(() => child.kill("SIGKILL"), (timeoutS + 10) * 1000);
+    child.stdout.on("data", (d) => (out += d));
+    child.stderr.on("data", (d) => (err += d));
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      fail(`could not run python: ${e.message}`);
+    });
+    child.on("close", () => {
+      clearTimeout(timer);
+      try {
+        resolveP(JSON.parse(out).results ?? {});
+      } catch {
+        fail(`the probe did not answer${err.trim() ? `: ${err.trim().split("\n").at(-1)}` : ""}`);
+      }
+    });
+    child.stdin.end(req);
+  });
+}
+
+/** Split a typed command line into words: spaces separate, quotes group, backslash escapes. */
+export function splitWords(line) {
+  const words = [];
+  let cur = "";
+  let q = null;
+  let any = false;
+  const s = String(line ?? "");
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (q) {
+      if (c === q) q = null;
+      else if (c === "\\" && q === '"' && i + 1 < s.length) cur += s[++i];
+      else cur += c;
+    } else if (c === '"' || c === "'") {
+      q = c;
+      any = true;
+    } else if (c === "\\" && i + 1 < s.length) {
+      cur += s[++i];
+      any = true;
+    } else if (/\s/.test(c)) {
+      if (cur || any) words.push(cur);
+      cur = "";
+      any = false;
+    } else {
+      cur += c;
+    }
+  }
+  if (cur || any) words.push(cur);
+  return words;
+}
+
+function statusLine(s, probe) {
+  const pad = s.name.padEnd(22);
+  if (s.error) return `✗ ${pad} ${s.scope.padEnd(7)} ${s.error}`;
+  if (s.disabled) return `– ${pad} ${s.scope.padEnd(7)} disabled — /mcp enable ${s.name}`;
+  if (!s.approved) return `○ ${pad} ${s.scope.padEnd(7)} not approved for this folder — /mcp approve ${s.name}`;
+  if (!probe) return `· ${pad} ${s.scope.padEnd(7)} not checked`;
+  if (probe.ok) return `✓ ${pad} ${s.scope.padEnd(7)} connected · ${probe.tools.length} tools (${(probe.ms / 1000).toFixed(1)}s)`;
+  return `✗ ${pad} ${s.scope.padEnd(7)} failed: ${probe.error}`;
+}
+
+/**
+ * Run one command. `print(line, kind?)` writes a line (kind: "ok" | "warn" | "dim" | undefined);
+ * `ask(label)` → the typed answer ("" = Enter), only given in the terminal UI, where it makes
+ * `add` interactive. → an exit code (0 ok, 1 failed, 2 usage).
+ */
+export async function runMcpCommand(words, { cwd = process.cwd(), print = console.log, ask = null, probe = probeServers } = {}) {
+  const w = (words ?? []).map(String);
+  const sub = (w[0] ?? "list").toLowerCase();
+  const rest = w.slice(1);
+  const needName = () => {
+    const n = rest[0];
+    if (!n) {
+      print(`which server? — gu mcp ${sub} <name>`, "warn");
+      return null;
+    }
+    return n;
+  };
+  const known = (name) => listServers({ cwd }).servers.find((s) => s.name === name);
+
+  try {
+    switch (sub) {
+      case "list":
+      case "ls": {
+        const { servers, warnings } = listServers({ cwd });
+        for (const x of warnings) print(x, "warn");
+        if (!servers.length) {
+          print("No MCP servers yet.");
+          print(`Add one:  /mcp add   (or in a shell: ${ADD_USAGE})`, "dim");
+          return 0;
+        }
+        const results = await probe(servers.filter((s) => s.runnable), { cwd });
+        print(`MCP servers — yours in ${userConfigPath()}, this folder's in ./.mcp.json`, "dim");
+        for (const s of servers) {
+          print(statusLine(s, results[s.name]), results[s.name]?.ok ? "ok" : undefined);
+          if (!s.error) print(`    ${describeServer(s)}`, "dim");
+        }
+        const { allow, deny } = readUserConfig();
+        if (allow.length) print(`Runs without asking: ${allow.join(", ")}`, "dim");
+        if (deny.length) print(`Blocked: ${deny.join(", ")}`, "dim");
+        print("Tools of one:  /mcp tools <name>", "dim");
+        return 0;
+      }
+      case "tools":
+      case "reconnect": {
+        const name = needName();
+        if (!name) return 2;
+        const s = known(name);
+        if (!s) {
+          print(`No MCP server named "${name}". /mcp lists them.`, "warn");
+          return 1;
+        }
+        if (!s.runnable) {
+          print(statusLine(s, null), "warn");
+          return 1;
+        }
+        const r = (await probe([s], { cwd }))[name];
+        print(statusLine(s, r), r?.ok ? "ok" : "warn");
+        if (r?.ok && sub === "tools") {
+          for (const t of r.tools) print(`    ${t.name}${t.description ? ` — ${t.description}` : ""}`, "dim");
+        }
+        return r?.ok ? 0 : 1;
+      }
+      case "add": {
+        let parsed;
+        if (!rest.length && ask) parsed = await askForServer(ask, print);
+        else parsed = parseAddArgs(rest);
+        if (!parsed) return 0; // cancelled
+        if (parsed.error) {
+          print(parsed.error, "warn");
+          return 2;
+        }
+        if (known(parsed.name)) {
+          if (!ask) {
+            print(`"${parsed.name}" already exists — gu mcp remove ${parsed.name} first`, "warn");
+            return 1;
+          }
+          const yes = /^y/i.test(await ask(`"${parsed.name}" already exists. Replace it? (y/N)`));
+          if (!yes) return 0;
+        }
+        const { file } = addServer({ ...parsed, cwd });
+        print(`Added "${parsed.name}" to ${file}.`, "ok");
+        const s = known(parsed.name);
+        const r = (await probe([s], { cwd }))[parsed.name];
+        print(statusLine(s, r), r?.ok ? "ok" : "warn");
+        if (!r?.ok) {
+          print("It is saved; fix the command and run  /mcp reconnect " + parsed.name, "dim");
+          return 1;
+        }
+        // You added it yourself: offer to trust its tools now, rather than one question per tool later.
+        if (ask) {
+          const yes = /^y/i.test(await ask(`Let the agent use its ${r.tools.length} tools without asking each time? (y/N)`));
+          if (yes) {
+            addAllowRule({ rule: `mcp__${parsed.name}__*` });
+            print(`Its tools run without asking. Undo: /mcp disallow ${parsed.name}`, "dim");
+          } else {
+            print("The agent will ask before each tool the first time it uses it.", "dim");
+          }
+        }
+        return 0;
+      }
+      case "remove":
+      case "rm": {
+        const name = needName();
+        if (!name) return 2;
+        const s = known(name);
+        if (s?.scope === "project") {
+          approveProjectServer({ name, cwd, approve: false });
+          print(`"${name}" is this project's (./.mcp.json) — it will not start here any more. Edit that file to delete it.`);
+          return 0;
+        }
+        const found = removeServer({ name });
+        print(found ? `Removed "${name}".` : `No MCP server named "${name}" in ${userConfigPath()}.`, found ? "ok" : "warn");
+        return found ? 0 : 1;
+      }
+      case "enable":
+      case "disable": {
+        const name = needName();
+        if (!name) return 2;
+        if (!known(name)) {
+          print(`No MCP server named "${name}".`, "warn");
+          return 1;
+        }
+        setDisabled({ name, disabled: sub === "disable" });
+        print(sub === "disable" ? `"${name}" will not start (still configured).` : `"${name}" will start on the next turn.`, "ok");
+        return 0;
+      }
+      case "approve":
+      case "unapprove": {
+        const name = needName();
+        if (!name) return 2;
+        const s = known(name);
+        if (!s || s.scope !== "project") {
+          print(`No project MCP server named "${name}" in ./.mcp.json.`, "warn");
+          return 1;
+        }
+        if (sub === "approve") print(`It runs: ${describeServer(s)}`, "dim");
+        approveProjectServer({ name, cwd, approve: sub === "approve" });
+        print(sub === "approve" ? `Approved "${name}" for this folder.` : `"${name}" will not start in this folder.`, "ok");
+        return 0;
+      }
+      case "allow": {
+        const name = needName();
+        if (!name) return 2;
+        if (!SERVER_NAME_RE.test(name)) {
+          print(`"${name}" is not a server name.`, "warn");
+          return 2;
+        }
+        const tool = rest[1];
+        const rule = tool ? `mcp__${name}__${tool}` : `mcp__${name}__*`;
+        addAllowRule({ rule });
+        print(`${tool ? `${name}/${tool}` : `Every tool of ${name}`} runs without asking. Undo: /mcp disallow ${name}`, "ok");
+        return 0;
+      }
+      case "disallow": {
+        const name = needName();
+        if (!name) return 2;
+        removeAllowRules({ server: name });
+        print(`The agent asks again before using ${name}'s tools.`, "ok");
+        return 0;
+      }
+      default:
+        print(`unknown "${sub}" — ${MCP_USAGE}`, "warn");
+        return 2;
+    }
+  } catch (e) {
+    print(e?.message || String(e), "warn");
+    return 1;
+  }
+}
+
+/** `/mcp add` with nothing after it: one question at a time. "" at the name = cancel. */
+async function askForServer(ask, print) {
+  print("Add an MCP server (stdio). Enter on an empty name cancels.", "dim");
+  const name = (await ask("Name (letters, digits, - or _):")).trim();
+  if (!name) return null;
+  if (!SERVER_NAME_RE.test(name)) return { error: `"${name}" is not a valid name — use letters, digits, _ or -` };
+  const line = (await ask("Command and its arguments (e.g. npx -y @modelcontextprotocol/server-filesystem ~/code):")).trim();
+  const words = splitWords(line);
+  if (!words.length) return { error: "no command given" };
+  const envLine = (await ask("Environment variables, KEY=value separated by spaces (Enter for none):")).trim();
+  const env = {};
+  for (const kv of splitWords(envLine)) {
+    const eq = kv.indexOf("=");
+    if (eq <= 0) return { error: `"${kv}" is not KEY=value` };
+    env[kv.slice(0, eq)] = kv.slice(eq + 1);
+  }
+  const scopeAns = (await ask("For every folder, or only this project (./.mcp.json)? [every/project] (Enter = every):")).trim().toLowerCase();
+  const scope = scopeAns.startsWith("p") ? "project" : "user";
+  return { name, command: words[0], args: words.slice(1), env, scope };
+}
+
+/** Project servers waiting for approval in this folder — the terminal mentions them at start. */
+export function unapprovedProjectServers(cwd) {
+  try {
+    return listServers({ cwd }).servers.filter((s) => s.scope === "project" && !s.approved && !s.error);
+  } catch {
+    return [];
+  }
+}