@learnrudi/cli 1.10.8 → 1.10.10

package/dist/index.cjs

@@ -33,6 +33,35 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // packages/env/src/index.js
+function getNodeRuntimeRoot() {
+  return import_path.default.join(PATHS.runtimes, "node");
+}
+function resolveNodeRuntimeBin(binName) {
+  const root = getNodeRuntimeRoot();
+  const isWindows = import_os.default.platform() === "win32";
+  const arch = import_os.default.arch() === "arm64" ? "arm64" : "x64";
+  const binDir = isWindows ? "Scripts" : "bin";
+  const candidates = [];
+  if (isWindows) {
+    const names = [`${binName}.cmd`, `${binName}.exe`, binName];
+    for (const name of names) {
+      candidates.push(import_path.default.join(root, arch, binDir, name));
+      candidates.push(import_path.default.join(root, binDir, name));
+    }
+  } else {
+    candidates.push(import_path.default.join(root, arch, binDir, binName));
+    candidates.push(import_path.default.join(root, binDir, binName));
+  }
+  for (const candidate of candidates) {
+    if (import_fs.default.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return candidates[candidates.length - 1];
+}
+function getNodeRuntimeBinDir() {
+  return import_path.default.dirname(resolveNodeRuntimeBin("node"));
+}
 function getPlatformArch() {
   const platform = import_os.default.platform();
   const arch = import_os.default.arch();
@@ -118,8 +147,20 @@ function isPackageInstalled(id) {
     return false;
   }
   if (kind2 === "agent") {
-    const binPath = import_path.default.join(packagePath, "node_modules", ".bin", name);
-    return import_fs.default.existsSync(binPath);
+    const manifestPath = import_path.default.join(packagePath, "manifest.json");
+    let bins = [];
+    if (import_fs.default.existsSync(manifestPath)) {
+      try {
+        const manifest = JSON.parse(import_fs.default.readFileSync(manifestPath, "utf-8"));
+        bins = manifest.bins || manifest.binaries || [];
+      } catch {
+        bins = [];
+      }
+    }
+    if (bins.length === 0) {
+      bins = [name];
+    }
+    return bins.some((bin) => import_fs.default.existsSync(resolveNodeRuntimeBin(bin)));
   }
   try {
     const contents = import_fs.default.readdirSync(packagePath);
@@ -8726,6 +8767,8 @@ function resolveBinTarget(manifest, bin) {
       return import_path5.default.join(manifest.installDir, bin);
     case "npm":
       return import_path5.default.join(manifest.installDir, "node_modules", ".bin", bin);
+    case "npm-global":
+      return resolveNodeRuntimeBin(bin);
     case "pip":
       return import_path5.default.join(manifest.installDir, "venv", "bin", bin);
     case "system":
@@ -8830,9 +8873,18 @@ var init_shims = __esm({
 });
 
 // packages/core/src/installer.js
-function discoverNpmBins(installPath, packageName) {
+function getNpmModulesRoot(installRoot, scope = "local") {
+  if (scope === "global") {
+    return import_path6.default.join(installRoot, "lib", "node_modules");
+  }
+  return import_path6.default.join(installRoot, "node_modules");
+}
+function getNpmPackageJsonPath(installRoot, packageName, scope = "local") {
+  return import_path6.default.join(getNpmModulesRoot(installRoot, scope), packageName, "package.json");
+}
+function discoverNpmBins(installRoot, packageName, scope = "local") {
   try {
-    const pkgJsonPath = import_path6.default.join(installPath, "node_modules", packageName, "package.json");
+    const pkgJsonPath = getNpmPackageJsonPath(installRoot, packageName, scope);
     if (!import_fs5.default.existsSync(pkgJsonPath)) {
       console.warn(`[Installer] Warning: Could not find package.json at ${pkgJsonPath}`);
       return [];
@@ -8853,9 +8905,9 @@ function discoverNpmBins(installPath, packageName) {
     return [];
   }
 }
-function hasInstallScripts(installPath, packageName) {
+function hasInstallScripts(installRoot, packageName, scope = "local") {
   try {
-    const pkgJsonPath = import_path6.default.join(installPath, "node_modules", packageName, "package.json");
+    const pkgJsonPath = getNpmPackageJsonPath(installRoot, packageName, scope);
     if (!import_fs5.default.existsSync(pkgJsonPath)) {
       return false;
     }
@@ -8910,35 +8962,60 @@ async function installPackage(id, options = {}) {
 async function installSinglePackage(pkg, options = {}) {
   const { force = false, allowScripts = false, onProgress } = options;
   const installPath = getPackagePath(pkg.id);
+  const pkgName = pkg.id.replace(/^(runtime|binary|agent):/, "");
+  const isAgentNpm = pkg.kind === "agent" && pkg.npmPackage;
   if (import_fs5.default.existsSync(installPath) && !force) {
-    return { success: true, id: pkg.id, path: installPath, skipped: true };
+    if (!isAgentNpm) {
+      return { success: true, id: pkg.id, path: installPath, skipped: true };
+    }
+    const manifestPath = import_path6.default.join(installPath, "manifest.json");
+    let bins = pkg.bins || [];
+    if (import_fs5.default.existsSync(manifestPath)) {
+      try {
+        const manifest2 = JSON.parse(import_fs5.default.readFileSync(manifestPath, "utf-8"));
+        bins = manifest2.bins || manifest2.binaries || bins;
+      } catch {
+      }
+    }
+    if (bins.length === 0) {
+      bins = [pkgName];
+    }
+    const hasGlobalBin = bins.some((bin) => import_fs5.default.existsSync(resolveNodeRuntimeBin(bin)));
+    if (hasGlobalBin) {
+      return { success: true, id: pkg.id, path: installPath, skipped: true };
+    }
   }
   if (pkg.kind === "runtime" || pkg.kind === "binary" || pkg.kind === "agent") {
-    const pkgName = pkg.id.replace(/^(runtime|binary|agent):/, "");
     onProgress?.({ phase: "downloading", package: pkg.id });
     if (pkg.npmPackage) {
       try {
         const { execSync: execSync11 } = await import("child_process");
+        const npmInstallRoot = isAgentNpm ? getNodeRuntimeRoot() : installPath;
+        const npmScope = isAgentNpm ? "global" : "local";
         if (!import_fs5.default.existsSync(installPath)) {
           import_fs5.default.mkdirSync(installPath, { recursive: true });
         }
+        if (isAgentNpm && !import_fs5.default.existsSync(npmInstallRoot)) {
+          import_fs5.default.mkdirSync(npmInstallRoot, { recursive: true });
+        }
         onProgress?.({ phase: "installing", package: pkg.id, message: `npm install ${pkg.npmPackage}` });
         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"))) {
-          execSync11(`"${npmCmd}" init -y`, { cwd: installPath, stdio: "pipe" });
+        const npmCmd = resourcesPath ? import_path6.default.join(resourcesPath, "bundled-runtimes", "node", "bin", "npm") : await findNpmExecutable();
+        if (!isAgentNpm && !import_fs5.default.existsSync(import_path6.default.join(installPath, "package.json"))) {
+          execSync11(`"${npmCmd}" init -y`, { cwd: installPath, stdio: "pipe", env: buildNpmEnv(npmCmd) });
         }
         const shouldIgnoreScripts = pkg.source?.type === "npm" && !allowScripts;
         const installFlags = shouldIgnoreScripts ? "--ignore-scripts --no-audit --no-fund" : "--no-audit --no-fund";
-        execSync11(`"${npmCmd}" install ${pkg.npmPackage} ${installFlags}`, { cwd: installPath, stdio: "pipe" });
+        const installCmd = isAgentNpm ? `install -g ${pkg.npmPackage} ${installFlags} --prefix "${npmInstallRoot}"` : `install ${pkg.npmPackage} ${installFlags}`;
+        execSync11(`"${npmCmd}" ${installCmd}`, { cwd: installPath, stdio: "pipe", env: buildNpmEnv(npmCmd) });
         let bins = pkg.bins;
         if (!bins || bins.length === 0) {
-          bins = discoverNpmBins(installPath, pkg.npmPackage);
+          bins = discoverNpmBins(npmInstallRoot, pkg.npmPackage, npmScope);
           console.log(`[Installer] Discovered binaries: ${bins.join(", ") || "(none)"}`);
         }
         let installedVersion = pkg.version || "latest";
         try {
-          const pkgJsonPath = import_path6.default.join(installPath, "node_modules", pkg.npmPackage, "package.json");
+          const pkgJsonPath = getNpmPackageJsonPath(npmInstallRoot, pkg.npmPackage, npmScope);
           if (import_fs5.default.existsSync(pkgJsonPath)) {
             const pkgJson = JSON.parse(import_fs5.default.readFileSync(pkgJsonPath, "utf8"));
             installedVersion = pkgJson.version;
@@ -8947,13 +9024,21 @@ async function installSinglePackage(pkg, options = {}) {
         }
         if (pkg.postInstall) {
           onProgress?.({ phase: "postInstall", package: pkg.id, message: pkg.postInstall });
+          const binDir = isAgentNpm ? getNodeRuntimeBinDir() : import_path6.default.join(installPath, "node_modules", ".bin");
           const postInstallCmd = pkg.postInstall.replace(
             /^npx\s+(\S+)/,
-            `"${import_path6.default.join(installPath, "node_modules", ".bin", "$1")}"`
+            `"${import_path6.default.join(binDir, "$1")}"`
           );
-          execSync11(postInstallCmd, { cwd: installPath, stdio: "pipe" });
+          execSync11(postInstallCmd, {
+            cwd: installPath,
+            stdio: "pipe",
+            env: {
+              ...process.env,
+              PATH: `${binDir}${import_path6.default.delimiter}${process.env.PATH || ""}`
+            }
+          });
         }
-        const scriptsDetected = hasInstallScripts(installPath, pkg.npmPackage);
+        const scriptsDetected = hasInstallScripts(npmInstallRoot, pkg.npmPackage, npmScope);
         const scriptsPolicy = installFlags.includes("--ignore-scripts") ? "ignore" : "allow";
         if (scriptsDetected && scriptsPolicy === "ignore") {
           console.warn(`
@@ -8972,6 +9057,8 @@ async function installSinglePackage(pkg, options = {}) {
           hasInstallScripts: scriptsDetected,
           scriptsPolicy,
           postInstall: pkg.postInstall,
+          installType: isAgentNpm ? "npm-global" : "npm",
+          npmPrefix: isAgentNpm ? npmInstallRoot : void 0,
           installedAt: (/* @__PURE__ */ new Date()).toISOString(),
           source: pkg.source || { type: "npm" }
         };
@@ -8982,14 +9069,20 @@ async function installSinglePackage(pkg, options = {}) {
         if (bins && bins.length > 0) {
           await createShimsForTool({
             id: pkg.id,
-            installType: "npm",
-            installDir: installPath,
+            installType: isAgentNpm ? "npm-global" : "npm",
+            installDir: npmInstallRoot,
             bins,
             name: pkgName
           });
         } else {
           console.warn(`[Installer] Warning: No binaries found for ${pkg.npmPackage}`);
         }
+        if (isAgentNpm) {
+          const legacyPath = import_path6.default.join(installPath, "node_modules");
+          if (import_fs5.default.existsSync(legacyPath)) {
+            import_fs5.default.rmSync(legacyPath, { recursive: true, force: true });
+          }
+        }
         return { success: true, id: pkg.id, path: installPath };
       } catch (error) {
         throw new Error(`Failed to install ${pkg.npmPackage}: ${error.message}`);
@@ -9138,17 +9231,31 @@ async function uninstallPackage(id) {
   }
   try {
     let bins = [];
+    let manifest = null;
     if (kind2 !== "prompt") {
       const manifestPath = import_path6.default.join(installPath, "manifest.json");
       if (import_fs5.default.existsSync(manifestPath)) {
         try {
-          const manifest = JSON.parse(import_fs5.default.readFileSync(manifestPath, "utf-8"));
+          manifest = JSON.parse(import_fs5.default.readFileSync(manifestPath, "utf-8"));
           bins = manifest.bins || manifest.binaries || [];
         } catch {
           bins = [name];
         }
       }
     }
+    if (kind2 === "agent" && manifest?.npmPackage) {
+      try {
+        const { execSync: execSync11 } = await import("child_process");
+        const npmCmd = await findNpmExecutable();
+        const npmPrefix = getNodeRuntimeRoot();
+        execSync11(`"${npmCmd}" uninstall -g ${manifest.npmPackage} --prefix "${npmPrefix}" --no-audit --no-fund`, {
+          stdio: "pipe",
+          env: buildNpmEnv(npmCmd)
+        });
+      } catch (error) {
+        console.warn(`[Installer] Warning: Failed to uninstall ${manifest.npmPackage}: ${error.message}`);
+      }
+    }
     if (bins.length > 0) {
       removeShims(bins);
     }
@@ -9328,7 +9435,7 @@ async function installStackDependencies(stackPath, onProgress) {
       onProgress?.({ phase: "installing-deps", message: "Installing Node.js dependencies..." });
       try {
         const npmCmd = await findNpmExecutable();
-        execSync11(`"${npmCmd}" install`, { cwd: nodePath, stdio: "pipe" });
+        execSync11(`"${npmCmd}" install`, { cwd: nodePath, stdio: "pipe", env: buildNpmEnv(npmCmd) });
       } catch (error) {
         console.warn(`Warning: Failed to install Node.js dependencies: ${error.message}`);
       }
@@ -9346,6 +9453,17 @@ async function installStackDependencies(stackPath, onProgress) {
     }
   }
 }
+function buildNpmEnv(npmCmd) {
+  if (!import_path6.default.isAbsolute(npmCmd)) {
+    return process.env;
+  }
+  const npmBinDir = import_path6.default.dirname(npmCmd);
+  const basePath = process.env.PATH || "";
+  return {
+    ...process.env,
+    PATH: [npmBinDir, basePath].join(import_path6.default.delimiter)
+  };
+}
 async function findNpmExecutable() {
   const isWindows = process.platform === "win32";
   const arch = process.arch === "arm64" ? "arm64" : "x64";
@@ -10358,6 +10476,8 @@ __export(src_exports2, {
   getInstallOrder: () => getInstallOrder,
   getInstalledPackages: () => getInstalledPackages,
   getLockfilePath: () => getLockfilePath,
+  getNodeRuntimeBinDir: () => getNodeRuntimeBinDir,
+  getNodeRuntimeRoot: () => getNodeRuntimeRoot,
   getPackage: () => getPackage,
   getPackagePath: () => getPackagePath,
   getShimOwner: () => getShimOwner,
@@ -10379,6 +10499,7 @@ __export(src_exports2, {
   registerSystemBinary: () => registerSystemBinary,
   removeShims: () => removeShims,
   removeStack: () => removeStack,
+  resolveNodeRuntimeBin: () => resolveNodeRuntimeBin,
   resolvePackage: () => resolvePackage,
   resolvePackages: () => resolvePackages,
   rudiConfigExists: () => rudiConfigExists,
@@ -39332,10 +39453,31 @@ function getVersion2(command, versionFlag) {
     return null;
   }
 }
+function getAgentBins(agentId) {
+  const manifestPath = import_path22.default.join(PATHS.agents, agentId, "manifest.json");
+  if (import_fs24.default.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(import_fs24.default.readFileSync(manifestPath, "utf-8"));
+      const bins = manifest.bins || manifest.binaries || [];
+      if (bins.length > 0) return bins;
+    } catch {
+    }
+  }
+  return [agentId];
+}
+function findRudiAgentBin(agentId) {
+  const bins = getAgentBins(agentId);
+  for (const bin of bins) {
+    const binPath = resolveNodeRuntimeBin(bin);
+    if (import_fs24.default.existsSync(binPath)) return binPath;
+  }
+  return null;
+}
 function findBinary(command, kind2 = "binary") {
   const rudiPaths = [
     import_path22.default.join(PATHS.agents, command, "node_modules", ".bin", command),
     import_path22.default.join(PATHS.runtimes, command, "bin", command),
+    resolveNodeRuntimeBin(command),
     import_path22.default.join(PATHS.binaries, command, command),
     import_path22.default.join(PATHS.binaries, command)
   ];
@@ -39358,8 +39500,8 @@ function findBinary(command, kind2 = "binary") {
   return { found: false, path: null, source: null };
 }
 function getAgentStatus(agent) {
-  const rudiPath = import_path22.default.join(PATHS.agents, agent.id, "node_modules", ".bin", agent.id);
-  const rudiInstalled = import_fs24.default.existsSync(rudiPath);
+  const rudiPath = findRudiAgentBin(agent.id);
+  const rudiInstalled = !!rudiPath;
   let globalPath = null;
   let globalInstalled = false;
   if (!rudiInstalled) {
@@ -39590,9 +39732,30 @@ function getVersion3(binaryPath, versionFlag = "--version") {
     return null;
   }
 }
+function getAgentBins2(name) {
+  const manifestPath = import_path23.default.join(PATHS.agents, name, "manifest.json");
+  if (import_fs25.default.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(import_fs25.default.readFileSync(manifestPath, "utf-8"));
+      const bins = manifest.bins || manifest.binaries || [];
+      if (bins.length > 0) return bins;
+    } catch {
+    }
+  }
+  return [name];
+}
+function findRudiAgentBin2(name) {
+  const bins = getAgentBins2(name);
+  for (const bin of bins) {
+    const binPath = resolveNodeRuntimeBin(bin);
+    if (import_fs25.default.existsSync(binPath)) return binPath;
+  }
+  return null;
+}
 function detectKindFromFilesystem(name) {
-  const agentPath = import_path23.default.join(PATHS.agents, name, "node_modules", ".bin", name);
-  if (import_fs25.default.existsSync(agentPath)) return "agent";
+  const agentManifestPath = import_path23.default.join(PATHS.agents, name, "manifest.json");
+  if (import_fs25.default.existsSync(agentManifestPath)) return "agent";
+  if (findRudiAgentBin2(name)) return "agent";
   const runtimePath = import_path23.default.join(PATHS.runtimes, name, "bin", name);
   if (import_fs25.default.existsSync(runtimePath)) return "runtime";
   const binaryPath = import_path23.default.join(PATHS.binaries, name, name);
@@ -39645,8 +39808,8 @@ async function cmdCheck(args, flags) {
   };
   switch (kind2) {
     case "agent": {
-      const rudiPath = import_path23.default.join(PATHS.agents, name, "node_modules", ".bin", name);
-      const rudiInstalled = import_fs25.default.existsSync(rudiPath);
+      const rudiPath = findRudiAgentBin2(name);
+      const rudiInstalled = !!rudiPath;
       let globalPath = null;
       let globalInstalled = false;
       if (!rudiInstalled) {
@@ -39801,16 +39964,6 @@ function getShimTarget(name, shimPath, type) {
 }
 function getPackageFromShim(shimName, target) {
   if (!target) return null;
-  const match = target.match(/\/(binaries|runtimes|agents)\/([^\/]+)/);
-  if (match) {
-    const [, kind2, pkgName] = match;
-    const kindMap = {
-      "binaries": "binary",
-      "runtimes": "runtime",
-      "agents": "agent"
-    };
-    return `${kindMap[kind2]}:${pkgName}`;
-  }
   const manifestDirs = [
     import_path24.default.join(PATHS.binaries),
     import_path24.default.join(PATHS.runtimes),
@@ -39834,6 +39987,16 @@ function getPackageFromShim(shimName, target) {
       }
     }
   }
+  const match = target.match(/\/(binaries|runtimes|agents)\/([^\/]+)/);
+  if (match) {
+    const [, kind2, pkgName] = match;
+    const kindMap = {
+      "binaries": "binary",
+      "runtimes": "runtime",
+      "agents": "agent"
+    };
+    return `${kindMap[kind2]}:${pkgName}`;
+  }
   return null;
 }
 function formatShimStatus(shim, flags) {
@@ -40670,7 +40833,7 @@ async function cmdStudio(args, flags) {
 }
 
 // src/index.js
-var VERSION2 = true ? "1.10.8" : process.env.npm_package_version || "0.0.0";
+var VERSION2 = true ? "1.10.10" : process.env.npm_package_version || "0.0.0";
 async function main() {
   const { command, args, flags } = parseArgs(process.argv.slice(2));
   if (flags.version || flags.v) {

package/dist/packages-manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0.0",
-  "generated": "2026-01-11T15:40:59.295Z",
+  "generated": "2026-01-11T22:42:52.951Z",
   "packages": {
     "runtimes": [
       {
@@ -122,13 +122,13 @@
         "id": "claude",
         "name": "Claude Code",
         "kind": "agent",
-        "installDir": "claude",
-        "basePath": "agents",
-        "installType": "npm",
+        "installDir": "node",
+        "basePath": "runtimes",
+        "installType": "npm-global",
         "commands": [
           {
             "name": "claude",
-            "bin": "node_modules/.bin/claude",
+            "bin": "bin/claude",
             "args": null
           }
         ]
@@ -137,13 +137,13 @@
         "id": "codex",
         "name": "OpenAI Codex",
         "kind": "agent",
-        "installDir": "codex",
-        "basePath": "agents",
-        "installType": "npm",
+        "installDir": "node",
+        "basePath": "runtimes",
+        "installType": "npm-global",
         "commands": [
           {
             "name": "codex",
-            "bin": "node_modules/.bin/codex",
+            "bin": "bin/codex",
             "args": null
           }
         ]
@@ -152,18 +152,18 @@
         "id": "copilot",
         "name": "GitHub Copilot",
         "kind": "agent",
-        "installDir": "copilot",
-        "basePath": "agents",
-        "installType": "npm",
+        "installDir": "node",
+        "basePath": "runtimes",
+        "installType": "npm-global",
         "commands": [
           {
             "name": "copilot",
-            "bin": "node_modules/.bin/github-copilot-cli",
+            "bin": "bin/github-copilot-cli",
             "args": null
           },
           {
             "name": "github-copilot-cli",
-            "bin": "node_modules/.bin/github-copilot-cli",
+            "bin": "bin/github-copilot-cli",
             "args": null
           }
         ]
@@ -172,13 +172,13 @@
         "id": "gemini",
         "name": "Gemini CLI",
         "kind": "agent",
-        "installDir": "gemini",
-        "basePath": "agents",
-        "installType": "npm",
+        "installDir": "node",
+        "basePath": "runtimes",
+        "installType": "npm-global",
         "commands": [
           {
             "name": "gemini",
-            "bin": "node_modules/.bin/gemini",
+            "bin": "bin/gemini",
             "args": null
           }
         ]

package/package.json

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

package/scripts/generate-manifest.js

@@ -113,6 +113,17 @@ function getKindBasePath(kind) {
   }
 }
 
+function normalizeGlobalNpmCommands(commands) {
+  return commands.map(cmd => {
+    const binName = path.basename(cmd.bin || cmd.name);
+    return {
+      name: cmd.name,
+      bin: path.posix.join('bin', binName),
+      args: cmd.args || null,
+    };
+  });
+}
+
 /**
  * Process packages from a catalog directory
  */
@@ -122,8 +133,18 @@ function processPackages(catalogPath, kind) {
 
   return packages.map(pkg => {
     const id = pkg.id.replace(/^(runtime|binary|agent):/, '');
-    const installDir = getInstallDir(pkg, kind);
-    const basePath = getKindBasePath(kind);
+    let installDir = getInstallDir(pkg, kind);
+    let basePath = getKindBasePath(kind);
+    let installType = pkg.installType || 'binary';
+    let commands = extractCommands(pkg, kind);
+
+    const isGlobalNpmAgent = kind === 'agent' && (installType === 'npm' || pkg.npmPackage);
+    if (isGlobalNpmAgent) {
+      basePath = 'runtimes';
+      installDir = 'node';
+      installType = 'npm-global';
+      commands = normalizeGlobalNpmCommands(commands);
+    }
 
     return {
       id,
@@ -131,8 +152,8 @@ function processPackages(catalogPath, kind) {
       kind,
       installDir,
       basePath,
-      installType: pkg.installType || 'binary',
-      commands: extractCommands(pkg, kind),
+      installType,
+      commands,
     };
   });
 }

package/scripts/postinstall.js

@@ -5,7 +5,7 @@
  * Fetches runtime manifests from registry and downloads:
  * 1. Node.js runtime → ~/.rudi/runtimes/node/
  * 2. Python runtime → ~/.rudi/runtimes/python/
- * 3. Creates shims → ~/.rudi/shims/
+ * 3. Creates shims → ~/.rudi/bins/
  * 4. Initializes rudi.json → ~/.rudi/rudi.json
  */
 
@@ -287,6 +287,37 @@ function loadPackagesManifest() {
   return { packages: { runtimes: [], agents: [], binaries: [] } };
 }
 
+function resolveNodeRuntimeBinDir() {
+  const isWindows = process.platform === 'win32';
+  const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+  const binDir = isWindows ? 'Scripts' : 'bin';
+  const nodeRoot = path.join(RUDI_HOME, 'runtimes', 'node');
+  const archBin = path.join(nodeRoot, arch, binDir);
+  const flatBin = path.join(nodeRoot, binDir);
+  const nodeExe = isWindows ? 'node.exe' : 'node';
+
+  if (fs.existsSync(path.join(archBin, nodeExe))) {
+    return archBin;
+  }
+
+  return flatBin;
+}
+
+function getCliEntryPath() {
+  const candidates = [
+    path.join(path.dirname(process.argv[1]), '..', 'dist', 'index.cjs'),
+    path.join(path.dirname(process.argv[1]), '..', 'src', 'index.js'),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
 /**
  * Build a shim script that executes a target binary
  * Shows helpful error if binary not installed
@@ -338,6 +369,7 @@ function createShims() {
 
   const manifest = loadPackagesManifest();
   const shimDefs = [];
+  const nodeBinDir = resolveNodeRuntimeBinDir();
 
   // ---------------------------------------------------------------------------
   // GENERATE SHIMS FROM MANIFEST (only for installed packages)
@@ -350,7 +382,10 @@ function createShims() {
   ];
 
   for (const pkg of allPackages) {
-    const installPath = path.join(RUDI_HOME, pkg.basePath, pkg.installDir);
+    const isAgentNpm = pkg.kind === 'agent' && (pkg.installType === 'npm' || pkg.installType === 'npm-global');
+    const installPath = isAgentNpm
+      ? path.join(RUDI_HOME, 'runtimes', 'node')
+      : path.join(RUDI_HOME, pkg.basePath, pkg.installDir);
 
     // Only create shims for packages that are actually installed
     // Check if the install directory exists
@@ -359,7 +394,10 @@ function createShims() {
     }
 
     for (const cmd of pkg.commands) {
-      const binPath = path.join(installPath, cmd.bin);
+      const binName = isAgentNpm ? path.basename(cmd.bin) : cmd.bin;
+      const binPath = isAgentNpm
+        ? path.join(nodeBinDir, binName)
+        : path.join(installPath, cmd.bin);
 
       // Only create shim if the target binary exists
       if (!fs.existsSync(binPath)) {
@@ -386,6 +424,26 @@ function createShims() {
   // RUDI SHIMS (router, mcp) - always included
   // ---------------------------------------------------------------------------
 
+  const cliEntryPath = getCliEntryPath();
+  if (cliEntryPath) {
+    const nodeBin = path.join(nodeBinDir, isWindows ? 'node.exe' : 'node');
+    shimDefs.push({
+      name: 'rudi',
+      script: `#!/bin/sh
+CLI_ENTRY="${cliEntryPath.replace(/"/g, '\\"')}"
+NODE_BIN="${nodeBin.replace(/"/g, '\\"')}"
+if [ -x "$CLI_ENTRY" ]; then
+  if [ -x "$NODE_BIN" ]; then
+    exec "$NODE_BIN" "$CLI_ENTRY" "$@"
+  fi
+  exec node "$CLI_ENTRY" "$@"
+fi
+echo "RUDI: CLI entry not found at $CLI_ENTRY" 1>&2
+exit 127
+`
+    });
+  }
+
   // rudi-mcp shim for direct stack access
   shimDefs.push({
     name: 'rudi-mcp',
@@ -397,14 +455,16 @@ exec rudi mcp "$@"
   });
 
   // rudi-router shim for aggregated MCP server
+  const routerNodeBin = path.join(nodeBinDir, isWindows ? 'node.exe' : 'node');
   shimDefs.push({
     name: 'rudi-router',
     script: `#!/bin/bash
 # RUDI Router - Master MCP server for all installed stacks
 # Reads ~/.rudi/rudi.json and proxies tool calls to correct stack
 RUDI_HOME="$HOME/.rudi"
-if [ -x "$RUDI_HOME/runtimes/node/bin/node" ]; then
-  exec "$RUDI_HOME/runtimes/node/bin/node" "$RUDI_HOME/router/router-mcp.js" "$@"
+NODE_BIN="${routerNodeBin.replace(/"/g, '\\"')}"
+if [ -x "$NODE_BIN" ]; then
+  exec "$NODE_BIN" "$RUDI_HOME/router/router-mcp.js" "$@"
 else
   exec node "$RUDI_HOME/router/router-mcp.js" "$@"
 fi