@learnrudi/cli 1.2.0 → 1.4.0

package/dist/index.cjs

@@ -199,6 +199,16 @@ __export(src_exports, {
   searchPackages: () => searchPackages,
   verifyHash: () => verifyHash
 });
+function getLocalRegistryPaths() {
+  if (process.env.USE_LOCAL_REGISTRY !== "true") {
+    return [];
+  }
+  return [
+    import_path2.default.join(process.cwd(), "registry", "index.json"),
+    import_path2.default.join(process.cwd(), "..", "registry", "index.json"),
+    "/Users/hoff/dev/RUDI/registry/index.json"
+  ];
+}
 async function fetchIndex(options = {}) {
   const { url = DEFAULT_REGISTRY_URL, force = false } = options;
   const localResult = getLocalIndex();
@@ -276,7 +286,7 @@ function getCacheMtime() {
   }
 }
 function getLocalIndex() {
-  for (const localPath of LOCAL_REGISTRY_PATHS) {
+  for (const localPath of getLocalRegistryPaths()) {
     if (import_fs2.default.existsSync(localPath)) {
       try {
         const index = JSON.parse(import_fs2.default.readFileSync(localPath, "utf-8"));
@@ -367,7 +377,7 @@ function getPackageKinds() {
 async function downloadPackage(pkg, destPath, options = {}) {
   const { onProgress } = options;
   const registryPath = pkg.path;
-  for (const basePath of LOCAL_REGISTRY_PATHS) {
+  for (const basePath of getLocalRegistryPaths()) {
     const registryDir = import_path2.default.dirname(basePath);
     const pkgSourcePath = import_path2.default.join(registryDir, registryPath);
     if (import_fs2.default.existsSync(pkgSourcePath)) {
@@ -415,8 +425,8 @@ async function downloadRuntime(runtime, version, destPath, options = {}) {
       import_fs2.default.rmSync(destPath, { recursive: true });
     }
     import_fs2.default.mkdirSync(destPath, { recursive: true });
-    const { execSync: execSync4 } = await import("child_process");
-    execSync4(`tar -xzf "${tempFile}" -C "${destPath}" --strip-components=1`, {
+    const { execSync: execSync5 } = await import("child_process");
+    execSync5(`tar -xzf "${tempFile}" -C "${destPath}" --strip-components=1`, {
       stdio: "pipe"
     });
     import_fs2.default.unlinkSync(tempFile);
@@ -454,7 +464,7 @@ async function downloadTool(toolName, destPath, options = {}) {
     import_fs2.default.rmSync(destPath, { recursive: true });
   }
   import_fs2.default.mkdirSync(destPath, { recursive: true });
-  const { execSync: execSync4 } = await import("child_process");
+  const { execSync: execSync5 } = await import("child_process");
   const downloads = toolManifest.downloads?.[platformArch];
   if (downloads && Array.isArray(downloads)) {
     const downloadedUrls = /* @__PURE__ */ new Set();
@@ -483,11 +493,11 @@ async function downloadTool(toolName, destPath, options = {}) {
         onProgress?.({ phase: "extracting", tool: toolName, binary: import_path2.default.basename(binary) });
         const archiveType = type || guessArchiveType(urlFilename);
         if (archiveType === "zip") {
-          execSync4(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
+          execSync5(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
         } else if (archiveType === "tar.xz") {
-          execSync4(`tar -xJf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
+          execSync5(`tar -xJf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
         } else if (archiveType === "tar.gz" || archiveType === "tgz") {
-          execSync4(`tar -xzf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
+          execSync5(`tar -xzf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
         } else {
           throw new Error(`Unsupported archive type: ${archiveType}`);
         }
@@ -534,11 +544,11 @@ async function downloadTool(toolName, destPath, options = {}) {
       onProgress?.({ phase: "extracting", tool: toolName });
       const archiveType = extractConfig.type || guessArchiveType(urlFilename);
       if (archiveType === "zip") {
-        execSync4(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
+        execSync5(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
       } else if (archiveType === "tar.xz") {
-        execSync4(`tar -xJf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
+        execSync5(`tar -xJf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
       } else if (archiveType === "tar.gz" || archiveType === "tgz") {
-        execSync4(`tar -xzf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
+        execSync5(`tar -xzf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
       } else {
         throw new Error(`Unsupported archive type: ${archiveType}`);
       }
@@ -608,7 +618,7 @@ async function extractBinaryFromPath(extractedPath, binaryPattern, destPath) {
   }
 }
 async function loadToolManifest(toolName) {
-  for (const basePath of LOCAL_REGISTRY_PATHS) {
+  for (const basePath of getLocalRegistryPaths()) {
     const registryDir = import_path2.default.dirname(basePath);
     const manifestPath = import_path2.default.join(registryDir, "catalog", "binaries", `${toolName}.json`);
     if (import_fs2.default.existsSync(manifestPath)) {
@@ -676,7 +686,7 @@ async function copyDirectory(src, dest) {
     }
   }
 }
-var import_fs2, import_path2, import_crypto, DEFAULT_REGISTRY_URL, RUNTIMES_DOWNLOAD_BASE, CACHE_TTL, LOCAL_REGISTRY_PATHS, PACKAGE_KINDS2, KIND_PLURALS, RUNTIMES_RELEASE_VERSION;
+var import_fs2, import_path2, import_crypto, DEFAULT_REGISTRY_URL, RUNTIMES_DOWNLOAD_BASE, CACHE_TTL, PACKAGE_KINDS2, KIND_PLURALS, RUNTIMES_RELEASE_VERSION;
 var init_src2 = __esm({
   "../packages/registry-client/src/index.js"() {
     import_fs2 = __toESM(require("fs"), 1);
@@ -686,11 +696,6 @@ var init_src2 = __esm({
     DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/learn-rudi/registry/main/index.json";
     RUNTIMES_DOWNLOAD_BASE = "https://github.com/learn-rudi/registry/releases/download";
     CACHE_TTL = 24 * 60 * 60 * 1e3;
-    LOCAL_REGISTRY_PATHS = process.env.USE_LOCAL_REGISTRY === "true" ? [
-      import_path2.default.join(process.cwd(), "registry", "index.json"),
-      import_path2.default.join(process.cwd(), "..", "registry", "index.json"),
-      "/Users/hoff/dev/RUDI/registry/index.json"
-    ] : [];
     PACKAGE_KINDS2 = ["stack", "prompt", "runtime", "binary", "agent"];
     KIND_PLURALS = {
       binary: "binaries"
@@ -776,17 +781,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path16) {
-      const ctrl = callVisitor(key, node, visitor, path16);
+    function visit_(key, node, visitor, path17) {
+      const ctrl = callVisitor(key, node, visitor, path17);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path16, ctrl);
-        return visit_(key, ctrl, visitor, path16);
+        replaceNode(key, path17, ctrl);
+        return visit_(key, ctrl, visitor, path17);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path16 = Object.freeze(path16.concat(node));
+          path17 = Object.freeze(path17.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path16);
+            const ci = visit_(i, node.items[i], visitor, path17);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -797,13 +802,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path16 = Object.freeze(path16.concat(node));
-          const ck = visit_("key", node.key, visitor, path16);
+          path17 = Object.freeze(path17.concat(node));
+          const ck = visit_("key", node.key, visitor, path17);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path16);
+          const cv = visit_("value", node.value, visitor, path17);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -824,17 +829,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path16) {
-      const ctrl = await callVisitor(key, node, visitor, path16);
+    async function visitAsync_(key, node, visitor, path17) {
+      const ctrl = await callVisitor(key, node, visitor, path17);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path16, ctrl);
-        return visitAsync_(key, ctrl, visitor, path16);
+        replaceNode(key, path17, ctrl);
+        return visitAsync_(key, ctrl, visitor, path17);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path16 = Object.freeze(path16.concat(node));
+          path17 = Object.freeze(path17.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path16);
+            const ci = await visitAsync_(i, node.items[i], visitor, path17);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -845,13 +850,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path16 = Object.freeze(path16.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path16);
+          path17 = Object.freeze(path17.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path17);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path16);
+          const cv = await visitAsync_("value", node.value, visitor, path17);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -878,23 +883,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path16) {
+    function callVisitor(key, node, visitor, path17) {
       if (typeof visitor === "function")
-        return visitor(key, node, path16);
+        return visitor(key, node, path17);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path16);
+        return visitor.Map?.(key, node, path17);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path16);
+        return visitor.Seq?.(key, node, path17);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path16);
+        return visitor.Pair?.(key, node, path17);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path16);
+        return visitor.Scalar?.(key, node, path17);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path16);
+        return visitor.Alias?.(key, node, path17);
       return void 0;
     }
-    function replaceNode(key, path16, node) {
-      const parent = path16[path16.length - 1];
+    function replaceNode(key, path17, node) {
+      const parent = path17[path17.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -1502,10 +1507,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path16, value) {
+    function collectionFromPath(schema, path17, value) {
       let v = value;
-      for (let i = path16.length - 1; i >= 0; --i) {
-        const k = path16[i];
+      for (let i = path17.length - 1; i >= 0; --i) {
+        const k = path17[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -1524,7 +1529,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path16) => path16 == null || typeof path16 === "object" && !!path16[Symbol.iterator]().next().done;
+    var isEmptyPath = (path17) => path17 == null || typeof path17 === "object" && !!path17[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -1554,11 +1559,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path16, value) {
-        if (isEmptyPath(path16))
+      addIn(path17, value) {
+        if (isEmptyPath(path17))
           this.add(value);
         else {
-          const [key, ...rest] = path16;
+          const [key, ...rest] = path17;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -1572,8 +1577,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path16) {
-        const [key, ...rest] = path16;
+      deleteIn(path17) {
+        const [key, ...rest] = path17;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -1587,8 +1592,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path16, keepScalar) {
-        const [key, ...rest] = path16;
+      getIn(path17, keepScalar) {
+        const [key, ...rest] = path17;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -1606,8 +1611,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path16) {
-        const [key, ...rest] = path16;
+      hasIn(path17) {
+        const [key, ...rest] = path17;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -1617,8 +1622,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path16, value) {
-        const [key, ...rest] = path16;
+      setIn(path17, value) {
+        const [key, ...rest] = path17;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -4122,9 +4127,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path16, value) {
+      addIn(path17, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path16, value);
+          this.contents.addIn(path17, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -4199,14 +4204,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path16) {
-        if (Collection.isEmptyPath(path16)) {
+      deleteIn(path17) {
+        if (Collection.isEmptyPath(path17)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path16) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path17) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -4221,10 +4226,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path16, keepScalar) {
-        if (Collection.isEmptyPath(path16))
+      getIn(path17, keepScalar) {
+        if (Collection.isEmptyPath(path17))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path16, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path17, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -4235,10 +4240,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path16) {
-        if (Collection.isEmptyPath(path16))
+      hasIn(path17) {
+        if (Collection.isEmptyPath(path17))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path16) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path17) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -4255,13 +4260,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path16, value) {
-        if (Collection.isEmptyPath(path16)) {
+      setIn(path17, value) {
+        if (Collection.isEmptyPath(path17)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path16), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path17), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path16, value);
+          this.contents.setIn(path17, value);
         }
       }
       /**
@@ -6213,9 +6218,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path16) => {
+    visit.itemAtPath = (cst, path17) => {
       let item = cst;
-      for (const [field, index] of path16) {
+      for (const [field, index] of path17) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -6224,23 +6229,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path16) => {
-      const parent = visit.itemAtPath(cst, path16.slice(0, -1));
-      const field = path16[path16.length - 1][0];
+    visit.parentCollection = (cst, path17) => {
+      const parent = visit.itemAtPath(cst, path17.slice(0, -1));
+      const field = path17[path17.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path16, item, visitor) {
-      let ctrl = visitor(item, path16);
+    function _visit(path17, item, visitor) {
+      let ctrl = visitor(item, path17);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path16.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path17.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -6251,10 +6256,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path16);
+            ctrl = ctrl(item, path17);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path16) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path17) : ctrl;
     }
     exports2.visit = visit;
   }
@@ -7539,14 +7544,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs18 = this.flowScalar(this.type);
+              const fs19 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs18, sep: [] });
+                map.items.push({ start, key: fs19, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs18);
+                this.stack.push(fs19);
               } else {
-                Object.assign(it, { key: fs18, sep: [] });
+                Object.assign(it, { key: fs19, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7674,13 +7679,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs18 = this.flowScalar(this.type);
+              const fs19 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs18, sep: [] });
+                fc.items.push({ start: [], key: fs19, sep: [] });
               else if (it.sep)
-                this.stack.push(fs18);
+                this.stack.push(fs19);
               else
-                Object.assign(it, { key: fs18, sep: [] });
+                Object.assign(it, { key: fs19, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -11181,8 +11186,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path16) {
-      let input = path16;
+    function removeDotSegments(path17) {
+      let input = path17;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -11381,8 +11386,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path16, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path16 && path16 !== "/" ? path16 : void 0;
+        const [path17, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path17 && path17 !== "/" ? path17 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -14735,12 +14740,12 @@ var require_dist2 = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats2(ajv2, list, fs18, exportName) {
+    function addFormats2(ajv2, list, fs19, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv2.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv2.addFormat(f, fs18[f]);
+        ajv2.addFormat(f, fs19[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -15275,7 +15280,7 @@ async function installSinglePackage(pkg, options = {}) {
     onProgress?.({ phase: "downloading", package: pkg.id });
     if (pkg.npmPackage) {
       try {
-        const { execSync: execSync4 } = await import("child_process");
+        const { execSync: execSync5 } = await import("child_process");
         if (!import_fs4.default.existsSync(installPath)) {
           import_fs4.default.mkdirSync(installPath, { recursive: true });
         }
@@ -15283,16 +15288,16 @@ async function installSinglePackage(pkg, options = {}) {
         const resourcesPath = process.env.RESOURCES_PATH;
         const npmCmd = resourcesPath ? import_path4.default.join(resourcesPath, "bundled-runtimes", "node", "bin", "npm") : "npm";
         if (!import_fs4.default.existsSync(import_path4.default.join(installPath, "package.json"))) {
-          execSync4(`"${npmCmd}" init -y`, { cwd: installPath, stdio: "pipe" });
+          execSync5(`"${npmCmd}" init -y`, { cwd: installPath, stdio: "pipe" });
         }
-        execSync4(`"${npmCmd}" install ${pkg.npmPackage}`, { cwd: installPath, stdio: "pipe" });
+        execSync5(`"${npmCmd}" install ${pkg.npmPackage}`, { cwd: installPath, stdio: "pipe" });
         if (pkg.postInstall) {
           onProgress?.({ phase: "postInstall", package: pkg.id, message: pkg.postInstall });
           const postInstallCmd = pkg.postInstall.replace(
             /^npx\s+(\S+)/,
             `"${import_path4.default.join(installPath, "node_modules", ".bin", "$1")}"`
           );
-          execSync4(postInstallCmd, { cwd: installPath, stdio: "pipe" });
+          execSync5(postInstallCmd, { cwd: installPath, stdio: "pipe" });
         }
         import_fs4.default.writeFileSync(
           import_path4.default.join(installPath, "manifest.json"),
@@ -15314,15 +15319,15 @@ async function installSinglePackage(pkg, options = {}) {
     }
     if (pkg.pipPackage) {
       try {
-        const { execSync: execSync4 } = await import("child_process");
+        const { execSync: execSync5 } = await import("child_process");
         if (!import_fs4.default.existsSync(installPath)) {
           import_fs4.default.mkdirSync(installPath, { recursive: true });
         }
         onProgress?.({ phase: "installing", package: pkg.id, message: `pip install ${pkg.pipPackage}` });
         const pythonPath = import_path4.default.join(PATHS.runtimes, "python", "bin", "python3");
         const pythonCmd = import_fs4.default.existsSync(pythonPath) ? pythonPath : "python3";
-        execSync4(`"${pythonCmd}" -m venv "${installPath}/venv"`, { stdio: "pipe" });
-        execSync4(`"${installPath}/venv/bin/pip" install ${pkg.pipPackage}`, { stdio: "pipe" });
+        execSync5(`"${pythonCmd}" -m venv "${installPath}/venv"`, { stdio: "pipe" });
+        execSync5(`"${installPath}/venv/bin/pip" install ${pkg.pipPackage}`, { stdio: "pipe" });
         import_fs4.default.writeFileSync(
           import_path4.default.join(installPath, "manifest.json"),
           JSON.stringify({
@@ -15544,7 +15549,7 @@ async function listInstalled(kind) {
   return packages;
 }
 async function installStackDependencies(stackPath, onProgress) {
-  const { execSync: execSync4 } = await import("child_process");
+  const { execSync: execSync5 } = await import("child_process");
   const nodePath = import_path4.default.join(stackPath, "node");
   if (import_fs4.default.existsSync(nodePath)) {
     const packageJsonPath = import_path4.default.join(nodePath, "package.json");
@@ -15552,7 +15557,7 @@ async function installStackDependencies(stackPath, onProgress) {
       onProgress?.({ phase: "installing-deps", message: "Installing Node.js dependencies..." });
       try {
         const npmCmd = await findNpmExecutable();
-        execSync4(`"${npmCmd}" install`, { cwd: nodePath, stdio: "pipe" });
+        execSync5(`"${npmCmd}" install`, { cwd: nodePath, stdio: "pipe" });
       } catch (error) {
         console.warn(`Warning: Failed to install Node.js dependencies: ${error.message}`);
       }
@@ -15565,8 +15570,8 @@ async function installStackDependencies(stackPath, onProgress) {
       onProgress?.({ phase: "installing-deps", message: "Installing Python dependencies..." });
       try {
         const pythonCmd = await findPythonExecutable();
-        execSync4(`"${pythonCmd}" -m venv venv`, { cwd: pythonPath, stdio: "pipe" });
-        execSync4("./venv/bin/pip install -r requirements.txt", { cwd: pythonPath, stdio: "pipe" });
+        execSync5(`"${pythonCmd}" -m venv venv`, { cwd: pythonPath, stdio: "pipe" });
+        execSync5("./venv/bin/pip install -r requirements.txt", { cwd: pythonPath, stdio: "pipe" });
       } catch (error) {
         console.warn(`Warning: Failed to install Python dependencies: ${error.message}`);
       }
@@ -15606,6 +15611,213 @@ async function findPythonExecutable() {
   return "python3";
 }
 
+// ../packages/core/src/deps.js
+var import_fs5 = __toESM(require("fs"), 1);
+var import_path5 = __toESM(require("path"), 1);
+var import_child_process = require("child_process");
+init_src();
+init_src2();
+function checkRuntime(runtime) {
+  const name = runtime.replace(/^runtime:/, "");
+  const rudiPath = import_path5.default.join(PATHS.runtimes, name);
+  if (import_fs5.default.existsSync(rudiPath)) {
+    const binPath = getBinPath(rudiPath, name);
+    if (binPath && import_fs5.default.existsSync(binPath)) {
+      const version = getVersion(binPath, name);
+      return { available: true, path: binPath, version, source: "rudi" };
+    }
+  }
+  const systemCmd = getSystemCommand(name);
+  const systemPath = which(systemCmd);
+  if (systemPath) {
+    const version = getVersion(systemPath, name);
+    return { available: true, path: systemPath, version, source: "system" };
+  }
+  return { available: false, path: null, version: null, source: null };
+}
+function checkBinary(binary) {
+  const name = binary.replace(/^binary:/, "");
+  const rudiPath = import_path5.default.join(PATHS.binaries, name);
+  if (import_fs5.default.existsSync(rudiPath)) {
+    const binPath = getBinPath(rudiPath, name);
+    if (binPath && import_fs5.default.existsSync(binPath)) {
+      const version = getVersion(binPath, name);
+      return { available: true, path: binPath, version, source: "rudi" };
+    }
+  }
+  const systemPath = which(name);
+  if (systemPath) {
+    const version = getVersion(systemPath, name);
+    return { available: true, path: systemPath, version, source: "system" };
+  }
+  return { available: false, path: null, version: null, source: null };
+}
+function checkAllDependencies(resolved) {
+  const results = [];
+  let satisfied = true;
+  if (resolved.runtime) {
+    const runtime = resolved.runtime.replace(/^runtime:/, "");
+    const check = checkRuntime(runtime);
+    results.push({
+      type: "runtime",
+      name: runtime,
+      required: true,
+      ...check
+    });
+    if (!check.available) satisfied = false;
+  }
+  for (const rt of resolved.requires?.runtimes || []) {
+    const name = rt.replace(/^runtime:/, "");
+    const check = checkRuntime(name);
+    results.push({
+      type: "runtime",
+      name,
+      required: true,
+      ...check
+    });
+    if (!check.available) satisfied = false;
+  }
+  for (const bin of resolved.requires?.binaries || []) {
+    const name = bin.replace(/^binary:/, "");
+    const check = checkBinary(name);
+    results.push({
+      type: "binary",
+      name,
+      required: true,
+      ...check
+    });
+    if (!check.available) satisfied = false;
+  }
+  return { satisfied, results };
+}
+function formatDependencyResults(results) {
+  const lines = [];
+  for (const r of results) {
+    const icon = r.available ? "\u2713" : "\u2717";
+    const version = r.version ? ` v${r.version}` : "";
+    const source = r.source ? ` (${r.source})` : "";
+    const status = r.available ? `${icon} ${r.name}${version}${source}` : `${icon} ${r.name} - not found`;
+    lines.push(`  ${status}`);
+  }
+  return lines;
+}
+function getBinPath(baseDir, name) {
+  const arch = process.arch === "arm64" ? "arm64" : "x64";
+  const isWindows = process.platform === "win32";
+  const ext = isWindows ? ".exe" : "";
+  const exeMap = {
+    node: "node",
+    python: "python3",
+    deno: "deno",
+    bun: "bun",
+    ffmpeg: "ffmpeg",
+    ripgrep: "rg",
+    sqlite: "sqlite3",
+    jq: "jq",
+    yq: "yq"
+  };
+  const exe = exeMap[name] || name;
+  const archPath = import_path5.default.join(baseDir, arch, "bin", exe + ext);
+  if (import_fs5.default.existsSync(archPath)) return archPath;
+  const flatPath = import_path5.default.join(baseDir, "bin", exe + ext);
+  if (import_fs5.default.existsSync(flatPath)) return flatPath;
+  const directPath = import_path5.default.join(baseDir, exe + ext);
+  if (import_fs5.default.existsSync(directPath)) return directPath;
+  return null;
+}
+function getSystemCommand(name) {
+  const cmdMap = {
+    python: "python3",
+    node: "node",
+    deno: "deno",
+    bun: "bun"
+  };
+  return cmdMap[name] || name;
+}
+function which(cmd) {
+  try {
+    const result = (0, import_child_process.execSync)(`which ${cmd} 2>/dev/null`, { encoding: "utf-8" });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+function getVersion(binPath, name) {
+  const versionFlags = {
+    node: "--version",
+    python: "--version",
+    python3: "--version",
+    deno: "--version",
+    bun: "--version",
+    ffmpeg: "-version",
+    rg: "--version",
+    ripgrep: "--version",
+    sqlite3: "--version",
+    jq: "--version",
+    yq: "--version"
+  };
+  const flag = versionFlags[name] || "--version";
+  try {
+    const output = (0, import_child_process.execSync)(`"${binPath}" ${flag} 2>&1`, { encoding: "utf-8" });
+    const match = output.match(/(\d+\.\d+(?:\.\d+)?)/);
+    return match ? match[1] : output.split("\n")[0].trim();
+  } catch {
+    return null;
+  }
+}
+function getAvailableDeps() {
+  const installedRuntimes = scanDirectory(PATHS.runtimes);
+  const installedBinaries = scanDirectory(PATHS.binaries);
+  const commonRuntimes = ["node", "python", "deno", "bun"];
+  const commonBinaries = ["ffmpeg", "ripgrep", "sqlite3", "jq", "yq", "git", "docker", "rg"];
+  const runtimeNames = [.../* @__PURE__ */ new Set([...installedRuntimes, ...commonRuntimes])];
+  const binaryNames = [.../* @__PURE__ */ new Set([...installedBinaries, ...commonBinaries])];
+  const runtimes = runtimeNames.map((name) => ({
+    name,
+    ...checkRuntime(name)
+  }));
+  const binaries = binaryNames.filter((name) => name !== "rg").map((name) => ({
+    name,
+    ...checkBinary(name)
+  }));
+  return { runtimes, binaries };
+}
+function scanDirectory(dir) {
+  if (!import_fs5.default.existsSync(dir)) return [];
+  try {
+    return import_fs5.default.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+async function getAllDepsFromRegistry() {
+  const index = await fetchIndex();
+  const runtimes = (index.packages?.runtimes?.official || []).map((rt) => {
+    const name = rt.id.replace(/^runtime:/, "");
+    const check = checkRuntime(name);
+    return {
+      name,
+      registryVersion: rt.version,
+      description: rt.description,
+      ...check,
+      status: check.available ? check.source === "rudi" ? "installed" : "system" : "available"
+    };
+  });
+  const binaries = (index.packages?.binaries?.official || []).map((bin) => {
+    const name = bin.id.replace(/^binary:/, "");
+    const check = checkBinary(name);
+    return {
+      name,
+      registryVersion: bin.version,
+      description: bin.description,
+      managed: bin.managed !== false,
+      ...check,
+      status: check.available ? check.source === "rudi" ? "installed" : "system" : "available"
+    };
+  });
+  return { runtimes, binaries };
+}
+
 // src/commands/search.js
 function pluralizeKind(kind) {
   if (!kind) return "packages";
@@ -15711,31 +15923,31 @@ Total: ${totalCount} package(s) available`);
 }
 
 // src/commands/install.js
-var fs6 = __toESM(require("fs/promises"), 1);
-var path6 = __toESM(require("path"), 1);
+var fs7 = __toESM(require("fs/promises"), 1);
+var path7 = __toESM(require("path"), 1);
 
 // src/utils/mcp-registry.js
-var fs5 = __toESM(require("fs/promises"), 1);
-var path5 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs/promises"), 1);
+var path6 = __toESM(require("path"), 1);
 var os2 = __toESM(require("os"), 1);
 var HOME = os2.homedir();
 var AGENT_CONFIGS = {
-  claude: path5.join(HOME, ".claude", "settings.json"),
-  codex: path5.join(HOME, ".codex", "config.toml"),
-  gemini: path5.join(HOME, ".gemini", "settings.json")
+  claude: path6.join(HOME, ".claude", "settings.json"),
+  codex: path6.join(HOME, ".codex", "config.toml"),
+  gemini: path6.join(HOME, ".gemini", "settings.json")
 };
 async function readJson(filePath) {
   try {
-    const content = await fs5.readFile(filePath, "utf-8");
+    const content = await fs6.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
   }
 }
 async function writeJson(filePath, data) {
-  const dir = path5.dirname(filePath);
-  await fs5.mkdir(dir, { recursive: true });
-  await fs5.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+  const dir = path6.dirname(filePath);
+  await fs6.mkdir(dir, { recursive: true });
+  await fs6.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
 }
 function parseTomlValue(value) {
   if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
@@ -15843,16 +16055,16 @@ function stringifyToml(config, prefix = "") {
 }
 async function readToml(filePath) {
   try {
-    const content = await fs5.readFile(filePath, "utf-8");
+    const content = await fs6.readFile(filePath, "utf-8");
     return parseToml(content);
   } catch {
     return {};
   }
 }
 async function writeToml(filePath, data) {
-  const dir = path5.dirname(filePath);
-  await fs5.mkdir(dir, { recursive: true });
-  await fs5.writeFile(filePath, stringifyToml(data), "utf-8");
+  const dir = path6.dirname(filePath);
+  await fs6.mkdir(dir, { recursive: true });
+  await fs6.writeFile(filePath, stringifyToml(data), "utf-8");
 }
 function parseEnvFile(content) {
   const env = {};
@@ -15874,9 +16086,9 @@ function parseEnvFile(content) {
   return env;
 }
 async function readStackEnv(installPath) {
-  const envPath = path5.join(installPath, ".env");
+  const envPath = path6.join(installPath, ".env");
   try {
-    const content = await fs5.readFile(envPath, "utf-8");
+    const content = await fs6.readFile(envPath, "utf-8");
     return parseEnvFile(content);
   } catch {
     return {};
@@ -15887,9 +16099,9 @@ async function buildMcpConfig(stackId, installPath, manifest) {
   let args = [];
   const cwd = installPath;
   const resolveRelativePath2 = (value) => {
-    if (!value || path5.isAbsolute(value)) return value;
+    if (!value || path6.isAbsolute(value)) return value;
     const isPathLike = value.startsWith(".") || value.includes("/") || value.includes("\\");
-    return isPathLike ? path5.join(installPath, value) : value;
+    return isPathLike ? path6.join(installPath, value) : value;
   };
   if (manifest.command) {
     const cmdArray = Array.isArray(manifest.command) ? manifest.command : [manifest.command];
@@ -15900,7 +16112,7 @@ async function buildMcpConfig(stackId, installPath, manifest) {
     args = (manifest.mcp.args || []).map((arg) => resolveRelativePath2(arg));
     if (manifest.mcp.entry) {
       args = args.map(
-        (arg) => arg === manifest.mcp.entry ? path5.join(installPath, manifest.mcp.entry) : arg
+        (arg) => arg === manifest.mcp.entry ? path6.join(installPath, manifest.mcp.entry) : arg
       );
     }
   } else {
@@ -15934,9 +16146,9 @@ async function optimizeEntryPoint(installPath, command, args) {
   }
   const tsFile = args[tsFileIndex];
   const jsFile = tsFile.replace("/src/", "/dist/").replace(".ts", ".js");
-  const jsPath = path5.isAbsolute(jsFile) ? jsFile : path5.join(installPath, jsFile);
+  const jsPath = path6.isAbsolute(jsFile) ? jsFile : path6.join(installPath, jsFile);
   try {
-    await fs5.access(jsPath);
+    await fs6.access(jsPath);
     return {
       command: "node",
       args: [jsPath]
@@ -16055,12 +16267,12 @@ async function unregisterMcpGemini(stackId) {
   }
 }
 async function getInstalledAgents() {
-  const agentsDir = path5.join(HOME, ".rudi", "agents");
+  const agentsDir = path6.join(HOME, ".rudi", "agents");
   const installed = [];
   for (const agent of ["claude", "codex", "gemini"]) {
-    const agentPath = path5.join(agentsDir, agent);
+    const agentPath = path6.join(agentsDir, agent);
     try {
-      await fs5.access(agentPath);
+      await fs6.access(agentPath);
       installed.push(agent);
     } catch {
     }
@@ -16106,9 +16318,9 @@ async function unregisterMcpAll(stackId, targetAgents = null) {
 
 // src/commands/install.js
 async function loadManifest(installPath) {
-  const manifestPath = path6.join(installPath, "manifest.json");
+  const manifestPath = path7.join(installPath, "manifest.json");
   try {
-    const content = await fs6.readFile(manifestPath, "utf-8");
+    const content = await fs7.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -16136,9 +16348,9 @@ function getSecretLabel(secret) {
 async function createEnvFile(installPath, manifest) {
   const secrets = getManifestSecrets(manifest);
   if (!secrets.length) return null;
-  const envPath = path6.join(installPath, ".env");
+  const envPath = path7.join(installPath, ".env");
   try {
-    await fs6.access(envPath);
+    await fs7.access(envPath);
     console.log(`  .env file already exists, preserving existing secrets`);
     return envPath;
   } catch {
@@ -16160,7 +16372,7 @@ async function createEnvFile(installPath, manifest) {
     lines.push(`${key}=`);
     lines.push("");
   }
-  await fs6.writeFile(envPath, lines.join("\n"), "utf-8");
+  await fs7.writeFile(envPath, lines.join("\n"), "utf-8");
   return envPath;
 }
 async function cmdInstall(args, flags) {
@@ -16212,6 +16424,19 @@ Required secrets:`);
         console.log(`  - ${name}`);
       }
     }
+    const depCheck = checkAllDependencies(resolved);
+    if (depCheck.results.length > 0) {
+      console.log(`
+System dependencies:`);
+      for (const line of formatDependencyResults(depCheck.results)) {
+        console.log(line);
+      }
+      if (!depCheck.satisfied && !force) {
+        console.error(`
+\u2717 Missing required dependencies. Install them first or use --force to skip.`);
+        process.exit(1);
+      }
+    }
     console.log(`
 Installing...`);
     const result = await installPackage(pkgId, {
@@ -16274,32 +16499,32 @@ Run with: rudi run ${pkgId}`);
 }
 
 // ../packages/runner/src/spawn.js
-var import_child_process = require("child_process");
-var import_path6 = __toESM(require("path"), 1);
-var import_fs6 = __toESM(require("fs"), 1);
+var import_child_process2 = require("child_process");
+var import_path7 = __toESM(require("path"), 1);
+var import_fs7 = __toESM(require("fs"), 1);
 
 // ../packages/runner/src/secrets.js
-var import_fs5 = __toESM(require("fs"), 1);
-var import_path5 = __toESM(require("path"), 1);
+var import_fs6 = __toESM(require("fs"), 1);
+var import_path6 = __toESM(require("path"), 1);
 var import_os2 = __toESM(require("os"), 1);
-var SECRETS_PATH = import_path5.default.join(import_os2.default.homedir(), ".rudi", "secrets.json");
+var SECRETS_PATH = import_path6.default.join(import_os2.default.homedir(), ".rudi", "secrets.json");
 function loadSecrets() {
-  if (!import_fs5.default.existsSync(SECRETS_PATH)) {
+  if (!import_fs6.default.existsSync(SECRETS_PATH)) {
     return {};
   }
   try {
-    const content = import_fs5.default.readFileSync(SECRETS_PATH, "utf-8");
+    const content = import_fs6.default.readFileSync(SECRETS_PATH, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
   }
 }
 function saveSecrets(secrets) {
-  const dir = import_path5.default.dirname(SECRETS_PATH);
-  if (!import_fs5.default.existsSync(dir)) {
-    import_fs5.default.mkdirSync(dir, { recursive: true });
+  const dir = import_path6.default.dirname(SECRETS_PATH);
+  if (!import_fs6.default.existsSync(dir)) {
+    import_fs6.default.mkdirSync(dir, { recursive: true });
   }
-  import_fs5.default.writeFileSync(SECRETS_PATH, JSON.stringify(secrets, null, 2), {
+  import_fs6.default.writeFileSync(SECRETS_PATH, JSON.stringify(secrets, null, 2), {
     mode: 384
     // Read/write only for owner
   });
@@ -16385,12 +16610,12 @@ async function runStack(id, options = {}) {
   const { inputs = {}, cwd, env = {}, onStdout, onStderr, onExit, signal } = options;
   const startTime = Date.now();
   const packagePath = getPackagePath(id);
-  const manifestPath = import_path6.default.join(packagePath, "manifest.json");
-  const { default: fs18 } = await import("fs");
-  if (!fs18.existsSync(manifestPath)) {
+  const manifestPath = import_path7.default.join(packagePath, "manifest.json");
+  const { default: fs19 } = await import("fs");
+  if (!fs19.existsSync(manifestPath)) {
     throw new Error(`Stack manifest not found: ${id}`);
   }
-  const manifest = JSON.parse(fs18.readFileSync(manifestPath, "utf-8"));
+  const manifest = JSON.parse(fs19.readFileSync(manifestPath, "utf-8"));
   const { command, args } = resolveCommandFromManifest(manifest, packagePath);
   const secrets = await getSecrets(manifest.requires?.secrets || []);
   const runEnv = {
@@ -16401,7 +16626,7 @@ async function runStack(id, options = {}) {
     RUDI_PACKAGE_ID: id,
     RUDI_PACKAGE_PATH: packagePath
   };
-  const proc = (0, import_child_process.spawn)(command, args, {
+  const proc = (0, import_child_process2.spawn)(command, args, {
     cwd: cwd || packagePath,
     env: runEnv,
     stdio: ["pipe", "pipe", "pipe"],
@@ -16446,15 +16671,15 @@ async function runStack(id, options = {}) {
 }
 function getCommand(runtime) {
   const runtimeName = runtime.replace("runtime:", "");
-  const runtimePath = import_path6.default.join(PATHS.runtimes, runtimeName);
+  const runtimePath = import_path7.default.join(PATHS.runtimes, runtimeName);
   const binaryPaths = [
-    import_path6.default.join(runtimePath, "bin", runtimeName === "python" ? "python3" : runtimeName),
-    import_path6.default.join(runtimePath, "bin", runtimeName),
-    import_path6.default.join(runtimePath, runtimeName === "python" ? "python3" : runtimeName),
-    import_path6.default.join(runtimePath, runtimeName)
+    import_path7.default.join(runtimePath, "bin", runtimeName === "python" ? "python3" : runtimeName),
+    import_path7.default.join(runtimePath, "bin", runtimeName),
+    import_path7.default.join(runtimePath, runtimeName === "python" ? "python3" : runtimeName),
+    import_path7.default.join(runtimePath, runtimeName)
   ];
   for (const binPath of binaryPaths) {
-    if (import_fs6.default.existsSync(binPath)) {
+    if (import_fs7.default.existsSync(binPath)) {
       return binPath;
     }
   }
@@ -16478,7 +16703,7 @@ function resolveCommandFromManifest(manifest, packagePath) {
     return { command: command2, args };
   }
   const entry = manifest.entry || "index.js";
-  const entryPath = import_path6.default.join(packagePath, entry);
+  const entryPath = import_path7.default.join(packagePath, entry);
   const runtime = manifest.runtime || "runtime:node";
   const command = getCommand(runtime);
   return { command, args: [entryPath] };
@@ -16487,21 +16712,21 @@ function resolveRelativePath(value, basePath) {
   if (typeof value !== "string" || value.startsWith("-")) {
     return value;
   }
-  if (import_path6.default.isAbsolute(value)) {
+  if (import_path7.default.isAbsolute(value)) {
     return value;
   }
   if (value.includes("/") || value.startsWith(".")) {
-    return import_path6.default.join(basePath, value);
+    return import_path7.default.join(basePath, value);
   }
   return value;
 }
 
 // ../packages/manifest/src/stack.js
 var import_yaml2 = __toESM(require_dist(), 1);
-var import_fs7 = __toESM(require("fs"), 1);
-var import_path7 = __toESM(require("path"), 1);
+var import_fs8 = __toESM(require("fs"), 1);
+var import_path8 = __toESM(require("path"), 1);
 function parseStackManifest(filePath) {
-  const content = import_fs7.default.readFileSync(filePath, "utf-8");
+  const content = import_fs8.default.readFileSync(filePath, "utf-8");
   return parseStackYaml(content, filePath);
 }
 function parseStackYaml(content, source = "stack.yaml") {
@@ -16619,8 +16844,8 @@ function validateStackManifest(manifest, source) {
 function findStackManifest(dir) {
   const candidates = ["stack.yaml", "stack.yml", "manifest.yaml", "manifest.yml"];
   for (const filename of candidates) {
-    const filePath = import_path7.default.join(dir, filename);
-    if (import_fs7.default.existsSync(filePath)) {
+    const filePath = import_path8.default.join(dir, filename);
+    if (import_fs8.default.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -16775,8 +17000,8 @@ var validatePromptInternal = ajv.compile(promptSchema);
 var validateRuntimeInternal = ajv.compile(runtimeSchema);
 
 // src/commands/run.js
-var import_fs8 = __toESM(require("fs"), 1);
-var import_path8 = __toESM(require("path"), 1);
+var import_fs9 = __toESM(require("fs"), 1);
+var import_path9 = __toESM(require("path"), 1);
 async function cmdRun(args, flags) {
   const stackId = args[0];
   if (!stackId) {
@@ -16797,9 +17022,9 @@ async function cmdRun(args, flags) {
     if (manifestPath) {
       manifest = parseStackManifest(manifestPath);
     } else {
-      const jsonPath = import_path8.default.join(packagePath, "manifest.json");
-      if (import_fs8.default.existsSync(jsonPath)) {
-        manifest = JSON.parse(import_fs8.default.readFileSync(jsonPath, "utf-8"));
+      const jsonPath = import_path9.default.join(packagePath, "manifest.json");
+      if (import_fs9.default.existsSync(jsonPath)) {
+        manifest = JSON.parse(import_fs9.default.readFileSync(jsonPath, "utf-8"));
       }
     }
   } catch (error) {
@@ -17255,13 +17480,13 @@ function promptSecret(prompt) {
 }
 
 // src/commands/db.js
-var import_fs10 = require("fs");
-var import_path10 = require("path");
+var import_fs11 = require("fs");
+var import_path11 = require("path");
 
 // ../packages/db/src/index.js
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
-var import_path9 = __toESM(require("path"), 1);
-var import_fs9 = __toESM(require("fs"), 1);
+var import_path10 = __toESM(require("path"), 1);
+var import_fs10 = __toESM(require("fs"), 1);
 init_src();
 
 // ../packages/db/src/schema.js
@@ -17301,7 +17526,7 @@ CREATE TABLE IF NOT EXISTS sessions (
   project_id TEXT,
 
   -- Origin tracking
-  origin TEXT NOT NULL CHECK (origin IN ('promptstack', 'provider-import', 'mixed')),
+  origin TEXT NOT NULL CHECK (origin IN ('rudi', 'provider-import', 'mixed')),
   origin_imported_at TEXT,
   origin_native_file TEXT,
 
@@ -17998,9 +18223,9 @@ var DB_PATH = PATHS.dbFile;
 var db = null;
 function getDb(options = {}) {
   if (!db) {
-    const dbDir = import_path9.default.dirname(DB_PATH);
-    if (!import_fs9.default.existsSync(dbDir)) {
-      import_fs9.default.mkdirSync(dbDir, { recursive: true });
+    const dbDir = import_path10.default.dirname(DB_PATH);
+    if (!import_fs10.default.existsSync(dbDir)) {
+      import_fs10.default.mkdirSync(dbDir, { recursive: true });
     }
     db = new import_better_sqlite3.default(DB_PATH, {
       readonly: options.readonly || false
@@ -18013,7 +18238,7 @@ function getDb(options = {}) {
   return db;
 }
 function isDatabaseInitialized() {
-  if (!import_fs9.default.existsSync(DB_PATH)) {
+  if (!import_fs10.default.existsSync(DB_PATH)) {
     return false;
   }
   try {
@@ -18033,7 +18258,7 @@ function getDbPath() {
 }
 function getDbSize() {
   try {
-    const stats = import_fs9.default.statSync(DB_PATH);
+    const stats = import_fs10.default.statSync(DB_PATH);
     return stats.size;
   } catch {
     return null;
@@ -18294,12 +18519,12 @@ function dbBackup(args, flags) {
   let backupPath = args[0];
   if (!backupPath) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-    backupPath = (0, import_path10.join)((0, import_path10.dirname)(dbPath), `rudi-backup-${timestamp}.db`);
+    backupPath = (0, import_path11.join)((0, import_path11.dirname)(dbPath), `rudi-backup-${timestamp}.db`);
   }
   if (backupPath.startsWith("~")) {
-    backupPath = (0, import_path10.join)(process.env.HOME || "", backupPath.slice(1));
+    backupPath = (0, import_path11.join)(process.env.HOME || "", backupPath.slice(1));
   }
-  if ((0, import_fs10.existsSync)(backupPath) && !flags.force) {
+  if ((0, import_fs11.existsSync)(backupPath) && !flags.force) {
     console.error(`Backup file already exists: ${backupPath}`);
     console.error("Use --force to overwrite.");
     process.exit(1);
@@ -18311,7 +18536,7 @@ function dbBackup(args, flags) {
     const db3 = getDb();
     db3.exec("VACUUM INTO ?", [backupPath]);
   } catch (e) {
-    (0, import_fs10.copyFileSync)(dbPath, backupPath);
+    (0, import_fs11.copyFileSync)(dbPath, backupPath);
   }
   const size = getDbSize();
   console.log(`  Size:   ${formatBytes(size)}`);
@@ -18416,24 +18641,24 @@ function dbTables(flags) {
 }
 
 // src/commands/import.js
-var import_fs11 = require("fs");
-var import_path11 = require("path");
+var import_fs12 = require("fs");
+var import_path12 = require("path");
 var import_os3 = require("os");
 var import_crypto2 = require("crypto");
 var PROVIDERS = {
   claude: {
     name: "Claude Code",
-    baseDir: (0, import_path11.join)((0, import_os3.homedir)(), ".claude", "projects"),
+    baseDir: (0, import_path12.join)((0, import_os3.homedir)(), ".claude", "projects"),
     pattern: /\.jsonl$/
   },
   codex: {
     name: "Codex",
-    baseDir: (0, import_path11.join)((0, import_os3.homedir)(), ".codex", "sessions"),
+    baseDir: (0, import_path12.join)((0, import_os3.homedir)(), ".codex", "sessions"),
     pattern: /\.jsonl$/
   },
   gemini: {
     name: "Gemini",
-    baseDir: (0, import_path11.join)((0, import_os3.homedir)(), ".gemini", "sessions"),
+    baseDir: (0, import_path12.join)((0, import_os3.homedir)(), ".gemini", "sessions"),
     pattern: /\.jsonl$/
   }
 };
@@ -18500,7 +18725,7 @@ async function importSessions(args, flags) {
     console.log(`
 \u25B6 ${provider.name}`);
     console.log(`  Source: ${provider.baseDir}`);
-    if (!(0, import_fs11.existsSync)(provider.baseDir)) {
+    if (!(0, import_fs12.existsSync)(provider.baseDir)) {
       console.log(`  \u26A0 Directory not found, skipping`);
       continue;
     }
@@ -18543,14 +18768,14 @@ async function importSessions(args, flags) {
     const now = Date.now();
     const maxAgeMs = maxAgeDays ? maxAgeDays * 24 * 60 * 60 * 1e3 : null;
     for (const filepath of files) {
-      const sessionId = (0, import_path11.basename)(filepath, ".jsonl");
+      const sessionId = (0, import_path12.basename)(filepath, ".jsonl");
       if (existingIds.has(sessionId)) {
         skipped.existing++;
         continue;
       }
       let stat;
       try {
-        stat = (0, import_fs11.statSync)(filepath);
+        stat = (0, import_fs12.statSync)(filepath);
       } catch (e) {
         skipped.error++;
         continue;
@@ -18648,7 +18873,7 @@ function showImportStatus(flags) {
   }
   console.log("\nProvider directories:");
   for (const [key, provider] of Object.entries(PROVIDERS)) {
-    const exists = (0, import_fs11.existsSync)(provider.baseDir);
+    const exists = (0, import_fs12.existsSync)(provider.baseDir);
     let count = 0;
     if (exists) {
       const files = findSessionFiles(provider.baseDir, provider.pattern);
@@ -18662,10 +18887,10 @@ function showImportStatus(flags) {
   console.log("To import: rudi import sessions [provider]");
 }
 function findSessionFiles(dir, pattern, files = []) {
-  if (!(0, import_fs11.existsSync)(dir)) return files;
+  if (!(0, import_fs12.existsSync)(dir)) return files;
   try {
-    for (const entry of (0, import_fs11.readdirSync)(dir, { withFileTypes: true })) {
-      const fullPath = (0, import_path11.join)(dir, entry.name);
+    for (const entry of (0, import_fs12.readdirSync)(dir, { withFileTypes: true })) {
+      const fullPath = (0, import_path12.join)(dir, entry.name);
       if (entry.isDirectory()) {
         findSessionFiles(fullPath, pattern, files);
       } else if (pattern.test(entry.name)) {
@@ -18678,11 +18903,11 @@ function findSessionFiles(dir, pattern, files = []) {
 }
 function parseSessionFile(filepath, provider) {
   try {
-    const stat = (0, import_fs11.statSync)(filepath);
-    const content = (0, import_fs11.readFileSync)(filepath, "utf-8");
+    const stat = (0, import_fs12.statSync)(filepath);
+    const content = (0, import_fs12.readFileSync)(filepath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     if (lines.length === 0) return null;
-    const sessionId = (0, import_path11.basename)(filepath, ".jsonl");
+    const sessionId = (0, import_path12.basename)(filepath, ".jsonl");
     const isAgent = sessionId.startsWith("agent-");
     let title = null;
     let cwd = null;
@@ -18714,7 +18939,7 @@ function parseSessionFile(filepath, provider) {
       title = isAgent ? "Agent Session" : "Imported Session";
     }
     if (!cwd) {
-      const parentDir = (0, import_path11.basename)((0, import_path11.dirname)(filepath));
+      const parentDir = (0, import_path12.basename)((0, import_path12.dirname)(filepath));
       if (parentDir.startsWith("-")) {
         cwd = parentDir.replace(/-/g, "/").replace(/^\//, "/");
       } else {
@@ -18738,7 +18963,7 @@ function parseSessionFile(filepath, provider) {
 }
 
 // src/commands/doctor.js
-var import_fs12 = __toESM(require("fs"), 1);
+var import_fs13 = __toESM(require("fs"), 1);
 async function cmdDoctor(args, flags) {
   console.log("RUDI Health Check");
   console.log("\u2550".repeat(50));
@@ -18756,12 +18981,12 @@ async function cmdDoctor(args, flags) {
     { path: PATHS.cache, name: "Cache" }
   ];
   for (const dir of dirs) {
-    const exists = import_fs12.default.existsSync(dir.path);
+    const exists = import_fs13.default.existsSync(dir.path);
     const status = exists ? "\u2713" : "\u2717";
     console.log(`  ${status} ${dir.name}: ${dir.path}`);
     if (!exists) {
       issues.push(`Missing directory: ${dir.name}`);
-      fixes.push(() => import_fs12.default.mkdirSync(dir.path, { recursive: true }));
+      fixes.push(() => import_fs13.default.mkdirSync(dir.path, { recursive: true }));
     }
   }
   console.log("\n\u{1F4BE} Database");
@@ -18798,10 +19023,40 @@ async function cmdDoctor(args, flags) {
   } catch (error) {
     console.log(`  \u2717 Error reading secrets: ${error.message}`);
   }
-  console.log("\n\u2699\uFE0F  Environment");
+  console.log("\n\u2699\uFE0F  Runtimes");
+  try {
+    const { runtimes, binaries } = flags.all ? await getAllDepsFromRegistry() : getAvailableDeps();
+    for (const rt of runtimes) {
+      const icon = rt.available ? "\u2713" : "\u25CB";
+      const version = rt.version ? `v${rt.version}` : "";
+      const source = rt.available ? `(${rt.source})` : flags.all ? "available" : "not found";
+      console.log(`  ${icon} ${rt.name}: ${version} ${source}`);
+    }
+    console.log("\n\u{1F527} Binaries");
+    for (const bin of binaries) {
+      const icon = bin.available ? "\u2713" : "\u25CB";
+      const version = bin.version ? `v${bin.version}` : "";
+      const managed = bin.managed === false ? " (external)" : "";
+      const source = bin.available ? `(${bin.source})` : flags.all ? `available${managed}` : "not found";
+      console.log(`  ${icon} ${bin.name}: ${version} ${source}`);
+    }
+    if (flags.all) {
+      const availableRuntimes = runtimes.filter((r) => !r.available).length;
+      const availableBinaries = binaries.filter((b) => !b.available && b.managed !== false).length;
+      if (availableRuntimes + availableBinaries > 0) {
+        console.log(`
+  Install with: rudi install runtime:<name> or rudi install binary:<name>`);
+      }
+    }
+  } catch (error) {
+    console.log(`  \u2717 Error checking dependencies: ${error.message}`);
+  }
+  console.log("\n\u{1F4CD} Environment");
   const nodeVersion = process.version;
   const nodeOk = parseInt(nodeVersion.slice(1)) >= 18;
   console.log(`  ${nodeOk ? "\u2713" : "\u2717"} Node.js: ${nodeVersion} ${nodeOk ? "" : "(requires >=18)"}`);
+  console.log(`  \u2713 Platform: ${process.platform}-${process.arch}`);
+  console.log(`  \u2713 RUDI Home: ${PATHS.home}`);
   if (!nodeOk) {
     issues.push("Node.js version too old (requires >=18)");
   }
@@ -18831,9 +19086,9 @@ async function cmdDoctor(args, flags) {
 }
 
 // src/commands/update.js
-var import_fs13 = __toESM(require("fs"), 1);
-var import_path12 = __toESM(require("path"), 1);
-var import_child_process2 = require("child_process");
+var import_fs14 = __toESM(require("fs"), 1);
+var import_path13 = __toESM(require("path"), 1);
+var import_child_process3 = require("child_process");
 init_src();
 init_src2();
 async function cmdUpdate(args, flags) {
@@ -18858,7 +19113,7 @@ async function cmdUpdate(args, flags) {
 async function updatePackage(pkgId, flags) {
   const [kind, name] = parsePackageId(pkgId);
   const installPath = getPackagePath(pkgId);
-  if (!import_fs13.default.existsSync(installPath)) {
+  if (!import_fs14.default.existsSync(installPath)) {
     return { success: false, error: "Package not installed" };
   }
   const pkg = await getPackage(pkgId);
@@ -18868,7 +19123,7 @@ async function updatePackage(pkgId, flags) {
   console.log(`Updating ${pkgId}...`);
   if (pkg.npmPackage) {
     try {
-      (0, import_child_process2.execSync)(`npm install ${pkg.npmPackage}@latest`, {
+      (0, import_child_process3.execSync)(`npm install ${pkg.npmPackage}@latest`, {
         cwd: installPath,
         stdio: flags.verbose ? "inherit" : "pipe"
       });
@@ -18881,11 +19136,11 @@ async function updatePackage(pkgId, flags) {
   }
   if (pkg.pipPackage) {
     try {
-      const venvPip = import_path12.default.join(installPath, "venv", "bin", "pip");
-      (0, import_child_process2.execSync)(`"${venvPip}" install --upgrade ${pkg.pipPackage}`, {
+      const venvPip = import_path13.default.join(installPath, "venv", "bin", "pip");
+      (0, import_child_process3.execSync)(`"${venvPip}" install --upgrade ${pkg.pipPackage}`, {
         stdio: flags.verbose ? "inherit" : "pipe"
       });
-      const versionOutput = (0, import_child_process2.execSync)(`"${venvPip}" show ${pkg.pipPackage} | grep Version`, {
+      const versionOutput = (0, import_child_process3.execSync)(`"${venvPip}" show ${pkg.pipPackage} | grep Version`, {
         encoding: "utf-8"
       });
       const version = versionOutput.split(":")[1]?.trim();
@@ -18898,7 +19153,7 @@ async function updatePackage(pkgId, flags) {
   if (kind === "runtime" && !pkg.npmPackage && !pkg.pipPackage) {
     try {
       const { downloadRuntime: downloadRuntime2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
-      import_fs13.default.rmSync(installPath, { recursive: true, force: true });
+      import_fs14.default.rmSync(installPath, { recursive: true, force: true });
       await downloadRuntime2(name, pkg.version || "latest", installPath, {
         onProgress: (p) => {
           if (flags.verbose) console.log(`  ${p.phase}...`);
@@ -18918,8 +19173,8 @@ async function updateAll(flags) {
   let failed = 0;
   for (const kind of kinds) {
     const dir = kind === "runtime" ? PATHS.runtimes : kind === "stack" ? PATHS.stacks : PATHS.prompts;
-    if (!import_fs13.default.existsSync(dir)) continue;
-    const entries = import_fs13.default.readdirSync(dir, { withFileTypes: true });
+    if (!import_fs14.default.existsSync(dir)) continue;
+    const entries = import_fs14.default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       const pkgId = `${kind}:${entry.name}`;
@@ -18938,14 +19193,14 @@ Updated ${updated} package(s)${failed > 0 ? `, ${failed} failed` : ""}`);
 }
 function getInstalledVersion(installPath, npmPackage) {
   try {
-    const pkgJsonPath = import_path12.default.join(installPath, "node_modules", npmPackage.replace("@", "").split("/")[0], "package.json");
-    if (import_fs13.default.existsSync(pkgJsonPath)) {
-      const pkgJson = JSON.parse(import_fs13.default.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJsonPath = import_path13.default.join(installPath, "node_modules", npmPackage.replace("@", "").split("/")[0], "package.json");
+    if (import_fs14.default.existsSync(pkgJsonPath)) {
+      const pkgJson = JSON.parse(import_fs14.default.readFileSync(pkgJsonPath, "utf-8"));
       return pkgJson.version;
     }
-    const rootPkgPath = import_path12.default.join(installPath, "package.json");
-    if (import_fs13.default.existsSync(rootPkgPath)) {
-      const rootPkg = JSON.parse(import_fs13.default.readFileSync(rootPkgPath, "utf-8"));
+    const rootPkgPath = import_path13.default.join(installPath, "package.json");
+    if (import_fs14.default.existsSync(rootPkgPath)) {
+      const rootPkg = JSON.parse(import_fs14.default.readFileSync(rootPkgPath, "utf-8"));
       const dep = rootPkg.dependencies?.[npmPackage];
       if (dep) return dep.replace(/[\^~]/, "");
     }
@@ -18954,30 +19209,30 @@ function getInstalledVersion(installPath, npmPackage) {
   return null;
 }
 function updateRuntimeMetadata(installPath, updates) {
-  const metaPath = import_path12.default.join(installPath, "runtime.json");
+  const metaPath = import_path13.default.join(installPath, "runtime.json");
   try {
     let meta = {};
-    if (import_fs13.default.existsSync(metaPath)) {
-      meta = JSON.parse(import_fs13.default.readFileSync(metaPath, "utf-8"));
+    if (import_fs14.default.existsSync(metaPath)) {
+      meta = JSON.parse(import_fs14.default.readFileSync(metaPath, "utf-8"));
     }
     meta = { ...meta, ...updates };
-    import_fs13.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+    import_fs14.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
   } catch {
   }
 }
 
 // db/index.js
 var import_better_sqlite32 = __toESM(require("better-sqlite3"), 1);
-var import_path13 = __toESM(require("path"), 1);
+var import_path14 = __toESM(require("path"), 1);
 var import_os4 = __toESM(require("os"), 1);
-var import_fs14 = __toESM(require("fs"), 1);
-var PROMPT_STACK_HOME = import_path13.default.join(import_os4.default.homedir(), ".prompt-stack");
-var DB_PATH2 = import_path13.default.join(PROMPT_STACK_HOME, "prompt-stack.db");
+var import_fs15 = __toESM(require("fs"), 1);
+var RUDI_HOME2 = import_path14.default.join(import_os4.default.homedir(), ".rudi");
+var DB_PATH2 = import_path14.default.join(RUDI_HOME2, "rudi.db");
 var db2 = null;
 function getDb2(options = {}) {
   if (!db2) {
-    if (!import_fs14.default.existsSync(PROMPT_STACK_HOME)) {
-      import_fs14.default.mkdirSync(PROMPT_STACK_HOME, { recursive: true });
+    if (!import_fs15.default.existsSync(RUDI_HOME2)) {
+      import_fs15.default.mkdirSync(RUDI_HOME2, { recursive: true });
     }
     db2 = new import_better_sqlite32.default(DB_PATH2, {
       readonly: options.readonly || false
@@ -19135,7 +19390,7 @@ function getBeforeCrashLogs() {
 }
 
 // src/commands/logs.js
-var import_fs15 = __toESM(require("fs"), 1);
+var import_fs16 = __toESM(require("fs"), 1);
 function parseTimeAgo(str) {
   const match = str.match(/^(\d+)([smhd])$/);
   if (!match) return null;
@@ -19235,7 +19490,7 @@ function exportLogs(logs, filepath, format) {
       });
       content = JSON.stringify(formatted, null, 2);
   }
-  import_fs15.default.writeFileSync(filepath, content, "utf-8");
+  import_fs16.default.writeFileSync(filepath, content, "utf-8");
   return filepath;
 }
 function printStats(stats) {
@@ -19361,9 +19616,9 @@ async function handleLogsCommand(args, flags) {
 }
 
 // src/commands/which.js
-var fs16 = __toESM(require("fs/promises"), 1);
-var path14 = __toESM(require("path"), 1);
-var import_child_process3 = require("child_process");
+var fs17 = __toESM(require("fs/promises"), 1);
+var path15 = __toESM(require("path"), 1);
+var import_child_process4 = require("child_process");
 init_src();
 async function cmdWhich(args, flags) {
   const stackId = args[0];
@@ -19431,7 +19686,7 @@ Installed stacks:`);
     if (runtimeInfo.entry) {
       console.log("");
       console.log("Run MCP server directly:");
-      const entryPath = path14.join(stackPath, runtimeInfo.entry);
+      const entryPath = path15.join(stackPath, runtimeInfo.entry);
       if (runtimeInfo.runtime === "node") {
         console.log(`  echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | node ${entryPath}`);
       } else if (runtimeInfo.runtime === "python") {
@@ -19450,27 +19705,27 @@ Installed stacks:`);
 async function detectRuntime(stackPath) {
   const runtimes = ["node", "python"];
   for (const runtime of runtimes) {
-    const runtimePath = path14.join(stackPath, runtime);
+    const runtimePath = path15.join(stackPath, runtime);
     try {
-      await fs16.access(runtimePath);
+      await fs17.access(runtimePath);
       if (runtime === "node") {
-        const distEntry = path14.join(runtimePath, "dist", "index.js");
-        const srcEntry = path14.join(runtimePath, "src", "index.ts");
+        const distEntry = path15.join(runtimePath, "dist", "index.js");
+        const srcEntry = path15.join(runtimePath, "src", "index.ts");
         try {
-          await fs16.access(distEntry);
+          await fs17.access(distEntry);
           return { runtime: "node", entry: `${runtime}/dist/index.js` };
         } catch {
           try {
-            await fs16.access(srcEntry);
+            await fs17.access(srcEntry);
             return { runtime: "node", entry: `${runtime}/src/index.ts` };
           } catch {
             return { runtime: "node", entry: null };
           }
         }
       } else if (runtime === "python") {
-        const entry = path14.join(runtimePath, "src", "index.py");
+        const entry = path15.join(runtimePath, "src", "index.py");
         try {
-          await fs16.access(entry);
+          await fs17.access(entry);
           return { runtime: "python", entry: `${runtime}/src/index.py` };
         } catch {
           return { runtime: "python", entry: null };
@@ -19486,21 +19741,21 @@ async function checkAuth(stackPath, runtime) {
   const authFiles = [];
   let configured = false;
   if (runtime === "node" || runtime === "python") {
-    const runtimePath = path14.join(stackPath, runtime);
-    const tokenPath = path14.join(runtimePath, "token.json");
+    const runtimePath = path15.join(stackPath, runtime);
+    const tokenPath = path15.join(runtimePath, "token.json");
     try {
-      await fs16.access(tokenPath);
+      await fs17.access(tokenPath);
       authFiles.push(`${runtime}/token.json`);
       configured = true;
     } catch {
-      const accountsPath = path14.join(runtimePath, "accounts");
+      const accountsPath = path15.join(runtimePath, "accounts");
       try {
-        const accounts = await fs16.readdir(accountsPath);
+        const accounts = await fs17.readdir(accountsPath);
         for (const account of accounts) {
           if (account.startsWith(".")) continue;
-          const accountTokenPath = path14.join(accountsPath, account, "token.json");
+          const accountTokenPath = path15.join(accountsPath, account, "token.json");
           try {
-            await fs16.access(accountTokenPath);
+            await fs17.access(accountTokenPath);
             authFiles.push(`${runtime}/accounts/${account}/token.json`);
             configured = true;
           } catch {
@@ -19510,9 +19765,9 @@ async function checkAuth(stackPath, runtime) {
       }
     }
   }
-  const envPath = path14.join(stackPath, ".env");
+  const envPath = path15.join(stackPath, ".env");
   try {
-    const envContent = await fs16.readFile(envPath, "utf-8");
+    const envContent = await fs17.readFile(envPath, "utf-8");
     const hasValues = envContent.split("\n").some((line) => {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) return false;
@@ -19541,7 +19796,7 @@ async function checkAuth(stackPath, runtime) {
 }
 function checkIfRunning(stackName) {
   try {
-    const result = (0, import_child_process3.execSync)(`ps aux | grep "${stackName}" | grep -v grep || true`, {
+    const result = (0, import_child_process4.execSync)(`ps aux | grep "${stackName}" | grep -v grep || true`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "ignore"]
       // Suppress stderr
@@ -19556,9 +19811,9 @@ function checkIfRunning(stackName) {
 }
 
 // src/commands/auth.js
-var fs17 = __toESM(require("fs/promises"), 1);
-var path15 = __toESM(require("path"), 1);
-var import_child_process4 = require("child_process");
+var fs18 = __toESM(require("fs/promises"), 1);
+var path16 = __toESM(require("path"), 1);
+var import_child_process5 = require("child_process");
 init_src();
 var net = __toESM(require("net"), 1);
 async function findAvailablePort(basePort = 3456) {
@@ -19589,26 +19844,26 @@ function isPortAvailable(port) {
 async function detectRuntime2(stackPath) {
   const runtimes = ["node", "python"];
   for (const runtime of runtimes) {
-    const runtimePath = path15.join(stackPath, runtime);
+    const runtimePath = path16.join(stackPath, runtime);
     try {
-      await fs17.access(runtimePath);
+      await fs18.access(runtimePath);
       if (runtime === "node") {
-        const authTs = path15.join(runtimePath, "src", "auth.ts");
-        const authJs = path15.join(runtimePath, "dist", "auth.js");
+        const authTs = path16.join(runtimePath, "src", "auth.ts");
+        const authJs = path16.join(runtimePath, "dist", "auth.js");
         try {
-          await fs17.access(authTs);
+          await fs18.access(authTs);
           return { runtime: "node", authScript: authTs, useTsx: true };
         } catch {
           try {
-            await fs17.access(authJs);
+            await fs18.access(authJs);
             return { runtime: "node", authScript: authJs, useTsx: false };
           } catch {
           }
         }
       } else if (runtime === "python") {
-        const authPy = path15.join(runtimePath, "src", "auth.py");
+        const authPy = path16.join(runtimePath, "src", "auth.py");
         try {
-          await fs17.access(authPy);
+          await fs18.access(authPy);
           return { runtime: "python", authScript: authPy, useTsx: false };
         } catch {
         }
@@ -19658,14 +19913,14 @@ Installed stacks:`);
     console.log(`Using port: ${port}`);
     console.log("");
     let cmd;
-    const cwd = path15.dirname(authInfo.authScript);
+    const cwd = path16.dirname(authInfo.authScript);
     if (authInfo.runtime === "node") {
-      const distAuth = path15.join(cwd, "..", "dist", "auth.js");
+      const distAuth = path16.join(cwd, "..", "dist", "auth.js");
       let useBuiltInPort = false;
       let tempAuthScript = null;
       try {
-        await fs17.access(distAuth);
-        const distContent = await fs17.readFile(distAuth, "utf-8");
+        await fs18.access(distAuth);
+        const distContent = await fs18.readFile(distAuth, "utf-8");
         if (distContent.includes("findAvailablePort")) {
           console.log("Using compiled authentication script...");
           cmd = `node ${distAuth}${accountEmail ? ` ${accountEmail}` : ""}`;
@@ -19674,11 +19929,11 @@ Installed stacks:`);
       } catch {
       }
       if (!useBuiltInPort) {
-        const authContent = await fs17.readFile(authInfo.authScript, "utf-8");
+        const authContent = await fs18.readFile(authInfo.authScript, "utf-8");
         const tempExt = authInfo.useTsx ? ".ts" : ".mjs";
-        tempAuthScript = path15.join(cwd, "..", `auth-temp${tempExt}`);
+        tempAuthScript = path16.join(cwd, "..", `auth-temp${tempExt}`);
         const modifiedContent = authContent.replace(/localhost:3456/g, `localhost:${port}`).replace(/server\.listen\(3456/g, `server.listen(${port}`);
-        await fs17.writeFile(tempAuthScript, modifiedContent);
+        await fs18.writeFile(tempAuthScript, modifiedContent);
         if (authInfo.useTsx) {
           cmd = `npx tsx ${tempAuthScript}${accountEmail ? ` ${accountEmail}` : ""}`;
         } else {
@@ -19688,17 +19943,17 @@ Installed stacks:`);
       console.log("Starting OAuth flow...");
       console.log("");
       try {
-        (0, import_child_process4.execSync)(cmd, {
+        (0, import_child_process5.execSync)(cmd, {
           cwd,
           stdio: "inherit"
         });
         if (tempAuthScript) {
-          await fs17.unlink(tempAuthScript);
+          await fs18.unlink(tempAuthScript);
         }
       } catch (error) {
         if (tempAuthScript) {
           try {
-            await fs17.unlink(tempAuthScript);
+            await fs18.unlink(tempAuthScript);
           } catch {
           }
         }
@@ -19708,7 +19963,7 @@ Installed stacks:`);
       cmd = `python3 ${authInfo.authScript}${accountEmail ? ` ${accountEmail}` : ""}`;
       console.log("Starting OAuth flow...");
       console.log("");
-      (0, import_child_process4.execSync)(cmd, {
+      (0, import_child_process5.execSync)(cmd, {
         cwd,
         stdio: "inherit",
         env: {