@learnrudi/cli 1.8.8 → 1.9.1

package/dist/index.cjs

@@ -422,6 +422,18 @@ Installing...`);
             console.error(`  rudi install ${result.id}`);
             process.exit(1);
           }
+          try {
+            (0, import_core2.addStack)(result.id, {
+              path: result.path,
+              runtime: manifest.runtime || manifest.mcp?.runtime || "node",
+              command: manifest.command || (manifest.mcp?.command ? [manifest.mcp.command, ...manifest.mcp.args || []] : null),
+              secrets: getManifestSecrets(manifest),
+              version: manifest.version
+            });
+            console.log(`  \u2713 Updated rudi.json`);
+          } catch (err) {
+            console.log(`  \u26A0 Failed to update rudi.json: ${err.message}`);
+          }
           const { found, missing } = await checkSecrets(manifest);
           const envExampleKeys = await parseEnvExample(result.path);
           for (const key of envExampleKeys) {
@@ -440,6 +452,16 @@ Installing...`);
               if (existing === null) {
                 await (0, import_secrets.setSecret)(key, "");
               }
+              try {
+                (0, import_core2.updateSecretStatus)(key, false);
+              } catch {
+              }
+            }
+          }
+          for (const key of found) {
+            try {
+              (0, import_core2.updateSecretStatus)(key, true);
+            } catch {
             }
           }
           console.log(`
@@ -3691,6 +3713,140 @@ async function migrateConfigs(flags) {
   console.log("Restart your agents to use the updated configs.");
 }
 
+// src/commands/index-tools.js
+var import_core10 = require("@learnrudi/core");
+var import_core11 = require("@learnrudi/core");
+async function cmdIndex(args, flags) {
+  const stackFilter = args.length > 0 ? args : null;
+  const forceReindex = flags.force || false;
+  const jsonOutput = flags.json || false;
+  const config = (0, import_core11.readRudiConfig)();
+  if (!config) {
+    console.error("Error: rudi.json not found. Run `rudi doctor` to check setup.");
+    process.exit(1);
+  }
+  const installedStacks = Object.keys(config.stacks || {}).filter(
+    (id) => config.stacks[id].installed
+  );
+  if (installedStacks.length === 0) {
+    if (jsonOutput) {
+      console.log(JSON.stringify({ indexed: 0, failed: 0, stacks: [] }));
+    } else {
+      console.log("No installed stacks to index.");
+      console.log("\nInstall stacks with: rudi install <stack>");
+    }
+    return;
+  }
+  const stacksToIndex = stackFilter ? stackFilter.filter((id) => {
+    if (!installedStacks.includes(id)) {
+      if (!jsonOutput) {
+        console.log(`\u26A0 Stack not installed: ${id}`);
+      }
+      return false;
+    }
+    return true;
+  }) : installedStacks;
+  if (stacksToIndex.length === 0) {
+    if (jsonOutput) {
+      console.log(JSON.stringify({ indexed: 0, failed: 0, stacks: [] }));
+    } else {
+      console.log("No valid stacks to index.");
+    }
+    return;
+  }
+  const existingIndex = (0, import_core10.readToolIndex)();
+  if (existingIndex && !forceReindex && !stackFilter) {
+    const allCached = stacksToIndex.every((id) => {
+      const entry = existingIndex.byStack?.[id];
+      return entry && entry.tools && entry.tools.length > 0 && !entry.error;
+    });
+    if (allCached) {
+      const totalTools = stacksToIndex.reduce((sum, id) => {
+        return sum + (existingIndex.byStack[id]?.tools?.length || 0);
+      }, 0);
+      if (jsonOutput) {
+        console.log(JSON.stringify({
+          indexed: stacksToIndex.length,
+          failed: 0,
+          cached: true,
+          totalTools,
+          stacks: stacksToIndex.map((id) => ({
+            id,
+            tools: existingIndex.byStack[id]?.tools?.length || 0,
+            indexedAt: existingIndex.byStack[id]?.indexedAt
+          }))
+        }));
+      } else {
+        console.log(`Tool index is up to date (${totalTools} tools from ${stacksToIndex.length} stacks)`);
+        console.log(`Last updated: ${existingIndex.updatedAt}`);
+        console.log(`
+Use --force to re-index.`);
+      }
+      return;
+    }
+  }
+  if (!jsonOutput) {
+    console.log(`Indexing ${stacksToIndex.length} stack(s)...
+`);
+  }
+  const log = jsonOutput ? () => {
+  } : console.log;
+  try {
+    const result = await (0, import_core10.indexAllStacks)({
+      stacks: stacksToIndex,
+      log,
+      timeout: 2e4
+      // 20s per stack
+    });
+    const totalTools = Object.values(result.index.byStack).reduce(
+      (sum, entry) => sum + (entry.tools?.length || 0),
+      0
+    );
+    if (jsonOutput) {
+      console.log(JSON.stringify({
+        indexed: result.indexed,
+        failed: result.failed,
+        totalTools,
+        stacks: stacksToIndex.map((id) => ({
+          id,
+          tools: result.index.byStack[id]?.tools?.length || 0,
+          error: result.index.byStack[id]?.error || null,
+          missingSecrets: result.index.byStack[id]?.missingSecrets || null
+        }))
+      }, null, 2));
+    } else {
+      console.log(`
+${"\u2500".repeat(50)}`);
+      console.log(`Indexed: ${result.indexed}/${stacksToIndex.length} stacks`);
+      console.log(`Tools discovered: ${totalTools}`);
+      console.log(`Cache: ${import_core10.TOOL_INDEX_PATH}`);
+      if (result.failed > 0) {
+        console.log(`
+\u26A0 ${result.failed} stack(s) failed to index.`);
+        const missingSecretStacks = Object.entries(result.index.byStack).filter(([_, entry]) => entry.missingSecrets?.length > 0);
+        if (missingSecretStacks.length > 0) {
+          console.log(`
+Missing secrets:`);
+          for (const [stackId, entry] of missingSecretStacks) {
+            for (const secret of entry.missingSecrets) {
+              console.log(`  rudi secrets set ${secret}`);
+            }
+          }
+          console.log(`
+After configuring secrets, run: rudi index`);
+        }
+      }
+    }
+  } catch (error) {
+    if (jsonOutput) {
+      console.log(JSON.stringify({ error: error.message }));
+    } else {
+      console.error(`Index failed: ${error.message}`);
+    }
+    process.exit(1);
+  }
+}
+
 // src/index.js
 var VERSION = "2.0.0";
 async function main() {
@@ -3772,6 +3928,9 @@ async function main() {
       case "migrate":
         await cmdMigrate(args, flags);
         break;
+      case "index":
+        await cmdIndex(args, flags);
+        break;
       case "home":
       case "status":
         await cmdHome(args, flags);

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.8.8",
+  "version": "1.9.1",
   "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__/"

package/scripts/postinstall.js

@@ -6,6 +6,7 @@
  * 1. Node.js runtime → ~/.rudi/runtimes/node/
  * 2. Python runtime → ~/.rudi/runtimes/python/
  * 3. Creates shims → ~/.rudi/shims/
+ * 4. Initializes rudi.json → ~/.rudi/rudi.json
  */
 
 import { execSync } from 'child_process';
@@ -14,8 +15,131 @@ import * as path from 'path';
 import * as os from 'os';
 
 const RUDI_HOME = path.join(os.homedir(), '.rudi');
+const RUDI_JSON_PATH = path.join(RUDI_HOME, 'rudi.json');
+const RUDI_JSON_TMP = path.join(RUDI_HOME, 'rudi.json.tmp');
 const REGISTRY_BASE = 'https://raw.githubusercontent.com/learn-rudi/registry/main';
 
+// =============================================================================
+// RUDI.JSON CONFIG MANAGEMENT
+// =============================================================================
+
+/**
+ * Create a new empty RudiConfig
+ */
+function createRudiConfig() {
+  const now = new Date().toISOString();
+  return {
+    version: '1.0.0',
+    schemaVersion: 1,
+    installed: false,
+    installedAt: now,
+    updatedAt: now,
+    runtimes: {},
+    stacks: {},
+    binaries: {},
+    secrets: {}
+  };
+}
+
+/**
+ * Read rudi.json
+ */
+function readRudiConfig() {
+  try {
+    const content = fs.readFileSync(RUDI_JSON_PATH, 'utf-8');
+    return JSON.parse(content);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return null;
+    }
+    console.log(`  ⚠ Failed to read rudi.json: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Write rudi.json atomically with secure permissions
+ */
+function writeRudiConfig(config) {
+  config.updatedAt = new Date().toISOString();
+  const content = JSON.stringify(config, null, 2);
+
+  // Write to temp file
+  fs.writeFileSync(RUDI_JSON_TMP, content, { mode: 0o600 });
+
+  // Atomic rename
+  fs.renameSync(RUDI_JSON_TMP, RUDI_JSON_PATH);
+
+  // Ensure permissions (rename may not preserve them)
+  fs.chmodSync(RUDI_JSON_PATH, 0o600);
+}
+
+/**
+ * Initialize rudi.json if it doesn't exist
+ */
+function initRudiConfig() {
+  if (fs.existsSync(RUDI_JSON_PATH)) {
+    console.log(`  ✓ rudi.json already exists`);
+    return readRudiConfig();
+  }
+
+  const config = createRudiConfig();
+  writeRudiConfig(config);
+  console.log(`  ✓ Created rudi.json`);
+  return config;
+}
+
+/**
+ * Update rudi.json with runtime info after successful download
+ */
+function updateRudiConfigRuntime(runtimeId, runtimePath, version) {
+  const config = readRudiConfig() || createRudiConfig();
+  const platform = process.platform;
+
+  let bin;
+  if (runtimeId === 'node') {
+    bin = platform === 'win32' ? 'node.exe' : 'bin/node';
+  } else if (runtimeId === 'python') {
+    bin = platform === 'win32' ? 'python.exe' : 'bin/python3';
+  } else {
+    bin = runtimeId;
+  }
+
+  config.runtimes[runtimeId] = {
+    path: runtimePath,
+    bin: path.join(runtimePath, bin),
+    version: version
+  };
+
+  writeRudiConfig(config);
+}
+
+/**
+ * Update rudi.json with binary info after successful download
+ */
+function updateRudiConfigBinary(binaryName, binaryPath, version) {
+  const config = readRudiConfig() || createRudiConfig();
+
+  config.binaries[binaryName] = {
+    path: binaryPath,
+    bin: path.join(binaryPath, binaryName),
+    version: version,
+    installed: true,
+    installedAt: new Date().toISOString()
+  };
+
+  writeRudiConfig(config);
+}
+
+/**
+ * Mark rudi.json as fully installed
+ */
+function markRudiConfigInstalled() {
+  const config = readRudiConfig() || createRudiConfig();
+  config.installed = true;
+  writeRudiConfig(config);
+}
+
 // Detect platform
 function getPlatformArch() {
   const platform = process.platform;
@@ -110,29 +234,115 @@ async function downloadRuntime(runtimeId, platformArch) {
     // Skip if already installed
     if (fs.existsSync(binaryPath)) {
       console.log(`  ✓ ${manifest.name} already installed`);
+      // Still update rudi.json in case it's missing this runtime
+      updateRudiConfigRuntime(runtimeId, destDir, manifest.version);
       return true;
     }
 
-    return await downloadAndExtract(downloadUrl, destDir, manifest.name);
+    const success = await downloadAndExtract(downloadUrl, destDir, manifest.name);
+    if (success) {
+      // Update rudi.json with runtime info
+      updateRudiConfigRuntime(runtimeId, destDir, manifest.version);
+    }
+    return success;
   } catch (error) {
     console.log(`  ⚠ Failed to fetch ${runtimeId} manifest: ${error.message}`);
     return false;
   }
 }
 
-// Create the rudi-mcp shim
-function createShim() {
-  const shimPath = path.join(RUDI_HOME, 'shims', 'rudi-mcp');
-
-  const shimContent = `#!/bin/bash
+// Create all shims
+function createShims() {
+  // Legacy shim for direct stack access: rudi-mcp <stack>
+  const mcpShimPath = path.join(RUDI_HOME, 'shims', 'rudi-mcp');
+  const mcpShimContent = `#!/bin/bash
 # RUDI MCP Shim - Routes agent calls to rudi mcp command
 # Usage: rudi-mcp <stack-name>
 exec rudi mcp "$@"
+`;
+  fs.writeFileSync(mcpShimPath, mcpShimContent);
+  fs.chmodSync(mcpShimPath, 0o755);
+  console.log(`  ✓ Created rudi-mcp shim`);
+
+  // New router shim: Master MCP server that aggregates all stacks
+  const routerShimPath = path.join(RUDI_HOME, 'shims', 'rudi-router');
+  const routerShimContent = `#!/bin/bash
+# RUDI Router - Master MCP server for all installed stacks
+# Reads ~/.rudi/rudi.json and proxies tool calls to correct stack
+# Usage: Point agent config to this shim (no args needed)
+
+RUDI_HOME="$HOME/.rudi"
+
+# Use bundled Node if available
+if [ -x "$RUDI_HOME/runtimes/node/bin/node" ]; then
+  exec "$RUDI_HOME/runtimes/node/bin/node" "$RUDI_HOME/router/router-mcp.js" "$@"
+else
+  exec node "$RUDI_HOME/router/router-mcp.js" "$@"
+fi
+`;
+  fs.writeFileSync(routerShimPath, routerShimContent);
+  fs.chmodSync(routerShimPath, 0o755);
+  console.log(`  ✓ Created rudi-router shim`);
+
+  // Create router directory for the router-mcp.js file
+  const routerDir = path.join(RUDI_HOME, 'router');
+  if (!fs.existsSync(routerDir)) {
+    fs.mkdirSync(routerDir, { recursive: true });
+  }
+
+  // Create package.json for ES module support
+  const routerPackageJson = path.join(routerDir, 'package.json');
+  fs.writeFileSync(routerPackageJson, JSON.stringify({
+    name: 'rudi-router',
+    type: 'module',
+    private: true
+  }, null, 2));
+
+  // Copy router-mcp.js to ~/.rudi/router/
+  copyRouterMcp();
+}
+
+/**
+ * Copy router-mcp.js to ~/.rudi/router/
+ * Looks for the file relative to this script's location
+ */
+function copyRouterMcp() {
+  const routerDir = path.join(RUDI_HOME, 'router');
+  const destPath = path.join(routerDir, 'router-mcp.js');
+
+  // Try multiple possible source locations
+  const possibleSources = [
+    // When running from npm install (scripts dir)
+    path.join(path.dirname(process.argv[1]), '..', 'src', 'router-mcp.js'),
+    // When running from npm link or local dev
+    path.join(path.dirname(process.argv[1]), '..', 'dist', 'router-mcp.js'),
+    // Relative to this script
+    path.resolve(import.meta.url.replace('file://', '').replace('/scripts/postinstall.js', ''), 'src', 'router-mcp.js'),
+  ];
+
+  for (const srcPath of possibleSources) {
+    try {
+      if (fs.existsSync(srcPath)) {
+        fs.copyFileSync(srcPath, destPath);
+        console.log(`  ✓ Installed router-mcp.js`);
+        return;
+      }
+    } catch {
+      // Try next path
+    }
+  }
+
+  // Create a minimal placeholder if source not found
+  // This will be updated on next CLI update
+  const placeholderContent = `#!/usr/bin/env node
+// RUDI Router MCP Server - Placeholder
+// This file should be replaced by the actual router-mcp.js from @learnrudi/cli
+console.error('[rudi-router] Router not properly installed. Run: npm update -g @learnrudi/cli');
+process.exit(1);
 `;
 
-  fs.writeFileSync(shimPath, shimContent);
-  fs.chmodSync(shimPath, 0o755);
-  console.log(`  ✓ Created shim at ${shimPath}`);
+  fs.writeFileSync(destPath, placeholderContent, { mode: 0o755 });
+  console.log(`  ⚠ Created router placeholder (will be updated on next CLI install)`);
 }
 
 // Initialize secrets file with secure permissions
@@ -185,10 +395,17 @@ async function downloadBinary(binaryName, platformArch) {
     // Skip if already installed
     if (fs.existsSync(binaryPath)) {
       console.log(`  ✓ ${manifest.name || binaryName} already installed`);
+      // Still update rudi.json in case it's missing this binary
+      updateRudiConfigBinary(binaryName, destDir, manifest.version);
       return true;
     }
 
-    return await downloadAndExtract(upstream, destDir, manifest.name || binaryName);
+    const success = await downloadAndExtract(upstream, destDir, manifest.name || binaryName);
+    if (success) {
+      // Update rudi.json with binary info
+      updateRudiConfigBinary(binaryName, destDir, manifest.version);
+    }
+    return success;
   } catch (error) {
     console.log(`  ⚠ Failed to fetch ${binaryName} manifest: ${error.message}`);
     return false;
@@ -220,6 +437,12 @@ async function setup() {
   // Check if already initialized (by Studio or previous install)
   if (isRudiInitialized()) {
     console.log('✓ RUDI already initialized');
+    // Still init rudi.json in case it's missing (migration from older version)
+    console.log('\nUpdating configuration...');
+    initRudiConfig();
+    // Ensure shims are up to date
+    console.log('\nUpdating shims...');
+    createShims();
     console.log('  Skipping runtime and binary downloads\n');
     console.log('Run `rudi doctor` to check system health\n');
     return;
@@ -229,8 +452,12 @@ async function setup() {
   ensureDirectories();
   console.log('✓ Created ~/.rudi directory structure\n');
 
+  // Initialize rudi.json (single source of truth)
+  console.log('Initializing configuration...');
+  initRudiConfig();
+
   // Download runtimes from registry manifests
-  console.log('Installing runtimes...');
+  console.log('\nInstalling runtimes...');
   await downloadRuntime('node', platformArch);
   await downloadRuntime('python', platformArch);
 
@@ -239,9 +466,9 @@ async function setup() {
   await downloadBinary('sqlite', platformArch);
   await downloadBinary('ripgrep', platformArch);
 
-  // Create shim
+  // Create shims (rudi-mcp for direct access, rudi-router for aggregated MCP)
   console.log('\nSetting up shims...');
-  createShim();
+  createShims();
 
   // Initialize secrets
   initSecrets();
@@ -250,6 +477,9 @@ async function setup() {
   console.log('\nInitializing database...');
   initDatabase();
 
+  // Mark config as fully installed
+  markRudiConfigInstalled();
+
   console.log('\n✓ RUDI setup complete!\n');
   console.log('Get started:');
   console.log('  rudi search --all      # See available stacks');