multiagents 0.1.3 → 0.1.5

package/cli/install-mcp.ts

@@ -1,13 +1,17 @@
 #!/usr/bin/env bun
 /**
- * multiagents install-mcp — Configure MCP servers for Claude Code.
+ * multiagents install-mcp — Configure MCP servers globally for all detected agent CLIs.
  *
- * 1. Writes multiagents + multiagents-orch to ~/.claude/.mcp.json
- * 2. Adds them to enabledMcpjsonServers in ~/.claude/settings.json
- * 3. Prints instructions to restart Claude Code
+ * Claude Code: `claude mcp add -s user` → writes to ~/.claude.json
+ *   Docs: https://docs.anthropic.com/en/docs/claude-code
  *
- * Uses the installed binary names (multiagents-server, multiagents-orch)
- * so it works regardless of where the package is installed.
+ * Codex CLI: `codex mcp add` → writes to ~/.codex/config.toml
+ *   Docs: https://developers.openai.com/codex/mcp
+ *
+ * Gemini CLI: Direct write to ~/.gemini/settings.json (no CLI command for mcp add)
+ *   Docs: https://geminicli.com/docs/tools/mcp-server/
+ *
+ * Each agent has its own config format and location. This script handles all three.
  */
 
 import * as fs from "node:fs";
@@ -15,9 +19,8 @@ import * as path from "node:path";
 import * as os from "node:os";
 
 const HOME = os.homedir();
-const CLAUDE_DIR = path.join(HOME, ".claude");
-const MCP_JSON = path.join(CLAUDE_DIR, ".mcp.json");
-const SETTINGS_JSON = path.join(CLAUDE_DIR, "settings.json");
+
+// --- Binary resolution ---
 
 function findBinary(name: string): string {
   try {
@@ -28,6 +31,8 @@ function findBinary(name: string): string {
 
   const candidates = [
     path.join(HOME, ".bun", "bin", name),
+    path.join(HOME, ".local", "bin", name),
+    path.join(HOME, ".npm-global", "bin", name),
     `/usr/local/bin/${name}`,
     `/opt/homebrew/bin/${name}`,
   ];
@@ -37,89 +42,230 @@ function findBinary(name: string): string {
   return name;
 }
 
-/** Core logic — configures .mcp.json + settings.json. Returns log lines. */
-function configureMcp(): string[] {
-  const logs: string[] = [];
-  const serverBin = findBinary("multiagents-server");
-  const orchBin = findBinary("multiagents-orch");
+function findAgentCli(name: string): string | null {
+  // Check `which` first
+  try {
+    const which = Bun.spawnSync(["which", name]);
+    if (which.exitCode === 0) return new TextDecoder().decode(which.stdout).trim();
+  } catch { /* ok */ }
+
+  // Known install locations
+  const knownPaths: Record<string, string[]> = {
+    claude: [
+      path.join(HOME, ".local", "bin", "claude"),
+      path.join(HOME, ".claude", "bin", "claude"),
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude",
+    ],
+    codex: [
+      path.join(HOME, ".local", "bin", "codex"),
+      path.join(HOME, ".npm-global", "bin", "codex"),
+      "/usr/local/bin/codex",
+      "/opt/homebrew/bin/codex",
+    ],
+    gemini: [
+      path.join(HOME, ".local", "bin", "gemini"),
+      path.join(HOME, ".npm-global", "bin", "gemini"),
+      "/usr/local/bin/gemini",
+      "/opt/homebrew/bin/gemini",
+    ],
+  };
 
-  // Step 1: Write ~/.claude/.mcp.json
-  if (!fs.existsSync(CLAUDE_DIR)) {
-    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+  for (const p of (knownPaths[name] ?? [])) {
+    if (fs.existsSync(p)) return p;
   }
+  return null;
+}
+
+// --- Claude Code ---
+// Uses: `claude mcp add <name> -s user -- <command>`
+// Writes to: ~/.claude.json → mcpServers
+// Docs: https://docs.anthropic.com/en/docs/claude-code
+
+function configureClaude(serverBin: string, orchBin: string): string[] {
+  const logs: string[] = [];
+  const claudePath = findAgentCli("claude");
+
+  if (claudePath) {
+    // Use the official CLI (preferred)
+    // Remove first to avoid duplicates
+    Bun.spawnSync([claudePath, "mcp", "remove", "multiagents", "-s", "user"], { stderr: "ignore", stdout: "ignore" });
+    Bun.spawnSync([claudePath, "mcp", "remove", "multiagents-orch", "-s", "user"], { stderr: "ignore", stdout: "ignore" });
+
+    const r1 = Bun.spawnSync([claudePath, "mcp", "add", "multiagents", "-s", "user", "--", serverBin]);
+    const r2 = Bun.spawnSync([claudePath, "mcp", "add", "multiagents-orch", "-s", "user", "--", orchBin]);
 
-  let mcpConfig: { mcpServers: Record<string, unknown> } = { mcpServers: {} };
-  if (fs.existsSync(MCP_JSON)) {
-    try {
-      mcpConfig = JSON.parse(fs.readFileSync(MCP_JSON, "utf-8"));
-      if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
-    } catch {
-      fs.copyFileSync(MCP_JSON, MCP_JSON + ".bak");
-      mcpConfig = { mcpServers: {} };
-      logs.push("  \x1b[33m!\x1b[0m Existing .mcp.json was corrupted — backed up and recreated");
+    if (r1.exitCode === 0 && r2.exitCode === 0) {
+      logs.push("  \x1b[32m✔\x1b[0m Claude Code: MCP servers added (via claude mcp add -s user)");
+      return logs;
     }
+    logs.push("  \x1b[33m!\x1b[0m Claude Code: CLI method failed, falling back to file config");
   }
 
-  mcpConfig.mcpServers["multiagents"] = { command: serverBin, args: [] };
-  mcpConfig.mcpServers["multiagents-orch"] = { command: orchBin, args: [] };
-  fs.writeFileSync(MCP_JSON, JSON.stringify(mcpConfig, null, 2) + "\n");
-  logs.push("  \x1b[32m✔\x1b[0m Global MCP configured (~/.claude/.mcp.json)");
+  // Fallback: write directly to ~/.claude.json
+  const configPath = path.join(HOME, ".claude.json");
+  let config: Record<string, unknown> = {};
+  if (fs.existsSync(configPath)) {
+    try { config = JSON.parse(fs.readFileSync(configPath, "utf-8")); } catch { config = {}; }
+  }
 
-  // Step 2: Enable in ~/.claude/settings.json
-  let settings: Record<string, unknown> = {};
-  if (fs.existsSync(SETTINGS_JSON)) {
-    try {
-      settings = JSON.parse(fs.readFileSync(SETTINGS_JSON, "utf-8"));
-    } catch {
-      logs.push("  \x1b[33m!\x1b[0m Could not parse settings.json — skipping auto-enable");
+  const mcpServers = (config.mcpServers as Record<string, unknown>) ?? {};
+  mcpServers["multiagents"] = { type: "stdio", command: serverBin, args: [], env: {} };
+  mcpServers["multiagents-orch"] = { type: "stdio", command: orchBin, args: [], env: {} };
+  config.mcpServers = mcpServers;
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  logs.push("  \x1b[32m✔\x1b[0m Claude Code: MCP servers written to ~/.claude.json");
+  return logs;
+}
+
+// --- Codex CLI ---
+// Uses: `codex mcp add <name> -- <command> <args...>`
+// Writes to: ~/.codex/config.toml → [mcp_servers.<name>]
+// Docs: https://developers.openai.com/codex/mcp
+
+function configureCodex(serverBin: string): string[] {
+  const logs: string[] = [];
+  const codexPath = findAgentCli("codex");
+
+  if (codexPath) {
+    // Use the official CLI (preferred)
+    // Remove first to avoid duplicates
+    Bun.spawnSync([codexPath, "mcp", "remove", "multiagents"], { stderr: "ignore", stdout: "ignore" });
+
+    const r1 = Bun.spawnSync([codexPath, "mcp", "add", "multiagents", "--", serverBin, "--agent-type", "codex"]);
+    if (r1.exitCode === 0) {
+      logs.push("  \x1b[32m✔\x1b[0m Codex CLI: MCP server added (via codex mcp add)");
       return logs;
     }
+    logs.push("  \x1b[33m!\x1b[0m Codex CLI: CLI method failed, falling back to file config");
+  }
+
+  // Fallback: write directly to ~/.codex/config.toml
+  const codexDir = path.join(HOME, ".codex");
+  const configPath = path.join(codexDir, "config.toml");
+
+  if (!fs.existsSync(codexDir)) {
+    fs.mkdirSync(codexDir, { recursive: true });
+  }
+
+  let existing = "";
+  if (fs.existsSync(configPath)) {
+    existing = fs.readFileSync(configPath, "utf-8");
   }
 
-  const enabled = (settings.enabledMcpjsonServers as string[]) ?? [];
-  let changed = false;
-  if (!enabled.includes("multiagents")) { enabled.push("multiagents"); changed = true; }
-  if (!enabled.includes("multiagents-orch")) { enabled.push("multiagents-orch"); changed = true; }
-  if (changed) {
-    settings.enabledMcpjsonServers = enabled;
-    fs.writeFileSync(SETTINGS_JSON, JSON.stringify(settings, null, 2) + "\n");
-    logs.push("  \x1b[32m✔\x1b[0m Enabled in ~/.claude/settings.json");
+  // Check if [mcp_servers.multiagents] already exists
+  if (existing.includes("[mcp_servers.multiagents]")) {
+    // Replace existing block
+    existing = existing.replace(
+      /\[mcp_servers\.multiagents\][^\[]*/s,
+      `[mcp_servers.multiagents]\ncommand = "${serverBin}"\nargs = ["--agent-type", "codex"]\n\n`
+    );
   } else {
-    logs.push("  \x1b[32m✔\x1b[0m Already enabled in settings.json");
+    // Append new block
+    existing += `\n[mcp_servers.multiagents]\ncommand = "${serverBin}"\nargs = ["--agent-type", "codex"]\n`;
   }
 
+  fs.writeFileSync(configPath, existing);
+  logs.push("  \x1b[32m✔\x1b[0m Codex CLI: MCP server written to ~/.codex/config.toml");
   return logs;
 }
 
+// --- Gemini CLI ---
+// No CLI command for adding MCP servers (as of March 2026).
+// Direct write to: ~/.gemini/settings.json → mcpServers
+// Docs: https://geminicli.com/docs/tools/mcp-server/
+
+function configureGemini(serverBin: string): string[] {
+  const logs: string[] = [];
+  const geminiDir = path.join(HOME, ".gemini");
+  const configPath = path.join(geminiDir, "settings.json");
+
+  if (!fs.existsSync(geminiDir)) {
+    fs.mkdirSync(geminiDir, { recursive: true });
+  }
+
+  let settings: Record<string, unknown> = {};
+  if (fs.existsSync(configPath)) {
+    try { settings = JSON.parse(fs.readFileSync(configPath, "utf-8")); } catch { settings = {}; }
+  }
+
+  const mcpServers = (settings.mcpServers as Record<string, unknown>) ?? {};
+  mcpServers["multiagents"] = {
+    command: serverBin,
+    args: ["--agent-type", "gemini"],
+    timeout: 30000,
+  };
+  settings.mcpServers = mcpServers;
+
+  fs.writeFileSync(configPath, JSON.stringify(settings, null, 2) + "\n");
+  logs.push("  \x1b[32m✔\x1b[0m Gemini CLI: MCP server written to ~/.gemini/settings.json");
+  return logs;
+}
+
+// --- Public API ---
+
+interface ConfigResult {
+  logs: string[];
+  configured: string[];
+}
+
+function configureMcp(): ConfigResult {
+  const serverBin = findBinary("multiagents-server");
+  const orchBin = findBinary("multiagents-orch");
+  const logs: string[] = [];
+  const configured: string[] = [];
+
+  // Claude Code (always — it's the primary orchestrator)
+  const claudeLogs = configureClaude(serverBin, orchBin);
+  logs.push(...claudeLogs);
+  configured.push("claude");
+
+  // Codex CLI (if installed)
+  if (findAgentCli("codex")) {
+    const codexLogs = configureCodex(serverBin);
+    logs.push(...codexLogs);
+    configured.push("codex");
+  } else {
+    logs.push("  \x1b[90m-\x1b[0m Codex CLI: not installed, skipping");
+  }
+
+  // Gemini CLI (if installed)
+  if (findAgentCli("gemini")) {
+    const geminiLogs = configureGemini(serverBin);
+    logs.push(...geminiLogs);
+    configured.push("gemini");
+  } else {
+    logs.push("  \x1b[90m-\x1b[0m Gemini CLI: not installed, skipping");
+  }
+
+  return { logs, configured };
+}
+
 /** Verbose version — standalone `multiagents install-mcp` command. */
 export async function installMcp(): Promise<void> {
   console.log("\n\x1b[1m\x1b[36m  multiagents install-mcp\x1b[0m");
-  console.log("\x1b[90m  Configure MCP servers for Claude Code\x1b[0m\n");
+  console.log("\x1b[90m  Configure MCP servers for all detected agent CLIs\x1b[0m\n");
 
-  const logs = configureMcp();
+  const { logs, configured } = configureMcp();
   for (const line of logs) console.log(line);
 
   console.log(`
-\x1b[1m\x1b[32mDone!\x1b[0m MCP servers configured.
-
-\x1b[1mNext step:\x1b[0m Restart Claude Code to load the new tools.
-  Exit Claude Code and run: \x1b[90mclaude\x1b[0m
+\x1b[1m\x1b[32mDone!\x1b[0m MCP configured for: ${configured.join(", ")}
 
-\x1b[1mManual setup:\x1b[0m If auto-config doesn't work, add to ~/.claude/.mcp.json:
-\x1b[90m  {
-    "mcpServers": {
-      "multiagents": { "command": "multiagents-server", "args": [] },
-      "multiagents-orch": { "command": "multiagents-orch", "args": [] }
-    }
-  }\x1b[0m
+\x1b[1mNext step:\x1b[0m Restart your agent CLIs to load the new tools.
 
-And add to ~/.claude/settings.json:
-\x1b[90m  "enabledMcpjsonServers": ["multiagents", "multiagents-orch"]\x1b[0m
+\x1b[1mVerify:\x1b[0m
+${configured.includes("claude") ? "  Claude:  \x1b[90mclaude mcp list | grep multiagent\x1b[0m\n" : ""}${configured.includes("codex") ? "  Codex:   \x1b[90mcodex mcp list\x1b[0m\n" : ""}${configured.includes("gemini") ? "  Gemini:  \x1b[90mCheck ~/.gemini/settings.json\x1b[0m\n" : ""}
+\x1b[1mManual setup:\x1b[0m
+  Claude:  \x1b[90mclaude mcp add multiagents -s user -- multiagents-server\x1b[0m
+  Codex:   \x1b[90mcodex mcp add multiagents -- multiagents-server --agent-type codex\x1b[0m
+  Gemini:  Add to ~/.gemini/settings.json:
+           \x1b[90m{"mcpServers":{"multiagents":{"command":"multiagents-server","args":["--agent-type","gemini"]}}}\x1b[0m
 `);
 }
 
-/** Quiet version — called from `setup` flow, prints compact output. */
+/** Quiet version — called from `setup` flow. */
 export async function installMcpSilent(): Promise<void> {
-  const logs = configureMcp();
+  const { logs } = configureMcp();
   for (const line of logs) console.log(line);
 }

package/orchestrator/launcher.ts

@@ -286,55 +286,18 @@ export function buildCliArgs(agentType: AgentType, task: string): string[] {
       ];
     }
     case "codex": {
-      // Inject multiagents MCP server via dotted-path config overrides.
-      //
-      // CRITICAL: Codex loads ALL MCP servers from ~/.codex/config.toml at
-      // startup. We must neutralize any global entries that would interfere:
-      //
-      // 1. Entries with `url` (like figma) are remote MCP — not supported
-      //    in stdio mode, causes connection errors.
-      // 2. Entries with slow `npx` commands (like chrome-devtools) cause
-      //    10s+ timeouts during MCP handshake.
-      // 3. NEVER use `echo "disabled"` as a dummy — Codex reads stdout as
-      //    JSON-RPC and "disabled" fails to parse, crashing the agent.
-      //
-      // The fix: read ~/.codex/config.toml, find all [mcp_servers.*] keys,
-      // and override each non-multiagents entry with noop-mcp.ts — a tiny
-      // MCP server that completes the JSON-RPC handshake instantly with zero
-      // tools, then stays alive. This avoids:
-      //   - /usr/bin/true: exits immediately → 10s MCP handshake timeout
-      //   - echo "disabled": stdout parsed as JSON-RPC → deserialization crash
-      const noopMcpPath = path.resolve(import.meta.dir, "..", "noop-mcp.ts");
+      // Inject multiagents MCP via dotted-path config overrides.
+      // We ONLY add our own MCP server — never touch other user-configured servers.
+      // The multiagents entry is already in ~/.codex/config.toml (written by install-mcp),
+      // but we override here to ensure the spawned agent uses the correct binary path.
       const codexMcp = mcpServerCommand("codex");
       const argsJson = JSON.stringify(codexMcp.args);
       const overrides: string[] = [
-        // Our MCP server
         `mcp_servers.multiagents.command="${codexMcp.command}"`,
         `mcp_servers.multiagents.args=${argsJson}`,
         'model_reasoning_effort="high"',
       ];
 
-      // Neutralize global MCP servers by reading config
-      const globalConfigPath = path.join(process.env.HOME ?? "", ".codex", "config.toml");
-      try {
-        const configText = fs.readFileSync(globalConfigPath, "utf-8");
-        // Find all [mcp_servers.XXX] section names
-        const mcpPattern = /\[mcp_servers\.(\w[\w-]*)\]/g;
-        let match;
-        while ((match = mcpPattern.exec(configText)) !== null) {
-          const serverName = match[1];
-          if (serverName !== "multiagents") {
-            // Override with noop-mcp.ts — instant handshake, zero tools
-            overrides.push(`mcp_servers.${serverName}.command="bun"`);
-            overrides.push(`mcp_servers.${serverName}.args=["${noopMcpPath}"]`);
-            // Clear url field if present (remote MCP entries)
-            overrides.push(`mcp_servers.${serverName}.url=""`);
-          }
-        }
-      } catch {
-        // No global config — nothing to neutralize
-      }
-
       const args: string[] = [
         "exec",
         "--sandbox", "workspace-write",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multiagents",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Multi-agent orchestration platform for Claude Code, Codex CLI, and Gemini CLI",
   "module": "index.ts",
   "type": "module",