maesttro 0.4.3 → 0.5.0

package/dist/maesttro.js

@@ -1,4 +1,95 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../node_modules/.bun/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS(function(exports, module) {
+  var ESC = "\x1B";
+  var CSI = `${ESC}[`;
+  var beep = "\x07";
+  var cursor = {
+    to(x, y) {
+      if (!y)
+        return `${CSI}${x + 1}G`;
+      return `${CSI}${y + 1};${x + 1}H`;
+    },
+    move(x, y) {
+      let ret = "";
+      if (x < 0)
+        ret += `${CSI}${-x}D`;
+      else if (x > 0)
+        ret += `${CSI}${x}C`;
+      if (y < 0)
+        ret += `${CSI}${-y}A`;
+      else if (y > 0)
+        ret += `${CSI}${y}B`;
+      return ret;
+    },
+    up: (count = 1) => `${CSI}${count}A`,
+    down: (count = 1) => `${CSI}${count}B`,
+    forward: (count = 1) => `${CSI}${count}C`,
+    backward: (count = 1) => `${CSI}${count}D`,
+    nextLine: (count = 1) => `${CSI}E`.repeat(count),
+    prevLine: (count = 1) => `${CSI}F`.repeat(count),
+    left: `${CSI}G`,
+    hide: `${CSI}?25l`,
+    show: `${CSI}?25h`,
+    save: `${ESC}7`,
+    restore: `${ESC}8`
+  };
+  var scroll = {
+    up: (count = 1) => `${CSI}S`.repeat(count),
+    down: (count = 1) => `${CSI}T`.repeat(count)
+  };
+  var erase = {
+    screen: `${CSI}2J`,
+    up: (count = 1) => `${CSI}1J`.repeat(count),
+    down: (count = 1) => `${CSI}J`.repeat(count),
+    line: `${CSI}2K`,
+    lineEnd: `${CSI}K`,
+    lineStart: `${CSI}1K`,
+    lines(count) {
+      let clear = "";
+      for (let i = 0;i < count; i++)
+        clear += this.line + (i < count - 1 ? cursor.up() : "");
+      if (count)
+        clear += cursor.left;
+      return clear;
+    }
+  };
+  module.exports = { cursor, scroll, erase, beep };
+});
 
 // src/credential-store.ts
 import {
@@ -832,6 +923,13 @@ function runnerInstructions(context) {
     "- Work in this directory. Anything outside it is not persisted.",
     "- Commit on a branch you create here. The user pushes it from their machine with `maesttro push`; the runner cannot push, merge, or delete remote branches.",
     "",
+    "## Installing tools",
+    "",
+    "- Preinstalled: Node 24 (npm, pnpm, yarn), TypeScript (`tsc`), Bun, Python 3.14 and uv (`uv venv`, `uv pip`, `uv tool`; plain `pip` and `python -m venv` work too), the .NET 10 SDK, a C/C++ build toolchain, and common CLI tools (jq, ripgrep, fd, unzip, zip, sqlite3).",
+    "- You can install more yourself without root: `npm i -g`, `bun add -g`, `pip install`, `uv tool install`, `uv python install`, `dotnet tool install -g`. They work as usual and are on `PATH` right away.",
+    "- Installs last only until this container exits; install again when a new session needs them. Don't install into your home directory to make them stick.",
+    "- System packages are unavailable: there is no root, `sudo` or `apt`. If a task needs one, tell the user which package and why.",
+    "",
     "## Pushing",
     "",
     "- `git push` does not work here: the runner has read-only access to the remote. This is deliberate.",
@@ -1043,6 +1141,30 @@ function purgeLegacyTokenOnce({
   saveConfig({ ...config, legacyTokenPurged: true });
 }
 
+// src/network-probe.ts
+import { connect } from "node:net";
+async function reachable(host, port, {
+  timeoutMs = 2000,
+  connectImpl = connect
+} = {}) {
+  return new Promise((resolve) => {
+    const socket = connectImpl(port, host);
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, timeoutMs);
+    socket.once("connect", () => {
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+
 // src/repo.ts
 import { appendFileSync, mkdirSync as mkdirSync5, realpathSync } from "node:fs";
 import { join as join5 } from "node:path";
@@ -1227,6 +1349,16 @@ async function doctor() {
         return broker;
       }
     ],
+    [
+      "dgx-spark reachable",
+      async () => {
+        const { hostname, port } = new URL(DGX_SPARK_URL);
+        if (!await reachable(hostname, Number(port))) {
+          throw new Error(`${DGX_SPARK_URL} (on the tailnet?)`);
+        }
+        return DGX_SPARK_URL;
+      }
+    ],
     [
       "Personal SSH key NOT visible inside runner (isolation intact)",
       () => {
@@ -1265,8 +1397,14 @@ Usage:
                           Same, in strict mode: no GitHub token reaches the runner, so \`gh\` is off
   maesttro resume <id>     Continue a kept session in its clone, in the mode it started with
                           (\`--strict\` or \`--no-strict\` after the id changes it)
-  maesttro sessions        List this repo's sessions (\`sessions remove <id>\` to drop one)
-  maesttro push [branch]   Push a branch a session created, after showing what goes out
+  maesttro sessions        List this repo's sessions
+  maesttro sessions remove <id>
+                          Drop one. Preserves its branches; asks before discarding commits that
+                          aren't on a branch (--force skips the ask)
+  maesttro sessions remove --all
+                          Drop all of this repo's sessions
+  maesttro push [branch] [--force]
+                          Push a branch a session created, after showing what goes out
   maesttro list            Show available clients
   maesttro setup           One-time: build image, create volume, log in to GitHub
   maesttro login           Log in to GitHub (device flow) so sessions get repo access
@@ -1660,6 +1798,14 @@ function stripControl(text) {
   }
   return out;
 }
+var ESC = String.fromCharCode(27);
+var BEL = String.fromCharCode(7);
+var ANSI = new RegExp(`${ESC}(?:\\[[0-9;?]*[a-zA-Z]|\\][^${BEL}]*${BEL})?`, "g");
+function cleanOutput(text) {
+  return text.split(`
+`).map((line) => stripControl(line.replace(ANSI, "")).replace(/\r+$/, "")).join(`
+`).trim();
+}
 var VALID_BRANCH = /^[A-Za-z0-9](?:[A-Za-z0-9._/-]*[A-Za-z0-9_-])?$/;
 function isSafeBranchName(name) {
   if (name.length === 0 || name.length > 255)
@@ -2277,6 +2423,1049 @@ async function launch({
 
 // src/push.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
+
+// ../node_modules/.bun/@clack+core@1.5.1/node_modules/@clack/core/dist/index.mjs
+import { stdout, stdin } from "node:process";
+import * as l from "node:readline";
+import l__default from "node:readline";
+
+// ../node_modules/.bun/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = (() => {
+  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/.bun/fast-string-truncated-width@3.0.3/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_default = getStringTruncatedWidth;
+
+// ../node_modules/.bun/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// ../node_modules/.bun/fast-wrap-ansi@0.2.2/node_modules/fast-wrap-ansi/lib/main.js
+var ESC2 = "\x1B";
+var CSI = "›";
+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;
+};
+var wrapAnsiCode = (code) => `${ESC2}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC2}${ANSI_ESCAPE_LINK}${url}${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 === undefined ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC2 || 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 !== undefined && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.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_default2(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_default2(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_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(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(`
+`);
+  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 === ESC2 || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== undefined) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? undefined : code;
+      } else if (groups?.uri !== undefined) {
+        escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+      }
+    }
+    if (preString[i + 1] === `
+`) {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === `
+`) {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join(`
+`);
+}
+
+// ../node_modules/.bun/@clack+core@1.5.1/node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream } from "node:tty";
+function findCursor(s, o, l) {
+  if (!l.some((r) => !r.disabled))
+    return s;
+  const t = s + o, n = Math.max(l.length - 1, 0), e = t < 0 ? n : t > n ? 0 : t;
+  return l[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l) : e;
+}
+var a$1 = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var settings = {
+  actions: new Set(a$1),
+  aliases: /* @__PURE__ */ new Map([
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["\x03", "cancel"],
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  accessible: undefined,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n, e) => `There are only ${n} days in ${e}`,
+      afterMin: (n) => `Date must be on or after ${n.toISOString().slice(0, 10)}`,
+      beforeMax: (n) => `Date must be on or before ${n.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isAccessible(n) {
+  if (n !== undefined)
+    return n;
+  if (settings.accessible !== undefined)
+    return settings.accessible;
+  const e = process.env.ACCESSIBLE;
+  return e !== undefined && e !== "" && e !== "0" && e !== "false";
+}
+function isActionKey(n, e) {
+  if (typeof n == "string")
+    return settings.aliases.get(n) === e;
+  for (const s of n)
+    if (s !== undefined && isActionKey(s, e))
+      return true;
+  return false;
+}
+function diffLines(i, s) {
+  if (i === s)
+    return;
+  const e = i.split(`
+`), t = s.split(`
+`), r = Math.max(e.length, t.length), f = [];
+  for (let n = 0;n < r; n++)
+    e[n] !== t[n] && f.push(n);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t.length,
+    numLines: r
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = Symbol("clack:cancel");
+function isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r) {
+  const o = e;
+  o.isTTY && o.setRawMode(r);
+}
+function block({
+  input: e = stdin,
+  output: r = stdout,
+  overwrite: o = true,
+  hideCursor: n = true
+} = {}) {
+  const s = l.createInterface({
+    input: e,
+    output: r,
+    prompt: "",
+    tabSize: 1
+  });
+  l.emitKeypressEvents(e, s), e instanceof ReadStream && e.isTTY && e.setRawMode(true);
+  const t = (f, { name: a, sequence: w }) => {
+    const c = String(f);
+    if (isActionKey([c, a, w], "cancel")) {
+      n && r.write(import_sisteransi.cursor.show), process.exit(0);
+      return;
+    }
+    if (!o)
+      return;
+    const i = a === "return" ? 0 : -1, m = a === "return" ? -1 : 0;
+    l.moveCursor(r, i, m, () => {
+      l.clearLine(r, 1, () => {
+        e.once("keypress", t);
+      });
+    });
+  };
+  return n && r.write(import_sisteransi.cursor.hide), e.once("keypress", t), () => {
+    e.off("keypress", t), n && r.write(import_sisteransi.cursor.show), e instanceof ReadStream && e.isTTY && !R && e.setRawMode(false), s.terminal = false, s.close();
+  };
+}
+var getColumns = (e) => ("columns" in e) && typeof e.columns == "number" ? e.columns : 80;
+var getRows = (e) => ("rows" in e) && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r, o, n = o, s = o, t) {
+  const f = getColumns(e ?? stdout);
+  return wrapAnsi(r, f - o.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c, i, m) => {
+    const d = t ? t(c, i) : c;
+    return i === 0 ? `${n}${d}` : i === m.length - 1 ? `${s}${d}` : `${o}${d}`;
+  }).join(`
+`);
+}
+function runValidation(e, a) {
+  if ("~standard" in e) {
+    const n = e["~standard"].validate(a);
+    return n instanceof Promise ? n.then((r) => r.issues?.at(0)?.message) : n.issues?.at(0)?.message;
+  }
+  return e(a);
+}
+
+class y {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map;
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  get accessible() {
+    return isAccessible(this.opts.accessible);
+  }
+  constructor(t, e = true) {
+    const { input: i = stdin, output: s = stdout, render: r, signal: n, ...o } = t;
+    this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = r.bind(this), this._track = e, this._abortSignal = n, this.input = i, this.output = s;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(t, e) {
+    const i = this._subscribers.get(t) ?? [];
+    i.push(e), this._subscribers.set(t, i);
+  }
+  on(t, e) {
+    this.setSubscriber(t, { cb: e });
+  }
+  once(t, e) {
+    this.setSubscriber(t, { cb: e, once: true });
+  }
+  emit(t, ...e) {
+    const i = this._subscribers.get(t) ?? [], s = [];
+    for (const r of i)
+      r.cb(...e), r.once && s.push(() => i.splice(i.indexOf(r), 1));
+    for (const r of s)
+      r();
+  }
+  prompt() {
+    return new Promise((t) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel", this.close();
+        }, { once: true });
+      }
+      this.rl = l__default.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== undefined && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t, e) {
+    return t === "\t";
+  }
+  _shouldSubmit(t, e) {
+    return true;
+  }
+  _setValue(t) {
+    this.value = t, this.emit("value", this.value);
+  }
+  _setUserInput(t, e) {
+    this.userInput = t ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  async onKeypress(t, e) {
+    if (this.state !== "validating") {
+      if (this._track && e.name !== "return" && (e.name && this._isActionKey(t, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t && (t.toLowerCase() === "y" || t.toLowerCase() === "n") && this.emit("confirm", t.toLowerCase() === "y"), this.emit("key", t, e), e?.name === "return" && this._shouldSubmit(t, e)) {
+        if (this.opts.validate) {
+          const i = runValidation(this.opts.validate, this.value);
+          let s;
+          i instanceof Promise ? (this.state = "validating", this.render(), s = await i) : s = i, s && (this.error = s instanceof Error ? s.message : s, this.state = "error", this.rl?.write(this.userInput));
+        }
+        this.state !== "error" && (this.state = "submit");
+      }
+      isActionKey([t, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+    }
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = undefined, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t * -1));
+  }
+  render() {
+    const t = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e = diffLines(this._prevFrame, t), i = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const s = Math.max(0, e.numLinesAfter - i), r = Math.max(0, e.numLinesBefore - i);
+          let n = e.lines.find((o) => o >= s);
+          if (n === undefined) {
+            this._prevFrame = t;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, n - r)), this.output.write(import_sisteransi.erase.lines(1));
+            const o = t.split(`
+`);
+            this.output.write(o[n]), this._prevFrame = t, this.output.write(import_sisteransi.cursor.move(0, o.length - n - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (s < r)
+              n = s;
+            else {
+              const h = n - r;
+              h > 0 && this.output.write(import_sisteransi.cursor.move(0, h));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t.split(`
+`).slice(n);
+            this.output.write(f.join(`
+`)), this._prevFrame = t;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t), this.state === "initial" && (this.state = "active"), this._prevFrame = t;
+    }
+  }
+}
+class r extends y {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t) {
+    super(t, false), this.value = !!t.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = i, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+}
+var n$1 = class n extends y {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    const e = this._selectedValue;
+    this.value = e === undefined ? undefined : e.value;
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options;
+    const o = this.options.findIndex(({ value: s }) => s === e.initialValue), t = o === -1 ? 0 : o;
+    this.cursor = this.options[t]?.disabled ? findCursor(t, 1, this.options) : t, this.changeValue(), this.on("cursor", (s) => {
+      switch (s) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+
+// ../node_modules/.bun/@clack+prompts@1.8.1/node_modules/@clack/prompts/dist/index.mjs
+import { styleText, stripVTControlCharacters } from "node:util";
+import process$1 from "node:process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+function isUnicodeSupported() {
+  if (process$1.platform !== "win32") {
+    return process$1.env.TERM !== "linux";
+  }
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var isCI = () => process.env.CI === "true";
+var unicodeOr = (o, e) => unicode ? o : e;
+var S_STEP_ACTIVE = unicodeOr("◆", "*");
+var S_STEP_CANCEL = unicodeOr("■", "x");
+var S_STEP_ERROR = unicodeOr("▲", "x");
+var S_STEP_SUBMIT = unicodeOr("◇", "o");
+var S_BAR_START = unicodeOr("┌", "T");
+var S_BAR = unicodeOr("│", "|");
+var S_BAR_END = unicodeOr("└", "—");
+var S_BAR_START_RIGHT = unicodeOr("┐", "T");
+var S_BAR_END_RIGHT = unicodeOr("┘", "—");
+var S_RADIO_ACTIVE = unicodeOr("●", ">");
+var S_RADIO_INACTIVE = unicodeOr("○", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("◻", "[•]");
+var S_CHECKBOX_SELECTED = unicodeOr("◼", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("◻", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("▪", "•");
+var S_BAR_H = unicodeOr("─", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("╮", "+");
+var S_CONNECT_LEFT = unicodeOr("├", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("╯", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("╰", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("╭", "+");
+var S_INFO = unicodeOr("●", "•");
+var S_SUCCESS = unicodeOr("◆", "*");
+var S_WARN = unicodeOr("▲", "!");
+var S_ERROR = unicodeOr("■", "x");
+var symbol = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return styleText("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return styleText("red", S_STEP_CANCEL);
+    case "error":
+      return styleText("yellow", S_STEP_ERROR);
+    case "submit":
+      return styleText("green", S_STEP_SUBMIT);
+    case "validating":
+      return styleText("dim", S_STEP_ACTIVE);
+  }
+};
+var symbolBar = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return styleText("cyan", S_BAR);
+    case "cancel":
+      return styleText("red", S_BAR);
+    case "error":
+      return styleText("yellow", S_BAR);
+    case "submit":
+      return styleText("green", S_BAR);
+  }
+};
+function formatInstructionFooter(o, e) {
+  const r = [`${e ? `${styleText("cyan", S_BAR)}  ` : ""}${o.join(" • ")}`];
+  return e && r.push(styleText("cyan", S_BAR_END)), r;
+}
+var I = (l, e, w, p, b, C = false) => {
+  let r = e, O = 0;
+  if (C)
+    for (let i = p - 1;i >= w; i--) {
+      const m = l[i];
+      if (m && (r -= m.length), O++, r <= b)
+        break;
+    }
+  else
+    for (let i = w;i < p; i++) {
+      const m = l[i];
+      if (m && (r -= m.length), O++, r <= b)
+        break;
+    }
+  return { lineCount: r, removals: O };
+};
+var limitOptions = ({
+  cursor: l,
+  options: e,
+  style: w,
+  output: p = process.stdout,
+  maxItems: b = Number.POSITIVE_INFINITY,
+  columnPadding: C = 0,
+  rowPadding: r = 4
+}) => {
+  const i = getColumns(p) - C, m = getRows(p), M = styleText("dim", "..."), v = Math.max(m - r, 0), a = Math.max(Math.min(b, v), 5);
+  let f = 0;
+  l >= a - 3 && (f = Math.max(Math.min(l - a + 3, e.length - a), 0));
+  let d = a < e.length && f > 0, c = a < e.length && f + a < e.length;
+  const W = Math.min(f + a, e.length), s = [];
+  let g = 0;
+  d && g++, c && g++;
+  const T = f + (d ? 1 : 0), y = W - (c ? 1 : 0);
+  for (let t = T;t < y; t++) {
+    const n = e[t], o = n ? w(n, t === l) : "", h = wrapAnsi(o, i, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s.push(h), g += h.length;
+  }
+  if (g > v) {
+    let t = 0, n = 0, o = g;
+    const h = l - T;
+    let u = v;
+    const L = () => I(s, o, 0, h, u), E = () => I(s, o, h + 1, s.length, u, true);
+    d ? ({ lineCount: o, removals: t } = L(), o > u && (c || (u -= 1), { lineCount: o, removals: n } = E())) : (c || (u -= 1), { lineCount: o, removals: n } = E(), o > u && (u -= 1, { lineCount: o, removals: t } = L())), t > 0 && (d = true, s.splice(0, t)), n > 0 && (c = true, s.splice(s.length - n, n));
+  }
+  const x = [];
+  d && x.push(M);
+  for (const t of s)
+    for (const n of t)
+      x.push(n);
+  return c && x.push(M), x;
+};
+var confirm = (e) => {
+  const a = e.active ?? "Yes", o = e.inactive ?? "No";
+  return new r({
+    active: a,
+    inactive: o,
+    signal: e.signal,
+    input: e.input,
+    output: e.output,
+    initialValue: e.initialValue ?? true,
+    render() {
+      const i = e.withGuide ?? settings.withGuide, u = `${symbol(this.state)}  `, l = i ? `${styleText("gray", S_BAR)}  ` : "", f = wrapTextWithPrefix(e.output, e.message, l, u), s = `${i ? `${styleText("gray", S_BAR)}
+` : ""}${f}
+`, c = this.value ? a : o;
+      switch (this.state) {
+        case "submit": {
+          const r = i ? `${styleText("gray", S_BAR)}  ` : "";
+          return `${s}${r}${styleText("dim", c)}`;
+        }
+        case "cancel": {
+          const r = i ? `${styleText("gray", S_BAR)}  ` : "";
+          return `${s}${r}${styleText(["strikethrough", "dim"], c)}${i ? `
+${styleText("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r = i ? `${styleText("cyan", S_BAR)}  ` : "", g = i ? styleText("cyan", S_BAR_END) : "";
+          return `${s}${r}${this.value ? `${styleText("green", S_RADIO_ACTIVE)} ${a}` : `${styleText("dim", S_RADIO_INACTIVE)} ${styleText("dim", a)}`}${e.vertical ? i ? `
+${styleText("cyan", S_BAR)}  ` : `
+` : ` ${styleText("dim", "/")} `}${this.value ? `${styleText("dim", S_RADIO_INACTIVE)} ${styleText("dim", o)}` : `${styleText("green", S_RADIO_ACTIVE)} ${o}`}
+${g}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText("dim", "↑/↓")} to navigate`,
+  `${styleText("dim", "Space:")} select`,
+  `${styleText("dim", "Enter:")} confirm`
+];
+var intro = (o = "", t) => {
+  const i = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR_START)}  ` : "";
+  i.write(`${e}${o}
+`);
+};
+var outro = (o = "", t) => {
+  const i = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR)}
+${styleText("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${o}
+
+`);
+};
+var W = (l) => styleText("magenta", l);
+var spinner = ({
+  indicator: l = "dots",
+  onCancel: h,
+  output: n = process.stdout,
+  cancelMessage: G,
+  errorMessage: O,
+  frames: E = unicode ? ["◒", "◐", "◓", "◑"] : ["•", "o", "O", "0"],
+  delay: F = unicode ? 80 : 120,
+  signal: m,
+  ...I
+} = {}) => {
+  const u = isCI();
+  let M, T, d = false, S = false, s = "", p, w = performance.now();
+  const x = getColumns(n), k = I?.styleFrame ?? W, g = (e) => {
+    const r = e > 1 ? O ?? settings.messages.error : G ?? settings.messages.cancel;
+    S = e === 1, d && (a(r, e), S && typeof h == "function" && h());
+  }, f = () => g(2), i = () => g(1), A = () => {
+    process.on("uncaughtExceptionMonitor", f), process.on("unhandledRejection", f), process.on("SIGINT", i), process.on("SIGTERM", i), process.on("exit", g), m && m.addEventListener("abort", i);
+  }, H = () => {
+    process.removeListener("uncaughtExceptionMonitor", f), process.removeListener("unhandledRejection", f), process.removeListener("SIGINT", i), process.removeListener("SIGTERM", i), process.removeListener("exit", g), m && m.removeEventListener("abort", i);
+  }, y = () => {
+    if (p === undefined)
+      return;
+    u && n.write(`
+`);
+    const r = wrapAnsi(p, x, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    r.length > 1 && n.write(import_sisteransi2.cursor.up(r.length - 1)), n.write(import_sisteransi2.cursor.to(0)), n.write(import_sisteransi2.erase.down());
+  }, C = (e) => e.replace(/\.+$/, ""), _ = (e) => {
+    const r = (performance.now() - e) / 1000, t = Math.floor(r / 60), o = Math.floor(r % 60);
+    return t > 0 ? `[${t}m ${o}s]` : `[${o}s]`;
+  }, N = I.withGuide ?? settings.withGuide, P = (e = "") => {
+    d = true, M = block({ output: n }), s = C(e), w = performance.now(), N && n.write(`${styleText("gray", S_BAR)}
+`);
+    let r = 0, t = 0;
+    A(), T = setInterval(() => {
+      if (u && s === p)
+        return;
+      y(), p = s;
+      const o = k(E[r]);
+      let v;
+      if (u)
+        v = `${o}  ${s}...`;
+      else if (l === "timer")
+        v = `${o}  ${s} ${_(w)}`;
+      else {
+        const B = ".".repeat(Math.floor(t)).slice(0, 3);
+        v = `${o}  ${s}${B}`;
+      }
+      const j = wrapAnsi(v, x, {
+        hard: true,
+        trim: false
+      });
+      n.write(j), r = r + 1 < E.length ? r + 1 : 0, t = t < 4 ? t + 0.125 : 0;
+    }, F);
+  }, a = (e = "", r = 0, t = false) => {
+    if (!d)
+      return;
+    d = false, clearInterval(T), y();
+    const o = r === 0 ? styleText("green", S_STEP_SUBMIT) : r === 1 ? styleText("red", S_STEP_CANCEL) : styleText("red", S_STEP_ERROR);
+    s = e ?? s, t || (l === "timer" ? n.write(`${o}  ${s} ${_(w)}
+`) : n.write(`${o}  ${s}
+`)), H(), M();
+  };
+  return {
+    start: P,
+    stop: (e = "") => a(e, 0),
+    message: (e = "") => {
+      s = C(e ?? s);
+    },
+    cancel: (e = "") => a(e, 1),
+    error: (e = "") => a(e, 2),
+    clear: () => a("", 0, true),
+    get isCancelled() {
+      return S;
+    }
+  };
+};
+var u2 = {
+  light: unicodeOr("─", "-"),
+  heavy: unicodeOr("━", "="),
+  block: unicodeOr("█", "#")
+};
+var SELECT_INSTRUCTIONS = [
+  `${styleText("dim", "↑/↓")} to navigate`,
+  `${styleText("dim", "Enter:")} confirm`
+];
+var c = (t, o) => t.includes(`
+`) ? t.split(`
+`).map((d) => o(d)).join(`
+`) : o(t);
+var select = (t) => {
+  const o = (n, m) => {
+    if (n === undefined)
+      return "";
+    const s = n.label ?? String(n.value);
+    switch (m) {
+      case "disabled":
+        return `${styleText("gray", S_RADIO_INACTIVE)} ${c(s, (i) => styleText("gray", i))}${n.hint ? ` ${styleText("dim", `(${n.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${c(s, (i) => styleText("dim", i))}`;
+      case "active":
+        return `${styleText("green", S_RADIO_ACTIVE)} ${s}${n.hint ? ` ${styleText("dim", `(${n.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${c(s, (i) => styleText(["strikethrough", "dim"], i))}`;
+      default:
+        return `${styleText("dim", S_RADIO_INACTIVE)} ${c(s, (i) => styleText("dim", i))}`;
+    }
+  }, d = t.showInstructions ?? true;
+  return new n$1({
+    options: t.options,
+    signal: t.signal,
+    input: t.input,
+    output: t.output,
+    initialValue: t.initialValue,
+    render() {
+      const n = t.withGuide ?? settings.withGuide, m = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, i = wrapTextWithPrefix(t.output, t.message, s, m), u = `${n ? `${styleText("gray", S_BAR)}
+` : ""}${i}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r = n ? `${styleText("gray", S_BAR)}  ` : "", a = wrapTextWithPrefix(t.output, o(this.options[this.cursor], "selected"), r);
+          return `${u}${a}`;
+        }
+        case "cancel": {
+          const r = n ? `${styleText("gray", S_BAR)}  ` : "", a = wrapTextWithPrefix(t.output, o(this.options[this.cursor], "cancelled"), r);
+          return `${u}${a}${n ? `
+${styleText("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r = n ? `${styleText("cyan", S_BAR)}  ` : "", a = u.split(`
+`).length, p = d ? formatInstructionFooter(SELECT_INSTRUCTIONS, n) : n ? [styleText("cyan", S_BAR_END)] : [], f = p.join(`
+`), b = p.length + 1;
+          return `${u}${r}${limitOptions({
+            output: t.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: t.maxItems,
+            columnPadding: r.length,
+            rowPadding: a + b,
+            style: (g, x) => o(g, g.disabled ? "disabled" : x ? "active" : "inactive")
+          }).join(`
+${r}`)}
+${f}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var i = `${styleText("gray", S_BAR)}  `;
+
+// src/push.ts
+var CONFIRM_FLAGS = new Set(["--yes", "-y"]);
+var FORWARDED_GIT_FLAGS = new Set(["--force"]);
+function parsePushArgs(args) {
+  const positionals = args.filter((arg) => !arg.startsWith("-"));
+  if (positionals.length > 1) {
+    return {
+      ok: false,
+      reason: `Expected at most one branch, got ${positionals.join(", ")}.`
+    };
+  }
+  const flags = args.filter((arg) => arg.startsWith("-"));
+  const unsupported = flags.filter((flag) => !CONFIRM_FLAGS.has(flag) && !FORWARDED_GIT_FLAGS.has(flag));
+  if (unsupported.length > 0) {
+    return {
+      ok: false,
+      reason: `maesttro push doesn't accept ${unsupported.join(", ")}; it takes --yes and --force.`
+    };
+  }
+  const [requested] = positionals;
+  return {
+    ok: true,
+    ...requested === undefined ? {} : { requested },
+    yes: flags.some((flag) => CONFIRM_FLAGS.has(flag)),
+    gitFlags: flags.filter((flag) => FORWARDED_GIT_FLAGS.has(flag))
+  };
+}
 function pushCandidates(sessions) {
   const candidates = new Map;
   for (const session of sessions) {
@@ -2320,43 +3509,78 @@ function planPush({
     reason: names.length === 0 ? "No session in this repo has a branch ready to push." : "Several session branches are ready; pick one."
   };
 }
-async function choose(candidates) {
-  if (!process.stdin.isTTY)
-    return;
-  console.log(candidates.map((name, index) => `  ${index + 1}) ${name}`).join(`
-`));
-  const answer = await ask("Branch to push: ");
-  return candidates[Number(answer) - 1];
-}
-function describe(run, root, branch, base, tip) {
-  const commits = git(run, root, [
-    "log",
-    "--format=  %h %s (%an / %cn)",
-    `${base}..${tip}`
+function branchHint(run, candidate) {
+  const count = git(run, candidate.dir, [
+    "rev-list",
+    "--count",
+    `${candidate.baseSha}..${candidate.branch}`
   ]).out;
-  const stat = git(run, root, ["diff", "--stat", `${base}...${tip}`]).out;
+  const stat = cleanOutput(git(run, candidate.dir, [
+    "diff",
+    "--no-color",
+    "--stat",
+    `${candidate.baseSha}...${candidate.branch}`
+  ]).out);
+  const files = stat.split(`
+`).pop() ?? "";
   return [
-    `Pushing ${branch} to origin (compared with ${base}):`,
-    stripControl(commits) || "  (no new commits)",
+    `${count || "0"} commit${count === "1" ? "" : "s"}`,
+    files || "no file changes"
+  ].join(" | ");
+}
+async function chooseInteractive(run, names, candidates) {
+  return select({
+    message: "Branch to push",
+    options: names.map((name) => ({
+      value: name,
+      label: name,
+      hint: branchHint(run, candidates.get(name))
+    }))
+  });
+}
+function describe(run, root, branch, base, tip, gitFlags) {
+  const commits = cleanOutput(git(run, root, ["log", "--format=  %h %s (%an / %cn)", `${base}..${tip}`]).out);
+  const stat = cleanOutput(git(run, root, ["diff", "--no-color", "--stat", `${base}...${tip}`]).out);
+  return [
+    `Pushing ${branch} to origin${gitFlags.length ? ` with ${gitFlags.join(" ")}` : ""} (compared with ${base}):`,
+    `
+Commits:`,
+    commits || "  (no new commits)",
     stat ? `
-${stripControl(stat)}` : ""
+Changed files:
+${stat}` : ""
   ].join(`
 `);
 }
 async function push({ args }) {
   const run = runCommand;
-  const yes = args.includes("--yes") || args.includes("-y");
-  const requested = args.find((arg) => !arg.startsWith("-"));
+  const parsed = parsePushArgs(args);
+  if (!parsed.ok) {
+    console.error(parsed.reason);
+    process.exitCode = 1;
+    return;
+  }
+  const { requested, yes, gitFlags } = parsed;
   let root;
   try {
     root = repoRoot(run, process.cwd());
   } catch (error) {
     throw error instanceof LaunchError ? error : new LaunchError(String(error));
   }
+  const tty = process.stdin.isTTY === true;
   const candidates = pushCandidates(sessionsForRepo(root));
   let plan = planPush({ requested, candidates });
   if (!plan.ok && !requested && plan.candidates.length > 1) {
-    const picked = await choose(plan.candidates);
+    let picked;
+    if (tty) {
+      intro("maesttro push");
+      const chosen = await chooseInteractive(run, plan.candidates, candidates);
+      if (isCancel(chosen)) {
+        console.log("Not pushed.");
+        return;
+      }
+      picked = chosen;
+    }
     if (picked)
       plan = planPush({ requested: picked, candidates });
   }
@@ -2366,62 +3590,125 @@ async function push({ args }) {
     return;
   }
   const { branch, base, baseSha, dir, sessionId } = plan.candidate;
+  const prepare = tty ? spinner() : undefined;
+  prepare?.start(`Preparing ${branch}...`);
   const tip = branchTip(dir, branch);
   if (!tip || !importObjects(run, root, dir, tip)) {
+    prepare?.stop(`Could not prepare ${branch}.`);
     console.error(`Could not read ${branch} from session ${sessionId}.`);
     process.exitCode = 1;
     return;
   }
   git(run, root, ["update-ref", `refs/maesttro/${sessionId}/${branch}`, tip]);
-  console.log(describe(run, root, branch, base, tip));
+  prepare?.stop(`Prepared ${branch}.`);
+  console.log(describe(run, root, branch, base, tip, gitFlags));
   if (!yes) {
-    if (!process.stdin.isTTY) {
+    if (!tty) {
       console.error("Not a terminal; re-run with --yes to push without confirming.");
       process.exitCode = 1;
       return;
     }
-    const answer = await ask(`
-Push? [y/N] `);
-    if (!/^y(es)?$/i.test(answer)) {
+    const answer = await confirm({ message: `Push ${branch} to origin?` });
+    if (isCancel(answer) || !answer) {
       console.log("Not pushed.");
       return;
     }
   }
-  const pushed = spawnSync3("git", ["-C", root, "push", "origin", `${tip}:refs/heads/${branch}`], { stdio: "inherit" });
+  const pushed = spawnSync3("git", ["-C", root, "push", ...gitFlags, "origin", `${tip}:refs/heads/${branch}`], { stdio: "inherit" });
   if (pushed.status === 0) {
-    console.log(`Pushed ${branch}. Base for comparison was ${baseSha.slice(0, 8)}.`);
+    const done = `Pushed ${branch}. Base for comparison was ${baseSha.slice(0, 8)}.`;
+    if (tty && !yes)
+      outro(done);
+    else
+      console.log(done);
   }
   process.exitCode = pushed.status ?? 1;
 }
 
 // src/sessions-command.ts
 import { existsSync as existsSync5, rmSync as rmSync7 } from "node:fs";
-function sessionsCommand({ args }) {
+function parseRemoveArgs(args) {
+  let all = false;
+  let force = false;
+  let id;
+  for (const arg of args) {
+    if (arg === "--all")
+      all = true;
+    else if (arg === "--force")
+      force = true;
+    else if (id === undefined)
+      id = arg;
+  }
+  return { all, force, id };
+}
+async function removeSession(run, session, force, ask, interactive) {
+  if (existsSync5(session.worktree)) {
+    const preserved = preserveBranches(run, session);
+    const head = cloneHead(session.worktree);
+    const unbranched = preserved.length === 0 && head?.detached !== undefined && head.detached !== session.baseSha;
+    if (unbranched && !force) {
+      let proceed;
+      if (interactive) {
+        const answer = await ask(`Session ${session.id} has commits on a detached HEAD not on any branch. Removing it discards them. Remove anyway? [y/N] `);
+        proceed = /^(y(es)?)?$/i.test(answer);
+      } else {
+        proceed = false;
+        console.error(`Session ${session.id} has commits on a detached HEAD not on any branch. Resume and create a branch, or re-run with --force.`);
+      }
+      if (!proceed) {
+        console.log(`Kept session ${session.id}.`);
+        return "kept";
+      }
+    }
+    rmSync7(session.worktree, { recursive: true, force: true });
+    const kept = preserved.length > 0 ? ` Its branches are kept as refs/maesttro/${session.id}/*.` : "";
+    console.log(`Removed session ${session.id}.${kept}`);
+  } else {
+    console.log(`Removed session ${session.id}.`);
+  }
+  deleteSession(session.id);
+  return "removed";
+}
+async function sessionsCommand({
+  args,
+  ask: ask2 = ask,
+  interactive = process.stdin.isTTY === true
+}) {
   const run = runCommand;
   const root = repoRoot(run, process.cwd());
-  const [action, id] = args;
+  const [action, ...rest] = args;
   if (action === "remove") {
-    const session = id ? readSession(id) : undefined;
-    if (!session || session.repoRoot !== root) {
-      console.error(`No session ${id ?? "(missing id)"} in this repo.`);
-      process.exitCode = 1;
-      return;
-    }
-    if (existsSync5(session.worktree)) {
-      const preserved = preserveBranches(run, session);
-      const head = cloneHead(session.worktree);
-      if (preserved.length === 0 && head?.detached !== undefined && head.detached !== session.baseSha) {
-        console.error(`${session.id} has commits on a detached HEAD not on any branch; resume and create a branch first.`);
+    const { all, force, id } = parseRemoveArgs(rest);
+    if (all) {
+      if (id !== undefined) {
+        console.error("`maesttro sessions remove` takes either `--all` or a session id, not both.");
         process.exitCode = 1;
         return;
       }
-      rmSync7(session.worktree, { recursive: true, force: true });
-      const kept = preserved.length > 0 ? ` Its branches are kept as refs/maesttro/${session.id}/*.` : "";
-      console.log(`Removed session ${session.id}.${kept}`);
-    } else {
-      console.log(`Removed session ${session.id}.`);
+      const sessions = sessionsForRepo(root);
+      if (sessions.length === 0) {
+        console.log("No maesttro sessions in this repo.");
+        return;
+      }
+      for (const session of sessions) {
+        await removeSession(run, session, force, ask2, interactive);
+      }
+      return;
     }
-    deleteSession(session.id);
+    if (id === undefined) {
+      console.error("Usage: maesttro sessions remove <id> | maesttro sessions remove --all");
+      process.exitCode = 1;
+      return;
+    }
+    const session = readSession(id);
+    if (!session || session.repoRoot !== root) {
+      console.error(`No session ${id} in this repo.`);
+      process.exitCode = 1;
+      return;
+    }
+    const result = await removeSession(run, session, force, ask2, interactive);
+    if (result === "kept")
+      process.exitCode = 1;
     return;
   }
   const sessions = sessionsForRepo(root);
@@ -2482,6 +3769,78 @@ async function setup({ args }) {
 // src/update.ts
 import { execSync as execSync5 } from "node:child_process";
 
+// src/runner-images.ts
+var RUNNER_LABEL = "org.maesttro.runner";
+var RUNNER_ENTRYPOINT = "/usr/local/bin/maesttro-entrypoint";
+var INSPECT_FORMAT = "{{.Id}}\t{{json .Config}}\t{{json .RepoTags}}";
+function parseJson(text, fallback) {
+  try {
+    return JSON.parse(text ?? "") ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+function parseImageRows(stdout) {
+  return stdout.split(`
+`).filter((line) => line.trim() !== "").map((line) => {
+    const [id = "", config, tags] = line.split("\t");
+    const { Entrypoint, Labels } = parseJson(config, {});
+    return {
+      id,
+      entrypoint: Entrypoint ?? [],
+      labels: Labels ?? {},
+      tags: parseJson(tags, [])
+    };
+  });
+}
+function isRunnerImage(row) {
+  return row.labels[RUNNER_LABEL] !== undefined || row.entrypoint.includes(RUNNER_ENTRYPOINT);
+}
+function staleRunnerImages({
+  rows,
+  latestId
+}) {
+  if (!latestId)
+    return [];
+  return rows.filter((row) => row.id !== latestId && isRunnerImage(row));
+}
+function currentLatestId(run) {
+  const result = run("docker", [
+    "image",
+    "inspect",
+    "--format",
+    "{{.Id}}",
+    IMAGE
+  ]);
+  return result.status === 0 ? result.stdout.trim() || undefined : undefined;
+}
+function removeStaleRunnerImages({
+  run = runCommand,
+  latestId = () => currentLatestId(run)
+} = {}) {
+  const listed = run("docker", ["image", "ls", "--quiet", "--no-trunc"]);
+  if (listed.status !== 0)
+    return 0;
+  const ids = [
+    ...new Set(listed.stdout.split(`
+`).map((id) => id.trim()).filter(Boolean))
+  ];
+  if (ids.length === 0)
+    return 0;
+  const inspected = run("docker", [
+    "image",
+    "inspect",
+    "--format",
+    INSPECT_FORMAT,
+    ...ids
+  ]);
+  const stale = staleRunnerImages({
+    rows: parseImageRows(inspected.stdout),
+    latestId: latestId()
+  });
+  return stale.filter((image) => run("docker", ["rmi", ...image.tags, image.id]).status === 0).length;
+}
+
 // src/version-check.ts
 import { execFile } from "node:child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync8 } from "node:fs";
@@ -2541,6 +3900,10 @@ function update() {
 -> Rebuilding runner image with refreshed client configs...`);
   execSync5(`docker build -t ${IMAGE} "${DOCKERFILE_DIR}"`, { stdio: "inherit" });
   console.log(`
+-> Removing older runner images...`);
+  const removed = removeStaleRunnerImages();
+  console.log(removed > 0 ? `   Removed ${removed} older runner image${removed === 1 ? "" : "s"}.` : "   None to remove.");
+  console.log(`
 Update complete. Bot identity and your project files are untouched —`);
   console.log("only the runner image (client versions + curated configs) was refreshed.");
 }