@tiens.nguyen/gu-cli 1.0.738 → 1.0.740

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 [];
+  }
+}

package/mcp-config.mjs

@@ -0,0 +1,329 @@
+/**
+ * MCP SERVERS — where they are configured, and who may call their tools (task #269).
+ *
+ *   ~/.gonext/mcp.json   yours: { mcpServers, disabled, permissions: { allow, deny }, approvedProjects }
+ *   <project>/.mcp.json  the project's — Claude Code's own file and format, so one file serves both
+ *
+ * The shapes are Claude Code's: `mcpServers: { name: { type: "stdio", command, args, env } }`, and
+ * permission rules `mcp__<server>` / `mcp__<server>__*` / `mcp__<server>__<tool>`. A command copied
+ * from an MCP server's README (`claude mcp add …`) works as `gu mcp add …`.
+ *
+ * A PROJECT'S SERVERS DO NOT START UNTIL YOU APPROVE THEM. Starting a stdio server runs a command,
+ * and a project's .mcp.json came with the repository — cloning something is not agreeing to run
+ * what it names. Claude Code asks before connecting them for the same reason. Approval is per
+ * folder and per server, and lives in YOUR file, never in the project's.
+ *
+ * PERMISSIONS: deny, then ask, then allow — the first rule that matches decides, and a deny can
+ * never be carved open by a narrower allow (Claude Code's order). No rule = ask. A server saying a
+ * tool is read-only (readOnlyHint) is NOT a rule: the MCP spec says clients must treat those hints
+ * as untrusted, and a hostile server would simply claim it.
+ *
+ * ONE WRITER SHAPE. Both `gu mcp` and `/mcp` go through updateUserConfig, which re-reads the file,
+ * changes one thing and writes it back atomically — keys it does not know are kept. Rebuilding the
+ * object from what one side knows is how a settings screen once deleted the other side's entries.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+export const SERVER_NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
+
+export function userConfigPath(home = homedir()) {
+  return join(home, ".gonext", "mcp.json");
+}
+export function projectConfigPath(cwd) {
+  return join(cwd, ".mcp.json");
+}
+
+function readJson(file) {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return { data: null }; // no file: nothing configured, not an error
+  }
+  try {
+    const data = JSON.parse(text);
+    if (!data || typeof data !== "object" || Array.isArray(data)) return { data: null, error: "not a JSON object" };
+    return { data };
+  } catch (e) {
+    return { data: null, error: `not valid JSON (${e.message})` };
+  }
+}
+
+export function readUserConfig(home = homedir()) {
+  const { data, error } = readJson(userConfigPath(home));
+  const cfg = data ?? {};
+  return {
+    raw: cfg,
+    error,
+    mcpServers: isObj(cfg.mcpServers) ? cfg.mcpServers : {},
+    disabled: Array.isArray(cfg.disabled) ? cfg.disabled.map(String) : [],
+    allow: Array.isArray(cfg.permissions?.allow) ? cfg.permissions.allow.map(String) : [],
+    deny: Array.isArray(cfg.permissions?.deny) ? cfg.permissions.deny.map(String) : [],
+    approvedProjects: isObj(cfg.approvedProjects) ? cfg.approvedProjects : {},
+  };
+}
+
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+
+/** Write ~/.gonext/mcp.json atomically: a crash mid-write leaves the old file, never half of one. */
+function writeUserRaw(raw, home) {
+  const file = userConfigPath(home);
+  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);
+}
+
+/**
+ * Re-read, change, write back. `mutate(raw)` edits the parsed file in place. A file that is not
+ * valid JSON is refused rather than overwritten — it may be hand-edited and one typo from fine.
+ */
+export function updateUserConfig(mutate, home = homedir()) {
+  const { data, error } = readJson(userConfigPath(home));
+  if (error) throw new Error(`${userConfigPath(home)} is ${error} — fix or remove it first`);
+  const raw = data ?? {};
+  mutate(raw);
+  writeUserRaw(raw, home);
+  return raw;
+}
+
+/** Normalize one server entry → { type, command, args, env } | { error }. */
+export function normalizeServer(entry) {
+  if (!isObj(entry)) return { error: "not an object" };
+  const type = String(entry.type ?? (entry.url ? "http" : "stdio"));
+  if (type !== "stdio") return { error: `transport "${type}" is not supported yet — only stdio` };
+  const command = String(entry.command ?? "").trim();
+  if (!command) return { error: "no command" };
+  const args = Array.isArray(entry.args) ? entry.args.map(String) : [];
+  const env = isObj(entry.env) ? Object.fromEntries(Object.entries(entry.env).map(([k, v]) => [k, String(v)])) : {};
+  return { type, command, args, env };
+}
+
+/**
+ * Every server this folder knows of, with its state.
+ * → { servers: [{ name, scope, type, command, args, env, disabled, approved, runnable, error? }], warnings }
+ */
+export function listServers({ cwd = process.cwd(), home = homedir() } = {}) {
+  const user = readUserConfig(home);
+  const warnings = [];
+  if (user.error) warnings.push(`${userConfigPath(home)} is ${user.error} — its servers are skipped`);
+  const servers = [];
+  const seen = new Set();
+  const add = (name, entry, scope, approved) => {
+    if (!SERVER_NAME_RE.test(name)) {
+      warnings.push(`${scope} MCP server "${name}": the name must be letters, digits, _ or - — skipped`);
+      return;
+    }
+    if (seen.has(name)) return; // yours wins over the project's
+    seen.add(name);
+    const n = normalizeServer(entry);
+    const disabled = user.disabled.includes(name);
+    servers.push({
+      name,
+      scope,
+      ...(n.error ? { error: n.error } : n),
+      disabled,
+      approved,
+      runnable: !n.error && !disabled && approved,
+    });
+  };
+  for (const [name, entry] of Object.entries(user.mcpServers)) add(name, entry, "user", true);
+  if (cwd) {
+    const proj = readJson(projectConfigPath(cwd));
+    if (proj.error) warnings.push(`${projectConfigPath(cwd)} is ${proj.error} — its servers are skipped`);
+    const approvedHere = (user.approvedProjects[resolve(cwd)] ?? []).map(String);
+    for (const [name, entry] of Object.entries(isObj(proj.data?.mcpServers) ? proj.data.mcpServers : {})) {
+      add(name, entry, "project", approvedHere.includes(name));
+    }
+  }
+  return { servers, warnings };
+}
+
+/** What the worker hands the agent for one turn: the servers it may start, and the rules. */
+export function mcpForTurn({ cwd, home = homedir() } = {}) {
+  const { servers } = listServers({ cwd, home });
+  const user = readUserConfig(home);
+  return {
+    servers: servers
+      .filter((s) => s.runnable)
+      .map(({ name, command, args, env, scope }) => ({ name, command, args, env, scope })),
+    allow: user.allow,
+    deny: user.deny,
+    configPath: userConfigPath(home),
+  };
+}
+
+/* ---------------------------------------------------------------- permissions ---------- */
+
+/** Does a rule name this server's tool? `mcp__s`, `mcp__s__*`, `mcp__s__tool`, `mcp__s__get_*`, `mcp__*`. */
+export function ruleMatches(rule, server, tool) {
+  const r = String(rule).trim();
+  if (r === "mcp__*" || r === "*") return true;
+  if (r === `mcp__${server}`) return true;
+  const full = `mcp__${server}__${tool}`;
+  if (!r.includes("*")) return r === full;
+  const re = new RegExp("^" + r.split("*").map((p) => p.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$");
+  return re.test(full);
+}
+
+/** → "deny" | "allow" | "ask". Deny first, then allow; nothing matching = ask. */
+export function decide({ allow = [], deny = [] }, server, tool) {
+  if (deny.some((r) => ruleMatches(r, server, tool))) return "deny";
+  if (allow.some((r) => ruleMatches(r, server, tool))) return "allow";
+  return "ask";
+}
+
+/* ---------------------------------------------------------------- changes -------------- */
+
+export function addServer({ name, command, args = [], env = {}, scope = "user", cwd, home = homedir() }) {
+  if (!SERVER_NAME_RE.test(name ?? "")) throw new Error(`"${name}" is not a valid name — use letters, digits, _ or -`);
+  if (!String(command ?? "").trim()) throw new Error("no command given");
+  const entry = { type: "stdio", command: String(command), args: args.map(String), env };
+  if (scope === "project") {
+    if (!cwd) throw new Error("no project folder");
+    const file = projectConfigPath(cwd);
+    const { data, error } = readJson(file);
+    if (error) throw new Error(`${file} is ${error} — fix or remove it first`);
+    const raw = data ?? {};
+    raw.mcpServers = isObj(raw.mcpServers) ? raw.mcpServers : {};
+    raw.mcpServers[name] = entry;
+    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, JSON.stringify(raw, null, 2) + "\n", "utf8");
+    renameSync(tmp, file);
+    // You added it yourself, from this folder: that IS the approval.
+    approveProjectServer({ name, cwd, home });
+    return { file };
+  }
+  updateUserConfig((raw) => {
+    raw.mcpServers = isObj(raw.mcpServers) ? raw.mcpServers : {};
+    raw.mcpServers[name] = entry;
+    if (Array.isArray(raw.disabled)) raw.disabled = raw.disabled.filter((d) => d !== name);
+  }, home);
+  return { file: userConfigPath(home) };
+}
+
+/** Remove from YOUR file. A project's server cannot be removed from here — only not approved. */
+export function removeServer({ name, home = homedir() }) {
+  let found = false;
+  updateUserConfig((raw) => {
+    if (isObj(raw.mcpServers) && name in raw.mcpServers) {
+      delete raw.mcpServers[name];
+      found = true;
+    }
+    if (Array.isArray(raw.disabled)) raw.disabled = raw.disabled.filter((d) => d !== name);
+    if (isObj(raw.permissions)) {
+      for (const k of ["allow", "deny"]) {
+        if (Array.isArray(raw.permissions[k])) {
+          raw.permissions[k] = raw.permissions[k].filter((r) => !(r === `mcp__${name}` || String(r).startsWith(`mcp__${name}__`)));
+        }
+      }
+    }
+  }, home);
+  return found;
+}
+
+export function setDisabled({ name, disabled, home = homedir() }) {
+  updateUserConfig((raw) => {
+    const list = Array.isArray(raw.disabled) ? raw.disabled.filter((d) => d !== name) : [];
+    if (disabled) list.push(name);
+    raw.disabled = list;
+  }, home);
+}
+
+export function approveProjectServer({ name, cwd, home = homedir(), approve = true }) {
+  const key = resolve(cwd);
+  updateUserConfig((raw) => {
+    raw.approvedProjects = isObj(raw.approvedProjects) ? raw.approvedProjects : {};
+    const list = (raw.approvedProjects[key] ?? []).filter((n) => n !== name);
+    if (approve) list.push(name);
+    raw.approvedProjects[key] = list;
+  }, home);
+}
+
+/** Add an allow rule (no duplicates). Used by "Always allow" at the approval prompt. */
+export function addAllowRule({ rule, home = homedir() }) {
+  updateUserConfig((raw) => {
+    raw.permissions = isObj(raw.permissions) ? raw.permissions : {};
+    const allow = Array.isArray(raw.permissions.allow) ? raw.permissions.allow : [];
+    if (!allow.includes(rule)) allow.push(rule);
+    raw.permissions.allow = allow;
+  }, home);
+}
+
+export function removeAllowRules({ server, home = homedir() }) {
+  updateUserConfig((raw) => {
+    if (isObj(raw.permissions) && Array.isArray(raw.permissions.allow)) {
+      raw.permissions.allow = raw.permissions.allow.filter(
+        (r) => !(r === `mcp__${server}` || String(r).startsWith(`mcp__${server}__`))
+      );
+    }
+  }, home);
+}
+
+/* ---------------------------------------------------------------- display -------------- */
+
+const SECRET_KEY_RE = /TOKEN|SECRET|PASSWORD|PASSWD|KEY|AUTH|CREDENTIAL/i;
+
+/** Env for display: values of secret-looking names become "****" + last 2. */
+export function maskEnv(env = {}) {
+  return Object.fromEntries(
+    Object.entries(env).map(([k, v]) => [k, SECRET_KEY_RE.test(k) ? (String(v).length > 6 ? `****${String(v).slice(-2)}` : "****") : v])
+  );
+}
+
+/** One line naming the command, with secret env values masked. */
+export function describeServer(s) {
+  const env = Object.entries(maskEnv(s.env ?? {})).map(([k, v]) => `${k}=${v}`);
+  return [...env, s.command, ...(s.args ?? [])].map((w) => (/\s/.test(w) ? JSON.stringify(w) : w)).join(" ");
+}
+
+/* ---------------------------------------------------------------- `add` arguments ------ */
+
+export const ADD_USAGE =
+  "gu mcp add [--scope user|project] [-e KEY=value …] <name> -- <command> [args…]";
+
+/**
+ * `claude mcp add`'s shape: options, then the name, then `--`, then the command. Without a `--`
+ * the first word after the name starts the command (a common way people type it).
+ * → { name, command, args, env, scope } | { error }
+ */
+export function parseAddArgs(words) {
+  const w = (words ?? []).map(String);
+  const dash = w.indexOf("--");
+  const head = dash >= 0 ? w.slice(0, dash) : w;
+  let tail = dash >= 0 ? w.slice(dash + 1) : [];
+  const env = {};
+  let scope = "user";
+  let name = null;
+  for (let i = 0; i < head.length; i++) {
+    const a = head[i];
+    if (a === "-e" || a === "--env") {
+      const kv = head[++i] ?? "";
+      const eq = kv.indexOf("=");
+      if (eq <= 0) return { error: `-e needs KEY=value, got "${kv}" — ${ADD_USAGE}` };
+      env[kv.slice(0, eq)] = kv.slice(eq + 1);
+    } else if (a === "-s" || a === "--scope") {
+      scope = head[++i] ?? "";
+      if (scope === "local") scope = "user"; // Claude Code's default scope; gu's user file is the same idea
+      if (!["user", "project"].includes(scope)) return { error: `--scope must be user or project — ${ADD_USAGE}` };
+    } else if (a === "-t" || a === "--transport") {
+      const t = head[++i] ?? "";
+      if (t !== "stdio") return { error: `transport "${t}" is not supported yet — only stdio` };
+    } else if (a.startsWith("-")) {
+      return { error: `unknown option ${a} — ${ADD_USAGE}` };
+    } else if (name === null) {
+      name = a;
+    } else if (dash < 0) {
+      tail = head.slice(i);
+      break;
+    } else {
+      return { error: `unexpected "${a}" before -- — ${ADD_USAGE}` };
+    }
+  }
+  if (!name) return { error: `no name — ${ADD_USAGE}` };
+  if (!SERVER_NAME_RE.test(name)) return { error: `"${name}" is not a valid name — use letters, digits, _ or -` };
+  if (!tail.length) return { error: `no command — ${ADD_USAGE}` };
+  return { name, command: tail[0], args: tail.slice(1), env, scope };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.738",
+  "version": "1.0.740",
   "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",
@@ -89,8 +89,13 @@
     "add-server.mjs",
     "powershell-alias.mjs",
     "install-path.mjs",
+    "skills.mjs",
+    "mcp-config.mjs",
+    "mcp-command.mjs",
     "gonext_probe_agent.py",
     "gonext_agent_chat.py",
+    "gu_mcp.py",
+    "gu_skills.py",
     "prompt_scaffold_check.py",
     "gonext_transcribe.py",
     "gonext_mlx_embed.py",