multiagents 0.1.0 → 0.1.2

package/cli/commands.ts

@@ -13,7 +13,8 @@ function printUsage(): void {
   console.log(`multiagents CLI
 
 Usage:
-  multiagents setup                          Interactive setup wizard
+  multiagents install-mcp                     Configure MCP servers for Claude Code
+  multiagents setup                           Interactive setup wizard
   multiagents dashboard [session-id]          TUI dashboard
   multiagents session create <name>           Create a new session
   multiagents session list                    List all sessions
@@ -35,6 +36,12 @@ export async function runCli(args: string[]): Promise<void> {
   const command = args[0];
 
   switch (command) {
+    case "install-mcp": {
+      const { installMcp } = await import("./install-mcp.ts");
+      await installMcp();
+      break;
+    }
+
     case "setup": {
       const { setup } = await import("./setup.ts");
       await setup();

package/cli/install-mcp.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env bun
+/**
+ * multiagents install-mcp — Configure MCP servers for Claude Code.
+ *
+ * 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
+ *
+ * Uses the installed binary names (multiagents-server, multiagents-orch)
+ * so it works regardless of where the package is installed.
+ */
+
+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");
+const SETTINGS_JSON = path.join(CLAUDE_DIR, "settings.json");
+
+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 candidates = [
+    path.join(HOME, ".bun", "bin", name),
+    `/usr/local/bin/${name}`,
+    `/opt/homebrew/bin/${name}`,
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  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");
+
+  // Step 1: Write ~/.claude/.mcp.json
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+  }
+
+  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");
+    }
+  }
+
+  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)");
+
+  // 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");
+      return logs;
+    }
+  }
+
+  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");
+  } else {
+    logs.push("  \x1b[32m✔\x1b[0m Already enabled in settings.json");
+  }
+
+  return logs;
+}
+
+/** 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.
+
+\x1b[1mNext step:\x1b[0m Restart Claude Code to load the new tools.
+  Exit Claude Code and run: \x1b[90mclaude\x1b[0m
+
+\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
+
+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

@@ -9,6 +9,7 @@ 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}`;
@@ -26,17 +27,66 @@ function prompt(question: string, defaultValue?: string): Promise<string> {
   });
 }
 
-function detectAgent(name: string): { available: boolean; version?: string } {
+/** Known install locations per agent type, checked as fallbacks when `which` fails. */
+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 } {
+  // 1. Try `which`
+  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 */ }
+
+  // 2. Fallback: check known paths
+  if (!agentPath) {
+    const candidates = KNOWN_PATHS[name] ?? [];
+    for (const p of candidates) {
+      if (fs.existsSync(p)) {
+        agentPath = p;
+        break;
+      }
+    }
+  }
+
+  if (!agentPath) return { available: false };
 
-    const ver = Bun.spawnSync([name, "--version"]);
-    const version = new TextDecoder().decode(ver.stdout).trim().split("\n")[0];
-    return { available: true, version: version || undefined };
+  // 3. Get version (with timeout protection — some CLIs hang)
+  let version: string | undefined;
+  try {
+    const ver = Bun.spawnSync([agentPath, "--version"], {
+      timeout: 5000, // 5s timeout
+    });
+    if (ver.exitCode === 0) {
+      version = new TextDecoder().decode(ver.stdout).trim().split("\n")[0] || undefined;
+    }
   } catch {
-    return { available: false };
+    // Version check failed — agent exists but version unknown
+    version = undefined;
   }
+
+  return { available: true, version, resolvedPath: agentPath };
 }
 
 export async function setup(): Promise<void> {
@@ -104,8 +154,13 @@ export async function setup(): Promise<void> {
   const sessionName = await prompt("Session name", dirName);
   const sessionId = slugify(sessionName);
 
-  // 6. Configure each selected agent's MCP server
-  console.log("\n\x1b[1mConfiguring MCP servers...\x1b[0m\n");
+  // 6. Install global MCP config (Claude Code + settings.json)
+  console.log("\n\x1b[1mConfiguring global MCP...\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, "..");
 

package/package.json

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

package/scripts/postinstall.ts

@@ -1,84 +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");
-
-// Resolve the installed package's bin paths
-const PKG_ROOT = path.resolve(import.meta.dir, "..");
-const SERVER_PATH = path.join(PKG_ROOT, "server.ts");
-const ORCH_PATH = path.join(PKG_ROOT, "orchestrator", "orchestrator-server.ts");
-
-// Find bun binary
-function findBun(): string {
-  const bunInPath = Bun.spawnSync(["which", "bun"]).stdout.toString().trim();
-  if (bunInPath) return bunInPath;
-  const defaultBun = path.join(HOME, ".bun", "bin", "bun");
-  if (fs.existsSync(defaultBun)) return defaultBun;
-  return "bun"; // fallback — hope it's in PATH at runtime
-}
-
-const BUN = findBun();
-
 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
-  if (!config.mcpServers["multiagents"]) {
-    config.mcpServers["multiagents"] = {
-      command: BUN,
-      args: [SERVER_PATH],
-    };
-    changed = true;
-  }
-
-  // Add orchestrator MCP server
-  if (!config.mcpServers["multiagents-orch"]) {
-    config.mcpServers["multiagents-orch"] = {
-      command: BUN,
-      args: [ORCH_PATH],
-    };
-    changed = true;
-  }
-
-  if (changed) {
-    fs.writeFileSync(MCP_JSON, JSON.stringify(config, null, 2) + "\n");
-    console.log("[multiagents] MCP servers configured in ~/.claude/.mcp.json");
-    console.log("  Restart Claude Code to pick up the new tools.");
-  } else {
-    console.log("[multiagents] MCP servers already configured.");
-  }
+  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.");
 }