@learnrudi/cli 1.6.0 → 1.8.0

package/dist/index.cjs

@@ -186,7 +186,6 @@ __export(src_exports, {
   PACKAGE_KINDS: () => PACKAGE_KINDS2,
   RUNTIMES_DOWNLOAD_BASE: () => RUNTIMES_DOWNLOAD_BASE,
   RUNTIMES_RELEASE_VERSION: () => RUNTIMES_RELEASE_VERSION,
-  STACKS_RELEASE_VERSION: () => STACKS_RELEASE_VERSION,
   checkCache: () => checkCache,
   clearCache: () => clearCache,
   computeHash: () => computeHash,
@@ -383,7 +382,7 @@ async function downloadPackage(pkg, destPath, options = {}) {
   }
   onProgress?.({ phase: "downloading", package: pkg.name || pkg.id });
   if (pkg.kind === "stack" || registryPath.includes("/stacks/")) {
-    await downloadStackTarball(pkg, destPath, onProgress);
+    await downloadStackFromGitHub(registryPath, destPath, onProgress);
     return { success: true, path: destPath };
   }
   if (registryPath.endsWith(".md")) {
@@ -404,45 +403,129 @@ async function downloadPackage(pkg, destPath, options = {}) {
   }
   throw new Error(`Unsupported package type: ${registryPath}`);
 }
-async function downloadStackTarball(pkg, destPath, onProgress) {
-  const stackName = pkg.id?.replace("stack:", "") || import_path2.default.basename(pkg.path);
-  const version = pkg.version || "1.0.0";
-  const tarballName = `${stackName}-${version}.tar.gz`;
-  const url = `${STACKS_DOWNLOAD_BASE}/${STACKS_RELEASE_VERSION}/${tarballName}`;
-  onProgress?.({ phase: "downloading", package: stackName, url });
-  const tempDir = import_path2.default.join(PATHS.cache, "downloads");
-  if (!import_fs2.default.existsSync(tempDir)) {
-    import_fs2.default.mkdirSync(tempDir, { recursive: true });
+async function downloadStackFromGitHub(registryPath, destPath, onProgress) {
+  const baseUrl = `${GITHUB_RAW_BASE}/${registryPath}`;
+  const apiUrl = `https://api.github.com/repos/learn-rudi/registry/contents/${registryPath}`;
+  const listResponse = await fetch(apiUrl, {
+    headers: {
+      "User-Agent": "rudi-cli/2.0",
+      "Accept": "application/vnd.github.v3+json"
+    }
+  });
+  if (!listResponse.ok) {
+    throw new Error(`Stack not found: ${registryPath}`);
+  }
+  const contents = await listResponse.json();
+  if (!Array.isArray(contents)) {
+    throw new Error(`Invalid stack directory: ${registryPath}`);
+  }
+  const existingItems = /* @__PURE__ */ new Map();
+  for (const item of contents) {
+    existingItems.set(item.name, item);
+  }
+  const manifestItem = existingItems.get("manifest.json");
+  if (!manifestItem) {
+    throw new Error(`Stack missing manifest.json: ${registryPath}`);
   }
-  const tempFile = import_path2.default.join(tempDir, tarballName);
+  const manifestResponse = await fetch(manifestItem.download_url, {
+    headers: { "User-Agent": "rudi-cli/2.0" }
+  });
+  const manifest = await manifestResponse.json();
+  import_fs2.default.writeFileSync(import_path2.default.join(destPath, "manifest.json"), JSON.stringify(manifest, null, 2));
+  onProgress?.({ phase: "downloading", file: "manifest.json" });
+  const pkgJsonItem = existingItems.get("package.json");
+  if (pkgJsonItem) {
+    const pkgJsonResponse = await fetch(pkgJsonItem.download_url, {
+      headers: { "User-Agent": "rudi-cli/2.0" }
+    });
+    if (pkgJsonResponse.ok) {
+      const pkgJson = await pkgJsonResponse.text();
+      import_fs2.default.writeFileSync(import_path2.default.join(destPath, "package.json"), pkgJson);
+      onProgress?.({ phase: "downloading", file: "package.json" });
+    }
+  }
+  const envExampleItem = existingItems.get(".env.example");
+  if (envExampleItem) {
+    const envResponse = await fetch(envExampleItem.download_url, {
+      headers: { "User-Agent": "rudi-cli/2.0" }
+    });
+    if (envResponse.ok) {
+      const envContent = await envResponse.text();
+      import_fs2.default.writeFileSync(import_path2.default.join(destPath, ".env.example"), envContent);
+    }
+  }
+  const tsconfigItem = existingItems.get("tsconfig.json");
+  if (tsconfigItem) {
+    const tsconfigResponse = await fetch(tsconfigItem.download_url, {
+      headers: { "User-Agent": "rudi-cli/2.0" }
+    });
+    if (tsconfigResponse.ok) {
+      const tsconfig = await tsconfigResponse.text();
+      import_fs2.default.writeFileSync(import_path2.default.join(destPath, "tsconfig.json"), tsconfig);
+    }
+  }
+  const requirementsItem = existingItems.get("requirements.txt");
+  if (requirementsItem) {
+    const reqResponse = await fetch(requirementsItem.download_url, {
+      headers: { "User-Agent": "rudi-cli/2.0" }
+    });
+    if (reqResponse.ok) {
+      const requirements = await reqResponse.text();
+      import_fs2.default.writeFileSync(import_path2.default.join(destPath, "requirements.txt"), requirements);
+    }
+  }
+  const sourceDirs = ["src", "dist", "node", "python", "lib"];
+  for (const dirName of sourceDirs) {
+    const dirItem = existingItems.get(dirName);
+    if (dirItem && dirItem.type === "dir") {
+      onProgress?.({ phase: "downloading", directory: dirName });
+      await downloadDirectoryFromGitHub(
+        `${baseUrl}/${dirName}`,
+        import_path2.default.join(destPath, dirName),
+        onProgress
+      );
+    }
+  }
+}
+async function downloadDirectoryFromGitHub(dirUrl, destDir, onProgress) {
+  const apiUrl = dirUrl.replace("https://raw.githubusercontent.com/", "https://api.github.com/repos/").replace("/main/", "/contents/");
   try {
-    const response = await fetch(url, {
+    const response = await fetch(apiUrl, {
       headers: {
         "User-Agent": "rudi-cli/2.0",
-        "Accept": "application/octet-stream"
+        "Accept": "application/vnd.github.v3+json"
       }
     });
     if (!response.ok) {
-      throw new Error(`Failed to download ${stackName}: HTTP ${response.status}`);
+      return;
     }
-    const buffer = await response.arrayBuffer();
-    import_fs2.default.writeFileSync(tempFile, Buffer.from(buffer));
-    onProgress?.({ phase: "extracting", package: stackName });
-    if (import_fs2.default.existsSync(destPath)) {
-      import_fs2.default.rmSync(destPath, { recursive: true });
+    const contents = await response.json();
+    if (!Array.isArray(contents)) {
+      return;
     }
-    import_fs2.default.mkdirSync(destPath, { recursive: true });
-    const { execSync: execSync7 } = await import("child_process");
-    execSync7(`tar -xzf "${tempFile}" -C "${destPath}"`, {
-      stdio: "pipe"
-    });
-    import_fs2.default.unlinkSync(tempFile);
-    onProgress?.({ phase: "complete", package: stackName, path: destPath });
-  } catch (error) {
-    if (import_fs2.default.existsSync(tempFile)) {
-      import_fs2.default.unlinkSync(tempFile);
+    if (!import_fs2.default.existsSync(destDir)) {
+      import_fs2.default.mkdirSync(destDir, { recursive: true });
     }
-    throw new Error(`Failed to install ${stackName}: ${error.message}`);
+    for (const item of contents) {
+      if (item.type === "file") {
+        const fileResponse = await fetch(item.download_url, {
+          headers: { "User-Agent": "rudi-cli/2.0" }
+        });
+        if (fileResponse.ok) {
+          const content = await fileResponse.text();
+          import_fs2.default.writeFileSync(import_path2.default.join(destDir, item.name), content);
+          onProgress?.({ phase: "downloading", file: item.name });
+        }
+      } else if (item.type === "dir") {
+        await downloadDirectoryFromGitHub(
+          item.url.replace("https://api.github.com/repos/", "https://raw.githubusercontent.com/").replace("/contents/", "/main/"),
+          import_path2.default.join(destDir, item.name),
+          onProgress
+        );
+      }
+    }
+  } catch (error) {
+    console.error(`Warning: Could not download ${dirUrl}: ${error.message}`);
   }
 }
 async function downloadRuntime(runtime, version, destPath, options = {}) {
@@ -720,7 +803,7 @@ async function computeHash(filePath) {
     stream.on("error", reject);
   });
 }
-var import_fs2, import_path2, import_crypto, DEFAULT_REGISTRY_URL, RUNTIMES_DOWNLOAD_BASE, CACHE_TTL, PACKAGE_KINDS2, KIND_PLURALS, GITHUB_RAW_BASE, STACKS_DOWNLOAD_BASE, STACKS_RELEASE_VERSION, RUNTIMES_RELEASE_VERSION;
+var import_fs2, import_path2, import_crypto, DEFAULT_REGISTRY_URL, RUNTIMES_DOWNLOAD_BASE, CACHE_TTL, PACKAGE_KINDS2, KIND_PLURALS, GITHUB_RAW_BASE, RUNTIMES_RELEASE_VERSION;
 var init_src2 = __esm({
   "../packages/registry-client/src/index.js"() {
     import_fs2 = __toESM(require("fs"), 1);
@@ -735,8 +818,6 @@ var init_src2 = __esm({
       binary: "binaries"
     };
     GITHUB_RAW_BASE = "https://raw.githubusercontent.com/learn-rudi/registry/main";
-    STACKS_DOWNLOAD_BASE = "https://github.com/learn-rudi/registry/releases/download";
-    STACKS_RELEASE_VERSION = "stacks-v1.0.0";
     RUNTIMES_RELEASE_VERSION = "v1.0.0";
   }
 });
@@ -16303,8 +16384,25 @@ async function loadManifest(installPath) {
     return null;
   }
 }
+function getBundledBinary(runtime, binary) {
+  const platform = process.platform;
+  const rudiHome = process.env.RUDI_HOME || path8.join(process.env.HOME || process.env.USERPROFILE, ".rudi");
+  if (runtime === "node") {
+    const npmPath = platform === "win32" ? path8.join(rudiHome, "runtimes", "node", "npm.cmd") : path8.join(rudiHome, "runtimes", "node", "bin", "npm");
+    if (require("fs").existsSync(npmPath)) {
+      return npmPath;
+    }
+  }
+  if (runtime === "python") {
+    const pipPath = platform === "win32" ? path8.join(rudiHome, "runtimes", "python", "Scripts", "pip.exe") : path8.join(rudiHome, "runtimes", "python", "bin", "pip3");
+    if (require("fs").existsSync(pipPath)) {
+      return pipPath;
+    }
+  }
+  return binary;
+}
 async function installDependencies(stackPath, manifest) {
-  const runtime = manifest?.runtime || "node";
+  const runtime = manifest?.runtime || manifest?.mcp?.runtime || "node";
   try {
     if (runtime === "node") {
       const packageJsonPath = path8.join(stackPath, "package.json");
@@ -16319,11 +16417,11 @@ async function installDependencies(stackPath, manifest) {
         return { installed: false, reason: "Dependencies already installed" };
       } catch {
       }
+      const npmCmd = getBundledBinary("node", "npm");
       console.log(`  Installing npm dependencies...`);
-      (0, import_child_process2.execSync)("npm install --production", {
+      (0, import_child_process2.execSync)(`"${npmCmd}" install --production`, {
         cwd: stackPath,
         stdio: "pipe"
-        // Suppress output
       });
       return { installed: true };
     } else if (runtime === "python") {
@@ -16333,8 +16431,9 @@ async function installDependencies(stackPath, manifest) {
       } catch {
         return { installed: false, reason: "No requirements.txt" };
       }
+      const pipCmd = getBundledBinary("python", "pip");
       console.log(`  Installing pip dependencies...`);
-      (0, import_child_process2.execSync)("pip install -r requirements.txt", {
+      (0, import_child_process2.execSync)(`"${pipCmd}" install -r requirements.txt`, {
         cwd: stackPath,
         stdio: "pipe"
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@learnrudi/cli",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "RUDI CLI - Install and manage MCP stacks, runtimes, and AI agents",
   "type": "module",
   "main": "dist/index.cjs",
@@ -9,11 +9,13 @@
   },
   "files": [
     "dist",
+    "scripts",
     "README.md"
   ],
   "scripts": {
     "start": "node src/index.js",
     "build": "esbuild src/index.js --bundle --platform=node --format=cjs --outfile=dist/index.cjs --external:better-sqlite3",
+    "postinstall": "node scripts/postinstall.js",
     "prepublishOnly": "npm run build",
     "test": "node --test src/__tests__/"
   },

package/scripts/postinstall.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * Post-install script for @learnrudi/cli
+ *
+ * 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/
+ */
+
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+const RUDI_HOME = path.join(os.homedir(), '.rudi');
+const REGISTRY_BASE = 'https://raw.githubusercontent.com/learn-rudi/registry/main';
+
+// Detect platform
+function getPlatformArch() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === 'darwin') {
+    return arch === 'arm64' ? 'darwin-arm64' : 'darwin-x64';
+  } else if (platform === 'linux') {
+    return arch === 'arm64' ? 'linux-arm64' : 'linux-x64';
+  } else if (platform === 'win32') {
+    return 'win32-x64';
+  }
+  return null;
+}
+
+// Create directory structure
+function ensureDirectories() {
+  const dirs = [
+    RUDI_HOME,
+    path.join(RUDI_HOME, 'runtimes'),
+    path.join(RUDI_HOME, 'stacks'),
+    path.join(RUDI_HOME, 'tools'),
+    path.join(RUDI_HOME, 'shims'),
+    path.join(RUDI_HOME, 'cache'),
+  ];
+
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+// Fetch JSON from URL
+async function fetchJson(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status}`);
+  }
+  return response.json();
+}
+
+// Download and extract a tarball
+async function downloadAndExtract(url, destDir, name) {
+  const tempFile = path.join(RUDI_HOME, 'cache', `${name}.tar.gz`);
+
+  console.log(`  Downloading ${name}...`);
+
+  try {
+    // Download using curl
+    execSync(`curl -fsSL "${url}" -o "${tempFile}"`, { stdio: 'pipe' });
+
+    // Create dest directory
+    if (fs.existsSync(destDir)) {
+      fs.rmSync(destDir, { recursive: true });
+    }
+    fs.mkdirSync(destDir, { recursive: true });
+
+    // Extract - strip first component to avoid nested dirs
+    execSync(`tar -xzf "${tempFile}" -C "${destDir}" --strip-components=1`, { stdio: 'pipe' });
+
+    // Clean up
+    fs.unlinkSync(tempFile);
+
+    console.log(`  ✓ ${name} installed`);
+    return true;
+  } catch (error) {
+    console.log(`  ⚠ Failed to install ${name}: ${error.message}`);
+    if (fs.existsSync(tempFile)) {
+      fs.unlinkSync(tempFile);
+    }
+    return false;
+  }
+}
+
+// Download runtime from manifest
+async function downloadRuntime(runtimeId, platformArch) {
+  const manifestUrl = `${REGISTRY_BASE}/catalog/runtimes/${runtimeId}.json`;
+
+  try {
+    const manifest = await fetchJson(manifestUrl);
+    const downloadUrl = manifest.download?.[platformArch];
+
+    if (!downloadUrl) {
+      console.log(`  ⚠ No ${runtimeId} available for ${platformArch}`);
+      return false;
+    }
+
+    const destDir = path.join(RUDI_HOME, 'runtimes', runtimeId);
+    const binaryPath = path.join(destDir, manifest.binary || `bin/${runtimeId}`);
+
+    // Skip if already installed
+    if (fs.existsSync(binaryPath)) {
+      console.log(`  ✓ ${manifest.name} already installed`);
+      return true;
+    }
+
+    return await downloadAndExtract(downloadUrl, destDir, manifest.name);
+  } 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
+# RUDI MCP Shim - Routes agent calls to rudi mcp command
+# Usage: rudi-mcp <stack-name>
+exec rudi mcp "$@"
+`;
+
+  fs.writeFileSync(shimPath, shimContent);
+  fs.chmodSync(shimPath, 0o755);
+  console.log(`  ✓ Created shim at ${shimPath}`);
+}
+
+// Initialize secrets file with secure permissions
+function initSecrets() {
+  const secretsPath = path.join(RUDI_HOME, 'secrets.json');
+
+  if (!fs.existsSync(secretsPath)) {
+    fs.writeFileSync(secretsPath, '{}', { mode: 0o600 });
+    console.log(`  ✓ Created secrets store`);
+  }
+}
+
+// Main setup
+async function setup() {
+  console.log('\nSetting up RUDI...\n');
+
+  const platformArch = getPlatformArch();
+  if (!platformArch) {
+    console.log('⚠ Unsupported platform. Skipping runtime download.');
+    console.log('  You can manually install runtimes later with: rudi install runtime:node\n');
+    return;
+  }
+
+  // Create directories
+  ensureDirectories();
+  console.log('✓ Created ~/.rudi directory structure\n');
+
+  // Download runtimes from registry manifests
+  console.log('Installing runtimes...');
+  await downloadRuntime('node', platformArch);
+  await downloadRuntime('python', platformArch);
+
+  // Create shim
+  console.log('\nSetting up shims...');
+  createShim();
+
+  // Initialize secrets
+  initSecrets();
+
+  console.log('\n✓ RUDI setup complete!\n');
+  console.log('Get started:');
+  console.log('  rudi search --all      # See available stacks');
+  console.log('  rudi install slack     # Install a stack');
+  console.log('  rudi doctor            # Check system health\n');
+}
+
+// Run
+setup().catch(err => {
+  console.error('Setup error:', err.message);
+  // Don't fail npm install - user can run rudi doctor later
+  process.exit(0);
+});