multiagents 0.1.2 → 0.1.4

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/cli/setup.ts

@@ -1,12 +1,9 @@
 // ============================================================================
-// multiagents — Interactive Setup Wizard
+// multiagents — Setup: detect agents + install MCP globally
 // ============================================================================
 
-import { DEFAULT_BROKER_PORT, BROKER_HOSTNAME, SESSION_DIR, SESSION_FILE } from "../shared/constants.ts";
+import { DEFAULT_BROKER_PORT, BROKER_HOSTNAME } from "../shared/constants.ts";
 import { BrokerClient } from "../shared/broker-client.ts";
-import { expandHome, getGitRoot, slugify } from "../shared/utils.ts";
-import type { AgentType, SessionFile } from "../shared/types.ts";
-import * as readline from "node:readline";
 import * as path from "node:path";
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -14,20 +11,7 @@ import * as os from "node:os";
 const BROKER_PORT = parseInt(process.env.MULTIAGENTS_PORT ?? String(DEFAULT_BROKER_PORT), 10);
 const BROKER_URL = `http://${BROKER_HOSTNAME}:${BROKER_PORT}`;
 
-// --- Helpers ---
-
-function prompt(question: string, defaultValue?: string): Promise<string> {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const suffix = defaultValue ? ` [${defaultValue}]` : "";
-    rl.question(`${question}${suffix}: `, (answer) => {
-      rl.close();
-      resolve(answer.trim() || defaultValue || "");
-    });
-  });
-}
-
-/** Known install locations per agent type, checked as fallbacks when `which` fails. */
+/** Known install locations per agent type. */
 const KNOWN_PATHS: Record<string, string[]> = {
   claude: [
     path.join(os.homedir(), ".local", "bin", "claude"),
@@ -50,7 +34,6 @@ const KNOWN_PATHS: Record<string, string[]> = {
 };
 
 function detectAgent(name: string): { available: boolean; version?: string; resolvedPath?: string } {
-  // 1. Try `which`
   let agentPath: string | null = null;
   try {
     const which = Bun.spawnSync(["which", name]);
@@ -59,50 +42,38 @@ function detectAgent(name: string): { available: boolean; version?: string; reso
     }
   } catch { /* which failed */ }
 
-  // 2. Fallback: check known paths
   if (!agentPath) {
-    const candidates = KNOWN_PATHS[name] ?? [];
-    for (const p of candidates) {
-      if (fs.existsSync(p)) {
-        agentPath = p;
-        break;
-      }
+    for (const p of (KNOWN_PATHS[name] ?? [])) {
+      if (fs.existsSync(p)) { agentPath = p; break; }
     }
   }
 
   if (!agentPath) return { available: false };
 
-  // 3. Get version (with timeout protection — some CLIs hang)
   let version: string | undefined;
   try {
-    const ver = Bun.spawnSync([agentPath, "--version"], {
-      timeout: 5000, // 5s timeout
-    });
+    const ver = Bun.spawnSync([agentPath, "--version"], { timeout: 5000 });
     if (ver.exitCode === 0) {
       version = new TextDecoder().decode(ver.stdout).trim().split("\n")[0] || undefined;
     }
-  } catch {
-    // Version check failed — agent exists but version unknown
-    version = undefined;
-  }
+  } catch { version = undefined; }
 
   return { available: true, version, resolvedPath: agentPath };
 }
 
 export async function setup(): Promise<void> {
-  // 1. Header banner
   console.log(`
-\x1b[1m\x1b[36m  multiagents\x1b[0m
-\x1b[90m  Interactive Setup Wizard\x1b[0m
+\x1b[1m\x1b[36m  multiagents setup\x1b[0m
+\x1b[90m  Configure MCP + detect agents\x1b[0m
 \x1b[90m  ─────────────────────────────────\x1b[0m
 `);
 
-  // 2. Detect installed agents
+  // 1. Detect agents
   console.log("\x1b[1mDetecting installed agents...\x1b[0m\n");
-  const agents: { type: AgentType; name: string; cmd: string; info: ReturnType<typeof detectAgent> }[] = [
-    { type: "claude", name: "Claude Code", cmd: "claude", info: detectAgent("claude") },
-    { type: "codex", name: "Codex CLI", cmd: "codex", info: detectAgent("codex") },
-    { type: "gemini", name: "Gemini CLI", cmd: "gemini", info: detectAgent("gemini") },
+  const agents = [
+    { name: "Claude Code", cmd: "claude", info: detectAgent("claude") },
+    { name: "Codex CLI", cmd: "codex", info: detectAgent("codex") },
+    { name: "Gemini CLI", cmd: "gemini", info: detectAgent("gemini") },
   ];
 
   for (const a of agents) {
@@ -111,202 +82,61 @@ export async function setup(): Promise<void> {
     console.log(`  ${icon} ${a.name}${ver}`);
   }
 
-  const available = agents.filter((a) => a.info.available);
+  const available = agents.filter(a => a.info.available);
   if (available.length === 0) {
-    console.error("\n\x1b[31mNo supported agents found. Install at least one agent CLI first.\x1b[0m");
-    process.exit(1);
-  }
-
-  // 3. Prompt user to select agents
-  console.log("\n\x1b[1mSelect agents to orchestrate:\x1b[0m\n");
-  for (let i = 0; i < available.length; i++) {
-    console.log(`  ${i + 1}. ${available[i].name} (${available[i].cmd})`);
-  }
-  console.log(`  a. All available agents`);
-
-  const selection = await prompt("\nEnter numbers separated by commas, or 'a' for all", "a");
-  let selected: typeof available;
-  if (selection === "a" || selection === "A") {
-    selected = available;
-  } else {
-    const indices = selection.split(",").map((s) => parseInt(s.trim(), 10) - 1);
-    selected = indices
-      .filter((i) => i >= 0 && i < available.length)
-      .map((i) => available[i]);
-  }
-
-  if (selected.length === 0) {
-    console.error("\n\x1b[31mNo agents selected.\x1b[0m");
+    console.error("\n\x1b[31mNo supported agents found. Install at least one: claude, codex, or gemini.\x1b[0m");
     process.exit(1);
   }
-  console.log(`\nSelected: ${selected.map((a) => a.name).join(", ")}`);
 
-  // 4. Prompt for working directory
-  const projectDir = await prompt("\nProject directory", process.cwd());
-  const resolvedDir = path.resolve(expandHome(projectDir));
-  if (!fs.existsSync(resolvedDir)) {
-    console.error(`\n\x1b[31mDirectory does not exist: ${resolvedDir}\x1b[0m`);
-    process.exit(1);
-  }
-
-  // 5. Prompt for session name
-  const dirName = path.basename(resolvedDir);
-  const sessionName = await prompt("Session name", dirName);
-  const sessionId = slugify(sessionName);
-
-  // 6. Install global MCP config (Claude Code + settings.json)
-  console.log("\n\x1b[1mConfiguring global MCP...\x1b[0m\n");
+  // 2. Install global MCP config
+  console.log("\n\x1b[1mConfiguring MCP servers...\x1b[0m\n");
   const { installMcpSilent } = await import("./install-mcp.ts");
   await installMcpSilent();
 
-  // 7. Configure per-agent MCP
-  console.log("\x1b[1mConfiguring per-agent MCP...\x1b[0m\n");
-
-  const cliPath = path.resolve(import.meta.dir, "..");
-
-  for (const agent of selected) {
-    try {
-      switch (agent.type) {
-        case "claude":
-          await configureClaudeMcp(resolvedDir, cliPath);
-          break;
-        case "codex":
-          await configureCodexMcp(resolvedDir, cliPath);
-          break;
-        case "gemini":
-          await configureGeminiMcp(cliPath);
-          break;
-      }
-      console.log(`  \x1b[32m✔\x1b[0m ${agent.name} MCP configured`);
-    } catch (e) {
-      console.error(`  \x1b[31m✗\x1b[0m ${agent.name}: ${e instanceof Error ? e.message : String(e)}`);
-    }
-  }
-
-  // 7. Start broker
+  // 3. Start broker
   console.log("\n\x1b[1mStarting broker...\x1b[0m");
   const client = new BrokerClient(BROKER_URL);
   let brokerAlive = await client.isAlive();
   if (!brokerAlive) {
-    const proc = Bun.spawn(["bun", path.resolve(cliPath, "broker.ts")], {
-      stdio: ["ignore", "ignore", "ignore"],
-    });
+    const brokerBin = findBrokerBinary();
+    const proc = Bun.spawn([brokerBin], { stdio: ["ignore", "ignore", "ignore"] });
     proc.unref();
     for (let i = 0; i < 30; i++) {
       if (await client.isAlive()) { brokerAlive = true; break; }
       await Bun.sleep(200);
     }
   }
-  if (!brokerAlive) {
-    console.error("  \x1b[31m✗\x1b[0m Broker failed to start");
-    process.exit(1);
-  }
-  console.log(`  \x1b[32m✔\x1b[0m Broker running on ${BROKER_URL}`);
-
-  // 8. Create session
-  console.log("\n\x1b[1mCreating session...\x1b[0m");
-  const gitRoot = await getGitRoot(resolvedDir);
-  try {
-    await client.createSession({
-      id: sessionId,
-      name: sessionName,
-      project_dir: resolvedDir,
-      git_root: gitRoot,
-    });
-    console.log(`  \x1b[32m✔\x1b[0m Session "${sessionName}" (${sessionId}) created`);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    if (msg.includes("409") || msg.includes("UNIQUE") || msg.includes("already")) {
-      console.log(`  \x1b[33m!\x1b[0m Session "${sessionId}" already exists, reusing`);
-    } else {
-      throw e;
-    }
+  if (brokerAlive) {
+    console.log(`  \x1b[32m✔\x1b[0m Broker running on ${BROKER_URL}`);
+  } else {
+    console.log(`  \x1b[33m!\x1b[0m Broker not started — will auto-start when agents connect`);
   }
 
-  // 9. Write session.json
-  const sessionDir = path.join(resolvedDir, SESSION_DIR);
-  if (!fs.existsSync(sessionDir)) fs.mkdirSync(sessionDir, { recursive: true });
-
-  const sessionFile: SessionFile = {
-    session_id: sessionId,
-    created_at: new Date().toISOString(),
-    broker_port: BROKER_PORT,
-  };
-  await Bun.write(path.join(resolvedDir, SESSION_FILE), JSON.stringify(sessionFile, null, 2));
-  console.log(`  \x1b[32m✔\x1b[0m Wrote ${SESSION_FILE}`);
-
-  // 10. Print next steps
+  // 4. Done
   console.log(`
 \x1b[1m\x1b[32mSetup complete!\x1b[0m
 
-\x1b[1mNext steps:\x1b[0m
-  1. Open your agents in the project directory:
-     \x1b[90mcd ${resolvedDir}\x1b[0m
-${selected.map((a) => `     \x1b[90m${a.cmd}\x1b[0m`).join("\n")}
-
-  2. Each agent will auto-connect to the session via MCP.
-
-  3. Monitor with the dashboard:
-     \x1b[90mmultiagents dashboard\x1b[0m
-
-  4. Or use the orchestrator for automated coordination:
-     \x1b[90mmultiagents orchestrator\x1b[0m
+\x1b[1mUsage:\x1b[0m
+  1. Restart Claude Code to load the multiagents tools.
+  2. In Claude Code, ask it to use the multiagents tools.
+  3. Or use the orchestrator to create a team:
+     \x1b[90mmultiagents create-team --project /path/to/project\x1b[0m
+
+\x1b[1mAvailable commands:\x1b[0m
+  \x1b[90mmultiagents dashboard\x1b[0m     Live monitoring
+  \x1b[90mmultiagents status\x1b[0m        Broker health + peers
+  \x1b[90mmultiagents peers\x1b[0m         List connected agents
+  \x1b[90mmultiagents install-mcp\x1b[0m   Reconfigure MCP if needed
 `);
 }
 
-// --- Agent MCP configuration ---
-
-async function configureClaudeMcp(projectDir: string, cliPath: string): Promise<void> {
-  // Write project-level .mcp.json
-  const mcpPath = path.join(projectDir, ".mcp.json");
-  let config: Record<string, unknown> = {};
-  try {
-    const existing = await Bun.file(mcpPath).text();
-    config = JSON.parse(existing);
-  } catch { /* file doesn't exist */ }
-
-  const mcpServers = (config.mcpServers as Record<string, unknown>) ?? {};
-  mcpServers["multiagents"] = {
-    command: "bun",
-    args: [path.resolve(cliPath, "cli.ts"), "mcp-server", "--agent-type", "claude"],
-  };
-  config.mcpServers = mcpServers;
-  await Bun.write(mcpPath, JSON.stringify(config, null, 2));
-}
-
-async function configureCodexMcp(projectDir: string, cliPath: string): Promise<void> {
-  // Write .codex/config.toml
-  const codexDir = path.join(projectDir, ".codex");
-  if (!fs.existsSync(codexDir)) fs.mkdirSync(codexDir, { recursive: true });
-
-  const tomlPath = path.join(codexDir, "config.toml");
-  let existing = "";
-  try { existing = await Bun.file(tomlPath).text(); } catch { /* ok */ }
-
-  // Remove any existing multiagents section
-  existing = existing.replace(/\[mcp_servers\.multiagents\][\s\S]*?(?=\n\[|$)/, "").trim();
-
-  const entry = `\n\n[mcp_servers.multiagents]\ncommand = "bun"\nargs = [${JSON.stringify(path.resolve(cliPath, "cli.ts"))}, "mcp-server", "--agent-type", "codex"]\n`;
-  await Bun.write(tomlPath, existing + entry);
-}
-
-async function configureGeminiMcp(cliPath: string): Promise<void> {
-  // Write ~/.gemini/settings.json
-  const geminiDir = expandHome("~/.gemini");
-  if (!fs.existsSync(geminiDir)) fs.mkdirSync(geminiDir, { recursive: true });
-
-  const settingsPath = path.join(geminiDir, "settings.json");
-  let config: Record<string, unknown> = {};
+function findBrokerBinary(): string {
   try {
-    const existing = await Bun.file(settingsPath).text();
-    config = JSON.parse(existing);
+    const which = Bun.spawnSync(["which", "multiagents-broker"]);
+    const found = new TextDecoder().decode(which.stdout).trim();
+    if (found) return found;
   } catch { /* ok */ }
-
-  const mcpServers = (config.mcpServers as Record<string, unknown>) ?? {};
-  mcpServers["multiagents"] = {
-    command: "bun",
-    args: [path.resolve(cliPath, "cli.ts"), "mcp-server", "--agent-type", "gemini"],
-  };
-  config.mcpServers = mcpServers;
-  await Bun.write(settingsPath, JSON.stringify(config, null, 2));
+  const bun = path.join(os.homedir(), ".bun", "bin", "multiagents-broker");
+  if (fs.existsSync(bun)) return bun;
+  return "multiagents-broker";
 }

package/package.json

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

package/.mcp.json

@@ -1,12 +0,0 @@
-{
-  "mcpServers": {
-    "agent-peers": {
-      "command": "/Users/armanandreasyan/.bun/bin/bun",
-      "args": ["/Users/armanandreasyan/Documents/multi-agent-peers/server.ts"]
-    },
-    "agent-peers-orchestrator": {
-      "command": "/Users/armanandreasyan/.bun/bin/bun",
-      "args": ["/Users/armanandreasyan/Documents/multi-agent-peers/orchestrator/orchestrator-server.ts"]
-    }
-  }
-}