multiagents 0.1.1 → 0.1.3

package/cli/install-mcp.ts

@@ -20,11 +20,12 @@ const MCP_JSON = path.join(CLAUDE_DIR, ".mcp.json");
 const SETTINGS_JSON = path.join(CLAUDE_DIR, "settings.json");
 
 function findBinary(name: string): string {
-  const which = Bun.spawnSync(["which", name]);
-  const found = new TextDecoder().decode(which.stdout).trim();
-  if (found) return found;
+  try {
+    const which = Bun.spawnSync(["which", name]);
+    const found = new TextDecoder().decode(which.stdout).trim();
+    if (found) return found;
+  } catch { /* ok */ }
 
-  // Fallback to common locations
   const candidates = [
     path.join(HOME, ".bun", "bin", name),
     `/usr/local/bin/${name}`,
@@ -33,20 +34,16 @@ function findBinary(name: string): string {
   for (const c of candidates) {
     if (fs.existsSync(c)) return c;
   }
-  return name; // hope it's in PATH at runtime
+  return name;
 }
 
-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");
-
+/** 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");
 
-  console.log(`  Server binary: ${serverBin}`);
-  console.log(`  Orchestrator binary: ${orchBin}\n`);
-
-  // --- Step 1: Write ~/.claude/.mcp.json ---
+  // Step 1: Write ~/.claude/.mcp.json
   if (!fs.existsSync(CLAUDE_DIR)) {
     fs.mkdirSync(CLAUDE_DIR, { recursive: true });
   }
@@ -59,57 +56,49 @@ export async function installMcp(): Promise<void> {
     } catch {
       fs.copyFileSync(MCP_JSON, MCP_JSON + ".bak");
       mcpConfig = { mcpServers: {} };
-      console.log("  \x1b[33m!\x1b[0m Existing .mcp.json was corrupted — backed up and recreated");
+      logs.push("  \x1b[33m!\x1b[0m Existing .mcp.json was corrupted — backed up and recreated");
     }
   }
 
-  mcpConfig.mcpServers["multiagents"] = {
-    command: serverBin,
-    args: [],
-  };
-  mcpConfig.mcpServers["multiagents-orch"] = {
-    command: orchBin,
-    args: [],
-  };
-
+  mcpConfig.mcpServers["multiagents"] = { command: serverBin, args: [] };
+  mcpConfig.mcpServers["multiagents-orch"] = { command: orchBin, args: [] };
   fs.writeFileSync(MCP_JSON, JSON.stringify(mcpConfig, null, 2) + "\n");
-  console.log("  \x1b[32m✔\x1b[0m Wrote ~/.claude/.mcp.json");
+  logs.push("  \x1b[32m✔\x1b[0m Global MCP configured (~/.claude/.mcp.json)");
 
-  // --- Step 2: Enable in ~/.claude/settings.json ---
+  // 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 {
-      console.log("  \x1b[33m!\x1b[0m Could not parse settings.json — skipping auto-enable");
-      printDone();
-      return;
+      logs.push("  \x1b[33m!\x1b[0m Could not parse settings.json — skipping auto-enable");
+      return logs;
     }
   }
 
-  // Ensure enabledMcpjsonServers includes our servers
-  let enabled = (settings.enabledMcpjsonServers as string[]) ?? [];
+  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 (!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");
-    console.log("  \x1b[32m✔\x1b[0m Enabled in ~/.claude/settings.json");
+    logs.push("  \x1b[32m✔\x1b[0m Enabled in ~/.claude/settings.json");
   } else {
-    console.log("  \x1b[32m✔\x1b[0m Already enabled in settings.json");
+    logs.push("  \x1b[32m✔\x1b[0m Already enabled in settings.json");
   }
 
-  printDone();
+  return logs;
 }
 
-function printDone(): void {
+/** 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");
+
+  const logs = configureMcp();
+  for (const line of logs) console.log(line);
+
   console.log(`
 \x1b[1m\x1b[32mDone!\x1b[0m MCP servers configured.
 
@@ -128,3 +117,9 @@ And add to ~/.claude/settings.json:
 \x1b[90m  "enabledMcpjsonServers": ["multiagents", "multiagents-orch"]\x1b[0m
 `);
 }
+
+/** Quiet version — called from `setup` flow, prints compact output. */
+export async function installMcpSilent(): Promise<void> {
+  const logs = configureMcp();
+  for (const line of logs) console.log(line);
+}

package/cli/setup.ts

@@ -1,58 +1,79 @@
 // ============================================================================
-// 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";
 
 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 || "");
-    });
-  });
-}
-
-function detectAgent(name: string): { available: boolean; version?: string } {
+/** Known install locations per agent type. */
+const KNOWN_PATHS: Record<string, string[]> = {
+  claude: [
+    path.join(os.homedir(), ".local", "bin", "claude"),
+    path.join(os.homedir(), ".claude", "bin", "claude"),
+    "/usr/local/bin/claude",
+    "/opt/homebrew/bin/claude",
+  ],
+  codex: [
+    "/usr/local/bin/codex",
+    path.join(os.homedir(), ".local", "bin", "codex"),
+    path.join(os.homedir(), ".npm-global", "bin", "codex"),
+    "/opt/homebrew/bin/codex",
+  ],
+  gemini: [
+    path.join(os.homedir(), ".local", "bin", "gemini"),
+    "/usr/local/bin/gemini",
+    "/opt/homebrew/bin/gemini",
+    path.join(os.homedir(), ".npm-global", "bin", "gemini"),
+  ],
+};
+
+function detectAgent(name: string): { available: boolean; version?: string; resolvedPath?: string } {
+  let agentPath: string | null = null;
   try {
     const which = Bun.spawnSync(["which", name]);
-    if (which.exitCode !== 0) return { available: false };
+    if (which.exitCode === 0) {
+      agentPath = new TextDecoder().decode(which.stdout).trim();
+    }
+  } catch { /* which failed */ }
 
-    const ver = Bun.spawnSync([name, "--version"]);
-    const version = new TextDecoder().decode(ver.stdout).trim().split("\n")[0];
-    return { available: true, version: version || undefined };
-  } catch {
-    return { available: false };
+  if (!agentPath) {
+    for (const p of (KNOWN_PATHS[name] ?? [])) {
+      if (fs.existsSync(p)) { agentPath = p; break; }
+    }
   }
+
+  if (!agentPath) return { available: false };
+
+  let version: string | undefined;
+  try {
+    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 = 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) {
@@ -61,197 +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");
+    console.error("\n\x1b[31mNo supported agents found. Install at least one: claude, codex, or gemini.\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");
-    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. Configure each selected agent's MCP server
+  // 2. Install global MCP config
   console.log("\n\x1b[1mConfiguring MCP servers...\x1b[0m\n");
+  const { installMcpSilent } = await import("./install-mcp.ts");
+  await installMcpSilent();
 
-  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.1",
+  "version": "0.1.3",
   "description": "Multi-agent orchestration platform for Claude Code, Codex CLI, and Gemini CLI",
   "module": "index.ts",
   "type": "module",

package/scripts/postinstall.ts

@@ -1,105 +1,16 @@
 #!/usr/bin/env bun
 /**
  * Post-install script: auto-configures MCP servers for Claude Code.
- *
- * Adds multiagents and multiagents-orch to ~/.claude/.mcp.json
- * so Claude Code can discover the tools without manual configuration.
- *
- * Safe: only adds entries if they don't already exist. Never overwrites.
+ * Delegates to the same logic as `multiagents install-mcp`.
+ * If it fails, prints fallback instructions — never breaks the install.
  */
 
-import * as fs from "node:fs";
-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");
-
-// Use installed binary names — works regardless of install location
-function findBinary(name: string): string {
-  try {
-    const which = Bun.spawnSync(["which", name]);
-    const found = new TextDecoder().decode(which.stdout).trim();
-    if (found) return found;
-  } catch { /* ok */ }
-  const defaultPath = path.join(HOME, ".bun", "bin", name);
-  if (fs.existsSync(defaultPath)) return defaultPath;
-  return name; // fallback
-}
-
-const SERVER_BIN = findBinary("multiagents-server");
-const ORCH_BIN = findBinary("multiagents-orch");
-
 try {
-  // Ensure ~/.claude/ exists
-  if (!fs.existsSync(CLAUDE_DIR)) {
-    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
-  }
-
-  // Read or create .mcp.json
-  let config: { mcpServers: Record<string, unknown> } = { mcpServers: {} };
-  if (fs.existsSync(MCP_JSON)) {
-    try {
-      config = JSON.parse(fs.readFileSync(MCP_JSON, "utf-8"));
-      if (!config.mcpServers) config.mcpServers = {};
-    } catch {
-      // Corrupted file — back up and recreate
-      fs.copyFileSync(MCP_JSON, MCP_JSON + ".bak");
-      config = { mcpServers: {} };
-    }
-  }
-
-  let changed = false;
-
-  // Add multiagents MCP server (using installed binary names)
-  if (!config.mcpServers["multiagents"]) {
-    config.mcpServers["multiagents"] = {
-      command: SERVER_BIN,
-      args: [],
-    };
-    changed = true;
-  }
-
-  // Add orchestrator MCP server
-  if (!config.mcpServers["multiagents-orch"]) {
-    config.mcpServers["multiagents-orch"] = {
-      command: ORCH_BIN,
-      args: [],
-    };
-    changed = true;
-  }
-
-  if (changed) {
-    fs.writeFileSync(MCP_JSON, JSON.stringify(config, null, 2) + "\n");
-    console.log("[multiagents] MCP servers configured in ~/.claude/.mcp.json");
-  } else {
-    console.log("[multiagents] MCP servers already configured in .mcp.json");
-  }
-
-  // Also enable in settings.json
-  const SETTINGS_JSON = path.join(CLAUDE_DIR, "settings.json");
-  if (fs.existsSync(SETTINGS_JSON)) {
-    try {
-      const settings = JSON.parse(fs.readFileSync(SETTINGS_JSON, "utf-8"));
-      const enabled: string[] = settings.enabledMcpjsonServers ?? [];
-      let settingsChanged = false;
-      if (!enabled.includes("multiagents")) { enabled.push("multiagents"); settingsChanged = true; }
-      if (!enabled.includes("multiagents-orch")) { enabled.push("multiagents-orch"); settingsChanged = true; }
-      if (settingsChanged) {
-        settings.enabledMcpjsonServers = enabled;
-        fs.writeFileSync(SETTINGS_JSON, JSON.stringify(settings, null, 2) + "\n");
-        console.log("[multiagents] Enabled in ~/.claude/settings.json");
-      }
-    } catch {
-      // Don't fail install over settings.json
-    }
-  }
-
+  const { installMcpSilent } = await import("../cli/install-mcp.ts");
+  await installMcpSilent();
   console.log("[multiagents] Restart Claude Code to pick up the new tools.");
   console.log("[multiagents] If tools don't appear, run: multiagents install-mcp");
 } catch (e) {
-  // Postinstall should never fail the install
   console.error(`[multiagents] postinstall warning: ${e instanceof Error ? e.message : String(e)}`);
   console.error("[multiagents] Run 'multiagents install-mcp' to configure manually.");
 }

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"]
-    }
-  }
-}