@craftspace/cli 0.1.0 → 0.2.1

package/dist/index.js

@@ -1199,9 +1199,9 @@ var require_command = __commonJS({
   "../../../node_modules/commander/lib/command.js"(exports) {
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
-    var path3 = __require("node:path");
+    var path5 = __require("node:path");
     var fs = __require("node:fs");
-    var process3 = __require("node:process");
+    var process5 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
     var { Help: Help2, stripColor } = require_help();
@@ -1248,13 +1248,13 @@ var require_command = __commonJS({
         this._showSuggestionAfterError = true;
         this._savedState = null;
         this._outputConfiguration = {
-          writeOut: (str) => process3.stdout.write(str),
-          writeErr: (str) => process3.stderr.write(str),
+          writeOut: (str) => process5.stdout.write(str),
+          writeErr: (str) => process5.stderr.write(str),
           outputError: (str, write) => write(str),
-          getOutHelpWidth: () => process3.stdout.isTTY ? process3.stdout.columns : void 0,
-          getErrHelpWidth: () => process3.stderr.isTTY ? process3.stderr.columns : void 0,
-          getOutHasColors: () => useColor() ?? (process3.stdout.isTTY && process3.stdout.hasColors?.()),
-          getErrHasColors: () => useColor() ?? (process3.stderr.isTTY && process3.stderr.hasColors?.()),
+          getOutHelpWidth: () => process5.stdout.isTTY ? process5.stdout.columns : void 0,
+          getErrHelpWidth: () => process5.stderr.isTTY ? process5.stderr.columns : void 0,
+          getOutHasColors: () => useColor() ?? (process5.stdout.isTTY && process5.stdout.hasColors?.()),
+          getErrHasColors: () => useColor() ?? (process5.stderr.isTTY && process5.stderr.hasColors?.()),
           stripColor: (str) => stripColor(str)
         };
         this._hidden = false;
@@ -1648,7 +1648,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._exitCallback) {
           this._exitCallback(new CommanderError2(exitCode, code, message));
         }
-        process3.exit(exitCode);
+        process5.exit(exitCode);
       }
       /**
        * Register callback `fn` for the command.
@@ -2048,16 +2048,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         parseOptions = parseOptions || {};
         if (argv === void 0 && parseOptions.from === void 0) {
-          if (process3.versions?.electron) {
+          if (process5.versions?.electron) {
             parseOptions.from = "electron";
           }
-          const execArgv = process3.execArgv ?? [];
+          const execArgv = process5.execArgv ?? [];
           if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
             parseOptions.from = "eval";
           }
         }
         if (argv === void 0) {
-          argv = process3.argv;
+          argv = process5.argv;
         }
         this.rawArgs = argv.slice();
         let userArgs;
@@ -2068,7 +2068,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             userArgs = argv.slice(2);
             break;
           case "electron":
-            if (process3.defaultApp) {
+            if (process5.defaultApp) {
               this._scriptPath = argv[1];
               userArgs = argv.slice(2);
             } else {
@@ -2212,9 +2212,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path3.resolve(baseDir, baseName);
+          const localBin = path5.resolve(baseDir, baseName);
           if (fs.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path3.extname(baseName))) return void 0;
+          if (sourceExt.includes(path5.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs.existsSync(`${localBin}${ext}`)
           );
@@ -2232,17 +2232,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path3.resolve(
-            path3.dirname(resolvedScriptPath),
+          executableDir = path5.resolve(
+            path5.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path3.basename(
+            const legacyName = path5.basename(
               this._scriptPath,
-              path3.extname(this._scriptPath)
+              path5.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2253,13 +2253,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path3.extname(executableFile));
+        launchWithNode = sourceExt.includes(path5.extname(executableFile));
         let proc;
-        if (process3.platform !== "win32") {
+        if (process5.platform !== "win32") {
           if (launchWithNode) {
             args.unshift(executableFile);
-            args = incrementNodeInspectorPort(process3.execArgv).concat(args);
-            proc = childProcess.spawn(process3.argv[0], args, { stdio: "inherit" });
+            args = incrementNodeInspectorPort(process5.execArgv).concat(args);
+            proc = childProcess.spawn(process5.argv[0], args, { stdio: "inherit" });
           } else {
             proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
           }
@@ -2270,13 +2270,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
             subcommand._name
           );
           args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process3.execArgv).concat(args);
-          proc = childProcess.spawn(process3.execPath, args, { stdio: "inherit" });
+          args = incrementNodeInspectorPort(process5.execArgv).concat(args);
+          proc = childProcess.spawn(process5.execPath, args, { stdio: "inherit" });
         }
         if (!proc.killed) {
-          const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
-          signals.forEach((signal) => {
-            process3.on(signal, () => {
+          const signals2 = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
+          signals2.forEach((signal) => {
+            process5.on(signal, () => {
               if (proc.killed === false && proc.exitCode === null) {
                 proc.kill(signal);
               }
@@ -2287,7 +2287,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         proc.on("close", (code) => {
           code = code ?? 1;
           if (!exitCallback) {
-            process3.exit(code);
+            process5.exit(code);
           } else {
             exitCallback(
               new CommanderError2(
@@ -2309,7 +2309,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             throw new Error(`'${executableFile}' not executable`);
           }
           if (!exitCallback) {
-            process3.exit(1);
+            process5.exit(1);
           } else {
             const wrappedError = new CommanderError2(
               1,
@@ -2809,13 +2809,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       _parseOptionsEnv() {
         this.options.forEach((option) => {
-          if (option.envVar && option.envVar in process3.env) {
+          if (option.envVar && option.envVar in process5.env) {
             const optionKey = option.attributeName();
             if (this.getOptionValue(optionKey) === void 0 || ["default", "config", "env"].includes(
               this.getOptionValueSource(optionKey)
             )) {
               if (option.required || option.optional) {
-                this.emit(`optionEnv:${option.name()}`, process3.env[option.envVar]);
+                this.emit(`optionEnv:${option.name()}`, process5.env[option.envVar]);
               } else {
                 this.emit(`optionEnv:${option.name()}`);
               }
@@ -3168,7 +3168,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path3.basename(filename, path3.extname(filename));
+        this._name = path5.basename(filename, path5.extname(filename));
         return this;
       }
       /**
@@ -3182,9 +3182,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path4) {
-        if (path4 === void 0) return this._executableDir;
-        this._executableDir = path4;
+      executableDir(path6) {
+        if (path6 === void 0) return this._executableDir;
+        this._executableDir = path6;
         return this;
       }
       /**
@@ -3339,7 +3339,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       help(contextOptions) {
         this.outputHelp(contextOptions);
-        let exitCode = Number(process3.exitCode ?? 0);
+        let exitCode = Number(process5.exitCode ?? 0);
         if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
           exitCode = 1;
         }
@@ -3429,9 +3429,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
     }
     function useColor() {
-      if (process3.env.NO_COLOR || process3.env.FORCE_COLOR === "0" || process3.env.FORCE_COLOR === "false")
+      if (process5.env.NO_COLOR || process5.env.FORCE_COLOR === "0" || process5.env.FORCE_COLOR === "false")
         return false;
-      if (process3.env.FORCE_COLOR || process3.env.CLICOLOR_FORCE !== void 0)
+      if (process5.env.FORCE_COLOR || process5.env.CLICOLOR_FORCE !== void 0)
         return true;
       return void 0;
     }
@@ -3462,6 +3462,171 @@ var require_commander = __commonJS({
   }
 });
 
+// ../../../node_modules/cli-width/index.js
+var require_cli_width = __commonJS({
+  "../../../node_modules/cli-width/index.js"(exports, module) {
+    "use strict";
+    module.exports = cliWidth2;
+    function normalizeOpts(options) {
+      const defaultOpts = {
+        defaultWidth: 0,
+        output: process.stdout,
+        tty: __require("tty")
+      };
+      if (!options) {
+        return defaultOpts;
+      }
+      Object.keys(defaultOpts).forEach(function(key) {
+        if (!options[key]) {
+          options[key] = defaultOpts[key];
+        }
+      });
+      return options;
+    }
+    function cliWidth2(options) {
+      const opts = normalizeOpts(options);
+      if (opts.output.getWindowSize) {
+        return opts.output.getWindowSize()[0] || opts.defaultWidth;
+      }
+      if (opts.tty.getWindowSize) {
+        return opts.tty.getWindowSize()[1] || opts.defaultWidth;
+      }
+      if (opts.output.columns) {
+        return opts.output.columns;
+      }
+      if (process.env.CLI_WIDTH) {
+        const width = parseInt(process.env.CLI_WIDTH, 10);
+        if (!isNaN(width) && width !== 0) {
+          return width;
+        }
+      }
+      return opts.defaultWidth;
+    }
+  }
+});
+
+// ../../../node_modules/mute-stream/lib/index.js
+var require_lib = __commonJS({
+  "../../../node_modules/mute-stream/lib/index.js"(exports, module) {
+    var Stream = __require("stream");
+    var MuteStream2 = class extends Stream {
+      #isTTY = null;
+      constructor(opts = {}) {
+        super(opts);
+        this.writable = this.readable = true;
+        this.muted = false;
+        this.on("pipe", this._onpipe);
+        this.replace = opts.replace;
+        this._prompt = opts.prompt || null;
+        this._hadControl = false;
+      }
+      #destSrc(key, def) {
+        if (this._dest) {
+          return this._dest[key];
+        }
+        if (this._src) {
+          return this._src[key];
+        }
+        return def;
+      }
+      #proxy(method, ...args) {
+        if (typeof this._dest?.[method] === "function") {
+          this._dest[method](...args);
+        }
+        if (typeof this._src?.[method] === "function") {
+          this._src[method](...args);
+        }
+      }
+      get isTTY() {
+        if (this.#isTTY !== null) {
+          return this.#isTTY;
+        }
+        return this.#destSrc("isTTY", false);
+      }
+      // basically just get replace the getter/setter with a regular value
+      set isTTY(val) {
+        this.#isTTY = val;
+      }
+      get rows() {
+        return this.#destSrc("rows");
+      }
+      get columns() {
+        return this.#destSrc("columns");
+      }
+      mute() {
+        this.muted = true;
+      }
+      unmute() {
+        this.muted = false;
+      }
+      _onpipe(src) {
+        this._src = src;
+      }
+      pipe(dest, options) {
+        this._dest = dest;
+        return super.pipe(dest, options);
+      }
+      pause() {
+        if (this._src) {
+          return this._src.pause();
+        }
+      }
+      resume() {
+        if (this._src) {
+          return this._src.resume();
+        }
+      }
+      write(c) {
+        if (this.muted) {
+          if (!this.replace) {
+            return true;
+          }
+          if (c.match(/^\u001b/)) {
+            if (c.indexOf(this._prompt) === 0) {
+              c = c.slice(this._prompt.length);
+              c = c.replace(/./g, this.replace);
+              c = this._prompt + c;
+            }
+            this._hadControl = true;
+            return this.emit("data", c);
+          } else {
+            if (this._prompt && this._hadControl && c.indexOf(this._prompt) === 0) {
+              this._hadControl = false;
+              this.emit("data", this._prompt);
+              c = c.slice(this._prompt.length);
+            }
+            c = c.toString().replace(/./g, this.replace);
+          }
+        }
+        this.emit("data", c);
+      }
+      end(c) {
+        if (this.muted) {
+          if (c && this.replace) {
+            c = c.toString().replace(/./g, this.replace);
+          } else {
+            c = null;
+          }
+        }
+        if (c) {
+          this.emit("data", c);
+        }
+        this.emit("end");
+      }
+      destroy(...args) {
+        return this.#proxy("destroy", ...args);
+      }
+      destroySoon(...args) {
+        return this.#proxy("destroySoon", ...args);
+      }
+      close(...args) {
+        return this.#proxy("close", ...args);
+      }
+    };
+    module.exports = MuteStream2;
+  }
+});
+
 // ../../../node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
 var {
@@ -4245,10 +4410,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path5) {
+  if (!path5)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path5.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4657,11 +4822,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path5, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path5);
     return iss;
   });
 }
@@ -4808,16 +4973,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path3 = []) => {
+  const processError = (error52, path5 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path5, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -4844,17 +5009,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path3 = []) => {
+  const processError = (error52, path5 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path5, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -4886,8 +5051,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path5) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17579,13 +17744,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path3 = ref.slice(1).split("/").filter(Boolean);
-  if (path3.length === 0) {
+  const path5 = ref.slice(1).split("/").filter(Boolean);
+  if (path5.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path3[0] === defsKey) {
-    const key = path3[1];
+  if (path5[0] === defsKey) {
+    const key = path5[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -19093,6 +19258,12 @@ var CreateConnectionBodySchema = external_exports.object({
   // sent it, and can start a connect for that one kit and nothing else.
   inviteToken: external_exports.string().optional()
 });
+var ReplaceConnectionSecretBodySchema = external_exports.object({
+  mcpUrl: external_exports.url().optional(),
+  authToken: external_exports.string().min(1).optional(),
+  dsn: external_exports.string().min(1).optional(),
+  apiKey: external_exports.string().min(1).optional()
+});
 var ConnectionIdParamsSchema = external_exports.object({ id: external_exports.string() });
 var PendingOAuthSchema = external_exports.object({
   id: external_exports.string(),
@@ -19589,7 +19760,7 @@ var SaveWorkstationBodySchema = external_exports.object({
 var WorkstationResponseSchema = external_exports.object({ workstation: WorkstationSchema });
 
 // ../../shared/dist/machines/machine.js
-var CLI_VERSION = "0.1.0";
+var CLI_VERSION = "0.2.0";
 var MACHINE_BEAT_INTERVAL_MS = 15e3;
 var MACHINE_BEAT_BUSY_INTERVAL_MS = 3e3;
 var MACHINE_RUN_OUTPUT_MAX = 32e3;
@@ -20056,12 +20227,1877 @@ var MemberActivityListResponse = external_exports.object({
 // dist/machine.js
 import { execFile as execFile3 } from "node:child_process";
 import { mkdir, readFile as readFile2, readdir, rm, writeFile } from "node:fs/promises";
-import os2 from "node:os";
-import path2 from "node:path";
+import os4 from "node:os";
+import path4 from "node:path";
 import { promisify as promisify3 } from "node:util";
 
+// ../../../node_modules/@inquirer/core/dist/lib/key.js
+var keybindings = ["emacs", "vim"];
+var keybindingLookup = new Set(keybindings);
+function isKeybinding(value) {
+  return keybindingLookup.has(value);
+}
+function getDefaultKeybindings() {
+  const env = process.env["INQUIRER_KEYBINDINGS"];
+  if (!env)
+    return [];
+  return Array.from(new Set(env.toLowerCase().split(/[\s,]+/).filter(isKeybinding)));
+}
+var isUpKey = (key, keybindings2 = []) => (
+  // The up key
+  key.name === "up" || // Vim keybinding: hjkl keys map to left/down/up/right
+  keybindings2.includes("vim") && key.name === "k" || // Emacs keybinding: Ctrl+P means "previous" in Emacs navigation conventions
+  keybindings2.includes("emacs") && key.ctrl && key.name === "p"
+);
+var isDownKey = (key, keybindings2 = []) => (
+  // The down key
+  key.name === "down" || // Vim keybinding: hjkl keys map to left/down/up/right
+  keybindings2.includes("vim") && key.name === "j" || // Emacs keybinding: Ctrl+N means "next" in Emacs navigation conventions
+  keybindings2.includes("emacs") && key.ctrl && key.name === "n"
+);
+var isBackspaceKey = (key) => key.name === "backspace";
+var isTabKey = (key) => key.name === "tab";
+var isNumberKey = (key) => "1234567890".includes(key.name);
+var isEnterKey = (key) => key.name === "enter" || key.name === "return";
+
+// ../../../node_modules/@inquirer/core/dist/lib/errors.js
+var AbortPromptError = class extends Error {
+  name = "AbortPromptError";
+  message = "Prompt was aborted";
+  constructor(options) {
+    super();
+    this.cause = options?.cause;
+  }
+};
+var CancelPromptError = class extends Error {
+  name = "CancelPromptError";
+  message = "Prompt was canceled";
+};
+var ExitPromptError = class extends Error {
+  name = "ExitPromptError";
+};
+var HookError = class extends Error {
+  name = "HookError";
+};
+var ValidationError = class extends Error {
+  name = "ValidationError";
+};
+
+// ../../../node_modules/@inquirer/core/dist/lib/use-state.js
+import { AsyncResource as AsyncResource2 } from "node:async_hooks";
+
+// ../../../node_modules/@inquirer/core/dist/lib/hook-engine.js
+import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
+var hookStorage = new AsyncLocalStorage();
+function createStore(rl) {
+  const store = {
+    rl,
+    hooks: [],
+    hooksCleanup: [],
+    hooksEffect: [],
+    index: 0,
+    handleChange() {
+    }
+  };
+  return store;
+}
+function withHooks(rl, cb) {
+  const store = createStore(rl);
+  return hookStorage.run(store, () => {
+    function cycle(render) {
+      store.handleChange = () => {
+        store.index = 0;
+        render();
+      };
+      store.handleChange();
+    }
+    return cb(cycle);
+  });
+}
+function getStore() {
+  const store = hookStorage.getStore();
+  if (!store) {
+    throw new HookError("[Inquirer] Hook functions can only be called from within a prompt");
+  }
+  return store;
+}
+function readline() {
+  return getStore().rl;
+}
+function withUpdates(fn) {
+  const wrapped = (...args) => {
+    const store = getStore();
+    let shouldUpdate = false;
+    const oldHandleChange = store.handleChange;
+    store.handleChange = () => {
+      shouldUpdate = true;
+    };
+    const returnValue = fn(...args);
+    if (shouldUpdate) {
+      oldHandleChange();
+    }
+    store.handleChange = oldHandleChange;
+    return returnValue;
+  };
+  return AsyncResource.bind(wrapped);
+}
+function withPointer(cb) {
+  const store = getStore();
+  const { index } = store;
+  const pointer = {
+    get() {
+      return store.hooks[index];
+    },
+    set(value) {
+      store.hooks[index] = value;
+    },
+    initialized: index in store.hooks
+  };
+  const returnValue = cb(pointer);
+  store.index++;
+  return returnValue;
+}
+function handleChange() {
+  getStore().handleChange();
+}
+var effectScheduler = {
+  queue(cb) {
+    const store = getStore();
+    const { index } = store;
+    store.hooksEffect.push(() => {
+      store.hooksCleanup[index]?.();
+      const cleanFn = cb(readline());
+      if (cleanFn != null && typeof cleanFn !== "function") {
+        throw new ValidationError("useEffect return value must be a cleanup function or nothing.");
+      }
+      store.hooksCleanup[index] = cleanFn;
+    });
+  },
+  run() {
+    const store = getStore();
+    withUpdates(() => {
+      store.hooksEffect.forEach((effect) => {
+        effect();
+      });
+      store.hooksEffect.length = 0;
+    })();
+  },
+  clearAll() {
+    const store = getStore();
+    store.hooksCleanup.forEach((cleanFn) => {
+      cleanFn?.();
+    });
+    store.hooksEffect.length = 0;
+    store.hooksCleanup.length = 0;
+  }
+};
+
+// ../../../node_modules/@inquirer/core/dist/lib/use-state.js
+function isFactory(value) {
+  return typeof value === "function";
+}
+function isReducer(value) {
+  return typeof value === "function";
+}
+function useState(defaultValue) {
+  return withPointer((pointer) => {
+    const setState = AsyncResource2.bind(function setState2(newValue) {
+      const currentValue = pointer.get();
+      const nextValue = isReducer(newValue) ? newValue(currentValue) : newValue;
+      if (!Object.is(currentValue, nextValue)) {
+        pointer.set(nextValue);
+        handleChange();
+      }
+    });
+    if (pointer.initialized) {
+      return [pointer.get(), setState];
+    }
+    const value = isFactory(defaultValue) ? defaultValue() : defaultValue;
+    pointer.set(value);
+    return [value, setState];
+  });
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/use-effect.js
+function useEffect(cb, depArray) {
+  withPointer((pointer) => {
+    const oldDeps = pointer.get();
+    const hasChanged = !Array.isArray(oldDeps) || depArray.some((dep, i) => !Object.is(dep, oldDeps[i]));
+    if (hasChanged) {
+      effectScheduler.queue(cb);
+    }
+    pointer.set(depArray);
+  });
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/theme.js
+import { styleText } from "node:util";
+
+// ../../../node_modules/@inquirer/figures/dist/index.js
+import process3 from "node:process";
+function isUnicodeSupported() {
+  if (!process3.platform.startsWith("win")) {
+    return process3.env["TERM"] !== "linux";
+  }
+  return Boolean(process3.env["CI"]) || // CI environments generally support unicode
+  Boolean(process3.env["WT_SESSION"]) || // Windows Terminal
+  Boolean(process3.env["TERMINUS_SUBLIME"]) || // Terminus (<0.2.27)
+  process3.env["ConEmuTask"] === "{cmd::Cmder}" || // ConEmu and cmder
+  process3.env["TERM_PROGRAM"] === "Terminus-Sublime" || process3.env["TERM_PROGRAM"] === "vscode" || process3.env["TERM"] === "xterm-256color" || process3.env["TERM"] === "alacritty" || process3.env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
+}
+var common = {
+  circleQuestionMark: "(?)",
+  questionMarkPrefix: "(?)",
+  square: "\u2588",
+  squareDarkShade: "\u2593",
+  squareMediumShade: "\u2592",
+  squareLightShade: "\u2591",
+  squareTop: "\u2580",
+  squareBottom: "\u2584",
+  squareLeft: "\u258C",
+  squareRight: "\u2590",
+  squareCenter: "\u25A0",
+  bullet: "\u25CF",
+  dot: "\u2024",
+  ellipsis: "\u2026",
+  pointerSmall: "\u203A",
+  triangleUp: "\u25B2",
+  triangleUpSmall: "\u25B4",
+  triangleDown: "\u25BC",
+  triangleDownSmall: "\u25BE",
+  triangleLeftSmall: "\u25C2",
+  triangleRightSmall: "\u25B8",
+  home: "\u2302",
+  heart: "\u2665",
+  musicNote: "\u266A",
+  musicNoteBeamed: "\u266B",
+  arrowUp: "\u2191",
+  arrowDown: "\u2193",
+  arrowLeft: "\u2190",
+  arrowRight: "\u2192",
+  arrowLeftRight: "\u2194",
+  arrowUpDown: "\u2195",
+  almostEqual: "\u2248",
+  notEqual: "\u2260",
+  lessOrEqual: "\u2264",
+  greaterOrEqual: "\u2265",
+  identical: "\u2261",
+  infinity: "\u221E",
+  subscriptZero: "\u2080",
+  subscriptOne: "\u2081",
+  subscriptTwo: "\u2082",
+  subscriptThree: "\u2083",
+  subscriptFour: "\u2084",
+  subscriptFive: "\u2085",
+  subscriptSix: "\u2086",
+  subscriptSeven: "\u2087",
+  subscriptEight: "\u2088",
+  subscriptNine: "\u2089",
+  oneHalf: "\xBD",
+  oneThird: "\u2153",
+  oneQuarter: "\xBC",
+  oneFifth: "\u2155",
+  oneSixth: "\u2159",
+  oneEighth: "\u215B",
+  twoThirds: "\u2154",
+  twoFifths: "\u2156",
+  threeQuarters: "\xBE",
+  threeFifths: "\u2157",
+  threeEighths: "\u215C",
+  fourFifths: "\u2158",
+  fiveSixths: "\u215A",
+  fiveEighths: "\u215D",
+  sevenEighths: "\u215E",
+  line: "\u2500",
+  lineBold: "\u2501",
+  lineDouble: "\u2550",
+  lineDashed0: "\u2504",
+  lineDashed1: "\u2505",
+  lineDashed2: "\u2508",
+  lineDashed3: "\u2509",
+  lineDashed4: "\u254C",
+  lineDashed5: "\u254D",
+  lineDashed6: "\u2574",
+  lineDashed7: "\u2576",
+  lineDashed8: "\u2578",
+  lineDashed9: "\u257A",
+  lineDashed10: "\u257C",
+  lineDashed11: "\u257E",
+  lineDashed12: "\u2212",
+  lineDashed13: "\u2013",
+  lineDashed14: "\u2010",
+  lineDashed15: "\u2043",
+  lineVertical: "\u2502",
+  lineVerticalBold: "\u2503",
+  lineVerticalDouble: "\u2551",
+  lineVerticalDashed0: "\u2506",
+  lineVerticalDashed1: "\u2507",
+  lineVerticalDashed2: "\u250A",
+  lineVerticalDashed3: "\u250B",
+  lineVerticalDashed4: "\u254E",
+  lineVerticalDashed5: "\u254F",
+  lineVerticalDashed6: "\u2575",
+  lineVerticalDashed7: "\u2577",
+  lineVerticalDashed8: "\u2579",
+  lineVerticalDashed9: "\u257B",
+  lineVerticalDashed10: "\u257D",
+  lineVerticalDashed11: "\u257F",
+  lineDownLeft: "\u2510",
+  lineDownLeftArc: "\u256E",
+  lineDownBoldLeftBold: "\u2513",
+  lineDownBoldLeft: "\u2512",
+  lineDownLeftBold: "\u2511",
+  lineDownDoubleLeftDouble: "\u2557",
+  lineDownDoubleLeft: "\u2556",
+  lineDownLeftDouble: "\u2555",
+  lineDownRight: "\u250C",
+  lineDownRightArc: "\u256D",
+  lineDownBoldRightBold: "\u250F",
+  lineDownBoldRight: "\u250E",
+  lineDownRightBold: "\u250D",
+  lineDownDoubleRightDouble: "\u2554",
+  lineDownDoubleRight: "\u2553",
+  lineDownRightDouble: "\u2552",
+  lineUpLeft: "\u2518",
+  lineUpLeftArc: "\u256F",
+  lineUpBoldLeftBold: "\u251B",
+  lineUpBoldLeft: "\u251A",
+  lineUpLeftBold: "\u2519",
+  lineUpDoubleLeftDouble: "\u255D",
+  lineUpDoubleLeft: "\u255C",
+  lineUpLeftDouble: "\u255B",
+  lineUpRight: "\u2514",
+  lineUpRightArc: "\u2570",
+  lineUpBoldRightBold: "\u2517",
+  lineUpBoldRight: "\u2516",
+  lineUpRightBold: "\u2515",
+  lineUpDoubleRightDouble: "\u255A",
+  lineUpDoubleRight: "\u2559",
+  lineUpRightDouble: "\u2558",
+  lineUpDownLeft: "\u2524",
+  lineUpBoldDownBoldLeftBold: "\u252B",
+  lineUpBoldDownBoldLeft: "\u2528",
+  lineUpDownLeftBold: "\u2525",
+  lineUpBoldDownLeftBold: "\u2529",
+  lineUpDownBoldLeftBold: "\u252A",
+  lineUpDownBoldLeft: "\u2527",
+  lineUpBoldDownLeft: "\u2526",
+  lineUpDoubleDownDoubleLeftDouble: "\u2563",
+  lineUpDoubleDownDoubleLeft: "\u2562",
+  lineUpDownLeftDouble: "\u2561",
+  lineUpDownRight: "\u251C",
+  lineUpBoldDownBoldRightBold: "\u2523",
+  lineUpBoldDownBoldRight: "\u2520",
+  lineUpDownRightBold: "\u251D",
+  lineUpBoldDownRightBold: "\u2521",
+  lineUpDownBoldRightBold: "\u2522",
+  lineUpDownBoldRight: "\u251F",
+  lineUpBoldDownRight: "\u251E",
+  lineUpDoubleDownDoubleRightDouble: "\u2560",
+  lineUpDoubleDownDoubleRight: "\u255F",
+  lineUpDownRightDouble: "\u255E",
+  lineDownLeftRight: "\u252C",
+  lineDownBoldLeftBoldRightBold: "\u2533",
+  lineDownLeftBoldRightBold: "\u252F",
+  lineDownBoldLeftRight: "\u2530",
+  lineDownBoldLeftBoldRight: "\u2531",
+  lineDownBoldLeftRightBold: "\u2532",
+  lineDownLeftRightBold: "\u252E",
+  lineDownLeftBoldRight: "\u252D",
+  lineDownDoubleLeftDoubleRightDouble: "\u2566",
+  lineDownDoubleLeftRight: "\u2565",
+  lineDownLeftDoubleRightDouble: "\u2564",
+  lineUpLeftRight: "\u2534",
+  lineUpBoldLeftBoldRightBold: "\u253B",
+  lineUpLeftBoldRightBold: "\u2537",
+  lineUpBoldLeftRight: "\u2538",
+  lineUpBoldLeftBoldRight: "\u2539",
+  lineUpBoldLeftRightBold: "\u253A",
+  lineUpLeftRightBold: "\u2536",
+  lineUpLeftBoldRight: "\u2535",
+  lineUpDoubleLeftDoubleRightDouble: "\u2569",
+  lineUpDoubleLeftRight: "\u2568",
+  lineUpLeftDoubleRightDouble: "\u2567",
+  lineUpDownLeftRight: "\u253C",
+  lineUpBoldDownBoldLeftBoldRightBold: "\u254B",
+  lineUpDownBoldLeftBoldRightBold: "\u2548",
+  lineUpBoldDownLeftBoldRightBold: "\u2547",
+  lineUpBoldDownBoldLeftRightBold: "\u254A",
+  lineUpBoldDownBoldLeftBoldRight: "\u2549",
+  lineUpBoldDownLeftRight: "\u2540",
+  lineUpDownBoldLeftRight: "\u2541",
+  lineUpDownLeftBoldRight: "\u253D",
+  lineUpDownLeftRightBold: "\u253E",
+  lineUpBoldDownBoldLeftRight: "\u2542",
+  lineUpDownLeftBoldRightBold: "\u253F",
+  lineUpBoldDownLeftBoldRight: "\u2543",
+  lineUpBoldDownLeftRightBold: "\u2544",
+  lineUpDownBoldLeftBoldRight: "\u2545",
+  lineUpDownBoldLeftRightBold: "\u2546",
+  lineUpDoubleDownDoubleLeftDoubleRightDouble: "\u256C",
+  lineUpDoubleDownDoubleLeftRight: "\u256B",
+  lineUpDownLeftDoubleRightDouble: "\u256A",
+  lineCross: "\u2573",
+  lineBackslash: "\u2572",
+  lineSlash: "\u2571"
+};
+var specialMainSymbols = {
+  tick: "\u2714",
+  info: "\u2139",
+  warning: "\u26A0",
+  cross: "\u2718",
+  squareSmall: "\u25FB",
+  squareSmallFilled: "\u25FC",
+  circle: "\u25EF",
+  circleFilled: "\u25C9",
+  circleDotted: "\u25CC",
+  circleDouble: "\u25CE",
+  circleCircle: "\u24DE",
+  circleCross: "\u24E7",
+  circlePipe: "\u24BE",
+  radioOn: "\u25C9",
+  radioOff: "\u25EF",
+  checkboxOn: "\u2612",
+  checkboxOff: "\u2610",
+  checkboxCircleOn: "\u24E7",
+  checkboxCircleOff: "\u24BE",
+  pointer: "\u276F",
+  triangleUpOutline: "\u25B3",
+  triangleLeft: "\u25C0",
+  triangleRight: "\u25B6",
+  lozenge: "\u25C6",
+  lozengeOutline: "\u25C7",
+  hamburger: "\u2630",
+  smiley: "\u32E1",
+  mustache: "\u0DF4",
+  star: "\u2605",
+  play: "\u25B6",
+  nodejs: "\u2B22",
+  oneSeventh: "\u2150",
+  oneNinth: "\u2151",
+  oneTenth: "\u2152"
+};
+var specialFallbackSymbols = {
+  tick: "\u221A",
+  info: "i",
+  warning: "\u203C",
+  cross: "\xD7",
+  squareSmall: "\u25A1",
+  squareSmallFilled: "\u25A0",
+  circle: "( )",
+  circleFilled: "(*)",
+  circleDotted: "( )",
+  circleDouble: "( )",
+  circleCircle: "(\u25CB)",
+  circleCross: "(\xD7)",
+  circlePipe: "(\u2502)",
+  radioOn: "(*)",
+  radioOff: "( )",
+  checkboxOn: "[\xD7]",
+  checkboxOff: "[ ]",
+  checkboxCircleOn: "(\xD7)",
+  checkboxCircleOff: "( )",
+  pointer: ">",
+  triangleUpOutline: "\u2206",
+  triangleLeft: "\u25C4",
+  triangleRight: "\u25BA",
+  lozenge: "\u2666",
+  lozengeOutline: "\u25CA",
+  hamburger: "\u2261",
+  smiley: "\u263A",
+  mustache: "\u250C\u2500\u2510",
+  star: "\u2736",
+  play: "\u25BA",
+  nodejs: "\u2666",
+  oneSeventh: "1/7",
+  oneNinth: "1/9",
+  oneTenth: "1/10"
+};
+var mainSymbols = {
+  ...common,
+  ...specialMainSymbols
+};
+var fallbackSymbols = {
+  ...common,
+  ...specialFallbackSymbols
+};
+var shouldUseMain = isUnicodeSupported();
+var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
+var dist_default = figures;
+var replacements = Object.entries(specialMainSymbols);
+
+// ../../../node_modules/@inquirer/core/dist/lib/theme.js
+var defaultTheme = {
+  prefix: {
+    idle: styleText("blue", "?"),
+    done: styleText("green", dist_default.tick)
+  },
+  spinner: {
+    interval: 80,
+    frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"].map((frame) => styleText("yellow", frame))
+  },
+  keybindings: [],
+  style: {
+    answer: (text) => styleText("cyan", text),
+    message: (text) => styleText("bold", text),
+    error: (text) => styleText("red", `> ${text}`),
+    defaultAnswer: (text) => styleText("dim", `(${text})`),
+    help: (text) => styleText("dim", text),
+    highlight: (text) => styleText("cyan", text),
+    key: (text) => styleText("cyan", styleText("bold", `<${text}>`))
+  }
+};
+function getDefaultTheme() {
+  return {
+    ...defaultTheme,
+    keybindings: getDefaultKeybindings()
+  };
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/make-theme.js
+function isPlainObject2(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  let proto = value;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value) === proto;
+}
+function deepMerge(...objects) {
+  const output = {};
+  for (const obj of objects) {
+    for (const [key, value] of Object.entries(obj)) {
+      const prevValue = output[key];
+      output[key] = isPlainObject2(prevValue) && isPlainObject2(value) ? deepMerge(prevValue, value) : value;
+    }
+  }
+  return output;
+}
+function makeTheme(...themes) {
+  const themesToMerge = [
+    getDefaultTheme(),
+    ...themes.filter((theme) => theme != null)
+  ];
+  return deepMerge(...themesToMerge);
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/use-prefix.js
+function usePrefix({ status = "idle", theme }) {
+  const [showLoader, setShowLoader] = useState(false);
+  const [tick, setTick] = useState(0);
+  const { prefix, spinner } = makeTheme(theme);
+  useEffect(() => {
+    if (status === "loading") {
+      let tickInterval;
+      let inc = -1;
+      const delayTimeout = setTimeout(() => {
+        setShowLoader(true);
+        tickInterval = setInterval(() => {
+          inc = inc + 1;
+          setTick(inc % spinner.frames.length);
+        }, spinner.interval);
+      }, 300);
+      return () => {
+        clearTimeout(delayTimeout);
+        clearInterval(tickInterval);
+      };
+    } else {
+      setShowLoader(false);
+    }
+  }, [status]);
+  if (showLoader) {
+    return spinner.frames[tick];
+  }
+  const iconName = status === "loading" ? "idle" : status;
+  return typeof prefix === "string" ? prefix : prefix[iconName] ?? prefix["idle"];
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/use-memo.js
+function useMemo(fn, dependencies) {
+  return withPointer((pointer) => {
+    const prev = pointer.get();
+    if (!pointer.initialized || prev.dependencies.length !== dependencies.length || prev.dependencies.some((dep, i) => dep !== dependencies[i])) {
+      const value = fn();
+      pointer.set({ value, dependencies });
+      return value;
+    }
+    return prev.value;
+  });
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/use-ref.js
+function useRef(val) {
+  return useState({ current: val })[0];
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/use-keypress.js
+function useKeypress(userHandler) {
+  const signal = useRef(userHandler);
+  signal.current = userHandler;
+  useEffect((rl) => {
+    let ignore = false;
+    const handler = withUpdates((_input, event) => {
+      if (ignore)
+        return;
+      void signal.current(event, rl);
+    });
+    rl.input.on("keypress", handler);
+    return () => {
+      ignore = true;
+      rl.input.removeListener("keypress", handler);
+    };
+  }, []);
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/utils.js
+var import_cli_width = __toESM(require_cli_width(), 1);
+
+// ../../../node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = /* @__PURE__ */ (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// ../../../node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer: while (true) {
+    if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+      const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+      lengthExtra = 0;
+      for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+        const codePoint = char.codePointAt(0) || 0;
+        if (isFullWidth(codePoint)) {
+          widthExtra = FULL_WIDTH_WIDTH;
+        } else if (isWideNotCJKTNotEmoji(codePoint)) {
+          widthExtra = WIDE_WIDTH;
+        } else {
+          widthExtra = REGULAR_WIDTH;
+        }
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        lengthExtra += char.length;
+        width += widthExtra;
+      }
+      unmatchedStart = unmatchedEnd = 0;
+    }
+    if (index >= length) {
+      break outer;
+    }
+    for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+      BLOCK_RE.lastIndex = index;
+      if (BLOCK_RE.test(input)) {
+        lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+        widthExtra = lengthExtra * BLOCK_WIDTH;
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        width += widthExtra;
+        unmatchedStart = indexPrev;
+        unmatchedEnd = index;
+        index = indexPrev = BLOCK_RE.lastIndex;
+        continue outer;
+      }
+    }
+    index += 1;
+  }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default2 = getStringTruncatedWidth;
+
+// ../../../node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default2(input, NO_TRUNCATION2, options).width;
+};
+var dist_default3 = fastStringWidth;
+
+// ../../../node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return void 0;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url2) => `${ESC}${ANSI_ESCAPE_LINK}${url2}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === void 0 ? 0 : dist_default3(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default3(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string4) => {
+  const words = string4.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default3(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string4;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string4, columns, options = {}) => {
+  if (options.trim !== false && string4.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string4.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0; index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default3(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default3(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default3(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default3(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join("\n");
+  let inSurrogate = false;
+  for (let i = 0; i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== void 0) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? void 0 : code;
+      } else if (groups?.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    if (preString[i + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === "\n") {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string4, columns, options) {
+  return String(string4).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/utils.js
+function breakLines(content, width) {
+  return content.split("\n").flatMap((line) => wrapAnsi(line, width, { trim: false, wordWrap: false }).split("\n").map((str) => str.trimEnd())).join("\n");
+}
+function readlineWidth() {
+  return (0, import_cli_width.default)({ defaultWidth: 80, output: readline().output });
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js
+function usePointerPosition({ active, renderedItems, pageSize, loop }) {
+  const state = useRef({
+    lastPointer: active,
+    lastActive: void 0
+  });
+  const { lastPointer, lastActive } = state.current;
+  const middle = Math.floor(pageSize / 2);
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const defaultPointerPosition = renderedItems.slice(0, active).reduce((acc, item) => acc + item.length, 0);
+  let pointer = defaultPointerPosition;
+  if (renderedLength > pageSize) {
+    if (loop) {
+      pointer = lastPointer;
+      if (
+        // First render, skip this logic.
+        lastActive != null && // Only move the pointer down when the user moves down.
+        lastActive < active && // Check user didn't move up across page boundary.
+        active - lastActive < pageSize
+      ) {
+        pointer = Math.min(
+          // Furthest allowed position for the pointer is the middle of the list
+          middle,
+          Math.abs(active - lastActive) === 1 ? Math.min(
+            // Move the pointer at most the height of the last active item.
+            lastPointer + (renderedItems[lastActive]?.length ?? 0),
+            // If the user moved by one item, move the pointer to the natural position of the active item as
+            // long as it doesn't move the cursor up.
+            Math.max(defaultPointerPosition, lastPointer)
+          ) : (
+            // Otherwise, move the pointer down by the difference between the active and last active item.
+            lastPointer + active - lastActive
+          )
+        );
+      }
+    } else {
+      const spaceUnderActive = renderedItems.slice(active).reduce((acc, item) => acc + item.length, 0);
+      pointer = spaceUnderActive < pageSize - middle ? (
+        // If the active item is near the end of the list, progressively move the cursor towards the end.
+        pageSize - spaceUnderActive
+      ) : (
+        // Otherwise, progressively move the pointer to the middle of the list.
+        Math.min(defaultPointerPosition, middle)
+      );
+    }
+  }
+  state.current.lastPointer = pointer;
+  state.current.lastActive = active;
+  return pointer;
+}
+function usePagination({ items, active, renderItem, pageSize, loop = true }) {
+  const width = readlineWidth();
+  const bound = (num) => (num % items.length + items.length) % items.length;
+  const renderedItems = items.map((item, index) => {
+    if (item == null)
+      return [];
+    return breakLines(renderItem({ item, index, isActive: index === active }), width).split("\n");
+  });
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const renderItemAtIndex = (index) => renderedItems[index] ?? [];
+  const pointer = usePointerPosition({ active, renderedItems, pageSize, loop });
+  const activeItem = renderItemAtIndex(active).slice(0, pageSize);
+  const activeItemPosition = pointer + activeItem.length <= pageSize ? pointer : pageSize - activeItem.length;
+  const pageBuffer = Array.from({ length: pageSize });
+  pageBuffer.splice(activeItemPosition, activeItem.length, ...activeItem);
+  const itemVisited = /* @__PURE__ */ new Set([active]);
+  let bufferPointer = activeItemPosition + activeItem.length;
+  let itemPointer = bound(active + 1);
+  while (bufferPointer < pageSize && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer > active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(0, pageSize - bufferPointer);
+    pageBuffer.splice(bufferPointer, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer += linesToAdd.length;
+    itemPointer = bound(itemPointer + 1);
+  }
+  bufferPointer = activeItemPosition - 1;
+  itemPointer = bound(active - 1);
+  while (bufferPointer >= 0 && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer < active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(Math.max(0, lines.length - bufferPointer - 1));
+    pageBuffer.splice(bufferPointer - linesToAdd.length + 1, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer -= linesToAdd.length;
+    itemPointer = bound(itemPointer - 1);
+  }
+  return pageBuffer.filter((line) => typeof line === "string").join("\n");
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/create-prompt.js
+var import_mute_stream = __toESM(require_lib(), 1);
+import * as readline2 from "node:readline";
+import { AsyncResource as AsyncResource3 } from "node:async_hooks";
+
+// ../../../node_modules/signal-exit/dist/mjs/signals.js
+var signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+  signals.push(
+    "SIGALRM",
+    "SIGABRT",
+    "SIGVTALRM",
+    "SIGXCPU",
+    "SIGXFSZ",
+    "SIGUSR2",
+    "SIGTRAP",
+    "SIGSYS",
+    "SIGQUIT",
+    "SIGIOT"
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  );
+}
+if (process.platform === "linux") {
+  signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+
+// ../../../node_modules/signal-exit/dist/mjs/index.js
+var processOk = (process5) => !!process5 && typeof process5 === "object" && typeof process5.removeListener === "function" && typeof process5.emit === "function" && typeof process5.reallyExit === "function" && typeof process5.listeners === "function" && typeof process5.kill === "function" && typeof process5.pid === "number" && typeof process5.on === "function";
+var kExitEmitter = /* @__PURE__ */ Symbol.for("signal-exit emitter");
+var global = globalThis;
+var ObjectDefineProperty = Object.defineProperty.bind(Object);
+var Emitter = class {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
+    }
+    ObjectDefineProperty(global, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
+    }
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+};
+var SignalExitBase = class {
+};
+var signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+};
+var SignalExitFallback = class extends SignalExitBase {
+  onExit() {
+    return () => {
+    };
+  }
+  load() {
+  }
+  unload() {
+  }
+};
+var SignalExit = class extends SignalExitBase {
+  // "SIGHUP" throws an `ENOSYS` error on Windows,
+  // so use a supported signal instead
+  /* c8 ignore start */
+  #hupSig = process4.platform === "win32" ? "SIGINT" : "SIGHUP";
+  /* c8 ignore stop */
+  #emitter = new Emitter();
+  #process;
+  #originalProcessEmit;
+  #originalProcessReallyExit;
+  #sigListeners = {};
+  #loaded = false;
+  constructor(process5) {
+    super();
+    this.#process = process5;
+    this.#sigListeners = {};
+    for (const sig of signals) {
+      this.#sigListeners[sig] = () => {
+        const listeners = this.#process.listeners(sig);
+        let { count } = this.#emitter;
+        const p = process5;
+        if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+          count += p.__signal_exit_emitter__.count;
+        }
+        if (listeners.length === count) {
+          this.unload();
+          const ret = this.#emitter.emit("exit", null, sig);
+          const s = sig === "SIGHUP" ? this.#hupSig : sig;
+          if (!ret)
+            process5.kill(process5.pid, s);
+        }
+      };
+    }
+    this.#originalProcessReallyExit = process5.reallyExit;
+    this.#originalProcessEmit = process5.emit;
+  }
+  onExit(cb, opts) {
+    if (!processOk(this.#process)) {
+      return () => {
+      };
+    }
+    if (this.#loaded === false) {
+      this.load();
+    }
+    const ev = opts?.alwaysLast ? "afterExit" : "exit";
+    this.#emitter.on(ev, cb);
+    return () => {
+      this.#emitter.removeListener(ev, cb);
+      if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+        this.unload();
+      }
+    };
+  }
+  load() {
+    if (this.#loaded) {
+      return;
+    }
+    this.#loaded = true;
+    this.#emitter.count += 1;
+    for (const sig of signals) {
+      try {
+        const fn = this.#sigListeners[sig];
+        if (fn)
+          this.#process.on(sig, fn);
+      } catch (_) {
+      }
+    }
+    this.#process.emit = (ev, ...a) => {
+      return this.#processEmit(ev, ...a);
+    };
+    this.#process.reallyExit = (code) => {
+      return this.#processReallyExit(code);
+    };
+  }
+  unload() {
+    if (!this.#loaded) {
+      return;
+    }
+    this.#loaded = false;
+    signals.forEach((sig) => {
+      const listener = this.#sigListeners[sig];
+      if (!listener) {
+        throw new Error("Listener not defined for signal: " + sig);
+      }
+      try {
+        this.#process.removeListener(sig, listener);
+      } catch (_) {
+      }
+    });
+    this.#process.emit = this.#originalProcessEmit;
+    this.#process.reallyExit = this.#originalProcessReallyExit;
+    this.#emitter.count -= 1;
+  }
+  #processReallyExit(code) {
+    if (!processOk(this.#process)) {
+      return 0;
+    }
+    this.#process.exitCode = code || 0;
+    this.#emitter.emit("exit", this.#process.exitCode, null);
+    return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+  }
+  #processEmit(ev, ...args) {
+    const og = this.#originalProcessEmit;
+    if (ev === "exit" && processOk(this.#process)) {
+      if (typeof args[0] === "number") {
+        this.#process.exitCode = args[0];
+      }
+      const ret = og.call(this.#process, ev, ...args);
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return ret;
+    } else {
+      return og.call(this.#process, ev, ...args);
+    }
+  }
+};
+var process4 = globalThis.process;
+var {
+  /**
+   * Called when the process is exiting, whether via signal, explicit
+   * exit, or running out of stuff to do.
+   *
+   * If the global process object is not suitable for instrumentation,
+   * then this will be a no-op.
+   *
+   * Returns a function that may be used to unload signal-exit.
+   */
+  onExit,
+  /**
+   * Load the listeners.  Likely you never need to call this, unless
+   * doing a rather deep integration with signal-exit functionality.
+   * Mostly exposed for the benefit of testing.
+   *
+   * @internal
+   */
+  load,
+  /**
+   * Unload the listeners.  Likely you never need to call this, unless
+   * doing a rather deep integration with signal-exit functionality.
+   * Mostly exposed for the benefit of testing.
+   *
+   * @internal
+   */
+  unload
+} = signalExitWrap(processOk(process4) ? new SignalExit(process4) : new SignalExitFallback());
+
+// ../../../node_modules/@inquirer/core/dist/lib/screen-manager.js
+import { stripVTControlCharacters } from "node:util";
+
+// ../../../node_modules/@inquirer/ansi/dist/index.js
+var ESC2 = "\x1B[";
+var cursorLeft = ESC2 + "G";
+var cursorHide = ESC2 + "?25l";
+var cursorShow = ESC2 + "?25h";
+var cursorUp = (rows = 1) => rows > 0 ? `${ESC2}${rows}A` : "";
+var cursorDown = (rows = 1) => rows > 0 ? `${ESC2}${rows}B` : "";
+var cursorTo = (x, y) => {
+  if (typeof y === "number" && !Number.isNaN(y)) {
+    return `${ESC2}${y + 1};${x + 1}H`;
+  }
+  return `${ESC2}${x + 1}G`;
+};
+var eraseLine = ESC2 + "2K";
+var eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : "";
+
+// ../../../node_modules/@inquirer/core/dist/lib/screen-manager.js
+var height = (content) => content.split("\n").length;
+var lastLine = (content) => content.split("\n").pop() ?? "";
+var ScreenManager = class {
+  // These variables are keeping information to allow correct prompt re-rendering
+  height = 0;
+  extraLinesUnderPrompt = 0;
+  cursorPos;
+  rl;
+  constructor(rl) {
+    this.rl = rl;
+    this.cursorPos = rl.getCursorPos();
+  }
+  write(content) {
+    this.rl.output.unmute();
+    this.rl.output.write(content);
+    this.rl.output.mute();
+  }
+  render(content, bottomContent = "") {
+    const promptLine = lastLine(content);
+    const rawPromptLine = stripVTControlCharacters(promptLine);
+    let prompt = rawPromptLine;
+    if (this.rl.line.length > 0) {
+      prompt = prompt.slice(0, -this.rl.line.length);
+    }
+    this.rl.setPrompt(prompt);
+    this.cursorPos = this.rl.getCursorPos();
+    const width = readlineWidth();
+    content = breakLines(content, width);
+    bottomContent = breakLines(bottomContent, width);
+    if (rawPromptLine.length % width === 0) {
+      content += "\n";
+    }
+    let output = content + (bottomContent ? "\n" + bottomContent : "");
+    const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+    const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+    if (bottomContentHeight > 0)
+      output += cursorUp(bottomContentHeight);
+    output += cursorTo(this.cursorPos.cols);
+    this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
+    this.extraLinesUnderPrompt = bottomContentHeight;
+    this.height = height(output);
+  }
+  checkCursorPos() {
+    const cursorPos = this.rl.getCursorPos();
+    if (cursorPos.cols !== this.cursorPos.cols) {
+      this.write(cursorTo(cursorPos.cols));
+      this.cursorPos = cursorPos;
+    }
+  }
+  done({ clearContent }) {
+    this.rl.setPrompt("");
+    let output = cursorDown(this.extraLinesUnderPrompt);
+    output += clearContent ? eraseLines(this.height) : "\n";
+    output += cursorLeft;
+    output += cursorShow;
+    this.write(output);
+    this.rl.close();
+  }
+};
+
+// ../../../node_modules/@inquirer/core/dist/lib/promise-polyfill.js
+var PromisePolyfill = class extends Promise {
+  // Available starting from Node 22
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
+  static withResolver() {
+    let resolve;
+    let reject;
+    const promise2 = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise: promise2, resolve, reject };
+  }
+};
+
+// ../../../node_modules/@inquirer/core/dist/lib/create-prompt.js
+import path from "node:path";
+var nativeSetImmediate = globalThis.setImmediate;
+function listenTo(target, event, listener) {
+  if ("on" in target) {
+    target.on(event, listener);
+    return () => target.removeListener(event, listener);
+  }
+  target.addEventListener(event, listener);
+  return () => target.removeEventListener(event, listener);
+}
+function getCallSites() {
+  const savedPrepareStackTrace = Error.prepareStackTrace;
+  let result = [];
+  try {
+    Error.prepareStackTrace = (_, callSites) => {
+      const callSitesWithoutCurrent = callSites.slice(1);
+      result = callSitesWithoutCurrent;
+      return callSitesWithoutCurrent;
+    };
+    new Error().stack;
+  } catch {
+    return result;
+  }
+  Error.prepareStackTrace = savedPrepareStackTrace;
+  return result;
+}
+function createPrompt(view) {
+  const callSites = getCallSites();
+  const prompt = (config2, context = {}) => {
+    const { input = process.stdin, signal } = context;
+    const cleanups = /* @__PURE__ */ new Set();
+    const output = new import_mute_stream.default();
+    output.pipe(context.output ?? process.stdout);
+    const rl = readline2.createInterface({
+      terminal: true,
+      input,
+      output
+    });
+    output.mute();
+    const screen = new ScreenManager(rl);
+    const { promise: promise2, resolve, reject } = PromisePolyfill.withResolver();
+    return withHooks(rl, (cycle) => {
+      const clearEffects = AsyncResource3.bind(() => effectScheduler.clearAll());
+      const settlePrompt = (settle) => {
+        try {
+          clearEffects();
+          settle();
+        } catch (error51) {
+          reject(error51);
+        }
+      };
+      const resolvePrompt = (value) => settlePrompt(() => resolve(value));
+      const rejectPrompt = (error51) => settlePrompt(() => reject(error51));
+      const promptPromise = Object.assign(promise2.finally(() => {
+        cleanups.forEach((cleanup) => cleanup());
+        screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
+        output.end();
+      }).then(() => promise2), { cancel: () => rejectPrompt(new CancelPromptError()) });
+      if (signal) {
+        const abort = () => rejectPrompt(new AbortPromptError({ cause: signal.reason }));
+        if (signal.aborted) {
+          abort();
+          return promptPromise;
+        }
+        cleanups.add(listenTo(signal, "abort", abort));
+      }
+      cleanups.add(onExit((code, signal2) => {
+        rejectPrompt(new ExitPromptError(`User force closed the prompt with ${code} ${signal2}`));
+      }));
+      cleanups.add(listenTo(rl, "SIGINT", () => rejectPrompt(new ExitPromptError(`User force closed the prompt with SIGINT`))));
+      cleanups.add(listenTo(rl, "close", clearEffects));
+      const startCycle = () => {
+        cleanups.add(listenTo(rl.input, "keypress", () => screen.checkCursorPos()));
+        let pendingDone = null;
+        cycle(() => {
+          let effectsSettled = false;
+          try {
+            const nextView = view(config2, (value) => {
+              if (effectsSettled) {
+                resolvePrompt(value);
+              } else {
+                pendingDone = { value };
+              }
+            });
+            if (nextView === void 0) {
+              let callerFilename = callSites[1]?.getFileName();
+              if (callerFilename && !callerFilename.startsWith("file://")) {
+                callerFilename = path.resolve(callerFilename);
+              }
+              throw new Error(`Prompt functions must return a string.
+    at ${callerFilename}`);
+            }
+            const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
+            screen.render(content, bottomContent);
+            effectScheduler.run();
+          } catch (error51) {
+            rejectPrompt(error51);
+          }
+          effectsSettled = true;
+          if (pendingDone !== null) {
+            const { value } = pendingDone;
+            pendingDone = null;
+            resolvePrompt(value);
+          }
+        });
+      };
+      if ("readableFlowing" in input) {
+        nativeSetImmediate(startCycle);
+      } else {
+        startCycle();
+      }
+      return promptPromise;
+    });
+  };
+  return prompt;
+}
+
+// ../../../node_modules/@inquirer/core/dist/lib/Separator.js
+import { styleText as styleText2 } from "node:util";
+var Separator = class {
+  separator = styleText2("dim", Array.from({ length: 15 }).join(dist_default.line));
+  type = "separator";
+  constructor(separator) {
+    if (separator) {
+      this.separator = separator;
+    }
+  }
+  static isSeparator(choice) {
+    return Boolean(choice && typeof choice === "object" && "type" in choice && choice.type === "separator");
+  }
+};
+
+// ../../../node_modules/@inquirer/confirm/dist/index.js
+import { styleText as styleText3 } from "node:util";
+var confirmTheme = {
+  keywords: {
+    yes: "Yes",
+    no: "No"
+  },
+  style: {
+    confirmDefault: (text) => {
+      const first = text[0] ?? "";
+      if (first.toLowerCase() === first.toUpperCase()) {
+        return styleText3("cyan", text);
+      }
+      return first.toUpperCase() + text.slice(1);
+    }
+  }
+};
+var dist_default4 = createPrompt((config2, done) => {
+  const [status, setStatus] = useState("idle");
+  const [value, setValue] = useState("");
+  const theme = makeTheme(confirmTheme, config2.theme);
+  const prefix = usePrefix({ status, theme });
+  const { yes, no } = theme.keywords;
+  const yesHint = (yes[0] ?? "").toLowerCase();
+  const noHint = (no[0] ?? "").toLowerCase();
+  const hint = config2.default === false ? `${yesHint}/${theme.style.confirmDefault(noHint)}` : `${theme.style.confirmDefault(yesHint)}/${noHint}`;
+  function boolToString(value2) {
+    return value2 ? yes : no;
+  }
+  const { transformer = boolToString } = config2;
+  function getBooleanValue(value2, defaultValue2) {
+    const v = value2.trim().toLowerCase();
+    if (v === "")
+      return defaultValue2 !== false;
+    if (yes.toLowerCase().startsWith(v))
+      return true;
+    if (no.toLowerCase().startsWith(v))
+      return false;
+    return defaultValue2 !== false;
+  }
+  useKeypress((key, rl) => {
+    if (status !== "idle")
+      return;
+    if (isEnterKey(key)) {
+      const answer = getBooleanValue(value, config2.default);
+      setValue(transformer(answer));
+      setStatus("done");
+      done(answer);
+    } else if (isTabKey(key)) {
+      const answer = boolToString(!getBooleanValue(value, config2.default));
+      rl.clearLine(0);
+      rl.write(answer);
+      setValue(answer);
+    } else {
+      setValue(rl.line);
+    }
+  });
+  let formattedValue = value;
+  let defaultValue = "";
+  if (status === "done") {
+    formattedValue = theme.style.answer(value);
+  } else {
+    defaultValue = ` ${theme.style.defaultAnswer(hint)}`;
+  }
+  const message = theme.style.message(config2.message, status);
+  return `${prefix} ${message}${defaultValue} ${formattedValue}`;
+});
+
+// ../../../node_modules/@inquirer/input/dist/index.js
+var inputTheme = {
+  validationFailureMode: "keep"
+};
+var dist_default5 = createPrompt((config2, done) => {
+  const { prefill = "tab" } = config2;
+  const theme = makeTheme(inputTheme, config2.theme);
+  const [status, setStatus] = useState("idle");
+  const [defaultValue, setDefaultValue] = useState(String(config2.default ?? ""));
+  const [errorMsg, setError] = useState();
+  const [value, setValue] = useState("");
+  const prefix = usePrefix({ status, theme });
+  async function validate(value2) {
+    const { required: required2, pattern, patternError = "Invalid input" } = config2;
+    if (required2 && !value2) {
+      return "You must provide a value";
+    }
+    if (pattern && !pattern.test(value2)) {
+      return patternError;
+    }
+    if (typeof config2.validate === "function") {
+      return await config2.validate(value2) || "You must provide a valid value";
+    }
+    return true;
+  }
+  useKeypress(async (key, rl) => {
+    if (status !== "idle") {
+      return;
+    }
+    if (isEnterKey(key)) {
+      const answer = value || defaultValue;
+      setStatus("loading");
+      const isValid = await validate(answer);
+      if (isValid === true) {
+        setValue(answer);
+        setStatus("done");
+        done(answer);
+      } else {
+        if (theme.validationFailureMode === "clear") {
+          setValue("");
+        } else {
+          rl.write(value);
+        }
+        setError(isValid);
+        setStatus("idle");
+      }
+    } else if (isBackspaceKey(key) && !value) {
+      setDefaultValue("");
+    } else if (isTabKey(key) && !value) {
+      setDefaultValue("");
+      rl.clearLine(0);
+      rl.write(defaultValue);
+      setValue(defaultValue);
+    } else {
+      setValue(rl.line);
+      setError(void 0);
+    }
+  });
+  useEffect((rl) => {
+    if (prefill === "editable" && defaultValue) {
+      rl.write(defaultValue);
+      setValue(defaultValue);
+    }
+  }, []);
+  const message = theme.style.message(config2.message, status);
+  let formattedValue = value;
+  if (typeof config2.transformer === "function") {
+    formattedValue = config2.transformer(value, { isFinal: status === "done" });
+  } else if (status === "done") {
+    formattedValue = theme.style.answer(value);
+  }
+  let defaultStr;
+  if (defaultValue && status !== "done" && !value) {
+    defaultStr = theme.style.defaultAnswer(defaultValue);
+  }
+  let error51 = "";
+  if (errorMsg) {
+    error51 = theme.style.error(errorMsg);
+  }
+  return [
+    [prefix, message, defaultStr, formattedValue].filter((v) => v !== void 0).join(" "),
+    error51
+  ];
+});
+
+// ../../../node_modules/@inquirer/select/dist/index.js
+import { styleText as styleText4 } from "node:util";
+var selectTheme = {
+  icon: { cursor: dist_default.pointer },
+  style: {
+    disabled: (text) => styleText4("dim", text),
+    description: (text) => styleText4("cyan", text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${styleText4("bold", key)} ${styleText4("dim", action)}`).join(styleText4("dim", " \u2022 "))
+  },
+  i18n: { disabledError: "This option is disabled and cannot be selected." },
+  indexMode: "hidden"
+};
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+function isNavigable(item) {
+  return !Separator.isSeparator(item);
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice))
+      return choice;
+    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+      const name2 = String(choice);
+      return {
+        value: choice,
+        name: name2,
+        short: name2,
+        disabled: false
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      disabled: choice.disabled ?? false
+    };
+    if (choice.description) {
+      normalizedChoice.description = choice.description;
+    }
+    return normalizedChoice;
+  });
+}
+var dist_default6 = createPrompt((config2, done) => {
+  const { loop = true, pageSize = 7 } = config2;
+  const theme = makeTheme(selectTheme, config2.theme);
+  const { keybindings: keybindings2 } = theme;
+  const [status, setStatus] = useState("idle");
+  const prefix = usePrefix({ status, theme });
+  const searchTimeoutRef = useRef();
+  const searchEnabled = !keybindings2.includes("vim");
+  const items = useMemo(() => normalizeChoices(config2.choices), [config2.choices]);
+  const bounds = useMemo(() => {
+    const first = items.findIndex(isNavigable);
+    const last = items.findLastIndex(isNavigable);
+    if (first === -1) {
+      throw new ValidationError("[select prompt] No selectable choices. All choices are disabled.");
+    }
+    return { first, last };
+  }, [items]);
+  const defaultItemIndex = useMemo(() => {
+    if (!("default" in config2))
+      return -1;
+    return items.findIndex((item) => isSelectable(item) && item.value === config2.default);
+  }, [config2.default, items]);
+  const [active, setActive] = useState(defaultItemIndex === -1 ? bounds.first : defaultItemIndex);
+  const selectedChoice = items[active];
+  if (selectedChoice == null || Separator.isSeparator(selectedChoice)) {
+    throw new Error("Active index does not point to a choice");
+  }
+  const [errorMsg, setError] = useState();
+  useKeypress((key, rl) => {
+    clearTimeout(searchTimeoutRef.current);
+    if (errorMsg) {
+      setError(void 0);
+    }
+    if (isEnterKey(key)) {
+      if (selectedChoice.disabled) {
+        setError(theme.i18n.disabledError);
+      } else {
+        setStatus("done");
+        done(selectedChoice.value);
+      }
+    } else if (isUpKey(key, keybindings2) || isDownKey(key, keybindings2)) {
+      rl.clearLine(0);
+      if (loop || isUpKey(key, keybindings2) && active !== bounds.first || isDownKey(key, keybindings2) && active !== bounds.last) {
+        const offset = isUpKey(key, keybindings2) ? -1 : 1;
+        let next = active;
+        do {
+          next = (next + offset + items.length) % items.length;
+        } while (!isNavigable(items[next]));
+        setActive(next);
+      }
+    } else if (isNumberKey(key) && !Number.isNaN(Number(rl.line))) {
+      const selectedIndex = Number(rl.line) - 1;
+      let selectableIndex = -1;
+      const position = items.findIndex((item2) => {
+        if (Separator.isSeparator(item2))
+          return false;
+        selectableIndex++;
+        return selectableIndex === selectedIndex;
+      });
+      const item = items[position];
+      if (item != null && isSelectable(item)) {
+        setActive(position);
+      }
+      searchTimeoutRef.current = setTimeout(() => {
+        rl.clearLine(0);
+      }, 700);
+    } else if (isBackspaceKey(key)) {
+      rl.clearLine(0);
+    } else if (searchEnabled) {
+      const searchTerm = rl.line.toLowerCase();
+      const matchIndex = items.findIndex((item) => {
+        if (Separator.isSeparator(item) || !isSelectable(item))
+          return false;
+        return item.name.toLowerCase().startsWith(searchTerm);
+      });
+      if (matchIndex !== -1) {
+        setActive(matchIndex);
+      }
+      searchTimeoutRef.current = setTimeout(() => {
+        rl.clearLine(0);
+      }, 700);
+    }
+  });
+  useEffect(() => () => {
+    clearTimeout(searchTimeoutRef.current);
+  }, []);
+  const message = theme.style.message(config2.message, status);
+  const helpLine = theme.style.keysHelpTip([
+    ["\u2191\u2193", "navigate"],
+    ["\u23CE", "select"]
+  ]);
+  let separatorCount = 0;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive, index }) {
+      if (Separator.isSeparator(item)) {
+        separatorCount++;
+        return ` ${item.separator}`;
+      }
+      const cursor = isActive ? theme.icon.cursor : " ";
+      const indexLabel = theme.indexMode === "number" ? `${index + 1 - separatorCount}. ` : "";
+      if (item.disabled) {
+        const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+        const disabledCursor = isActive ? theme.icon.cursor : "-";
+        return theme.style.disabled(`${disabledCursor} ${indexLabel}${item.name} ${disabledLabel}`);
+      }
+      const color = isActive ? theme.style.highlight : (x) => x;
+      return color(`${cursor} ${indexLabel}${item.name}`);
+    },
+    pageSize,
+    loop
+  });
+  if (status === "done") {
+    return [prefix, message, theme.style.answer(selectedChoice.short)].filter(Boolean).join(" ");
+  }
+  const { description } = selectedChoice;
+  const lines = [
+    [prefix, message].filter(Boolean).join(" "),
+    page,
+    " ",
+    description ? theme.style.description(description) : "",
+    errorMsg ? theme.style.error(errorMsg) : "",
+    helpLine
+  ].filter(Boolean).join("\n").trimEnd();
+  return `${lines}${cursorHide}`;
+});
+
 // dist/run.js
 import { spawn } from "node:child_process";
+import os from "node:os";
 var runner = {
   attended(argv) {
     return new Promise((resolve) => {
@@ -20072,6 +22108,7 @@ var runner = {
   },
   async unattended({ work, onProgress }) {
     const argv = headlessArgv(work);
+    const raw = argv[0] === "script";
     let output = "";
     let agentSessionId = work.agentSessionId ?? void 0;
     let lastText = "";
@@ -20097,10 +22134,24 @@ var runner = {
       }
     };
     const code = await new Promise((resolve) => {
-      const child = spawn(argv[0], argv.slice(1), { stdio: ["ignore", "pipe", "pipe"] });
+      const child = spawn(argv[0], argv.slice(1), {
+        stdio: ["ignore", "pipe", "pipe"],
+        cwd: os.homedir(),
+        env: {
+          ...process.env,
+          TERM: process.env.TERM ?? "xterm-256color",
+          COLUMNS: process.env.COLUMNS ?? "120",
+          LINES: process.env.LINES ?? "40"
+        }
+      });
+      append("");
       child.stdout.setEncoding("utf8");
       child.stderr.setEncoding("utf8");
       child.stdout.on("data", (chunk) => {
+        if (raw) {
+          append(chunk);
+          return;
+        }
         pending += chunk;
         const lines = pending.split("\n");
         pending = lines.pop() ?? "";
@@ -20140,7 +22191,7 @@ function headlessArgv(work) {
   if (!isAgent(argv[0]))
     return argv;
   if (argv.includes("--remote-control"))
-    return argv;
+    return underTty(argv);
   const streaming = ["--output-format", "stream-json", "--verbose"];
   if (work.answer !== null && work.agentSessionId !== null) {
     return [argv[0], "--resume", work.agentSessionId, "-p", work.answer, ...streaming];
@@ -20149,6 +22200,12 @@ function headlessArgv(work) {
     return [...argv, ...streaming];
   return [argv[0], "-p", argv.slice(1).join(" "), ...streaming];
 }
+function underTty(argv) {
+  const line = `stty rows ${PTY_ROWS} cols ${PTY_COLS} 2>/dev/null; exec ${argv.join(" ")}`;
+  return process.platform === "linux" ? ["script", "-qec", line, "/dev/null"] : ["script", "-q", "/dev/null", "sh", "-c", line];
+}
+var PTY_ROWS = 40;
+var PTY_COLS = 120;
 function isAgent(command) {
   return AGENTS.has((command ?? "").split("/").pop() ?? "");
 }
@@ -20177,18 +22234,20 @@ function parseJson(line) {
 
 // dist/setup.js
 import { execFile as execFile2 } from "node:child_process";
+import os3 from "node:os";
+import path3 from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // dist/probe.js
 import { execFile } from "node:child_process";
 import net from "node:net";
 import { access, readFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
+import os2 from "node:os";
+import path2 from "node:path";
 import { promisify } from "node:util";
 var run = promisify(execFile);
 var probe = {
-  async tools({ mcpPath = path.join(os.homedir(), ".mcp.json") } = {}) {
+  async tools({ mcpPath = path2.join(os2.homedir(), ".mcp.json") } = {}) {
     const [brain, claude, codex, git, chrome, ssh] = await Promise.all([
       brainWired(mcpPath),
       version2({ id: "claude", command: "claude" }),
@@ -20215,26 +22274,26 @@ async function brainWired(mcpPath) {
 }
 async function version2({ id, command }) {
   const found = await firstLine(command, ["--version"]);
-  if (typeof found === "string")
-    return { id, ok: true, detail: found };
-  return { id, ok: false, detail: found === "absent" ? "not installed" : "installed, but it will not report a version" };
+  if (found.ran)
+    return { id, ok: true, detail: found.line };
+  return { id, ok: false, detail: found.why === "absent" ? "not installed" : "installed, but it will not report a version" };
 }
 async function gitAndGithub() {
   const git = await firstLine("git", ["--version"]);
-  if (typeof git !== "string")
+  if (!git.ran)
     return { id: "git", ok: false, detail: "git is not installed" };
   const gh = await firstLine("gh", ["--version"]);
-  if (typeof gh !== "string")
-    return { id: "git", ok: false, detail: `${git} \xB7 the GitHub CLI is not installed yet` };
+  if (!gh.ran)
+    return { id: "git", ok: false, detail: `${git.line} \xB7 the GitHub CLI is not installed yet` };
   const account = await githubAccount();
   return {
     id: "git",
     ok: account !== null,
-    detail: account === null ? `${git} \xB7 ${gh}, run gh auth login on this machine` : `${git} \xB7 ${gh}, signed in as ${account}`
+    detail: account === null ? `${git.line} \xB7 ${gh.line}, run gh auth login on this machine` : `${git.line} \xB7 ${gh.line}, signed in as ${account}`
   };
 }
 async function githubAccount() {
-  const raw = await readFile(path.join(os.homedir(), ".config", "gh", "hosts.yml"), "utf8").catch(() => null);
+  const raw = await readFile(path2.join(os2.homedir(), ".config", "gh", "hosts.yml"), "utf8").catch(() => null);
   return raw === null ? null : githubUser(raw);
 }
 function githubUser(hostsYml) {
@@ -20243,8 +22302,8 @@ function githubUser(hostsYml) {
 async function chromeInstalled() {
   for (const command of [...MAC_CHROME, ...LINUX_CHROME]) {
     const found = await firstLine(command, ["--version"]);
-    if (typeof found === "string")
-      return { id: "chrome", ok: true, detail: found };
+    if (found.ran)
+      return { id: "chrome", ok: true, detail: found.line };
   }
   return { id: "chrome", ok: false, detail: "not installed yet, so browser runs will fail" };
 }
@@ -20265,16 +22324,16 @@ async function firstLine(command, args) {
   if (command.includes("/")) {
     const reachable = await access(command).then(() => true, () => false);
     if (!reachable)
-      return "absent";
+      return { ran: false, why: "absent" };
   }
   const answer = await run(command, args, { timeout: PROBE_TIMEOUT_MS }).catch((thrown) => thrown);
   if (answer instanceof Error)
-    return answer.code === "ENOENT" ? "absent" : "broken";
+    return { ran: false, why: answer.code === "ENOENT" ? "absent" : "broken" };
   const line = answer.stdout.split("\n")[0]?.trim() ?? "";
-  return line === "" ? "broken" : line.slice(0, 200);
+  return line === "" ? { ran: false, why: "broken" } : { ran: true, line: line.slice(0, 200) };
 }
 function short(target) {
-  return target.startsWith(os.homedir()) ? `~${target.slice(os.homedir().length)}` : target;
+  return target.startsWith(os2.homedir()) ? `~${target.slice(os2.homedir().length)}` : target;
 }
 var MAC_CHROME = ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"];
 var LINUX_CHROME = ["google-chrome", "google-chrome-stable", "chromium"];
@@ -20284,29 +22343,68 @@ var SSH_PROBE_TIMEOUT_MS = 1500;
 // dist/setup.js
 var run2 = promisify2(execFile2);
 var setup = {
+  widenPath() {
+    const current = (process.env.PATH ?? "").split(path3.delimiter).filter((entry) => entry !== "");
+    const missing = toolDirs().filter((entry) => !current.includes(entry));
+    if (missing.length > 0)
+      process.env.PATH = [...current, ...missing].join(path3.delimiter);
+  },
   async run({ install, rewire: rewire2, say }) {
     const found = await probe.tools();
     if (!install)
-      return found;
+      return withReasons(found);
     const repairs = { ...REPAIRS, ...rewire2 === void 0 ? {} : { brain: { name: "the brain", fix: rewire2 } } };
-    const broken = found.filter((tool) => !tool.ok && repairs[tool.id] !== void 0);
+    const broken = found.filter((tool) => !tool.ok && repairs[tool.id] !== void 0 && isDue(tool.id));
     if (broken.length === 0)
-      return found;
+      return withReasons(found);
     for (const tool of broken) {
       const repair = repairs[tool.id];
       if (repair === void 0)
         continue;
       say?.(`Setting up ${repair.name}`);
+      tried.set(tool.id, Date.now());
       const failed = await repair.fix().then(() => null, (error51) => firstLine2(error51.message));
+      if (failed === null)
+        reasons.delete(tool.id);
+      else
+        reasons.set(tool.id, failed);
       say?.(failed === null ? `  ${repair.name} is ready` : `  could not set up ${repair.name}: ${failed}`);
     }
-    return probe.tools();
+    return withReasons(await probe.tools());
   }
 };
+function isDue(id) {
+  const last = tried.get(id);
+  return last === void 0 || Date.now() - last > RETRY_AFTER_MS;
+}
+function withReasons(tools2) {
+  return tools2.map((tool) => {
+    const reason = tool.ok ? void 0 : reasons.get(tool.id);
+    return reason === void 0 ? tool : { ...tool, detail: `${tool.detail} \xB7 ${reason}`.slice(0, 200) };
+  });
+}
+function toolDirs() {
+  const prefix = process.env.npm_config_prefix;
+  return [
+    path3.dirname(process.execPath),
+    ...prefix === void 0 ? [] : [path3.join(prefix, "bin")],
+    path3.join(os3.homedir(), ".local", "bin"),
+    path3.join(os3.homedir(), ".npm-global", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin"
+  ];
+}
 var REPAIRS = {
   claude: { name: "Claude Code", fix: () => npmGlobal("@anthropic-ai/claude-code") },
   codex: { name: "Codex", fix: () => npmGlobal("@openai/codex") },
-  git: { name: "the GitHub CLI", fix: () => installPackage({ brew: ["gh"], apt: ["gh"], dnf: ["gh"] }) },
+  git: {
+    name: "the GitHub CLI",
+    fix: async () => {
+      if (await firstAvailable(["gh"]) !== null)
+        return;
+      await installPackage({ brew: ["gh"], apt: ["gh"], dnf: ["gh"] });
+    }
+  },
   chrome: {
     name: "Google Chrome",
     fix: () => installPackage({ brew: ["--cask", "google-chrome"], apt: ["chromium"], dnf: ["chromium"] })
@@ -20337,13 +22435,16 @@ async function firstAvailable(commands) {
 function firstLine2(message) {
   return message.split("\n")[0] ?? "it failed";
 }
+var tried = /* @__PURE__ */ new Map();
+var reasons = /* @__PURE__ */ new Map();
 var INSTALL_TIMEOUT_MS = 18e4;
+var RETRY_AFTER_MS = 216e5;
 
 // dist/machine.js
 var run3 = promisify3(execFile3);
 var machine = {
   home() {
-    return process.env.CRAFTSPACE_CLI_HOME ?? path2.join(os2.homedir(), ".craftspace");
+    return process.env.CRAFTSPACE_CLI_HOME ?? path4.join(os4.homedir(), ".craftspace");
   },
   async login({ token, url: url2, install }) {
     const answer = await call({
@@ -20352,11 +22453,11 @@ var machine = {
       method: "POST",
       path: "/api/machines/login",
       body: {
-        name: os2.hostname().split(".")[0] ?? "machine",
+        name: os4.hostname().split(".")[0] ?? "machine",
         platform: `${process.platform}-${process.arch}`,
-        sshUser: os2.userInfo().username,
-        cores: os2.cpus().length,
-        memoryGb: Math.max(1, Math.round(os2.totalmem() / 1024 ** 3)),
+        sshUser: os4.userInfo().username,
+        cores: os4.cpus().length,
+        memoryGb: Math.max(1, Math.round(os4.totalmem() / 1024 ** 3)),
         cli: CLI_VERSION,
         publicKey: await ensureKey()
       },
@@ -20374,15 +22475,37 @@ var machine = {
     };
     return answer.machine;
   },
+  async signIn({ url: url2, why, install = false }) {
+    const where = url2 ?? (await readConfig())?.url ?? DEFAULT_URL;
+    if (!process.stdin.isTTY)
+      throw new Error(`${why} Run: craftspace login --token <token>`);
+    const page = `${where}/workstations`;
+    process.stdout.write(`
+${why}
+
+`);
+    if (await dist_default4({ message: `Open ${page} for a key?`, default: true })) {
+      await openInBrowser(page);
+      process.stdout.write('  Click "Add a workstation" there, then copy the line it gives you.\n');
+    } else {
+      process.stdout.write(`  Get one at ${page} under "Add a workstation".
+`);
+    }
+    const token = tokenIn(await dist_default5({
+      message: "Paste it here",
+      validate: (line) => tokenIn(line) !== void 0 || "No cst_\u2026 token in that. Paste the whole line if it is easier."
+    }));
+    if (token === void 0)
+      throw new Error("That line carries no key.");
+    const signed = await machine.login({ token, url: where, install });
+    process.stdout.write(`
+Signed in as ${signed.ownerName}. This machine is ${signed.name}.
+`);
+    return { url: where, token, machine: signed };
+  },
   async status() {
-    const config2 = await readConfig();
-    if (!config2)
-      return null;
-    const token = await readToken();
-    if (!token)
-      return null;
-    const found = await call({ url: config2.url, token, method: "GET", path: "/api/machines/me", schema: MachineSchema });
-    return { machine: found, url: config2.url };
+    const found = await withAuth(await signedInOrAsk(), (auth) => call({ ...auth, method: "GET", path: "/api/machines/me", schema: MachineSchema }));
+    return { machine: found.value, url: found.auth.url };
   },
   async beatOnce() {
     const { url: url2, token } = await requireSignedIn();
@@ -20393,11 +22516,11 @@ var machine = {
       path: "/api/machines/beat",
       body: {
         cli: CLI_VERSION,
-        ...load(),
+        ...load2(),
         sessions: await readSessions(),
         runs: drainReports(),
         tools: await tools(),
-        sshUser: os2.userInfo().username
+        sshUser: os4.userInfo().username
       },
       schema: MachineBeatResponseSchema
     });
@@ -20458,8 +22581,9 @@ async function runHere(argv) {
   }
 }
 async function runThere({ argv, on }) {
-  const { url: url2, token } = await requireSignedIn();
-  const target = await machineNamed({ url: url2, token, name: on });
+  const first = await signedInOrAsk();
+  const { auth, value: target } = await withAuth(first, (live) => machineNamed({ ...live, name: on }));
+  const { url: url2, token } = auth;
   let run4 = await call({
     url: url2,
     token,
@@ -20519,10 +22643,24 @@ async function readRun({ url: url2, token, machineId, runId }) {
 async function machineNamed({ url: url2, token, name }) {
   const answer = await call({ url: url2, token, method: "GET", path: "/api/machines", schema: MachinesResponseSchema });
   const found = answer.machines.find((candidate) => candidate.name === name || candidate.id === name);
-  if (found === void 0) {
+  if (found !== void 0)
+    return found;
+  if (answer.machines.length === 0)
+    throw new Error("This team has no workstations yet. Add one at /workstations.");
+  if (!process.stdin.isTTY) {
     throw new Error(`No workstation called ${name}. This team has: ${answer.machines.map((m) => m.name).join(", ")}`);
   }
-  return found;
+  process.stdout.write(`
+No workstation called ${name}.
+
+`);
+  return dist_default6({
+    message: "Run it on",
+    choices: answer.machines.map((candidate) => ({
+      name: `${candidate.name.padEnd(20)} ${candidate.state}`,
+      value: candidate
+    }))
+  });
 }
 function readStdinLine() {
   return new Promise((resolve) => {
@@ -20577,18 +22715,53 @@ async function call({ url: url2, token, method, path: route, body, schema }) {
     ...body === void 0 ? {} : { body: JSON.stringify(body) },
     signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
   });
+  if (response.status === 401)
+    throw new Unauthorized();
   if (!response.ok)
     throw new Error(`${route} answered ${response.status}`);
   return schema.parse(await response.json());
 }
+var Unauthorized = class extends Error {
+  constructor() {
+    super("This machine no longer has a key Craftspace accepts.");
+  }
+};
+async function signedInOrAsk() {
+  const config2 = await readConfig();
+  const token = await readToken();
+  if (config2 && token)
+    return { url: config2.url, token };
+  return machine.signIn({ why: "This machine is not signed in to Craftspace yet." });
+}
+async function withAuth(auth, work) {
+  try {
+    return { auth, value: await work(auth) };
+  } catch (error51) {
+    if (!(error51 instanceof Unauthorized))
+      throw error51;
+    const next = await machine.signIn({
+      url: auth.url,
+      why: "Craftspace does not know this machine any more. Its key was revoked, which is what forgetting the workstation, or signing the same box in somewhere else, does."
+    });
+    process.stdout.write("\nPicking up where you left off.\n\n");
+    return { auth: next, value: await work(next) };
+  }
+}
+async function openInBrowser(url2) {
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  await run3(opener, [url2]).catch(() => void 0);
+}
+function tokenIn(line) {
+  return /cst_[A-Za-z0-9_-]+/.exec(line)?.[0];
+}
 async function ensureKey() {
-  const priv = path2.join(machine.home(), "id_ed25519");
+  const priv = path4.join(machine.home(), "id_ed25519");
   const pub = `${priv}.pub`;
   const existing = await readFile2(pub, "utf8").catch(() => null);
   if (existing !== null)
     return existing.trim();
   await mkdir(machine.home(), { recursive: true, mode: 448 });
-  await run3("ssh-keygen", ["-t", "ed25519", "-N", "", "-q", "-f", priv, "-C", `craftspace-${os2.hostname()}`]);
+  await run3("ssh-keygen", ["-t", "ed25519", "-N", "", "-q", "-f", priv, "-C", `craftspace-${os4.hostname()}`]);
   return (await readFile2(pub, "utf8")).trim();
 }
 async function readConfig() {
@@ -20602,11 +22775,11 @@ async function readToken() {
   return raw === null ? null : raw.trim();
 }
 async function readSessions() {
-  const dir = path2.join(machine.home(), "sessions");
+  const dir = path4.join(machine.home(), "sessions");
   const names = await readdir(dir).catch(() => []);
   const sessions = [];
   for (const name of names.filter((entry) => entry.endsWith(".json"))) {
-    const raw = await readFile2(path2.join(dir, name), "utf8").catch(() => null);
+    const raw = await readFile2(path4.join(dir, name), "utf8").catch(() => null);
     if (raw === null)
       continue;
     const parsed = MachineSessionSchema.safeParse(JSON.parse(raw));
@@ -20616,7 +22789,7 @@ async function readSessions() {
   return sessions.slice(0, MAX_REPORTED_SESSIONS);
 }
 async function writeAuthorizedKeys(keys) {
-  const target = path2.join(os2.homedir(), ".ssh", "authorized_keys");
+  const target = path4.join(os4.homedir(), ".ssh", "authorized_keys");
   const current = await readFile2(target, "utf8").catch(() => "");
   const before = current.split(KEYS_BEGIN)[0] ?? "";
   const after = current.includes(KEYS_END) ? current.split(KEYS_END)[1] ?? "" : "";
@@ -20627,26 +22800,26 @@ ${KEYS_END}
   const next = `${trimEnd(before)}${trimEnd(before) === "" ? "" : "\n"}${block}${after.replace(/^\n/, "")}`;
   if (next === current)
     return;
-  await mkdir(path2.dirname(target), { recursive: true, mode: 448 });
+  await mkdir(path4.dirname(target), { recursive: true, mode: 448 });
   await writeFile(target, next, { mode: 384 });
 }
 function trimEnd(text) {
   return text.replace(/\s+$/, "");
 }
 async function writeSession(session) {
-  const dir = path2.join(machine.home(), "sessions");
+  const dir = path4.join(machine.home(), "sessions");
   await mkdir(dir, { recursive: true, mode: 448 });
-  await writeFile(path2.join(dir, `${session.id}.json`), JSON.stringify(session), { mode: 384 });
+  await writeFile(path4.join(dir, `${session.id}.json`), JSON.stringify(session), { mode: 384 });
 }
 async function clearSession(id) {
-  await rm(path2.join(machine.home(), "sessions", `${id}.json`), { force: true });
+  await rm(path4.join(machine.home(), "sessions", `${id}.json`), { force: true });
 }
 async function writeAgentConfigs({ url: url2, token, writes }) {
   const planned = writes.length > 0 ? writes : defaultWrites({ url: url2, token });
   const owned = [];
   for (const write of planned) {
     const target = expand(write.path);
-    await mkdir(path2.dirname(target), { recursive: true });
+    await mkdir(path4.dirname(target), { recursive: true });
     const current = await readFile2(target, "utf8").catch(() => null);
     if (current !== null)
       await writeFile(`${target}.craftspace-backup`, current, { flag: "wx" }).catch(() => void 0);
@@ -20656,16 +22829,41 @@ async function writeAgentConfigs({ url: url2, token, writes }) {
     owned.push(target);
   }
   await writeFile(ownedPath(), JSON.stringify({ paths: owned }, null, 2));
+  await acceptClaudeGates(serversIn(planned));
+}
+function serversIn(writes) {
+  return writes.flatMap((write) => isPlainObject3(write.contents.mcpServers) ? Object.keys(write.contents.mcpServers) : []);
+}
+async function acceptClaudeGates(servers) {
+  const target = path4.join(os4.homedir(), ".claude.json");
+  const raw = await readFile2(target, "utf8").catch(() => null);
+  if (raw === null)
+    return;
+  const parsed = JSON.parse(raw);
+  const projects = isPlainObject3(parsed.projects) ? parsed.projects : {};
+  const found = projects[os4.homedir()];
+  const here = isPlainObject3(found) ? { ...found } : {};
+  const enabled = /* @__PURE__ */ new Set([...Array.isArray(here.enabledMcpjsonServers) ? here.enabledMcpjsonServers : [], ...servers]);
+  if (here.hasTrustDialogAccepted === true && enabled.size === asArray(here.enabledMcpjsonServers).length)
+    return;
+  here.hasTrustDialogAccepted = true;
+  here.enabledMcpjsonServers = [...enabled];
+  const next = { ...parsed, projects: { ...projects, [os4.homedir()]: here } };
+  await writeFile(target, `${JSON.stringify(next, null, 2)}
+`, { mode: 384 });
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
 }
 function mergeInto(current, incoming) {
   const merged = { ...current };
   for (const [key, value] of Object.entries(incoming)) {
     const existing = merged[key];
-    merged[key] = isPlainObject2(existing) && isPlainObject2(value) ? mergeInto(existing, value) : value;
+    merged[key] = isPlainObject3(existing) && isPlainObject3(value) ? mergeInto(existing, value) : value;
   }
   return merged;
 }
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function defaultWrites({ url: url2, token }) {
@@ -20683,7 +22881,7 @@ async function removeAgentConfigs() {
       continue;
     const parsed = JSON.parse(current);
     const servers = parsed.mcpServers;
-    if (isPlainObject2(servers))
+    if (isPlainObject3(servers))
       delete servers.craftspace;
     if (await weCreated(target)) {
       await rm(target, { force: true });
@@ -20703,16 +22901,16 @@ async function installService() {
     return;
   }
   if (process.platform === "linux") {
-    const dir = path2.join(os2.homedir(), ".config", "systemd", "user");
+    const dir = path4.join(os4.homedir(), ".config", "systemd", "user");
     await mkdir(dir, { recursive: true });
-    await writeFile(path2.join(dir, `${SERVICE_NAME}.service`), systemdUnit());
+    await writeFile(path4.join(dir, `${SERVICE_NAME}.service`), systemdUnit());
     await run3("systemctl", ["--user", "daemon-reload"]).catch(() => void 0);
     await run3("systemctl", ["--user", "enable", "--now", SERVICE_NAME]).catch(() => void 0);
     return;
   }
   if (process.platform === "darwin") {
-    const target = path2.join(os2.homedir(), "Library", "LaunchAgents", `${LAUNCH_LABEL}.plist`);
-    await mkdir(path2.dirname(target), { recursive: true });
+    const target = path4.join(os4.homedir(), "Library", "LaunchAgents", `${LAUNCH_LABEL}.plist`);
+    await mkdir(path4.dirname(target), { recursive: true });
     await writeFile(target, launchdPlist());
     await run3("launchctl", ["unload", target]).catch(() => void 0);
     await run3("launchctl", ["load", target]).catch(() => void 0);
@@ -20721,11 +22919,11 @@ async function installService() {
 async function uninstallService() {
   if (process.platform === "linux") {
     await run3("systemctl", ["--user", "disable", "--now", SERVICE_NAME]).catch(() => void 0);
-    await rm(path2.join(os2.homedir(), ".config", "systemd", "user", `${SERVICE_NAME}.service`), { force: true });
+    await rm(path4.join(os4.homedir(), ".config", "systemd", "user", `${SERVICE_NAME}.service`), { force: true });
     return;
   }
   if (process.platform === "darwin") {
-    const target = path2.join(os2.homedir(), "Library", "LaunchAgents", `${LAUNCH_LABEL}.plist`);
+    const target = path4.join(os4.homedir(), "Library", "LaunchAgents", `${LAUNCH_LABEL}.plist`);
     await run3("launchctl", ["unload", target]).catch(() => void 0);
     await rm(target, { force: true });
   }
@@ -20760,24 +22958,24 @@ function launchdPlist() {
 `;
 }
 function entryPath() {
-  return path2.join(path2.dirname(new URL(import.meta.url).pathname), "index.js");
+  return path4.join(path4.dirname(new URL(import.meta.url).pathname), "index.js");
 }
 function expand(target) {
-  return target.startsWith("~/") ? path2.join(os2.homedir(), target.slice(2)) : target;
+  return target.startsWith("~/") ? path4.join(os4.homedir(), target.slice(2)) : target;
 }
 function configPath() {
-  return path2.join(machine.home(), "config.json");
+  return path4.join(machine.home(), "config.json");
 }
 function tokenPath() {
-  return path2.join(machine.home(), "token");
+  return path4.join(machine.home(), "token");
 }
 function ownedPath() {
-  return path2.join(machine.home(), "owned.json");
+  return path4.join(machine.home(), "owned.json");
 }
-function load() {
-  const cores = Math.max(1, os2.cpus().length);
-  const busy = Math.min(100, (os2.loadavg()[0] ?? 0) / cores * 100);
-  const used = (os2.totalmem() - os2.freemem()) / os2.totalmem() * 100;
+function load2() {
+  const cores = Math.max(1, os4.cpus().length);
+  const busy = Math.min(100, (os4.loadavg()[0] ?? 0) / cores * 100);
+  const used = (os4.totalmem() - os4.freemem()) / os4.totalmem() * 100;
   return { cpuPercent: Math.round(busy), memoryPercent: Math.round(used) };
 }
 function nextDelayMs(failures, busy = false) {
@@ -20801,16 +22999,19 @@ var MAX_BACKOFF_MS = 12e4;
 var KEYS_BEGIN = "# craftspace begin";
 var KEYS_END = "# craftspace end";
 var POLL_INTERVAL_MS = 1e3;
+var DEFAULT_URL = process.env.CRAFTSPACE_URL ?? "https://craftspace.app";
 var PROBE_EVERY_MS = 3e5;
 var probed = null;
 var reports = /* @__PURE__ */ new Map();
 var running = /* @__PURE__ */ new Set();
 
 // dist/index.js
+setup.widenPath();
 var program2 = new Command();
 program2.enablePositionalOptions().name("craftspace").description("Sign this machine in to your team, so every agent on it reads the same brain.").version(CLI_VERSION).showHelpAfterError();
-program2.command("login").description("sign this machine in").requiredOption("--token <token>", "the login token from your team", process.env.CRAFTSPACE_TOKEN).option("--url <url>", "your control plane", process.env.CRAFTSPACE_URL ?? "https://craftspace.app").option("--no-install", "do not install anything this machine is missing").action(async ({ token, url: url2, install }) => {
-  const signed = await machine.login({ token, url: url2.replace(/\/$/, ""), install });
+program2.command("login").description("sign this machine in").option("--token <token>", "the login token from your team", process.env.CRAFTSPACE_TOKEN).option("--url <url>", "your control plane", process.env.CRAFTSPACE_URL ?? "https://craftspace.app").option("--no-install", "do not install anything this machine is missing").action(async ({ token, url: url2, install }) => {
+  const where = url2.replace(/\/$/, "");
+  const signed = token === void 0 ? (await machine.signIn({ url: where, why: "Signing this machine in.", install })).machine : await machine.login({ token, url: where, install });
   process.stdout.write([
     `Signed in as ${signed.ownerName}`,
     `Machine      ${signed.name} \xB7 ${signed.platform} \xB7 ${signed.cores ?? "?"} vCPU`,
@@ -20825,13 +23026,7 @@ program2.command("run").description("run a command here, or on another workstati
   process.exitCode = await machine.run({ argv: command, ...on === void 0 ? {} : { on } });
 });
 program2.command("status").description("what this machine is and what it is doing").action(async () => {
-  const current = await machine.status();
-  if (!current) {
-    process.stdout.write("Not signed in. Run: craftspace login --token <token>\n");
-    process.exitCode = 1;
-    return;
-  }
-  const { machine: found } = current;
+  const { machine: found } = await machine.status();
   const since = found.lastBeatAt === null ? "never" : `${secondsSince(found.lastBeatAt)}s ago`;
   process.stdout.write([
     `${found.name}  ${found.state}  cli ${found.cli}  beat ${since}`,