@learnrudi/cli 1.7.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.7.0",
+  "version": "1.8.0",
   "description": "RUDI CLI - Install and manage MCP stacks, runtimes, and AI agents",
   "type": "module",
   "main": "dist/index.cjs",