@learnrudi/cli 1.8.7 → 1.9.0

package/dist/index.cjs

@@ -245,10 +245,29 @@ function validateStackEntryPoint(stackPath, manifest) {
   if (!command || command.length === 0) {
     return { valid: false, error: "No command defined in manifest" };
   }
-  const runtimeCommands = ["node", "python", "python3", "npx", "deno", "bun"];
+  const skipCommands = [
+    "node",
+    "python",
+    "python3",
+    "npx",
+    "deno",
+    "bun",
+    "tsx",
+    "ts-node",
+    "tsm",
+    "esno",
+    "esbuild-register",
+    // TypeScript runners
+    "-y",
+    "--yes"
+    // npx flags
+  ];
+  const fileExtensions = [".js", ".ts", ".mjs", ".cjs", ".py", ".mts", ".cts"];
   for (const arg of command) {
-    if (runtimeCommands.includes(arg)) continue;
+    if (skipCommands.includes(arg)) continue;
     if (arg.startsWith("-")) continue;
+    const looksLikeFile = fileExtensions.some((ext) => arg.endsWith(ext)) || arg.includes("/");
+    if (!looksLikeFile) continue;
     const entryPath = require("path").join(stackPath, arg);
     if (!require("fs").existsSync(entryPath)) {
       return { valid: false, error: `Entry point not found: ${arg}` };
@@ -403,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) {
@@ -421,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(`
@@ -3672,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() {
@@ -3753,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@learnrudi/cli",
-  "version": "1.8.7",
+  "version": "1.9.0",
   "description": "RUDI CLI - Install and manage MCP stacks, runtimes, and AI agents",
   "type": "module",
   "main": "dist/index.cjs",

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');