multiagents 0.1.0 → 0.1.1

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,130 @@
+#!/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 {
+  const which = Bun.spawnSync(["which", name]);
+  const found = new TextDecoder().decode(which.stdout).trim();
+  if (found) return found;
+
+  // Fallback to common locations
+  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; // hope it's in PATH at runtime
+}
+
+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 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 ---
+  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: {} };
+      console.log("  \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");
+  console.log("  \x1b[32m✔\x1b[0m Wrote ~/.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 {
+      console.log("  \x1b[33m!\x1b[0m Could not parse settings.json — skipping auto-enable");
+      printDone();
+      return;
+    }
+  }
+
+  // Ensure enabledMcpjsonServers includes our servers
+  let 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");
+    console.log("  \x1b[32m✔\x1b[0m Enabled in ~/.claude/settings.json");
+  } else {
+    console.log("  \x1b[32m✔\x1b[0m Already enabled in settings.json");
+  }
+
+  printDone();
+}
+
+function printDone(): void {
+  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
+`);
+}

package/package.json

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

package/scripts/postinstall.ts

@@ -16,21 +16,20 @@ 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
+// 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 BUN = findBun();
+const SERVER_BIN = findBinary("multiagents-server");
+const ORCH_BIN = findBinary("multiagents-orch");
 
 try {
   // Ensure ~/.claude/ exists
@@ -53,11 +52,11 @@ try {
 
   let changed = false;
 
-  // Add multiagents MCP server
+  // Add multiagents MCP server (using installed binary names)
   if (!config.mcpServers["multiagents"]) {
     config.mcpServers["multiagents"] = {
-      command: BUN,
-      args: [SERVER_PATH],
+      command: SERVER_BIN,
+      args: [],
     };
     changed = true;
   }
@@ -65,8 +64,8 @@ try {
   // Add orchestrator MCP server
   if (!config.mcpServers["multiagents-orch"]) {
     config.mcpServers["multiagents-orch"] = {
-      command: BUN,
-      args: [ORCH_PATH],
+      command: ORCH_BIN,
+      args: [],
     };
     changed = true;
   }
@@ -74,11 +73,33 @@ try {
   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.");
+    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
+    }
+  }
+
+  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.");
 }