multiagents 0.1.0

package/cli/session.ts

@@ -0,0 +1,278 @@
+// ============================================================================
+// multiagents — Session Management Commands
+// ============================================================================
+
+import { DEFAULT_BROKER_PORT, BROKER_HOSTNAME, SESSION_DIR, SESSION_FILE } from "../shared/constants.ts";
+import { BrokerClient } from "../shared/broker-client.ts";
+import { getGitRoot, formatTime, timeSince, slugify } from "../shared/utils.ts";
+import type { SessionFile } from "../shared/types.ts";
+import * as readline from "node:readline";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const BROKER_PORT = parseInt(process.env.MULTIAGENTS_PORT ?? String(DEFAULT_BROKER_PORT), 10);
+const BROKER_URL = `http://${BROKER_HOSTNAME}:${BROKER_PORT}`;
+
+function prompt(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${question}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function readLocalSession(): SessionFile | null {
+  try {
+    const text = fs.readFileSync(path.resolve(process.cwd(), SESSION_FILE), "utf-8");
+    return JSON.parse(text) as SessionFile;
+  } catch {
+    return null;
+  }
+}
+
+export async function sessionCommand(args: string[]): Promise<void> {
+  const sub = args[0];
+  const client = new BrokerClient(BROKER_URL);
+
+  switch (sub) {
+    case "create":
+      await create(client, args.slice(1).join(" ") || undefined);
+      break;
+    case "list":
+      await list(client);
+      break;
+    case "resume":
+      await resume(client, args[1]);
+      break;
+    case "pause":
+      await pause(client, args[1]);
+      break;
+    case "archive":
+      await archive(client, args[1]);
+      break;
+    case "delete":
+      await deleteSession(client, args[1]);
+      break;
+    case "export":
+      await exportSession(client, args[1]);
+      break;
+    default:
+      console.log(`Usage: multiagents session <create|list|resume|pause|archive|delete|export> [args]`);
+      process.exit(1);
+  }
+}
+
+async function create(client: BrokerClient, name?: string): Promise<void> {
+  if (!name) {
+    console.error("Usage: multiagents session create <name>");
+    process.exit(1);
+  }
+
+  const projectDir = process.cwd();
+  const gitRoot = await getGitRoot(projectDir);
+  const sessionId = slugify(name);
+
+  const session = await client.createSession({
+    id: sessionId,
+    name,
+    project_dir: projectDir,
+    git_root: gitRoot,
+  });
+
+  // Write local session file
+  const sessionDir = path.join(projectDir, SESSION_DIR);
+  if (!fs.existsSync(sessionDir)) fs.mkdirSync(sessionDir, { recursive: true });
+  const sessionFile: SessionFile = {
+    session_id: session.id,
+    created_at: new Date().toISOString(),
+    broker_port: BROKER_PORT,
+  };
+  await Bun.write(path.join(projectDir, SESSION_FILE), JSON.stringify(sessionFile, null, 2));
+
+  console.log(`Session created: ${session.name} (${session.id})`);
+  console.log(`Wrote ${SESSION_FILE}`);
+}
+
+async function list(client: BrokerClient): Promise<void> {
+  const sessions = await client.listSessions();
+
+  if (sessions.length === 0) {
+    console.log("No sessions found.");
+    return;
+  }
+
+  const local = readLocalSession();
+  console.log("\n  Sessions:\n");
+
+  for (const s of sessions) {
+    const active = local?.session_id === s.id ? " \x1b[36m(current)\x1b[0m" : "";
+    const statusColor = s.status === "active" ? "\x1b[32m" : s.status === "paused" ? "\x1b[33m" : "\x1b[90m";
+    console.log(`  ${s.id}${active}`);
+    console.log(`    Name:    ${s.name}`);
+    console.log(`    Status:  ${statusColor}${s.status}\x1b[0m`);
+    console.log(`    Dir:     ${s.project_dir}`);
+    console.log(`    Active:  ${timeSince(s.last_active_at)}`);
+    console.log(`    Created: ${formatTime(s.created_at)}`);
+
+    try {
+      const slots = await client.listSlots(s.id);
+      const connected = slots.filter((sl) => sl.status === "connected").length;
+      console.log(`    Agents:  ${connected}/${slots.length} connected`);
+    } catch { /* broker may not support slots yet */ }
+
+    console.log();
+  }
+}
+
+async function resume(client: BrokerClient, sessionId?: string): Promise<void> {
+  const id = sessionId ?? readLocalSession()?.session_id;
+  if (!id) {
+    console.error("No session specified and no local session found.");
+    process.exit(1);
+  }
+
+  await client.updateSession({ id, status: "active", pause_reason: null, paused_at: null });
+  console.log(`Session "${id}" resumed.`);
+
+  // Check for disconnected slots and offer to relaunch
+  try {
+    const slots = await client.listSlots(id);
+    const disconnected = slots.filter((s) => s.status === "disconnected");
+    if (disconnected.length > 0) {
+      console.log(`\n${disconnected.length} agent(s) disconnected:`);
+      for (const s of disconnected) {
+        console.log(`  Slot ${s.id}: ${s.display_name ?? s.agent_type} (${s.agent_type}) - ${s.role ?? "no role"}`);
+      }
+      const answer = await prompt("\nRelaunch disconnected agents? (y/n)");
+      if (answer.toLowerCase() === "y") {
+        await relaunchAgents(disconnected, id);
+      }
+    }
+  } catch { /* ok */ }
+}
+
+async function relaunchAgents(slots: Array<{ id: number; agent_type: string; display_name: string | null; role: string | null }>, sessionId: string): Promise<void> {
+  const platform = process.platform;
+
+  for (const slot of slots) {
+    const cmd = slot.agent_type; // claude, codex, gemini
+    const envVars = `MULTIAGENTS_SESSION=${sessionId} MULTIAGENTS_ROLE=${slot.role ?? ""} MULTIAGENTS_NAME=${slot.display_name ?? ""}`;
+    try {
+      if (platform === "darwin") {
+        // macOS: open a new Terminal tab with session env vars
+        Bun.spawnSync([
+          "osascript", "-e",
+          `tell application "Terminal" to do script "${envVars} ${cmd}"`,
+        ]);
+      } else {
+        // Linux: try gnome-terminal with session env vars
+        Bun.spawn(["gnome-terminal", "--", "env", `MULTIAGENTS_SESSION=${sessionId}`, `MULTIAGENTS_ROLE=${slot.role ?? ""}`, `MULTIAGENTS_NAME=${slot.display_name ?? ""}`, cmd], { stdio: ["ignore", "ignore", "ignore"] });
+      }
+      console.log(`  Launched ${slot.display_name ?? slot.agent_type} in new terminal`);
+    } catch (e) {
+      console.error(`  Failed to launch ${slot.agent_type}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+}
+
+async function pause(client: BrokerClient, sessionId?: string): Promise<void> {
+  const id = sessionId ?? readLocalSession()?.session_id;
+  if (!id) {
+    console.error("No session specified and no local session found.");
+    process.exit(1);
+  }
+
+  await client.updateSession({
+    id,
+    status: "paused",
+    pause_reason: "Paused via CLI",
+    paused_at: Date.now(),
+  });
+
+  // Pause all slots
+  try {
+    const slots = await client.listSlots(id);
+    for (const s of slots) {
+      await client.updateSlot({ id: s.id, paused: true, paused_at: Date.now() });
+    }
+  } catch { /* ok */ }
+
+  console.log(`Session "${id}" paused.`);
+}
+
+async function archive(client: BrokerClient, sessionId?: string): Promise<void> {
+  if (!sessionId) {
+    console.error("Usage: multiagents session archive <session-id>");
+    process.exit(1);
+  }
+  await client.updateSession({ id: sessionId, status: "archived" });
+  console.log(`Session "${sessionId}" archived.`);
+}
+
+async function deleteSession(client: BrokerClient, sessionId?: string): Promise<void> {
+  if (!sessionId) {
+    console.error("Usage: multiagents session delete <session-id>");
+    process.exit(1);
+  }
+
+  const answer = await prompt(`Delete session "${sessionId}" and all data? This cannot be undone. (yes/no)`);
+  if (answer !== "yes") {
+    console.log("Cancelled.");
+    return;
+  }
+
+  // Archive first (soft delete via broker — actual delete if broker supports it)
+  try {
+    await client.updateSession({ id: sessionId, status: "archived" });
+  } catch { /* ok */ }
+
+  // Clean local session file if it matches
+  const local = readLocalSession();
+  if (local?.session_id === sessionId) {
+    const sessionFilePath = path.resolve(process.cwd(), SESSION_FILE);
+    if (fs.existsSync(sessionFilePath)) fs.unlinkSync(sessionFilePath);
+  }
+
+  console.log(`Session "${sessionId}" deleted.`);
+}
+
+async function exportSession(client: BrokerClient, sessionId?: string): Promise<void> {
+  const id = sessionId ?? readLocalSession()?.session_id;
+  if (!id) {
+    console.error("Usage: multiagents session export <session-id>");
+    process.exit(1);
+  }
+
+  const session = await client.getSession(id);
+  const messages = await client.getMessageLog(id, { limit: 10000 });
+  const slots = await client.listSlots(id);
+
+  // Build slot lookup
+  const slotMap = new Map(slots.map((s) => [s.id, s]));
+
+  // Format as markdown
+  let md = `# Session: ${session.name}\n\n`;
+  md += `- **ID:** ${session.id}\n`;
+  md += `- **Status:** ${session.status}\n`;
+  md += `- **Directory:** ${session.project_dir}\n`;
+  md += `- **Created:** ${new Date(session.created_at).toISOString()}\n\n`;
+
+  md += `## Agents\n\n`;
+  for (const s of slots) {
+    md += `- **Slot ${s.id}:** ${s.display_name ?? "unnamed"} (${s.agent_type}) — ${s.role ?? "no role"}\n`;
+  }
+
+  md += `\n## Message Log\n\n`;
+  for (const m of messages) {
+    const fromSlot = m.from_slot_id !== null ? slotMap.get(m.from_slot_id) : null;
+    const fromName = fromSlot?.display_name ?? m.from_id;
+    const time = formatTime(m.sent_at);
+    md += `**[${time}] ${fromName}** (${m.msg_type}):\n${m.text}\n\n---\n\n`;
+  }
+
+  const filename = `session-${id}-export.md`;
+  await Bun.write(filename, md);
+  console.log(`Exported ${messages.length} messages to ${filename}`);
+}

package/cli/setup.ts

@@ -0,0 +1,257 @@
+// ============================================================================
+// multiagents — Interactive Setup Wizard
+// ============================================================================
+
+import { DEFAULT_BROKER_PORT, BROKER_HOSTNAME, SESSION_DIR, SESSION_FILE } 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";
+
+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 } {
+  try {
+    const which = Bun.spawnSync(["which", name]);
+    if (which.exitCode !== 0) 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 };
+  } catch {
+    return { available: false };
+  }
+}
+
+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[90m  ─────────────────────────────────\x1b[0m
+`);
+
+  // 2. Detect installed 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") },
+  ];
+
+  for (const a of agents) {
+    const icon = a.info.available ? "\x1b[32m✔\x1b[0m" : "\x1b[31m✗\x1b[0m";
+    const ver = a.info.version ? ` \x1b[90m(${a.info.version})\x1b[0m` : "";
+    console.log(`  ${icon} ${a.name}${ver}`);
+  }
+
+  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");
+    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
+  console.log("\n\x1b[1mConfiguring MCP servers...\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
+  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"],
+    });
+    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;
+    }
+  }
+
+  // 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
+  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
+`);
+}
+
+// --- 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> = {};
+  try {
+    const existing = await Bun.file(settingsPath).text();
+    config = JSON.parse(existing);
+  } 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));
+}

package/cli.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+// ============================================================================
+// multiagents — CLI Entry Point
+// ============================================================================
+// Routes to the new modular CLI. Maintains backward compatibility with
+// the original cli.ts commands (status, peers, send, kill-broker).
+// ============================================================================
+
+import { runCli } from "./cli/commands.ts";
+
+const args = process.argv.slice(2);
+
+// Backward compatibility: old cli.ts accepted these directly
+// The new router handles them natively, so just pass through.
+// "kill-broker" is explicitly aliased in commands.ts.
+
+await runCli(args);

package/index.ts

@@ -0,0 +1,41 @@
+/**
+ * multiagents
+ *
+ * Multi-agent orchestration platform for Claude Code, Codex CLI, and Gemini CLI.
+ *
+ * Entry points:
+ *   - server.ts                         — MCP server (one per agent instance)
+ *   - broker.ts                         — Shared broker daemon (one per machine)
+ *   - orchestrator/orchestrator-server.ts — Orchestrator MCP (for Claude Desktop)
+ *   - cli.ts                            — CLI tool (setup, dashboard, session mgmt)
+ *
+ * See README.md for setup and usage.
+ */
+
+export type {
+  PeerId,
+  AgentType,
+  MessageType,
+  SessionStatus,
+  Peer,
+  Message,
+  Session,
+  Slot,
+  FileLock,
+  FileOwnership,
+  Guardrail,
+  GuardrailState,
+  BufferedMessage,
+  SessionFile,
+  AgentLaunchConfig,
+  TeamConfig,
+} from "./shared/types.ts";
+
+export { BrokerClient } from "./shared/broker-client.ts";
+
+export {
+  DEFAULT_BROKER_PORT,
+  DEFAULT_GUARDRAILS,
+  POLL_INTERVALS,
+  SESSION_FILE,
+} from "./shared/constants.ts";

package/noop-mcp.ts

@@ -0,0 +1,63 @@
+#!/usr/bin/env bun
+/**
+ * No-op MCP server — responds to the JSON-RPC initialize handshake instantly,
+ * reports zero tools, then stays alive reading stdin until the client disconnects.
+ *
+ * Used to neutralize unwanted global MCP server entries in Codex config without
+ * causing 10s handshake timeouts (like /usr/bin/true does) or deserialization
+ * errors (like `echo disabled` does).
+ */
+
+const decoder = new TextDecoder();
+let buffer = "";
+
+process.stdin.on("data", (chunk: Buffer) => {
+  buffer += decoder.decode(chunk, { stream: true });
+
+  // Process complete lines (JSON-RPC uses newline-delimited JSON)
+  const lines = buffer.split("\n");
+  buffer = lines.pop() ?? "";
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    try {
+      const msg = JSON.parse(trimmed);
+
+      if (msg.method === "initialize") {
+        const response = JSON.stringify({
+          jsonrpc: "2.0",
+          id: msg.id,
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            serverInfo: { name: "noop", version: "0.0.0" },
+          },
+        });
+        process.stdout.write(response + "\n");
+      } else if (msg.method === "notifications/initialized") {
+        // Client acknowledged — nothing to do
+      } else if (msg.method === "tools/list") {
+        const response = JSON.stringify({
+          jsonrpc: "2.0",
+          id: msg.id,
+          result: { tools: [] },
+        });
+        process.stdout.write(response + "\n");
+      } else if (msg.id !== undefined) {
+        // Unknown request — respond with empty result
+        const response = JSON.stringify({
+          jsonrpc: "2.0",
+          id: msg.id,
+          result: {},
+        });
+        process.stdout.write(response + "\n");
+      }
+    } catch {
+      // Not JSON — ignore
+    }
+  }
+});
+
+process.stdin.on("end", () => process.exit(0));