@tiens.nguyen/gu-cli 1.0.783 → 1.0.785

package/mcp-config.mjs

@@ -18,13 +18,27 @@
  * 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.
  *
+ * CLAUDE CODE'S SERVERS (#325). A folder that chose "Claude's skills" (/switch-skill) takes YOUR
+ * servers from Claude Code's own file instead of ~/.gonext/mcp.json:
+ *   ~/.claude.json   projects["<this folder>"].mcpServers   (Claude's "local" scope — this folder only)
+ *   ~/.claude.json   mcpServers                             (Claude's "user" scope — every folder)
+ * The project's .mcp.json is the same file either way. Yours still win over the project's. gu's own
+ * bookkeeping — disabled, the allow/deny rules, which project servers you approved — stays in
+ * ~/.gonext/mcp.json whichever source is chosen: Claude Code's file has no place for it, and gu
+ * reads Claude's setup without Claude ever having to read gu's.
+ *
+ * ~/.claude.json IS CLAUDE CODE'S WHOLE STATE FILE, not a config file of ours. It is only written
+ * when you add or remove a server yourself, and then only its mcpServers entry changes: re-read,
+ * change one key, write back atomically with the file's own permissions.
+ *
  * 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 { mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { resolveSkillSource } from "./skill-source.mjs";
 
 export const SERVER_NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
 
@@ -34,6 +48,13 @@ export function userConfigPath(home = homedir()) {
 export function projectConfigPath(cwd) {
   return join(cwd, ".mcp.json");
 }
+/** Claude Code's state file — where its user- and local-scope MCP servers are (#325). */
+export function claudeConfigPath(home = homedir()) {
+  return join(home, ".claude.json");
+}
+/** The file YOUR servers are in, for the source in use. */
+export const userServersPath = (home = homedir(), source = "gu") =>
+  source === "claude" ? claudeConfigPath(home) : userConfigPath(home);
 
 function readJson(file) {
   let text;
@@ -67,6 +88,39 @@ export function readUserConfig(home = homedir()) {
 
 const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 
+/** Claude Code's servers for this folder → { local, user, error? }. A missing file is no servers. */
+export function readClaudeServers({ cwd, home = homedir() } = {}) {
+  const { data, error } = readJson(claudeConfigPath(home));
+  const proj = cwd && isObj(data?.projects) ? data.projects[resolve(cwd)] : null;
+  return {
+    error,
+    local: isObj(proj?.mcpServers) ? proj.mcpServers : {},
+    user: isObj(data?.mcpServers) ? data.mcpServers : {},
+  };
+}
+
+/**
+ * Change ~/.claude.json: re-read, edit in place, write back atomically, permissions kept. Refused
+ * when the file is not valid JSON — it is Claude Code's, and not ours to "repair".
+ */
+export function updateClaudeConfig(mutate, home = homedir()) {
+  const file = claudeConfigPath(home);
+  const { data, error } = readJson(file);
+  if (error) throw new Error(`${file} is ${error} — fix it first (it is Claude Code's own file)`);
+  const raw = data ?? {};
+  mutate(raw);
+  let mode = 0o600;
+  try {
+    mode = statSync(file).mode & 0o777;
+  } catch {
+    /* a new file: private, as Claude Code makes it */
+  }
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmp, JSON.stringify(raw, null, 2) + "\n", { encoding: "utf8", mode });
+  renameSync(tmp, file);
+  return raw;
+}
+
 /** 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);
@@ -103,12 +157,17 @@ export function normalizeServer(entry) {
 
 /**
  * Every server this folder knows of, with its state.
- * → { servers: [{ name, scope, type, command, args, env, disabled, approved, runnable, error? }], warnings }
+ * `source` = whose servers ("gu" | "claude"); left out, it is the folder's own choice.
+ * scope: "user" (yours, every folder), "local" (Claude's: yours, this folder only), "project".
+ * → { servers: [{ name, scope, type, command, args, env, disabled, approved, runnable, error? }], warnings, source }
  */
-export function listServers({ cwd = process.cwd(), home = homedir() } = {}) {
+export function listServers({ cwd = process.cwd(), home = homedir(), source } = {}) {
+  const src = resolveSkillSource({ source, cwd, home });
   const user = readUserConfig(home);
   const warnings = [];
-  if (user.error) warnings.push(`${userConfigPath(home)} is ${user.error} — its servers are skipped`);
+  if (user.error) {
+    warnings.push(`${userConfigPath(home)} is ${user.error} — ${src === "claude" ? "its rules and approvals are skipped" : "its servers are skipped"}`);
+  }
   const servers = [];
   const seen = new Set();
   const add = (name, entry, scope, approved) => {
@@ -129,7 +188,14 @@ export function listServers({ cwd = process.cwd(), home = homedir() } = {}) {
       runnable: !n.error && !disabled && approved,
     });
   };
-  for (const [name, entry] of Object.entries(user.mcpServers)) add(name, entry, "user", true);
+  if (src === "claude") {
+    const claude = readClaudeServers({ cwd, home });
+    if (claude.error) warnings.push(`${claudeConfigPath(home)} is ${claude.error} — its servers are skipped`);
+    for (const [name, entry] of Object.entries(claude.local)) add(name, entry, "local", true);
+    for (const [name, entry] of Object.entries(claude.user)) add(name, entry, "user", true);
+  } else {
+    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`);
@@ -138,12 +204,12 @@ export function listServers({ cwd = process.cwd(), home = homedir() } = {}) {
       add(name, entry, "project", approvedHere.includes(name));
     }
   }
-  return { servers, warnings };
+  return { servers, warnings, source: src };
 }
 
 /** 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 });
+export function mcpForTurn({ cwd, home = homedir(), source } = {}) {
+  const { servers } = listServers({ cwd, home, source });
   const user = readUserConfig(home);
   return {
     servers: servers
@@ -177,7 +243,7 @@ export function decide({ allow = [], deny = [] }, server, tool) {
 
 /* ---------------------------------------------------------------- changes -------------- */
 
-export function addServer({ name, command, args = [], env = {}, scope = "user", cwd, home = homedir() }) {
+export function addServer({ name, command, args = [], env = {}, scope = "user", cwd, home = homedir(), source }) {
   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 };
@@ -196,6 +262,15 @@ export function addServer({ name, command, args = [], env = {}, scope = "user",
     approveProjectServer({ name, cwd, home });
     return { file };
   }
+  if (resolveSkillSource({ source, cwd, home }) === "claude") {
+    // Claude Code's user scope. Its entry, its file; gu's file only forgets a stale "disabled".
+    updateClaudeConfig((raw) => {
+      raw.mcpServers = isObj(raw.mcpServers) ? raw.mcpServers : {};
+      raw.mcpServers[name] = entry;
+    }, home);
+    if (readUserConfig(home).disabled.includes(name)) setDisabled({ name, disabled: false, home });
+    return { file: claudeConfigPath(home) };
+  }
   updateUserConfig((raw) => {
     raw.mcpServers = isObj(raw.mcpServers) ? raw.mcpServers : {};
     raw.mcpServers[name] = entry;
@@ -205,10 +280,23 @@ export function addServer({ name, command, args = [], env = {}, scope = "user",
 }
 
 /** Remove from YOUR file. A project's server cannot be removed from here — only not approved. */
-export function removeServer({ name, home = homedir() }) {
+export function removeServer({ name, home = homedir(), cwd, source }) {
   let found = false;
+  const claude = resolveSkillSource({ source, cwd, home }) === "claude";
+  if (claude) {
+    // From Claude Code's file: this folder's own entry and the every-folder one.
+    const has = readClaudeServers({ cwd, home });
+    if (name in has.local || name in has.user) {
+      updateClaudeConfig((raw) => {
+        if (isObj(raw.mcpServers) && name in raw.mcpServers) delete raw.mcpServers[name];
+        const proj = cwd && isObj(raw.projects) ? raw.projects[resolve(cwd)] : null;
+        if (isObj(proj?.mcpServers) && name in proj.mcpServers) delete proj.mcpServers[name];
+      }, home);
+      found = true;
+    }
+  }
   updateUserConfig((raw) => {
-    if (isObj(raw.mcpServers) && name in raw.mcpServers) {
+    if (!claude && isObj(raw.mcpServers) && name in raw.mcpServers) {
       delete raw.mcpServers[name];
       found = true;
     }