@learnrudi/cli 1.9.0 → 1.9.2

package/dist/index.cjs

@@ -3228,34 +3228,15 @@ var import_os2 = __toESM(require("os"), 1);
 var import_env6 = require("@learnrudi/env");
 var import_mcp4 = require("@learnrudi/mcp");
 var HOME = import_os2.default.homedir();
-var SHIM_PATH = path9.join(import_env6.PATHS.home, "shims", "rudi-mcp");
-function getInstalledStacks() {
-  const stacksDir = import_env6.PATHS.stacks;
-  if (!fs11.existsSync(stacksDir)) return [];
-  return fs11.readdirSync(stacksDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).filter((d) => fs11.existsSync(path9.join(stacksDir, d.name, "manifest.json"))).map((d) => d.name);
-}
-function ensureShim() {
-  const shimsDir = path9.dirname(SHIM_PATH);
-  if (!fs11.existsSync(shimsDir)) {
-    fs11.mkdirSync(shimsDir, { recursive: true });
-  }
-  const shimContent = `#!/usr/bin/env bash
-set -euo pipefail
-# Try rudi in PATH first, fall back to npx
-if command -v rudi &> /dev/null; then
-  exec rudi mcp "$1"
-else
-  exec npx --yes @learnrudi/cli mcp "$1"
-fi
-`;
-  if (fs11.existsSync(SHIM_PATH)) {
-    const existing = fs11.readFileSync(SHIM_PATH, "utf-8");
-    if (existing === shimContent) {
-      return { created: false, path: SHIM_PATH };
-    }
+var ROUTER_SHIM_PATH = path9.join(import_env6.PATHS.home, "shims", "rudi-router");
+function checkRouterShim() {
+  if (!fs11.existsSync(ROUTER_SHIM_PATH)) {
+    throw new Error(
+      `Router shim not found at ${ROUTER_SHIM_PATH}
+Run: npm install -g @learnrudi/cli@latest`
+    );
   }
-  fs11.writeFileSync(SHIM_PATH, shimContent, { mode: 493 });
-  return { created: true, path: SHIM_PATH };
+  return ROUTER_SHIM_PATH;
 }
 function backupConfig(configPath) {
   if (!fs11.existsSync(configPath)) return null;
@@ -3280,24 +3261,23 @@ function writeJsonConfig(configPath, config) {
   }
   fs11.writeFileSync(configPath, JSON.stringify(config, null, 2));
 }
-function buildMcpEntry(stackName, agentId) {
+function buildRouterEntry(agentId) {
   const base = {
-    command: SHIM_PATH,
-    args: [stackName]
+    command: ROUTER_SHIM_PATH,
+    args: []
   };
   if (agentId === "claude-desktop" || agentId === "claude-code") {
     return { type: "stdio", ...base };
   }
   return base;
 }
-async function integrateAgent(agentId, stacks, flags) {
+async function integrateAgent(agentId, flags) {
   const agentConfig = import_mcp4.AGENT_CONFIGS.find((a) => a.id === agentId);
   if (!agentConfig) {
     console.error(`Unknown agent: ${agentId}`);
     return { success: false, error: "Unknown agent" };
   }
   const configPath = (0, import_mcp4.findAgentConfig)(agentConfig);
-  const configDir = configPath ? path9.dirname(configPath) : null;
   const targetPath = configPath || path9.join(HOME, agentConfig.paths[process.platform]?.[0] || agentConfig.paths.darwin[0]);
   console.log(`
 ${agentConfig.name}:`);
@@ -3313,32 +3293,54 @@ ${agentConfig.name}:`);
   if (!config[key]) {
     config[key] = {};
   }
-  let added = 0;
-  let updated = 0;
-  for (const stackName of stacks) {
-    const entry = buildMcpEntry(stackName, agentId);
-    const existing = config[key][stackName];
-    if (!existing) {
-      config[key][stackName] = entry;
-      added++;
-    } else if (existing.command !== entry.command || JSON.stringify(existing.args) !== JSON.stringify(entry.args)) {
-      config[key][stackName] = entry;
-      updated++;
-    }
-  }
-  if (added > 0 || updated > 0) {
+  const rudiMcpShimPath = path9.join(import_env6.PATHS.home, "shims", "rudi-mcp");
+  const removedEntries = [];
+  for (const [serverName, serverConfig] of Object.entries(config[key])) {
+    if (serverConfig.command === rudiMcpShimPath) {
+      delete config[key][serverName];
+      removedEntries.push(serverName);
+    }
+  }
+  if (removedEntries.length > 0) {
+    console.log(`  Removed old entries: ${removedEntries.join(", ")}`);
+  }
+  const routerEntry = buildRouterEntry(agentId);
+  const existing = config[key]["rudi"];
+  let action = "none";
+  if (!existing) {
+    config[key]["rudi"] = routerEntry;
+    action = "added";
+  } else if (existing.command !== routerEntry.command || JSON.stringify(existing.args) !== JSON.stringify(routerEntry.args)) {
+    config[key]["rudi"] = routerEntry;
+    action = "updated";
+  }
+  if (action !== "none" || removedEntries.length > 0) {
     writeJsonConfig(targetPath, config);
-    console.log(`  Added: ${added}, Updated: ${updated}`);
+    if (action !== "none") {
+      console.log(`  ${action === "added" ? "\u2713 Added" : "\u2713 Updated"} rudi router`);
+    }
   } else {
-    console.log(`  Already up to date`);
+    console.log(`  \u2713 Already configured`);
   }
-  return { success: true, added, updated };
+  return { success: true, action, removed: removedEntries };
 }
 async function cmdIntegrate(args, flags) {
   const target = args[0];
+  if (flags.list || target === "list") {
+    const installed = (0, import_mcp4.getInstalledAgents)();
+    console.log("\nDetected agents:");
+    for (const agent of installed) {
+      console.log(`  \u2713 ${agent.name}`);
+      console.log(`    ${agent.configFile}`);
+    }
+    if (installed.length === 0) {
+      console.log("  (none detected)");
+    }
+    return;
+  }
   if (!target) {
     console.log(`
-rudi integrate - Wire RUDI stacks into agent configs
+rudi integrate - Wire RUDI router into agent configs
 
 USAGE
   rudi integrate <agent>     Integrate with specific agent
@@ -3364,29 +3366,14 @@ EXAMPLES
 `);
     return;
   }
-  if (flags.list || target === "list") {
-    const installed = (0, import_mcp4.getInstalledAgents)();
-    console.log("\nDetected agents:");
-    for (const agent of installed) {
-      console.log(`  \u2713 ${agent.name}`);
-      console.log(`    ${agent.configFile}`);
-    }
-    if (installed.length === 0) {
-      console.log("  (none detected)");
-    }
-    return;
-  }
-  const stacks = getInstalledStacks();
-  if (stacks.length === 0) {
-    console.log("No stacks installed. Install with: rudi install <stack>");
+  try {
+    checkRouterShim();
+  } catch (err) {
+    console.error(err.message);
     return;
   }
   console.log(`
-Integrating ${stacks.length} stack(s)...`);
-  const shimResult = ensureShim();
-  if (shimResult.created) {
-    console.log(`Created shim: ${shimResult.path}`);
-  }
+Wiring up RUDI router...`);
   let targetAgents = [];
   if (target === "all") {
     targetAgents = (0, import_mcp4.getInstalledAgents)().map((a) => a.id);
@@ -3416,25 +3403,25 @@ Integrating ${stacks.length} stack(s)...`);
     targetAgents = [agentId];
   }
   if (flags["dry-run"]) {
-    console.log("\nDry run - would integrate:");
+    console.log("\nDry run - would add RUDI router to:");
     for (const agentId of targetAgents) {
       const agent = import_mcp4.AGENT_CONFIGS.find((a) => a.id === agentId);
-      console.log(`  ${agent?.name || agentId}:`);
-      for (const stack of stacks) {
-        console.log(`    - ${stack}`);
-      }
+      console.log(`  ${agent?.name || agentId}`);
     }
     return;
   }
   const results = [];
   for (const agentId of targetAgents) {
-    const result = await integrateAgent(agentId, stacks, flags);
+    const result = await integrateAgent(agentId, flags);
     results.push({ agent: agentId, ...result });
   }
   const successful = results.filter((r) => r.success);
   console.log(`
 \u2713 Integrated with ${successful.length} agent(s)`);
-  console.log("\nRestart your agent(s) to use the new stacks.");
+  console.log("\nRestart your agent(s) to access all installed stacks.");
+  console.log("\nManage stacks:");
+  console.log("  rudi install <stack>   # Install a new stack");
+  console.log("  rudi index             # Rebuild tool cache");
 }
 
 // src/commands/migrate.js
@@ -3445,7 +3432,7 @@ var import_env7 = require("@learnrudi/env");
 var import_mcp5 = require("@learnrudi/mcp");
 var HOME2 = import_os3.default.homedir();
 var OLD_PROMPT_STACK = path10.join(HOME2, ".prompt-stack");
-var SHIM_PATH2 = path10.join(import_env7.PATHS.home, "shims", "rudi-mcp");
+var SHIM_PATH = path10.join(import_env7.PATHS.home, "shims", "rudi-mcp");
 function getOldStacks() {
   const stacksDir = path10.join(OLD_PROMPT_STACK, "stacks");
   if (!fs12.existsSync(stacksDir)) return [];
@@ -3481,8 +3468,8 @@ function copyRecursive(src, dest) {
     fs12.copyFileSync(src, dest);
   }
 }
-function ensureShim2() {
-  const shimsDir = path10.dirname(SHIM_PATH2);
+function ensureShim() {
+  const shimsDir = path10.dirname(SHIM_PATH);
   if (!fs12.existsSync(shimsDir)) {
     fs12.mkdirSync(shimsDir, { recursive: true });
   }
@@ -3494,11 +3481,11 @@ else
   exec npx --yes @learnrudi/cli mcp "$1"
 fi
 `;
-  fs12.writeFileSync(SHIM_PATH2, shimContent, { mode: 493 });
+  fs12.writeFileSync(SHIM_PATH, shimContent, { mode: 493 });
 }
 function buildNewEntry(stackName, agentId) {
   const base = {
-    command: SHIM_PATH2,
+    command: SHIM_PATH,
     args: [stackName]
   };
   if (agentId === "claude-desktop" || agentId === "claude-code") {
@@ -3676,8 +3663,8 @@ Stacks migrated to: ${import_env7.PATHS.stacks}`);
 async function migrateConfigs(flags) {
   console.log("=== Updating Agent Configs ===\n");
   if (!flags.dryRun) {
-    ensureShim2();
-    console.log(`Shim ready: ${SHIM_PATH2}
+    ensureShim();
+    console.log(`Shim ready: ${SHIM_PATH}
 `);
   }
   let installedStacks = [];

package/dist/router-mcp.js

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+/**
+ * RUDI Router MCP Server
+ *
+ * Central MCP dispatcher that:
+ * - Reads ~/.rudi/rudi.json
+ * - Lists all installed stack tools (namespaced)
+ * - Proxies tool calls to correct stack subprocess
+ * - Maintains connection pool per stack
+ *
+ * Design decisions:
+ * - Cached tool index: Fast tools/list without spawning all stacks
+ * - Lazy spawn: Only spawn stack servers when needed
+ * - stdout = protocol only: All logging goes to stderr
+ * - Handle null IDs: MCP notifications have id: null
+ */
+
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import * as os from 'os';
+
+// =============================================================================
+// CONSTANTS
+// =============================================================================
+
+const RUDI_HOME = process.env.RUDI_HOME || path.join(os.homedir(), '.rudi');
+const RUDI_JSON_PATH = path.join(RUDI_HOME, 'rudi.json');
+const SECRETS_PATH = path.join(RUDI_HOME, 'secrets.json');
+const TOOL_INDEX_PATH = path.join(RUDI_HOME, 'cache', 'tool-index.json');
+
+const REQUEST_TIMEOUT_MS = 30000;
+const PROTOCOL_VERSION = '2024-11-05';
+
+// =============================================================================
+// STATE
+// =============================================================================
+
+/** @type {Map<string, StackServer>} */
+const serverPool = new Map();
+
+/** @type {RudiConfig | null} */
+let rudiConfig = null;
+
+/** @type {Object | null} */
+let toolIndex = null;
+
+// =============================================================================
+// TYPES (JSDoc)
+// =============================================================================
+
+/**
+ * @typedef {Object} StackServer
+ * @property {import('child_process').ChildProcess} process
+ * @property {readline.Interface} rl
+ * @property {Map<string|number, PendingRequest>} pending
+ * @property {string} buffer
+ * @property {boolean} initialized
+ */
+
+/**
+ * @typedef {Object} PendingRequest
+ * @property {(value: JsonRpcResponse) => void} resolve
+ * @property {(error: Error) => void} reject
+ * @property {NodeJS.Timeout} timeout
+ */
+
+/**
+ * @typedef {Object} JsonRpcRequest
+ * @property {'2.0'} jsonrpc
+ * @property {string|number|null} [id]
+ * @property {string} method
+ * @property {Object} [params]
+ */
+
+/**
+ * @typedef {Object} JsonRpcResponse
+ * @property {'2.0'} jsonrpc
+ * @property {string|number|null} id
+ * @property {*} [result]
+ * @property {{code: number, message: string, data?: *}} [error]
+ */
+
+// =============================================================================
+// LOGGING (all to stderr to keep stdout clean for MCP protocol)
+// =============================================================================
+
+function log(msg) {
+  process.stderr.write(`[rudi-router] ${msg}\n`);
+}
+
+function debug(msg) {
+  if (process.env.DEBUG) {
+    process.stderr.write(`[rudi-router:debug] ${msg}\n`);
+  }
+}
+
+// =============================================================================
+// CONFIG & SECRETS
+// =============================================================================
+
+/**
+ * Load rudi.json
+ * @returns {Object}
+ */
+function loadRudiConfig() {
+  try {
+    const content = fs.readFileSync(RUDI_JSON_PATH, 'utf-8');
+    return JSON.parse(content);
+  } catch (err) {
+    log(`Failed to load rudi.json: ${err.message}`);
+    return { stacks: {}, runtimes: {}, binaries: {}, secrets: {} };
+  }
+}
+
+/**
+ * Load tool index from cache file
+ * @returns {Object | null}
+ */
+function loadToolIndex() {
+  try {
+    const content = fs.readFileSync(TOOL_INDEX_PATH, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load secrets.json
+ * @returns {Object<string, string>}
+ */
+function loadSecrets() {
+  try {
+    const content = fs.readFileSync(SECRETS_PATH, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Get secrets for a specific stack
+ * @param {string} stackId
+ * @returns {Object<string, string>}
+ */
+function getStackSecrets(stackId) {
+  const allSecrets = loadSecrets();
+  const stackConfig = rudiConfig?.stacks?.[stackId];
+  if (!stackConfig?.secrets) return {};
+
+  const result = {};
+  for (const secretDef of stackConfig.secrets) {
+    const name = typeof secretDef === 'string' ? secretDef : secretDef.name;
+    if (allSecrets[name]) {
+      result[name] = allSecrets[name];
+    }
+  }
+  return result;
+}
+
+// =============================================================================
+// STACK SERVER MANAGEMENT
+// =============================================================================
+
+/**
+ * Spawn a stack MCP server as subprocess
+ * @param {string} stackId
+ * @param {Object} stackConfig
+ * @returns {StackServer}
+ */
+function spawnStackServer(stackId, stackConfig) {
+  const launch = stackConfig.launch;
+  if (!launch || !launch.bin) {
+    throw new Error(`Stack ${stackId} has no launch configuration`);
+  }
+
+  const secrets = getStackSecrets(stackId);
+  const env = { ...process.env, ...secrets };
+
+  // Add bundled runtimes to PATH
+  const nodeBin = path.join(RUDI_HOME, 'runtimes', 'node', 'bin');
+  const pythonBin = path.join(RUDI_HOME, 'runtimes', 'python', 'bin');
+  if (fs.existsSync(nodeBin) || fs.existsSync(pythonBin)) {
+    const runtimePaths = [];
+    if (fs.existsSync(nodeBin)) runtimePaths.push(nodeBin);
+    if (fs.existsSync(pythonBin)) runtimePaths.push(pythonBin);
+    env.PATH = runtimePaths.join(path.delimiter) + path.delimiter + (env.PATH || '');
+  }
+
+  debug(`Spawning stack ${stackId}: ${launch.bin} ${launch.args?.join(' ')}`);
+
+  const childProcess = spawn(launch.bin, launch.args || [], {
+    cwd: launch.cwd || stackConfig.path,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env
+  });
+
+  const rl = readline.createInterface({
+    input: childProcess.stdout,
+    terminal: false
+  });
+
+  /** @type {StackServer} */
+  const server = {
+    process: childProcess,
+    rl,
+    pending: new Map(),
+    buffer: '',
+    initialized: false
+  };
+
+  // Handle responses from stack
+  rl.on('line', (line) => {
+    try {
+      const response = JSON.parse(line);
+      debug(`<< ${stackId}: ${line.slice(0, 200)}`);
+
+      // Handle notifications (id is null or missing)
+      if (response.id === null || response.id === undefined) {
+        debug(`Notification from ${stackId}: ${response.method || 'unknown'}`);
+        return;
+      }
+
+      const pending = server.pending.get(response.id);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        server.pending.delete(response.id);
+        pending.resolve(response);
+      }
+    } catch (err) {
+      debug(`Failed to parse response from ${stackId}: ${err.message}`);
+    }
+  });
+
+  // Pipe stack stderr to our stderr
+  childProcess.stderr?.on('data', (data) => {
+    process.stderr.write(`[${stackId}] ${data}`);
+  });
+
+  childProcess.on('error', (err) => {
+    log(`Stack process error (${stackId}): ${err.message}`);
+    serverPool.delete(stackId);
+  });
+
+  childProcess.on('exit', (code, signal) => {
+    debug(`Stack ${stackId} exited: code=${code}, signal=${signal}`);
+    rl.close();
+    serverPool.delete(stackId);
+  });
+
+  return server;
+}
+
+/**
+ * Get or spawn a stack server
+ * @param {string} stackId
+ * @returns {StackServer}
+ */
+function getOrSpawnServer(stackId) {
+  const existing = serverPool.get(stackId);
+  if (existing && !existing.process.killed) {
+    return existing;
+  }
+
+  const stackConfig = rudiConfig?.stacks?.[stackId];
+  if (!stackConfig) {
+    throw new Error(`Stack not found: ${stackId}`);
+  }
+
+  if (!stackConfig.installed) {
+    throw new Error(`Stack not installed: ${stackId}`);
+  }
+
+  const server = spawnStackServer(stackId, stackConfig);
+  serverPool.set(stackId, server);
+  return server;
+}
+
+/**
+ * Send JSON-RPC request to stack server
+ * @param {StackServer} server
+ * @param {JsonRpcRequest} request
+ * @param {number} [timeoutMs]
+ * @returns {Promise<JsonRpcResponse>}
+ */
+async function sendToStack(server, request, timeoutMs = REQUEST_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      server.pending.delete(request.id);
+      reject(new Error(`Request timeout: ${request.method}`));
+    }, timeoutMs);
+
+    server.pending.set(request.id, { resolve, reject, timeout });
+
+    const line = JSON.stringify(request) + '\n';
+    debug(`>> ${line.slice(0, 200)}`);
+    server.process.stdin?.write(line);
+  });
+}
+
+/**
+ * Initialize a stack server (MCP handshake)
+ * @param {StackServer} server
+ * @param {string} stackId
+ */
+async function initializeStack(server, stackId) {
+  if (server.initialized) return;
+
+  const initRequest = {
+    jsonrpc: '2.0',
+    id: `init-${stackId}-${Date.now()}`,
+    method: 'initialize',
+    params: {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: {},
+      clientInfo: {
+        name: 'rudi-router',
+        version: '1.0.0'
+      }
+    }
+  };
+
+  try {
+    const response = await sendToStack(server, initRequest);
+    if (!response.error) {
+      server.initialized = true;
+      debug(`Stack ${stackId} initialized`);
+
+      // Send initialized notification
+      server.process.stdin?.write(JSON.stringify({
+        jsonrpc: '2.0',
+        method: 'notifications/initialized'
+      }) + '\n');
+    }
+  } catch (err) {
+    debug(`Failed to initialize ${stackId}: ${err.message}`);
+  }
+}
+
+// =============================================================================
+// MCP HANDLERS
+// =============================================================================
+
+/**
+ * List all tools from all installed stacks (namespaced)
+ * Priority: 1. tool-index.json cache, 2. rudi.json inline tools, 3. live query
+ * @returns {Promise<Array<{name: string, description: string, inputSchema: Object}>>}
+ */
+async function listTools() {
+  const tools = [];
+
+  for (const [stackId, stackConfig] of Object.entries(rudiConfig?.stacks || {})) {
+    if (!stackConfig.installed) continue;
+
+    // 1. Check tool-index.json cache (from `rudi index` command)
+    const indexEntry = toolIndex?.byStack?.[stackId];
+    if (indexEntry?.tools && indexEntry.tools.length > 0 && !indexEntry.error) {
+      tools.push(...indexEntry.tools.map(t => ({
+        name: `${stackId}.${t.name}`,
+        description: `[${stackId}] ${t.description || t.name}`,
+        inputSchema: t.inputSchema || { type: 'object', properties: {} }
+      })));
+      continue;
+    }
+
+    // 2. Check inline tools in rudi.json (legacy/fallback)
+    if (stackConfig.tools && stackConfig.tools.length > 0) {
+      tools.push(...stackConfig.tools.map(t => ({
+        name: `${stackId}.${t.name}`,
+        description: `[${stackId}] ${t.description || t.name}`,
+        inputSchema: t.inputSchema || { type: 'object', properties: {} }
+      })));
+      continue;
+    }
+
+    // 3. Fall back to querying the stack (slow, spawns server)
+    try {
+      const server = getOrSpawnServer(stackId);
+      await initializeStack(server, stackId);
+
+      const response = await sendToStack(server, {
+        jsonrpc: '2.0',
+        id: `list-${stackId}-${Date.now()}`,
+        method: 'tools/list'
+      });
+
+      if (response.result?.tools) {
+        tools.push(...response.result.tools.map(t => ({
+          name: `${stackId}.${t.name}`,
+          description: `[${stackId}] ${t.description || t.name}`,
+          inputSchema: t.inputSchema || { type: 'object', properties: {} }
+        })));
+      }
+    } catch (err) {
+      log(`Failed to list tools from ${stackId}: ${err.message}`);
+      // Continue with other stacks
+    }
+  }
+
+  return tools;
+}
+
+/**
+ * Call a tool on the appropriate stack
+ * @param {string} toolName - Namespaced tool name (e.g., "slack.send_message")
+ * @param {Object} arguments_
+ * @returns {Promise<*>}
+ */
+async function callTool(toolName, arguments_) {
+  // Parse namespace: "slack.send_message" → stackId="slack", actualTool="send_message"
+  const dotIndex = toolName.indexOf('.');
+  if (dotIndex === -1) {
+    throw new Error(`Invalid tool name format: ${toolName} (expected: stack.tool_name)`);
+  }
+
+  const stackId = toolName.slice(0, dotIndex);
+  const actualToolName = toolName.slice(dotIndex + 1);
+
+  if (!rudiConfig?.stacks?.[stackId]) {
+    throw new Error(`Stack not found: ${stackId}`);
+  }
+
+  const server = getOrSpawnServer(stackId);
+  await initializeStack(server, stackId);
+
+  const response = await sendToStack(server, {
+    jsonrpc: '2.0',
+    id: `call-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    method: 'tools/call',
+    params: {
+      name: actualToolName,
+      arguments: arguments_
+    }
+  });
+
+  if (response.error) {
+    throw new Error(`Tool error: ${response.error.message}`);
+  }
+
+  return response.result;
+}
+
+// =============================================================================
+// MAIN MCP PROTOCOL LOOP
+// =============================================================================
+
+/**
+ * Handle incoming JSON-RPC request
+ * @param {JsonRpcRequest} request
+ * @returns {Promise<JsonRpcResponse>}
+ */
+async function handleRequest(request) {
+  /** @type {JsonRpcResponse} */
+  const response = {
+    jsonrpc: '2.0',
+    id: request.id ?? null
+  };
+
+  try {
+    switch (request.method) {
+      case 'initialize':
+        response.result = {
+          protocolVersion: PROTOCOL_VERSION,
+          capabilities: {
+            tools: {}
+          },
+          serverInfo: {
+            name: 'rudi-router',
+            version: '1.0.0'
+          }
+        };
+        break;
+
+      case 'notifications/initialized':
+        // Client acknowledges initialization - no response needed for notifications
+        return null;
+
+      case 'tools/list': {
+        const tools = await listTools();
+        response.result = { tools };
+        break;
+      }
+
+      case 'tools/call': {
+        const params = request.params;
+        const result = await callTool(params.name, params.arguments || {});
+        response.result = result;
+        break;
+      }
+
+      case 'ping':
+        response.result = {};
+        break;
+
+      default:
+        // Unknown method
+        if (request.id !== null && request.id !== undefined) {
+          response.error = {
+            code: -32601,
+            message: `Method not found: ${request.method}`
+          };
+        } else {
+          // It's a notification, don't respond
+          return null;
+        }
+    }
+  } catch (err) {
+    response.error = {
+      code: -32603,
+      message: err.message || 'Internal error'
+    };
+  }
+
+  return response;
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  log('Starting RUDI Router MCP Server');
+
+  // Load config
+  rudiConfig = loadRudiConfig();
+  const stackCount = Object.keys(rudiConfig.stacks || {}).length;
+  log(`Loaded ${stackCount} stacks from rudi.json`);
+
+  // Load tool index cache
+  toolIndex = loadToolIndex();
+  if (toolIndex) {
+    const cachedStacks = Object.keys(toolIndex.byStack || {}).length;
+    log(`Loaded tool index (${cachedStacks} stacks cached)`);
+  } else {
+    log('No tool index cache found (run: rudi index)');
+  }
+
+  // Set up stdin/stdout for MCP protocol
+  const rl = readline.createInterface({
+    input: process.stdin,
+    terminal: false
+  });
+
+  rl.on('line', async (line) => {
+    try {
+      const request = JSON.parse(line);
+      debug(`Received: ${line.slice(0, 200)}`);
+
+      const response = await handleRequest(request);
+
+      // Don't respond to notifications
+      if (response !== null) {
+        const responseStr = JSON.stringify(response);
+        debug(`Sending: ${responseStr.slice(0, 200)}`);
+        process.stdout.write(responseStr + '\n');
+      }
+    } catch (err) {
+      // Parse error
+      const errorResponse = {
+        jsonrpc: '2.0',
+        id: null,
+        error: {
+          code: -32700,
+          message: `Parse error: ${err.message}`
+        }
+      };
+      process.stdout.write(JSON.stringify(errorResponse) + '\n');
+    }
+  });
+
+  rl.on('close', () => {
+    log('stdin closed, shutting down');
+    // Clean up all spawned servers
+    for (const [stackId, server] of serverPool) {
+      debug(`Killing stack ${stackId}`);
+      server.process.kill();
+    }
+    process.exit(0);
+  });
+
+  // Handle process termination
+  process.on('SIGTERM', () => {
+    log('SIGTERM received, shutting down');
+    for (const [stackId, server] of serverPool) {
+      server.process.kill();
+    }
+    process.exit(0);
+  });
+
+  process.on('SIGINT', () => {
+    log('SIGINT received, shutting down');
+    for (const [stackId, server] of serverPool) {
+      server.process.kill();
+    }
+    process.exit(0);
+  });
+}
+
+// Run
+main().catch(err => {
+  log(`Fatal error: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@learnrudi/cli",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "description": "RUDI CLI - Install and manage MCP stacks, runtimes, and AI agents",
   "type": "module",
   "main": "dist/index.cjs",
@@ -14,7 +14,7 @@
   ],
   "scripts": {
     "start": "node src/index.js",
-    "build": "esbuild src/index.js --bundle --platform=node --format=cjs --outfile=dist/index.cjs --external:better-sqlite3 --external:@learnrudi/core --external:@learnrudi/db --external:@learnrudi/env --external:@learnrudi/manifest --external:@learnrudi/mcp --external:@learnrudi/registry-client --external:@learnrudi/runner --external:@learnrudi/secrets --external:@learnrudi/utils",
+    "build": "esbuild src/index.js --bundle --platform=node --format=cjs --outfile=dist/index.cjs --external:better-sqlite3 --external:@learnrudi/core --external:@learnrudi/db --external:@learnrudi/env --external:@learnrudi/manifest --external:@learnrudi/mcp --external:@learnrudi/registry-client --external:@learnrudi/runner --external:@learnrudi/secrets --external:@learnrudi/utils && cp src/router-mcp.js dist/router-mcp.js",
     "postinstall": "node scripts/postinstall.js",
     "prepublishOnly": "npm run build",
     "test": "node --test src/__tests__/"