@learnrudi/cli 1.10.4 → 1.10.6

package/dist/index.cjs

@@ -662,7 +662,7 @@ async function downloadDirectoryFromGitHub(dirUrl, destDir, onProgress) {
 async function downloadRuntime(runtime, version, destPath, options = {}) {
   const { onProgress } = options;
   const platformArch = getPlatformArch2();
-  const { execSync: execSync10 } = await import("child_process");
+  const { execSync: execSync11 } = await import("child_process");
   const runtimeManifest = await loadRuntimeManifest(runtime);
   const customDownload = runtimeManifest?.download?.[platformArch];
   const tempDir = import_path3.default.join(PATHS2.cache, "downloads");
@@ -688,7 +688,7 @@ async function downloadRuntime(runtime, version, destPath, options = {}) {
   const tempFile = import_path3.default.join(tempDir, `${runtime}-${version}-${platformArch}.download`);
   try {
     if (url.includes("github.com")) {
-      execSync10(`curl -sL "${url}" -o "${tempFile}"`, { stdio: "pipe" });
+      execSync11(`curl -sL "${url}" -o "${tempFile}"`, { stdio: "pipe" });
     } else {
       const response = await fetch(url, {
         headers: {
@@ -709,13 +709,13 @@ async function downloadRuntime(runtime, version, destPath, options = {}) {
       import_fs2.default.renameSync(tempFile, binaryPath);
       import_fs2.default.chmodSync(binaryPath, 493);
     } else if (downloadType === "tar.gz" || downloadType === "tgz") {
-      execSync10(`tar -xzf "${tempFile}" -C "${destPath}" --strip-components=1`, { stdio: "pipe" });
+      execSync11(`tar -xzf "${tempFile}" -C "${destPath}" --strip-components=1`, { stdio: "pipe" });
       import_fs2.default.unlinkSync(tempFile);
     } else if (downloadType === "tar.xz") {
-      execSync10(`tar -xJf "${tempFile}" -C "${destPath}" --strip-components=1`, { stdio: "pipe" });
+      execSync11(`tar -xJf "${tempFile}" -C "${destPath}" --strip-components=1`, { stdio: "pipe" });
       import_fs2.default.unlinkSync(tempFile);
     } else if (downloadType === "zip") {
-      execSync10(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
+      execSync11(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
       import_fs2.default.unlinkSync(tempFile);
     } else {
       throw new Error(`Unsupported download type: ${downloadType}`);
@@ -756,7 +756,7 @@ async function downloadTool(toolName, destPath, options = {}) {
     import_fs2.default.rmSync(destPath, { recursive: true });
   }
   import_fs2.default.mkdirSync(destPath, { recursive: true });
-  const { execSync: execSync10 } = await import("child_process");
+  const { execSync: execSync11 } = await import("child_process");
   const downloads = toolManifest.downloads?.[platformArch];
   if (downloads && Array.isArray(downloads)) {
     const downloadedUrls = /* @__PURE__ */ new Set();
@@ -785,11 +785,11 @@ async function downloadTool(toolName, destPath, options = {}) {
         onProgress?.({ phase: "extracting", tool: toolName, binary: import_path3.default.basename(binary) });
         const archiveType = type || guessArchiveType(urlFilename);
         if (archiveType === "zip") {
-          execSync10(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
+          execSync11(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
         } else if (archiveType === "tar.xz") {
-          execSync10(`tar -xJf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
+          execSync11(`tar -xJf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
         } else if (archiveType === "tar.gz" || archiveType === "tgz") {
-          execSync10(`tar -xzf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
+          execSync11(`tar -xzf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
         } else {
           throw new Error(`Unsupported archive type: ${archiveType}`);
         }
@@ -838,11 +838,11 @@ async function downloadTool(toolName, destPath, options = {}) {
       const stripComponents = extractConfig.strip || 0;
       const stripFlag = stripComponents > 0 ? ` --strip-components=${stripComponents}` : "";
       if (archiveType === "zip") {
-        execSync10(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
+        execSync11(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
       } else if (archiveType === "tar.xz") {
-        execSync10(`tar -xJf "${tempFile}" -C "${destPath}"${stripFlag}`, { stdio: "pipe" });
+        execSync11(`tar -xJf "${tempFile}" -C "${destPath}"${stripFlag}`, { stdio: "pipe" });
       } else if (archiveType === "tar.gz" || archiveType === "tgz") {
-        execSync10(`tar -xzf "${tempFile}" -C "${destPath}"${stripFlag}`, { stdio: "pipe" });
+        execSync11(`tar -xzf "${tempFile}" -C "${destPath}"${stripFlag}`, { stdio: "pipe" });
       } else {
         throw new Error(`Unsupported archive type: ${archiveType}`);
       }
@@ -8918,7 +8918,7 @@ async function installSinglePackage(pkg, options = {}) {
     onProgress?.({ phase: "downloading", package: pkg.id });
     if (pkg.npmPackage) {
       try {
-        const { execSync: execSync10 } = await import("child_process");
+        const { execSync: execSync11 } = await import("child_process");
         if (!import_fs5.default.existsSync(installPath)) {
           import_fs5.default.mkdirSync(installPath, { recursive: true });
         }
@@ -8926,11 +8926,11 @@ async function installSinglePackage(pkg, options = {}) {
         const resourcesPath = process.env.RESOURCES_PATH;
         const npmCmd = resourcesPath ? import_path6.default.join(resourcesPath, "bundled-runtimes", "node", "bin", "npm") : "npm";
         if (!import_fs5.default.existsSync(import_path6.default.join(installPath, "package.json"))) {
-          execSync10(`"${npmCmd}" init -y`, { cwd: installPath, stdio: "pipe" });
+          execSync11(`"${npmCmd}" init -y`, { cwd: installPath, stdio: "pipe" });
         }
         const shouldIgnoreScripts = pkg.source?.type === "npm" && !allowScripts;
         const installFlags = shouldIgnoreScripts ? "--ignore-scripts --no-audit --no-fund" : "--no-audit --no-fund";
-        execSync10(`"${npmCmd}" install ${pkg.npmPackage} ${installFlags}`, { cwd: installPath, stdio: "pipe" });
+        execSync11(`"${npmCmd}" install ${pkg.npmPackage} ${installFlags}`, { cwd: installPath, stdio: "pipe" });
         let bins = pkg.bins;
         if (!bins || bins.length === 0) {
           bins = discoverNpmBins(installPath, pkg.npmPackage);
@@ -8951,7 +8951,7 @@ async function installSinglePackage(pkg, options = {}) {
             /^npx\s+(\S+)/,
             `"${import_path6.default.join(installPath, "node_modules", ".bin", "$1")}"`
           );
-          execSync10(postInstallCmd, { cwd: installPath, stdio: "pipe" });
+          execSync11(postInstallCmd, { cwd: installPath, stdio: "pipe" });
         }
         const scriptsDetected = hasInstallScripts(installPath, pkg.npmPackage);
         const scriptsPolicy = installFlags.includes("--ignore-scripts") ? "ignore" : "allow";
@@ -9320,7 +9320,7 @@ async function updateAll(options = {}) {
   return results;
 }
 async function installStackDependencies(stackPath, onProgress) {
-  const { execSync: execSync10 } = await import("child_process");
+  const { execSync: execSync11 } = await import("child_process");
   const nodePath = import_path6.default.join(stackPath, "node");
   if (import_fs5.default.existsSync(nodePath)) {
     const packageJsonPath = import_path6.default.join(nodePath, "package.json");
@@ -9328,7 +9328,7 @@ async function installStackDependencies(stackPath, onProgress) {
       onProgress?.({ phase: "installing-deps", message: "Installing Node.js dependencies..." });
       try {
         const npmCmd = await findNpmExecutable();
-        execSync10(`"${npmCmd}" install`, { cwd: nodePath, stdio: "pipe" });
+        execSync11(`"${npmCmd}" install`, { cwd: nodePath, stdio: "pipe" });
       } catch (error) {
         console.warn(`Warning: Failed to install Node.js dependencies: ${error.message}`);
       }
@@ -9386,8 +9386,8 @@ function findUvExecutable() {
     return uvPath;
   }
   try {
-    const { execSync: execSync10 } = require("child_process");
-    execSync10("uv --version", { stdio: "pipe" });
+    const { execSync: execSync11 } = require("child_process");
+    execSync11("uv --version", { stdio: "pipe" });
     return "uv";
   } catch {
     return null;
@@ -9411,37 +9411,37 @@ async function ensureUv(onProgress) {
   return null;
 }
 async function installPythonPackage(installPath, pipPackage, onProgress) {
-  const { execSync: execSync10 } = await import("child_process");
+  const { execSync: execSync11 } = await import("child_process");
   const uvCmd = findUvExecutable();
   if (uvCmd) {
     onProgress?.({ phase: "installing", message: `uv pip install ${pipPackage}` });
-    execSync10(`"${uvCmd}" venv "${installPath}/venv"`, { stdio: "pipe" });
-    execSync10(`"${uvCmd}" pip install --python "${installPath}/venv/bin/python" ${pipPackage}`, { stdio: "pipe" });
+    execSync11(`"${uvCmd}" venv "${installPath}/venv"`, { stdio: "pipe" });
+    execSync11(`"${uvCmd}" pip install --python "${installPath}/venv/bin/python" ${pipPackage}`, { stdio: "pipe" });
     return { usedUv: true };
   } else {
     onProgress?.({ phase: "installing", message: `pip install ${pipPackage}` });
     const pythonCmd = await findPythonExecutable();
-    execSync10(`"${pythonCmd}" -m venv "${installPath}/venv"`, { stdio: "pipe" });
-    execSync10(`"${installPath}/venv/bin/pip" install ${pipPackage}`, { stdio: "pipe" });
+    execSync11(`"${pythonCmd}" -m venv "${installPath}/venv"`, { stdio: "pipe" });
+    execSync11(`"${installPath}/venv/bin/pip" install ${pipPackage}`, { stdio: "pipe" });
     return { usedUv: false };
   }
 }
 async function installPythonRequirements(pythonPath, onProgress) {
-  const { execSync: execSync10 } = await import("child_process");
+  const { execSync: execSync11 } = await import("child_process");
   const uvCmd = findUvExecutable();
   const isWindows = process.platform === "win32";
   const venvPython = isWindows ? import_path6.default.join(pythonPath, "venv", "Scripts", "python.exe") : import_path6.default.join(pythonPath, "venv", "bin", "python");
   if (uvCmd) {
     onProgress?.({ phase: "installing-deps", message: "Installing Python dependencies with uv..." });
-    execSync10(`"${uvCmd}" venv "${pythonPath}/venv"`, { cwd: pythonPath, stdio: "pipe" });
-    execSync10(`"${uvCmd}" pip install --python "${venvPython}" -r requirements.txt`, { cwd: pythonPath, stdio: "pipe" });
+    execSync11(`"${uvCmd}" venv "${pythonPath}/venv"`, { cwd: pythonPath, stdio: "pipe" });
+    execSync11(`"${uvCmd}" pip install --python "${venvPython}" -r requirements.txt`, { cwd: pythonPath, stdio: "pipe" });
     return { usedUv: true };
   } else {
     onProgress?.({ phase: "installing-deps", message: "Installing Python dependencies..." });
     const pythonCmd = await findPythonExecutable();
-    execSync10(`"${pythonCmd}" -m venv venv`, { cwd: pythonPath, stdio: "pipe" });
+    execSync11(`"${pythonCmd}" -m venv venv`, { cwd: pythonPath, stdio: "pipe" });
     const pipCmd = isWindows ? ".\\venv\\Scripts\\pip" : "./venv/bin/pip";
-    execSync10(`${pipCmd} install -r requirements.txt`, { cwd: pythonPath, stdio: "pipe" });
+    execSync11(`${pipCmd} install -r requirements.txt`, { cwd: pythonPath, stdio: "pipe" });
     return { usedUv: false };
   }
 }
@@ -31643,9 +31643,9 @@ async function checkProviderStatus() {
     }
   };
   try {
-    const { execSync: execSync10 } = await import("child_process");
+    const { execSync: execSync11 } = await import("child_process");
     try {
-      execSync10("which ollama", { stdio: "pipe" });
+      execSync11("which ollama", { stdio: "pipe" });
       status.ollama.installed = true;
     } catch {
     }
@@ -31721,9 +31721,9 @@ async function autoSetupOllama() {
     };
   }
   try {
-    const { execSync: execSync10 } = await import("child_process");
+    const { execSync: execSync11 } = await import("child_process");
     console.log("Pulling nomic-embed-text model...");
-    execSync10("ollama pull nomic-embed-text", { stdio: "inherit" });
+    execSync11("ollama pull nomic-embed-text", { stdio: "inherit" });
     return { success: true, message: "Ollama configured with nomic-embed-text" };
   } catch (err) {
     return { success: false, message: `Failed to pull model: ${err.message}` };
@@ -36342,8 +36342,8 @@ async function ensureEmbeddingProvider(preferredProvider = "auto", options = {})
     server.unref();
     await new Promise((r2) => setTimeout(r2, 2e3));
     console.log("  Pulling nomic-embed-text model (274MB)...");
-    const { execSync: execSync10 } = await import("child_process");
-    execSync10("ollama pull nomic-embed-text", { stdio: "inherit" });
+    const { execSync: execSync11 } = await import("child_process");
+    execSync11("ollama pull nomic-embed-text", { stdio: "inherit" });
     console.log("  \u2713 Model ready\n");
     return await getProvider2("ollama");
   } catch (err) {
@@ -40481,6 +40481,31 @@ function findStudioPath() {
       return p2;
     }
   }
+  if (platform === "darwin") {
+    try {
+      const result = (0, import_child_process13.execSync)(`mdfind "kMDItemCFBundleIdentifier == 'com.rudi.studio'" 2>/dev/null`, {
+        encoding: "utf-8",
+        timeout: 5e3
+      }).trim();
+      if (result) {
+        const foundPath = result.split("\n")[0];
+        if (import_fs29.default.existsSync(foundPath)) {
+          return foundPath;
+        }
+      }
+      const nameResult = (0, import_child_process13.execSync)(`mdfind "kMDItemDisplayName == 'RUDI Studio' && kMDItemContentType == 'com.apple.application-bundle'" 2>/dev/null`, {
+        encoding: "utf-8",
+        timeout: 5e3
+      }).trim();
+      if (nameResult) {
+        const foundPath = nameResult.split("\n")[0];
+        if (import_fs29.default.existsSync(foundPath)) {
+          return foundPath;
+        }
+      }
+    } catch {
+    }
+  }
   return null;
 }
 function getStudioVersion(studioPath) {

package/dist/packages-manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0.0",
-  "generated": "2026-01-10T22:42:24.427Z",
+  "generated": "2026-01-11T00:47:39.830Z",
   "packages": {
     "runtimes": [
       {

package/dist/router-mcp.js

@@ -32,6 +32,16 @@ const TOOL_INDEX_PATH = path.join(RUDI_HOME, 'cache', 'tool-index.json');
 
 const REQUEST_TIMEOUT_MS = 30000;
 const PROTOCOL_VERSION = '2024-11-05';
+const DEFAULT_IDLE_TTL_MS = 10 * 60 * 1000;
+const DEFAULT_MAX_SERVERS = 8;
+const DEFAULT_CLEANUP_INTERVAL_MS = 30000;
+const DEFAULT_FORCE_KILL_MS = 2000;
+
+const IDLE_TTL_MS = readIntEnv('RUDI_ROUTER_IDLE_TTL_MS', DEFAULT_IDLE_TTL_MS);
+const MAX_SERVERS = readIntEnv('RUDI_ROUTER_MAX_SERVERS', DEFAULT_MAX_SERVERS);
+const CLEANUP_INTERVAL_MS = readIntEnv('RUDI_ROUTER_CLEANUP_INTERVAL_MS', DEFAULT_CLEANUP_INTERVAL_MS);
+const FORCE_KILL_MS = readIntEnv('RUDI_ROUTER_FORCE_KILL_MS', DEFAULT_FORCE_KILL_MS);
+const LIVE_TOOL_LIST = readBoolEnv('RUDI_ROUTER_LIVE_TOOL_LIST', false);
 
 // =============================================================================
 // STATE
@@ -45,6 +55,7 @@ let rudiConfig = null;
 
 /** @type {Object | null} */
 let toolIndex = null;
+let cleanupTimer = null;
 
 // =============================================================================
 // TYPES (JSDoc)
@@ -57,6 +68,10 @@ let toolIndex = null;
  * @property {Map<string|number, PendingRequest>} pending
  * @property {string} buffer
  * @property {boolean} initialized
+ * @property {string} stackId
+ * @property {number} spawnedAt
+ * @property {number} lastUsedAt
+ * @property {boolean} terminating
  */
 
 /**
@@ -96,6 +111,102 @@ function debug(msg) {
   }
 }
 
+// =============================================================================
+// ENV & PROCESS HELPERS
+// =============================================================================
+
+function readIntEnv(name, fallback) {
+  const raw = process.env[name];
+  if (raw === undefined) return fallback;
+  const value = Number(raw);
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+
+function readBoolEnv(name, fallback) {
+  const raw = process.env[name];
+  if (raw === undefined) return fallback;
+  return ['1', 'true', 'yes', 'on'].includes(String(raw).toLowerCase());
+}
+
+function hasProcessExited(proc) {
+  return proc.exitCode !== null || proc.signalCode !== null;
+}
+
+function isProcessUsable(proc) {
+  return proc && !hasProcessExited(proc) && !proc.killed;
+}
+
+function markServerUsed(server) {
+  server.lastUsedAt = Date.now();
+}
+
+function rejectPending(server, reason) {
+  for (const [, pending] of server.pending) {
+    clearTimeout(pending.timeout);
+    pending.reject(new Error(reason));
+  }
+  server.pending.clear();
+}
+
+function terminateServer(stackId, server, reason) {
+  if (!server || server.terminating) return;
+
+  server.terminating = true;
+  serverPool.delete(stackId);
+
+  if (hasProcessExited(server.process)) {
+    rejectPending(server, `Stack ${stackId} exited`);
+    return;
+  }
+
+  log(`Stopping stack ${stackId}: ${reason}`);
+  try {
+    server.process.kill('SIGTERM');
+  } catch {
+    // Ignore kill errors; process may already be gone.
+  }
+
+  const killTimer = setTimeout(() => {
+    if (!hasProcessExited(server.process)) {
+      log(`Force killing stack ${stackId}`);
+      try {
+        server.process.kill('SIGKILL');
+      } catch {
+        // Ignore kill errors; process may already be gone.
+      }
+    }
+  }, FORCE_KILL_MS);
+  if (killTimer.unref) killTimer.unref();
+}
+
+function cleanupServerPool() {
+  const now = Date.now();
+
+  for (const [stackId, server] of serverPool) {
+    if (server.terminating) continue;
+    if (!isProcessUsable(server.process)) {
+      terminateServer(stackId, server, 'process-not-usable');
+      continue;
+    }
+    if (server.pending.size > 0) continue;
+    if (IDLE_TTL_MS > 0 && now - server.lastUsedAt > IDLE_TTL_MS) {
+      terminateServer(stackId, server, `idle ${Math.round((now - server.lastUsedAt) / 1000)}s`);
+    }
+  }
+
+  if (MAX_SERVERS > 0 && serverPool.size > MAX_SERVERS) {
+    const evictable = Array.from(serverPool.entries())
+      .filter(([, server]) => !server.terminating && server.pending.size === 0)
+      .sort((a, b) => a[1].lastUsedAt - b[1].lastUsedAt);
+
+    let index = 0;
+    while (serverPool.size > MAX_SERVERS && index < evictable.length) {
+      const [stackId, server] = evictable[index++];
+      terminateServer(stackId, server, 'pool-limit');
+    }
+  }
+}
+
 // =============================================================================
 // CONFIG & SECRETS
 // =============================================================================
@@ -208,7 +319,11 @@ function spawnStackServer(stackId, stackConfig) {
     rl,
     pending: new Map(),
     buffer: '',
-    initialized: false
+    initialized: false,
+    stackId,
+    spawnedAt: Date.now(),
+    lastUsedAt: Date.now(),
+    terminating: false
   };
 
   // Handle responses from stack
@@ -227,6 +342,7 @@ function spawnStackServer(stackId, stackConfig) {
       if (pending) {
         clearTimeout(pending.timeout);
         server.pending.delete(response.id);
+        markServerUsed(server);
         pending.resolve(response);
       }
     } catch (err) {
@@ -241,11 +357,13 @@ function spawnStackServer(stackId, stackConfig) {
 
   childProcess.on('error', (err) => {
     log(`Stack process error (${stackId}): ${err.message}`);
+    rejectPending(server, `Stack ${stackId} error: ${err.message}`);
     serverPool.delete(stackId);
   });
 
   childProcess.on('exit', (code, signal) => {
     debug(`Stack ${stackId} exited: code=${code}, signal=${signal}`);
+    rejectPending(server, `Stack ${stackId} exited (code=${code}, signal=${signal || 'none'})`);
     rl.close();
     serverPool.delete(stackId);
   });
@@ -260,9 +378,13 @@ function spawnStackServer(stackId, stackConfig) {
  */
 function getOrSpawnServer(stackId) {
   const existing = serverPool.get(stackId);
-  if (existing && !existing.process.killed) {
+  if (existing && isProcessUsable(existing.process) && !existing.terminating) {
+    markServerUsed(existing);
     return existing;
   }
+  if (existing) {
+    terminateServer(stackId, existing, 'stale');
+  }
 
   const stackConfig = rudiConfig?.stacks?.[stackId];
   if (!stackConfig) {
@@ -287,6 +409,11 @@ function getOrSpawnServer(stackId) {
  */
 async function sendToStack(server, request, timeoutMs = REQUEST_TIMEOUT_MS) {
   return new Promise((resolve, reject) => {
+    if (!isProcessUsable(server.process) || server.terminating) {
+      reject(new Error(`Stack ${server.stackId} is not available`));
+      return;
+    }
+
     const timeout = setTimeout(() => {
       server.pending.delete(request.id);
       reject(new Error(`Request timeout: ${request.method}`));
@@ -296,6 +423,7 @@ async function sendToStack(server, request, timeoutMs = REQUEST_TIMEOUT_MS) {
 
     const line = JSON.stringify(request) + '\n';
     debug(`>> ${line.slice(0, 200)}`);
+    markServerUsed(server);
     server.process.stdin?.write(line);
   });
 }
@@ -307,6 +435,7 @@ async function sendToStack(server, request, timeoutMs = REQUEST_TIMEOUT_MS) {
  */
 async function initializeStack(server, stackId) {
   if (server.initialized) return;
+  markServerUsed(server);
 
   const initRequest = {
     jsonrpc: '2.0',
@@ -350,6 +479,7 @@ async function initializeStack(server, stackId) {
  */
 async function listTools() {
   const tools = [];
+  const skippedStacks = [];
 
   for (const [stackId, stackConfig] of Object.entries(rudiConfig?.stacks || {})) {
     if (!stackConfig.installed) continue;
@@ -376,6 +506,10 @@ async function listTools() {
     }
 
     // 3. Fall back to querying the stack (slow, spawns server)
+    if (!LIVE_TOOL_LIST) {
+      skippedStacks.push(stackId);
+      continue;
+    }
     try {
       const server = getOrSpawnServer(stackId);
       await initializeStack(server, stackId);
@@ -399,6 +533,10 @@ async function listTools() {
     }
   }
 
+  if (skippedStacks.length > 0) {
+    log(`Skipped live tools/list for ${skippedStacks.length} stacks (enable RUDI_ROUTER_LIVE_TOOL_LIST=1 or run "rudi index")`);
+  }
+
   return tools;
 }
 
@@ -521,6 +659,8 @@ async function handleRequest(request) {
  */
 async function main() {
   log('Starting RUDI Router MCP Server');
+  log(`Pool config: max=${MAX_SERVERS <= 0 ? 'unlimited' : MAX_SERVERS}, idleTTL=${IDLE_TTL_MS}ms, cleanup=${CLEANUP_INTERVAL_MS}ms`);
+  log(`Live tools/list: ${LIVE_TOOL_LIST ? 'enabled' : 'disabled'}`);
 
   // Load config
   rudiConfig = loadRudiConfig();
@@ -574,8 +714,9 @@ async function main() {
     // Clean up all spawned servers
     for (const [stackId, server] of serverPool) {
       debug(`Killing stack ${stackId}`);
-      server.process.kill();
+      terminateServer(stackId, server, 'stdin-closed');
     }
+    if (cleanupTimer) clearInterval(cleanupTimer);
     process.exit(0);
   });
 
@@ -583,18 +724,24 @@ async function main() {
   process.on('SIGTERM', () => {
     log('SIGTERM received, shutting down');
     for (const [stackId, server] of serverPool) {
-      server.process.kill();
+      terminateServer(stackId, server, 'sigterm');
     }
+    if (cleanupTimer) clearInterval(cleanupTimer);
     process.exit(0);
   });
 
   process.on('SIGINT', () => {
     log('SIGINT received, shutting down');
     for (const [stackId, server] of serverPool) {
-      server.process.kill();
+      terminateServer(stackId, server, 'sigint');
     }
+    if (cleanupTimer) clearInterval(cleanupTimer);
     process.exit(0);
   });
+
+  // Periodic pool cleanup (idle eviction, LRU capping)
+  cleanupTimer = setInterval(cleanupServerPool, CLEANUP_INTERVAL_MS);
+  if (cleanupTimer.unref) cleanupTimer.unref();
 }
 
 // Run

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@learnrudi/cli",
-  "version": "1.10.4",
+  "version": "1.10.6",
   "description": "RUDI CLI - Install and manage MCP stacks, runtimes, and AI agents",
   "type": "module",
   "main": "dist/index.cjs",
@@ -12,18 +12,26 @@
     "scripts",
     "README.md"
   ],
+  "scripts": {
+    "start": "node src/index.js",
+    "prebuild": "node scripts/generate-manifest.js",
+    "build": "esbuild src/index.js --bundle --platform=node --format=cjs --outfile=dist/index.cjs --external:better-sqlite3 && cp src/router-mcp.js dist/router-mcp.js && cp src/packages-manifest.json dist/packages-manifest.json",
+    "postinstall": "node scripts/postinstall.js",
+    "prepublishOnly": "npm run build",
+    "test": "node --test src/__tests__/"
+  },
   "dependencies": {
-    "better-sqlite3": "^12.5.0",
-    "@learnrudi/core": "1.0.5",
-    "@learnrudi/embeddings": "0.1.0",
-    "@learnrudi/db": "1.0.2",
-    "@learnrudi/env": "1.0.1",
-    "@learnrudi/manifest": "1.0.0",
-    "@learnrudi/mcp": "1.0.0",
-    "@learnrudi/runner": "1.0.1",
-    "@learnrudi/registry-client": "1.0.5",
-    "@learnrudi/secrets": "1.0.1",
-    "@learnrudi/utils": "1.0.0"
+    "@learnrudi/core": "workspace:*",
+    "@learnrudi/db": "workspace:*",
+    "@learnrudi/embeddings": "workspace:*",
+    "@learnrudi/env": "workspace:*",
+    "@learnrudi/manifest": "workspace:*",
+    "@learnrudi/mcp": "workspace:*",
+    "@learnrudi/registry-client": "workspace:*",
+    "@learnrudi/runner": "workspace:*",
+    "@learnrudi/secrets": "workspace:*",
+    "@learnrudi/utils": "workspace:*",
+    "better-sqlite3": "^12.5.0"
   },
   "devDependencies": {
     "esbuild": "^0.27.2"
@@ -49,12 +57,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT",
-  "scripts": {
-    "start": "node src/index.js",
-    "prebuild": "node scripts/generate-manifest.js",
-    "build": "esbuild src/index.js --bundle --platform=node --format=cjs --outfile=dist/index.cjs --external:better-sqlite3 && cp src/router-mcp.js dist/router-mcp.js && cp src/packages-manifest.json dist/packages-manifest.json",
-    "postinstall": "node scripts/postinstall.js",
-    "test": "node --test src/__tests__/"
-  }
-}
+  "license": "MIT"
+}