@kaynooo/cli-docker 0.2.0 → 0.4.0

package/dist/sf-cli.js

@@ -0,0 +1,1339 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/sf-cli.ts
+import process11 from "process";
+
+// ../kit/src/args.ts
+import process4 from "process";
+import { parseArgs } from "util";
+
+// ../kit/src/style.ts
+import process2 from "process";
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.2+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-mtetydvc.js
+function x(s) {
+  let r = s.startsWith("#") ? s.slice(1).toLowerCase() : s.toLowerCase();
+  if (!/^[a-f0-9]+$/.test(r))
+    return [0, 0, 0];
+  let t = r.length, n = (c) => Number.parseInt(c, 16);
+  if (t === 3 || t === 4) {
+    let c = n(r[0] + r[0]), u = n(r[1] + r[1]), h = n(r[2] + r[2]), g = t === 4 ? n(r[3] + r[3]) : undefined;
+    return g !== undefined ? [c, u, h, g] : [c, u, h];
+  }
+  if (t !== 6 && t !== 8)
+    throw Error(`Invalid hex color length: ${t}`);
+  let a = n(r.slice(0, 2)), b = n(r.slice(2, 4)), o = n(r.slice(4, 6)), y = t === 8 ? n(r.slice(6, 8)) : undefined;
+  if ([a, b, o].some(Number.isNaN) || y !== undefined && Number.isNaN(y))
+    throw Error(`Invalid hex color value: ${s}`);
+  return y !== undefined ? [a, b, o, y] : [a, b, o];
+}
+function A(s) {
+  let [r, t, n, a] = s;
+  if (a)
+    return `#${(r << 24 | t << 16 | n << 8 | Math.round((a ?? 1) * 255)).toString(16).padStart(8, "0").toUpperCase()}`;
+  return `#${(r << 16 | t << 8 | n).toString(16).padStart(6, "0").toUpperCase()}`;
+}
+function R(s, r, t) {
+  s = (s % 360 + 360) % 360, t /= 100;
+  let n = r * Math.min(t, 1 - t) / 100, a = (b) => {
+    let o = (b + s / 30) % 12, y = t - n * Math.max(Math.min(o - 3, 9 - o, 1), -1);
+    return Math.round(255 * y);
+  };
+  return [a(0), a(8), a(4)];
+}
+function k(s) {
+  let [r, t, n] = s;
+  r /= 255, t /= 255, n /= 255;
+  let a = Math.max(r, t, n), b = Math.min(r, t, n), o = 0, y = 0, c = (a + b) / 2;
+  if (a !== b) {
+    let u = a - b;
+    if (y = c > 0 && c < 1 ? u / (1 - Math.abs(2 * c - 1)) : 0, a === r)
+      o = (t - n) / u + (t < n ? 6 : 0);
+    else if (a === t)
+      o = (n - r) / u + 2;
+    else
+      o = (r - t) / u + 4;
+    o /= 6;
+  }
+  return [Math.round(o * 360), Math.round(y * 100), Math.round(c * 100)];
+}
+function H(s, r, t) {
+  s = (s % 360 + 360) % 360, r /= 100, t /= 100;
+  let n = (a) => {
+    let b = (a + s / 60) % 6, o = t - t * r * Math.max(Math.min(b, 4 - b, 1), 0);
+    return Math.round(255 * o);
+  };
+  return [n(5), n(3), n(1)];
+}
+function f(s) {
+  let [r, t, n] = s;
+  r /= 255, t /= 255, n /= 255;
+  let a = Math.max(r, t, n), b = Math.min(r, t, n), o = a - b, y = 0, c = a === 0 ? 0 : o / a, u = a;
+  if (o !== 0) {
+    if (a === r)
+      y = (t - n) / o + (t < n ? 6 : 0);
+    else if (a === t)
+      y = (n - r) / o + 2;
+    else
+      y = (r - t) / o + 4;
+    y /= 6;
+  }
+  return [Math.round(y * 360), Math.round(c * 100), Math.round(u * 100)];
+}
+function O(s) {
+  let r = s[0] / 255, t = s[1] / 255, n = s[2] / 255, a = 1 - Math.max(r, t, n);
+  if (a === 1)
+    return [0, 0, 0, 100];
+  let b = (1 - r - a) / (1 - a), o = (1 - t - a) / (1 - a), y = (1 - n - a) / (1 - a);
+  return [Math.round(b * 100), Math.round(o * 100), Math.round(y * 100), Math.round(a * 100)];
+}
+function v(s, r, t, n) {
+  return s /= 100, r /= 100, t /= 100, n /= 100, [Math.round(255 * (1 - s) * (1 - n)), Math.round(255 * (1 - r) * (1 - n)), Math.round(255 * (1 - t) * (1 - n))];
+}
+var m = (s) => s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+var p = (s) => s <= 0.0031308 ? 12.92 * s : 1.055 * s ** 0.4166666666666667 - 0.055;
+var i = (s, r) => Math.round(s * 10 ** r) / 10 ** r;
+function T(s) {
+  let r = m(s[0] / 255), t = m(s[1] / 255), n = m(s[2] / 255), a = Math.cbrt(0.4122214708 * r + 0.5363325363 * t + 0.0514459929 * n), b = Math.cbrt(0.2119034982 * r + 0.6806995451 * t + 0.1073969566 * n), o = Math.cbrt(0.0883024619 * r + 0.2817188376 * t + 0.6299787005 * n);
+  return [i(0.2104542553 * a + 0.793617785 * b - 0.0040720468 * o, 4), i(1.9779984951 * a - 2.428592205 * b + 0.4505937099 * o, 4), i(0.0259040371 * a + 0.7827717662 * b - 0.808675766 * o, 4)];
+}
+function M(s, r, t) {
+  let n = (s + 0.3963377774 * r + 0.2158037573 * t) ** 3, a = (s - 0.1055613458 * r - 0.0638541728 * t) ** 3, b = (s - 0.0894841775 * r - 1.291485548 * t) ** 3, o = p(4.0767416621 * n - 3.3077115913 * a + 0.2309699292 * b), y = p(-1.2684380046 * n + 2.6097574011 * a - 0.3413193965 * b), c = p(-0.0041960863 * n - 0.7034186147 * a + 1.707614701 * b), u = (h) => Math.min(255, Math.max(0, Math.round(h * 255)));
+  return [u(o), u(y), u(c)];
+}
+function d(s) {
+  let [r, t, n] = T(s), a = Math.sqrt(t * t + n * n), b = (Math.atan2(n, t) * 180 / Math.PI + 360) % 360;
+  return [i(r, 4), i(a, 4), i(b, 2)];
+}
+function C(s, r, t) {
+  let n = t * Math.PI / 180;
+  return M(s, r * Math.cos(n), r * Math.sin(n));
+}
+function l(s) {
+  let r = s / 255;
+  return r <= 0.03928 ? r / 12.92 : ((r + 0.055) / 1.055) ** 2.4;
+}
+
+class e {
+  r;
+  g;
+  b;
+  a;
+  constructor(s, r, t, n = 1) {
+    this.r = s, this.g = r, this.b = t, this.a = n;
+  }
+  static from(s, r) {
+    if (s === "hex") {
+      let [t, n, a, b] = x(r);
+      return new e(t, n, a, b);
+    }
+    if (s === "rgb") {
+      if (Array.isArray(r)) {
+        let [o, y, c, u] = r;
+        return new e(o, y, c, u);
+      }
+      let { r: t, g: n, b: a, a: b } = r;
+      return new e(t, n, a, b);
+    }
+    if (s === "hsl") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ h: t, s: n, l: a, a: b } = r);
+      let [o, y, c] = R(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "hsv") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ h: t, s: n, v: a, a: b } = r);
+      let [o, y, c] = H(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "cmyk") {
+      let t, n, a, b, o;
+      if (Array.isArray(r))
+        [t, n, a, b, o] = r;
+      else
+        ({ c: t, m: n, y: a, k: b, a: o } = r);
+      let [y, c, u] = v(t, n, a, b);
+      return new e(y, c, u, o);
+    }
+    if (s === "oklch") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ l: t, c: n, h: a, a: b } = r);
+      let [o, y, c] = C(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "oklab") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ l: t, a: n, b: a, alpha: b } = r);
+      let [o, y, c] = M(t, n, a);
+      return new e(o, y, c, b);
+    }
+    throw Error("Invalid input");
+  }
+  to(s) {
+    switch (s) {
+      case "rgb":
+        return [this.r, this.g, this.b];
+      case "rgba":
+        return [this.r, this.g, this.b, this.a];
+      case "hex":
+        return A([this.r, this.g, this.b]);
+      case "hexa":
+        return A([this.r, this.g, this.b, this.a]);
+      case "hsl":
+        return k([this.r, this.g, this.b]);
+      case "hsla":
+        return [...k([this.r, this.g, this.b]), this.a];
+      case "hsv":
+        return f([this.r, this.g, this.b]);
+      case "hsva":
+        return [...f([this.r, this.g, this.b]), this.a];
+      case "cmyk":
+        return O([this.r, this.g, this.b]);
+      case "cmyka":
+        return [...O([this.r, this.g, this.b]), this.a];
+      case "oklch":
+        return d([this.r, this.g, this.b]);
+      case "oklcha":
+        return [...d([this.r, this.g, this.b]), this.a];
+      case "oklab":
+        return T([this.r, this.g, this.b]);
+      case "oklaba":
+        return [...T([this.r, this.g, this.b]), this.a];
+      default:
+        return [this.r, this.g, this.b];
+    }
+  }
+  getLuminance() {
+    let s = l(this.r), r = l(this.g), t = l(this.b);
+    return 0.2126 * s + 0.7152 * r + 0.0722 * t;
+  }
+  contrastRatio(s) {
+    let r = this.getLuminance(), t = s.getLuminance(), [n, a] = r >= t ? [r, t] : [t, r];
+    return (n + 0.05) / (a + 0.05);
+  }
+  bestContrastForeground() {
+    let s = new e(255, 255, 255, 1), r = new e(0, 0, 0, 1), t = this.contrastRatio(s), n = this.contrastRatio(r);
+    return t >= n ? s : r;
+  }
+}
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.2+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-y1msbssb.js
+var r = 39;
+var o = 49;
+var f2 = "\x1B[";
+var C2 = { reset: [0, 0], bold: [1, 22], dim: [2, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], hidden: [8, 28], strikethrough: [9, 29], black: [30, r], red: [31, r], green: [32, r], yellow: [33, r], blue: [34, r], magenta: [35, r], cyan: [36, r], white: [37, r], gray: [90, r], grey: [90, r], blackBright: [90, r], redBright: [91, r], greenBright: [92, r], yellowBright: [93, r], blueBright: [94, r], magentaBright: [95, r], cyanBright: [96, r], whiteBright: [97, r], bgBlack: [40, o], bgRed: [41, o], bgGreen: [42, o], bgYellow: [43, o], bgBlue: [44, o], bgMagenta: [45, o], bgCyan: [46, o], bgWhite: [47, o], bgBlackBright: [100, o], bgRedBright: [101, o], bgGreenBright: [102, o], bgYellowBright: [103, o], bgBlueBright: [104, o], bgMagentaBright: [105, o], bgCyanBright: [106, o], bgWhiteBright: [107, o], rgb: (i, n, a, l = "fg") => [`${l === "fg" ? 38 : 48};2;${i};${n};${a}`, l === "fg" ? r : o], hex: (i, n = "fg") => {
+  let [a, l, s] = e.from("hex", i).to("rgb");
+  return [`${n === "fg" ? 38 : 48};2;${a};${l};${s}`, n === "fg" ? r : o];
+}, ansi256: (i, n = "fg") => [`${n === "fg" ? 38 : 48};5;${i}`, n === "fg" ? r : o] };
+var b = new Set(["", "1", "2", "3", "true"]);
+function h(i, n = globalThis.process?.env ?? {}) {
+  if (n.FORCE_COLOR !== undefined)
+    return b.has(n.FORCE_COLOR);
+  if (n.NO_COLOR !== undefined || n.NODE_DISABLE_COLORS !== undefined || n.TERM === "dumb")
+    return false;
+  return i?.isTTY === true;
+}
+function d2(i, n, a) {
+  if (!h(a.stream ?? globalThis.process?.stdout, a.env))
+    return n;
+  let l = "", s = "";
+  for (let g = 0, y = i.length;g < y; g++) {
+    let [c, p] = i[g];
+    l += `${f2}${c}m`, s = `${f2}${p}m${s}`;
+  }
+  return l + n + s;
+}
+function u(i, n = []) {
+  return new Proxy((l) => d2(n, l, i), { get(l, s) {
+    let g = C2[s];
+    if (Array.isArray(g))
+      return u(i, [...n, g]);
+    if (typeof g === "function")
+      return (...y) => u(i, [...n, g(...y)]);
+    throw Error(`Unknown style: ${String(s)}`);
+  } });
+}
+function le(i = {}) {
+  return u(i);
+}
+var t = le();
+
+// ../kit/src/style.ts
+function takesControlCodes(stream, env = process2.env) {
+  return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb";
+}
+function paint(stream, env = process2.env) {
+  return le({ stream: { isTTY: takesControlCodes(stream, env) }, env });
+}
+var STATUSES = {
+  passed: { symbol: "\u2713", words: ["passed", "success", "succeeded", "ok"], paint: (colors) => colors.green },
+  failed: { symbol: "\u2717", words: ["failed", "failure", "error", "errored"], paint: (colors) => colors.red },
+  running: { symbol: "\u25CF", words: ["running", "in_progress", "started"], paint: (colors) => colors.cyan },
+  queued: { symbol: "\u25CB", words: ["queued", "waiting", "pending", "created", "blocked", "scheduled"], paint: (colors) => colors.yellow },
+  skipped: { symbol: "-", words: ["skipped", "cancelled", "canceled", "manual"], paint: (colors) => colors.dim }
+};
+var STATUS_OF = new Map(Object.entries(STATUSES).flatMap(([status, { words }]) => words.map((word) => [word, status])));
+
+// ../kit/src/format.ts
+function upTo(text, separator) {
+  const end = text.indexOf(separator);
+  return end === -1 ? text : text.slice(0, end);
+}
+var ESCAPE = String.fromCharCode(27);
+function printJson(value) {
+  console.log(JSON.stringify(value, undefined, 2));
+}
+
+// ../kit/src/help.ts
+import process3 from "process";
+var OPTIONAL = /\[[^\]]+\]/g;
+var USAGE_PREFIX = /^usage:\s*/i;
+var FULL_STOP = /\.$/;
+function usageLine(usage, colors = paint(process3.stdout)) {
+  return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
+}
+function helpText(usage, options, colors = paint(process3.stdout), { examples = [], replaces } = {}) {
+  return [usageLine(usage, colors), ...replacesRows(replaces, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exampleRows(examples, colors)].join(`
+`);
+}
+function replacesRows(replaces, colors = paint(process3.stdout)) {
+  return replaces === undefined ? [] : ["", `${colors.bold("Instead of:")} ${replaces}`];
+}
+function wantsHelpJson(env = process3.env) {
+  return env.KIT_HELP === "json";
+}
+function description(usage, { examples = [], replaces } = {}) {
+  const lines = usage.replace(USAGE_PREFIX, "").split(`
+`);
+  const first = lines[0];
+  const colon = first.indexOf(": ");
+  const prose = lines[lines.indexOf("") + 1] ?? "";
+  const fallback = lines.includes("") ? `${prose.charAt(0).toLowerCase()}${prose.slice(1)}`.replace(FULL_STOP, "") : "";
+  return {
+    synopsis: colon === -1 ? first : first.slice(0, colon),
+    summary: colon === -1 ? fallback : first.slice(colon + 2),
+    ...replaces === undefined ? {} : { replaces },
+    examples: examples.map((example) => typeof example === "string" ? { line: example } : { line: example[0], note: example[1] })
+  };
+}
+function exampleRows(examples, colors = paint(process3.stdout)) {
+  if (examples.length === 0)
+    return [];
+  return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? `  ${example}` : `  ${example[0]}  ${colors.dim(`# ${example[1]}`)}`)];
+}
+function optionRows(options, colors = paint(process3.stdout)) {
+  const rows = Object.entries(options).map(([name, option]) => {
+    const short = option.short === undefined ? "    " : `${colors.cyan(`-${option.short}`)}, `;
+    const named = option.choices === undefined ? "<value>" : `<${option.choices.join("|")}>`;
+    const placeholder = option.optional === undefined ? named : `[${named}]`;
+    const value = option.type === "string" ? ` ${colors.dim(placeholder)}` : "";
+    return { flag: `${short}${colors.cyan(`--${name}`)}${value}`, width: `-x, --${name}`.length + (option.type === "string" ? placeholder.length + 1 : 0), description: option.description ?? "" };
+  });
+  const width = Math.max(0, ...rows.map((row) => row.width));
+  return rows.map((row) => row.description === "" ? `  ${row.flag}` : `  ${row.flag}${" ".repeat(width - row.width)}  ${colors.dim(row.description)}`);
+}
+
+// ../kit/src/text.ts
+var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
+function stripAnsi(text) {
+  return text.replace(ANSI, "");
+}
+function distance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (const [i, left] of [...a].entries()) {
+    const current = [i + 1];
+    for (const [j, right] of [...b].entries())
+      current.push(Math.min((previous[j + 1] ?? 0) + 1, (current[j] ?? 0) + 1, (previous[j] ?? 0) + (left === right ? 0 : 1)));
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+function closest(name, names) {
+  const started = names.find((known) => known.startsWith(name));
+  if (started !== undefined)
+    return started;
+  const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
+  return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
+}
+
+// ../kit/src/args.ts
+var DASHES = /^-+/;
+function jsonOption(holds) {
+  return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
+}
+
+class Exit extends Error {
+  code;
+  hint;
+  constructor(message, code, hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+  }
+}
+function fail(message, code = 2, hint) {
+  throw new Exit(message, code, hint);
+}
+
+class UsageError extends Exit {
+  constructor(message, hint) {
+    super(message, 2, hint);
+  }
+}
+function badUsage(message) {
+  throw new UsageError(message);
+}
+
+class HelpShown extends Exit {
+  constructor() {
+    super("help shown", 0);
+  }
+}
+
+class Completing {
+  options;
+  positionals;
+  candidates;
+  constructor(options, positionals = [], candidates = {}) {
+    this.options = options;
+    this.positionals = positionals;
+    this.candidates = candidates;
+  }
+}
+var completion = { active: false };
+var OUTPUT_OPTIONS = {
+  color: { type: "string", description: "auto (on a terminal alone), always or never" },
+  plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
+};
+function applyOutput(color, plain, env = process4.env) {
+  const when = plain === true ? "never" : color ?? "auto";
+  if (when === "auto")
+    return;
+  if (when !== "always" && when !== "never")
+    badUsage(`--color takes auto, always or never, not ${when}`);
+  if (when === "always") {
+    env.FORCE_COLOR = "1";
+    delete env.NO_COLOR;
+  } else {
+    env.NO_COLOR = "1";
+    delete env.FORCE_COLOR;
+  }
+}
+function parse(args, usage, options, settings = {}) {
+  const output = Object.fromEntries(Object.entries(OUTPUT_OPTIONS).filter(([name]) => !(name in options)));
+  const all = { ...options, ...output, help: { type: "boolean", short: "h", description: "show this help" } };
+  const listing = listed(all, settings.allowNegative === true);
+  if (completion.active)
+    throw new Completing(listing, settings.positionals, settings.candidates);
+  const { own, rest } = settings.trailing === true ? splitTrailing(args, all, settings.positionals?.length ?? 0) : splitRest(args, settings.rest === true);
+  let parsed;
+  try {
+    parsed = parseArgs({ args: joinDashValues(withBare(own, all), all), options: all, allowPositionals: true, allowNegative: settings.allowNegative === true, strict: true });
+  } catch (error) {
+    const message = parseError(error);
+    throw new UsageError(message, nearestOption(message, all, settings.allowNegative === true));
+  }
+  const values = parsed.values;
+  applyOutput("color" in output ? values.color : undefined, "plain" in output ? values.plain : undefined);
+  if (values.help === true) {
+    console.log(wantsHelpJson() ? JSON.stringify(description(usage, settings)) : helpText(usage, listing, undefined, settings));
+    throw new HelpShown;
+  }
+  checkChoices(parsed.values, all);
+  checkConflicts(parsed.values, all);
+  if (settings.positionals !== undefined)
+    checkPositionals(parsed.positionals, settings.positionals);
+  return { ...parsed, values: parsed.values, positionals: parsed.positionals, rest };
+}
+function splitRest(args, passes) {
+  const separator = passes ? args.indexOf("--") : -1;
+  return { own: separator === -1 ? args : args.slice(0, separator), rest: separator === -1 ? undefined : args.slice(separator + 1) };
+}
+function splitTrailing(args, options, count) {
+  const takesValue = (word) => !word.includes("=") && Object.entries(options).some(([name, { short, type }]) => type === "string" && (word === `--${name}` || word === `-${short}`));
+  let seen = 0;
+  if (count === 0)
+    return { own: args, rest: undefined };
+  for (let at = 0;at < args.length; at++) {
+    const word = args[at];
+    if (word === "--")
+      break;
+    if (word.startsWith("-")) {
+      if (takesValue(word))
+        at++;
+      continue;
+    }
+    seen++;
+    if (seen === count)
+      return { own: args.slice(0, at + 1), rest: args.slice(at + 1) };
+  }
+  return { own: args, rest: undefined };
+}
+function listed(options, allowNegative) {
+  if (!allowNegative)
+    return options;
+  return Object.fromEntries(Object.entries(options).flatMap(([name, option]) => {
+    if (option.type !== "boolean" || option.negative === undefined)
+      return [[name, option]];
+    return [...option.description === undefined ? [] : [[name, option]], [`no-${name}`, { type: "boolean", description: option.negative }]];
+  }));
+}
+function withBare(args, options) {
+  const bare = new Map(Object.entries(options).flatMap(([name, { short, optional }]) => optional === undefined ? [] : [[`--${name}`, optional], ...short === undefined ? [] : [[`-${short}`, optional]]]));
+  if (bare.size === 0)
+    return args;
+  const separator = args.indexOf("--");
+  const own = separator === -1 ? args : args.slice(0, separator);
+  return [...own.flatMap((arg, index) => {
+    const optional = bare.get(arg);
+    const next = own[index + 1];
+    const value = next !== undefined && (optional?.accepts === undefined ? !next.startsWith("-") : optional.accepts.test(next));
+    return optional === undefined || value ? [arg] : [arg, optional.bare];
+  }), ...separator === -1 ? [] : args.slice(separator)];
+}
+function checkConflicts(values, options) {
+  const given = (name) => values[name] !== undefined && values[name] !== false;
+  for (const [name, { conflicts = [] }] of Object.entries(options)) {
+    const other = given(name) ? conflicts.find(given) : undefined;
+    if (other !== undefined)
+      badUsage(`--${name} cannot be used with --${other}`);
+  }
+}
+function checkChoices(values, options) {
+  for (const [name, option] of Object.entries(options)) {
+    if (option.choices === undefined)
+      continue;
+    const given = values[name];
+    for (const value of Array.isArray(given) ? given : [given]) {
+      if (typeof value === "string")
+        oneOf(value, name, option.choices);
+    }
+  }
+}
+function oneOf(value, name, choices) {
+  if (!choices.includes(value))
+    badUsage(`${name.startsWith("<") ? name : `--${name}`} takes one of ${choices.join(", ")}, not ${value}`);
+  return value;
+}
+function checkPositionals(given, names) {
+  const variadic = names.at(-1)?.replace("]", "").endsWith("...") === true;
+  const required = names.filter((name) => !name.startsWith("[")).length;
+  if (given.length < required)
+    badUsage(`missing ${names[given.length]}`);
+  if (!variadic && given.length > names.length)
+    badUsage(`unexpected argument ${given[names.length]}`);
+}
+function joinDashValues(args, options) {
+  const longOf = new Map(Object.entries(options).flatMap(([name, option]) => option.short === undefined ? [[`--${name}`, name]] : [[`--${name}`, name], [`-${option.short}`, name]]));
+  const isOption = (arg) => arg === "--" || longOf.has(arg.includes("=") ? arg.slice(0, arg.indexOf("=")) : arg);
+  const joined = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg === "--")
+      return [...joined, ...args.slice(i)];
+    const name = longOf.get(arg);
+    const next = args[i + 1];
+    if (name !== undefined && options[name]?.type === "string" && next !== undefined && next.startsWith("-") && next !== "-" && !isOption(next)) {
+      joined.push(`--${name}=${next}`);
+      i++;
+    } else {
+      joined.push(arg);
+    }
+  }
+  return joined;
+}
+function parseError(error) {
+  const message = upTo(error instanceof Error ? error.message : String(error), ". ");
+  return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
+}
+var UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
+function nearestOption(message, options, allowNegative) {
+  const typed = UNKNOWN_OPTION.exec(message)?.[1];
+  if (typed === undefined)
+    return;
+  const word = typed.replace(DASHES, "");
+  if (word.length < 2 && !typed.startsWith("--"))
+    return;
+  const known = Object.entries(options).flatMap(([name, option]) => [
+    ...option.short === undefined ? [] : [`-${option.short}`],
+    `--${name}`,
+    ...allowNegative && option.type === "boolean" ? [`--no-${name}`] : []
+  ]);
+  const meant = closest(word, known.map((flag) => flag.replace(DASHES, "")));
+  return meant === undefined ? undefined : `did you mean ${known.find((flag) => flag.replace(DASHES, "") === meant)}?`;
+}
+// ../kit/src/progress.ts
+var ESC = String.fromCharCode(27);
+var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, "y");
+var RESET_STYLE = `${ESC}[0m`;
+var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
+// ../kit/src/cli.ts
+import process6 from "process";
+
+// ../kit/src/usage.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, isAbsolute, join } from "path";
+import process5 from "process";
+
+// ../kit/src/logs.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+var CLI_FOLDER = "kaynooo-cli";
+
+// ../kit/src/usage.ts
+var UNKNOWN_OPTION2 = /unknown option '(--[a-z][a-z0-9-]*)[=']/;
+var FLAG_NAME = /^(?:--[a-z][a-z0-9-]*|-[a-zA-Z])$/;
+var LONGEST_NAME = 40;
+var usageError;
+function noteUsageError(message) {
+  usageError = message;
+}
+function stateHome(env = process5.env) {
+  const dir = env.XDG_STATE_HOME;
+  return dir !== undefined && isAbsolute(dir) ? dir : join(homedir(), ".local", "state");
+}
+function usagePath(env = process5.env) {
+  return join(stateHome(env), CLI_FOLDER, "usage.jsonl");
+}
+function usageRecorded(env = process5.env) {
+  const off = env.KAYNOOO_CLI_NO_USAGE;
+  return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
+}
+function flagNames(argv) {
+  const end = argv.indexOf("--");
+  const names = (end === -1 ? argv : argv.slice(0, end)).filter((word) => word.startsWith("-") && word !== "-").map((word) => word.includes("=") ? word.slice(0, word.indexOf("=")) : word);
+  return [...new Set(names)].filter((name) => name.length <= LONGEST_NAME && FLAG_NAME.test(name));
+}
+function usageEntry(bin, command, argv, code, now = new Date) {
+  const unknown = code === 2 && usageError !== undefined ? UNKNOWN_OPTION2.exec(usageError)?.[1] : undefined;
+  usageError = undefined;
+  return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
+}
+function recordUsage(entry, env = process5.env) {
+  if (!usageRecorded(env))
+    return;
+  try {
+    const path = usagePath(env);
+    mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    appendFileSync(path, `${JSON.stringify(entry)}
+`, { mode: 384 });
+  } catch {}
+}
+
+// ../kit/src/cli.ts
+var LEVEL_OPTIONS = {
+  ...OUTPUT_OPTIONS,
+  help: { type: "boolean", short: "h", description: "show this help" }
+};
+var TOP_OPTIONS = { ...LEVEL_OPTIONS, version: { type: "boolean", short: "v", description: "print the version" } };
+function printError(prefix, message, hint, cause) {
+  const colors = paint(process6.stderr);
+  const styled = takesControlCodes(process6.stderr);
+  const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
+  const under = (label, text, tint) => text === undefined ? "" : `
+  ${styled ? tint(label) : `${label}:`} ${text}`;
+  console.error(`${head} ${message}${under("cause", cause, colors.dim)}${under("hint", hint, colors.yellow)}`);
+}
+function printJsonError(message, hint, cause) {
+  console.error(JSON.stringify({ error: message, ...hint === undefined ? {} : { hint }, ...cause === undefined ? {} : { cause } }));
+}
+function wantsJson(argv) {
+  const end = argv.indexOf("--");
+  return (end === -1 ? argv : argv.slice(0, end)).includes("--json");
+}
+function reportThrown(prefix, error, redact = (text) => text, json = false) {
+  if (error instanceof HelpShown)
+    return 0;
+  const help = error instanceof UsageError ? `run ${prefix} --help for its options` : undefined;
+  const named = error instanceof Error && !(error instanceof Exit) && error.name !== "Error" ? `${error.name}: ${error.message}` : undefined;
+  const cause = error instanceof Error && error.cause instanceof Error ? redact(error.cause.message) : undefined;
+  if (error instanceof UsageError)
+    noteUsageError(error.message);
+  const report = json ? printJsonError : (message, hint, causeText) => printError(prefix, message, hint, causeText);
+  report(redact(named ?? (error instanceof Error ? error.message : String(error))), error instanceof Exit ? error.hint ?? help : undefined, cause);
+  return error instanceof Exit ? error.code : 1;
+}
+var COMPLETE = "__complete";
+var FILES = "__files__";
+async function completingOf(run) {
+  completion.active = true;
+  try {
+    await run([]);
+  } catch (error) {
+    if (error instanceof Completing)
+      return error;
+  } finally {
+    completion.active = false;
+  }
+  return new Completing({});
+}
+function candidateLine(candidate) {
+  return typeof candidate === "string" ? candidate : candidate.join("\t");
+}
+function positionalBeingTyped(before, { options, positionals }) {
+  const takesValue = (word) => !word.includes("=") && Object.entries(options).some(([name, { short, type }]) => type === "string" && (word === `--${name}` || word === `-${short}`));
+  let index = 0;
+  let at = 0;
+  while (at < before.length) {
+    const word = before[at];
+    if (word === "--") {
+      index += before.length - at - 1;
+      break;
+    }
+    if (!word.startsWith("-"))
+      index++;
+    else if (takesValue(word))
+      at++;
+    at++;
+  }
+  const last = positionals.at(-1);
+  if (index < positionals.length)
+    return positionals[index];
+  return last?.replace("]", "").endsWith("...") === true ? last : undefined;
+}
+async function leafCandidates(run, words) {
+  const completing = await completingOf(run);
+  if ((words.at(-1) ?? "").startsWith("-"))
+    return Object.entries(completing.options).map(([name, option]) => option.description === undefined ? `--${name}` : `--${name}	${option.description}`);
+  const flag = words.at(-2);
+  const option = flag?.startsWith("-") === true ? Object.entries(completing.options).find(([name, { short }]) => flag === `--${name}` || flag === `-${short}`)?.[1] : undefined;
+  if (option?.type === "string") {
+    const values = option.choices === undefined ? await option.candidates?.() : option.choices;
+    return values === undefined ? [FILES] : values.map(candidateLine);
+  }
+  const name = positionalBeingTyped(words.slice(0, -1), completing);
+  const values = name === undefined ? undefined : await completing.candidates[name]?.();
+  return values === undefined ? [FILES] : values.map(candidateLine);
+}
+async function printCandidates(found) {
+  for (const line of await found)
+    console.log(line);
+  return 0;
+}
+async function runMain({ name, version, run, redact, usage }, argv = process6.argv.slice(2)) {
+  if (argv[0] === COMPLETE)
+    return printCandidates(leafCandidates(run, argv.slice(1)));
+  if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
+    console.log(version);
+    return 0;
+  }
+  let code;
+  try {
+    code = await run(argv);
+  } catch (error) {
+    code = reportThrown(name, error, redact, wantsJson(argv));
+  }
+  if (usage !== false)
+    recordUsage(usageEntry(name, undefined, argv, code));
+  return code;
+}
+// ../kit/src/secrets.ts
+var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
+// ../kit/src/sessions.ts
+var {Glob } = globalThis.Bun;
+var SESSION_FILES = new Glob("*.json");
+var ACCOUNT_DIRS = new Glob("*/sessions");
+// package.json
+var version = "0.4.0";
+
+// src/sf.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname4, join as join4, resolve as resolve2 } from "path";
+import process10 from "process";
+
+// ../kit/src/fzf.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2 } from "path";
+import process8 from "process";
+var REMEMBERED = 20;
+function table(rows) {
+  const widths = rows[0]?.cells.map((_, index) => Math.max(...rows.map((row) => Bun.stringWidth(row.cells[index])))) ?? [];
+  return rows.map((row) => [
+    ...row.hidden,
+    ...row.cells.map((cell, index) => index === row.cells.length - 1 ? cell.trimEnd() : `${cell}${" ".repeat(widths[index] + 1 - Bun.stringWidth(cell))}`)
+  ].join("\t"));
+}
+function fzf(rows, options) {
+  const hidden = options.hidden ?? rows[0]?.hidden.length ?? 0;
+  const proc = Bun.spawnSync([
+    "fzf",
+    "--prompt",
+    options.prompt,
+    ...options.header === undefined ? [] : ["--header", options.header],
+    ...(options.expect ?? []).length > 0 ? ["--expect", (options.expect ?? []).join(",")] : [],
+    "--ansi",
+    "--reverse",
+    "--height",
+    options.height ?? "100%",
+    "--delimiter",
+    "\t",
+    "--with-nth",
+    `${hidden + 1}..`,
+    "--nth",
+    `1..${options.searched}`,
+    "--tabstop",
+    "1",
+    "--tiebreak",
+    "chunk,index",
+    ...options.preview === undefined ? [] : ["--preview", options.preview, "--preview-window", "down,40%"],
+    ...(options.bind ?? []).flatMap((bind) => ["--bind", bind]),
+    ...options.query === true ? ["--print-query"] : []
+  ], {
+    stdin: new TextEncoder().encode(table(rows).join(`
+`)),
+    stdout: "pipe",
+    stderr: "inherit"
+  });
+  return picked(proc.stdout.toString(), hidden, options);
+}
+function picked(output, hidden, options) {
+  const lines = output.split(`
+`);
+  const query = options.query === true ? lines.shift() : "";
+  const [key, line] = (options.expect ?? []).length > 0 ? [lines[0], lines[1]] : ["", lines[0]];
+  if (line !== undefined && line !== "")
+    return { key, hidden: line.split("\t").slice(0, hidden), query };
+  return options.query === true && key !== "" ? { key, hidden: [], query } : undefined;
+}
+function heightFor(count) {
+  return String(Math.max(15, Math.ceil((count + 4) / 0.6)));
+}
+function historyFile(name) {
+  return join2(process8.env.XDG_CACHE_HOME ?? join2(homedir2(), ".cache"), name, "history.json");
+}
+function history(name) {
+  try {
+    const file = historyFile(name);
+    return existsSync(file) ? JSON.parse(readFileSync(file, "utf-8")) : {};
+  } catch {
+    return {};
+  }
+}
+function runs(name) {
+  return history(name)[process8.cwd()] ?? [];
+}
+function record(name, run) {
+  const all = history(name);
+  const file = historyFile(name);
+  all[process8.cwd()] = [run, ...(all[process8.cwd()] ?? []).filter((earlier) => earlier.id !== run.id)].slice(0, REMEMBERED);
+  mkdirSync2(dirname2(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(all));
+}
+function byRecency(items, previous, idOf) {
+  const rank = new Map(previous.map((run, index) => [run.id, index]));
+  const recent = items.filter((item) => rank.has(idOf(item))).sort((a, b) => rank.get(idOf(a)) - rank.get(idOf(b)));
+  return [...recent, ...items.filter((item) => !rank.has(idOf(item)))];
+}
+function word(arg) {
+  if (typeof arg === "string")
+    return `=${arg}`;
+  return "given" in arg ? `+${arg.given}` : `?${arg.ask}`;
+}
+function emit(mode, typed, recorded, command) {
+  const words = command.map(word);
+  console.log([mode, typed, recorded, ...words].join(`
+`));
+}
+function list(rows) {
+  console.log(JSON.stringify(rows));
+}
+
+// ../kit/src/prompt.ts
+import process9 from "process";
+var KEY_SEQUENCES = /\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|[\s\S]/giu;
+var CONTROL = /^[\x00-\x1F\x7F]/;
+var KEYS = { "\x1B[A": "up", "\x1BOA": "up", "\x1B[B": "down", "\x1BOB": "down", "\r": "enter", "\n": "enter", "\x03": "cancel", "\x1B": "cancel", "\x7F": "erase", "\b": "erase" };
+function readKeys(input) {
+  return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => KEYS[sequence] ?? (CONTROL.test(sequence) ? [] : [{ text: sequence }]));
+}
+async function input2(question, { default: fallback, mask = false, validate, ...settings } = {}) {
+  let value = "";
+  let invalid;
+  const taken = () => value === "" ? fallback ?? "" : value;
+  const shown = () => mask ? "*".repeat([...taken()].length) : taken();
+  const accepted = await ask(question, settings, (colors, state, { columns }) => {
+    if (state !== "asking")
+      return [answer(colors, question, state, shown())];
+    const characters = [...shown()];
+    const room = Math.max(columns - question.length - 5, 1);
+    const tail = characters.length > room ? `\u2026${characters.slice(1 - room).join("")}` : shown();
+    const typed = value === "" ? colors.dim(tail) : tail;
+    return [`${colors.cyan("?")} ${question} ${typed}${colors.dim("\u2588")}`, ...invalid === undefined ? [] : [`  ${colors.red(invalid)}`]];
+  }, (key) => {
+    if (key === "cancel")
+      return "cancel";
+    invalid = undefined;
+    if (key === "enter") {
+      invalid = validate?.(taken());
+      return invalid === undefined ? "enter" : undefined;
+    }
+    if (key === "erase")
+      value = [...value].slice(0, -1).join("");
+    else if (typeof key === "object")
+      value += key.text;
+    return;
+  });
+  return accepted ? taken() : undefined;
+}
+function answer(colors, question, state, picked) {
+  return state === "enter" ? `${colors.green("\u2713")} ${question} ${colors.cyan(picked)}` : `${colors.red("\u2717")} ${question} ${colors.dim("cancelled")}`;
+}
+async function ask(question, { hint, terminal = process9 }, render, press) {
+  const { stdin, stderr } = terminal;
+  if (stdin.isTTY !== true || stderr.isTTY !== true)
+    fail(`cannot ask "${question}" off a terminal`, 2, hint);
+  const colors = paint(stderr);
+  let drawn = 0;
+  let outcome;
+  const draw = (state) => {
+    const frame = render(colors, state, { columns: stderr.columns || 80, rows: stderr.rows || 24 });
+    stderr.write(`${drawn > 1 ? `\x1B[${drawn - 1}A` : ""}\r\x1B[0J${frame.join(`
+`)}`);
+    drawn = frame.length;
+  };
+  try {
+    stdin.setRawMode(true);
+    stdin.resume();
+    stderr.write("\x1B[?25l");
+    draw("asking");
+    return await new Promise((resolve) => {
+      function onData(data) {
+        for (const key of readKeys(data.toString())) {
+          const pressed = press(key);
+          if (pressed !== undefined) {
+            settle(pressed);
+            return;
+          }
+        }
+        draw("asking");
+      }
+      function onEnd() {
+        settle("cancel");
+      }
+      function settle(settled) {
+        outcome = settled;
+        stdin.off("data", onData);
+        stdin.off("end", onEnd);
+        resolve(settled === "enter");
+      }
+      stdin.on("data", onData);
+      stdin.on("end", onEnd);
+    });
+  } finally {
+    draw(outcome ?? "cancel");
+    stderr.write(`
+\x1B[?25h`);
+    stdin.setRawMode(false);
+    stdin.pause();
+  }
+}
+
+// src/stack.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname3, join as join3, relative, resolve } from "path";
+var LABEL_FORMAT = ["project", "project.config_files", "project.environment_file", "project.working_dir"].map((label) => `{{.Label "com.docker.compose.${label}"}}`).join("\t");
+var COMPOSE_FILE_VAR = /^\s*(?:export\s+)?COMPOSE_FILE\s*=\s*\S/m;
+var COMPOSE_FILES = ["compose.yaml", "compose.yml", "docker-compose.yaml", "docker-compose.yml"];
+var SKIPPED = new Set(["node_modules", "vendor", "dist", "build", "target", "venv", "__pycache__"]);
+var ACTIONS = ["shell", "logs", "restart", "up", "stop", "build"];
+function from(dir, command) {
+  return dir === "." ? command : ["env", "-C", dir, ...command];
+}
+function children(dir = ".") {
+  return readdirSync(dir, { withFileTypes: true }).filter((child) => child.isDirectory() && !child.name.startsWith(".") && !SKIPPED.has(child.name)).map((child) => child.name).sort();
+}
+function up(dir) {
+  const dirs = [];
+  for (let current = dir;; current = join3(current, "..")) {
+    dirs.push(current);
+    const absolute = resolve(current);
+    if (existsSync2(join3(current, ".git")) || dirname3(absolute) === absolute)
+      return dirs;
+  }
+}
+function stackAt(dir) {
+  return { dir, run: from(dir, ["docker", "compose"]), list: { argv: ["docker", "compose"], cwd: resolve(dir), env: process.env } };
+}
+function holdsStack(dir) {
+  if (COMPOSE_FILES.some((name) => existsSync2(join3(dir, name))))
+    return true;
+  try {
+    return COMPOSE_FILE_VAR.test(readFileSync2(join3(dir, ".env"), "utf-8"));
+  } catch {
+    return false;
+  }
+}
+function nearestStack(dir) {
+  const found = up(dir).find(holdsStack);
+  return found === undefined ? undefined : stackAt(found);
+}
+function stacks() {
+  const here = nearestStack(".");
+  const below = children().filter(holdsStack);
+  return [...here ? [here] : [], ...below.filter((dir) => dir !== here?.dir).map(stackAt)];
+}
+function labelled(text) {
+  const projects = new Map;
+  for (const line of text.split(`
+`)) {
+    const [project, files, envFiles = "", workdir = ""] = line.split("\t");
+    if (project !== undefined && project !== "" && files !== undefined && files !== "" && workdir !== "" && !projects.has(project))
+      projects.set(project, { project, files: files.split(","), envFiles: envFiles.split(",").filter(Boolean), workdir });
+  }
+  return [...projects.values()];
+}
+async function labels(project) {
+  const filter = project === undefined ? [] : ["--filter", `label=com.docker.compose.project=${project}`];
+  const proc = Bun.spawn(["docker", "ps", "--all", ...filter, "--format", LABEL_FORMAT], { stdout: "pipe", stderr: "ignore" });
+  if (await proc.exited !== 0)
+    return [];
+  return labelled(await new Response(proc.stdout).text()).filter((stack) => [...stack.files, ...stack.envFiles].every((file) => existsSync2(file)));
+}
+function labelledStack(dir, { project, files, envFiles, workdir }) {
+  const options = (paths) => ["-p", project, ...files.flatMap((file) => ["-f", paths(file)]), ...envFiles.flatMap((file) => ["--env-file", paths(file)])];
+  return {
+    dir,
+    project,
+    run: from(dir, ["docker", "compose", ...options((file) => relative(workdir, file))]),
+    list: { argv: ["docker", "compose", ...options((file) => file)], cwd: workdir, env: process.env }
+  };
+}
+function stackOf(recorded) {
+  return labelledStack(relative(".", recorded.workdir) || ".", recorded);
+}
+async function recordedNearby() {
+  const dirs = new Set([...up("."), ...children()].map((dir) => resolve(dir)));
+  return (await labels()).filter((stack) => dirs.has(stack.workdir));
+}
+async function attempt(stack, args) {
+  const proc = Bun.spawn([...stack.list.argv, ...args], { cwd: stack.list.cwd, env: stack.list.env, stdout: "pipe", stderr: "pipe" });
+  const [text, stderr, code] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+  if (code === 0)
+    return { text, error: undefined };
+  const last = stderr.trim().split(`
+`).at(-1) ?? "";
+  return { text: "", error: last === "" ? `exit ${code}` : last };
+}
+async function output(stack, args) {
+  return (await attempt(stack, args)).text;
+}
+function containers(text) {
+  const trimmed = text.trim();
+  if (!trimmed)
+    return [];
+  return trimmed.startsWith("[") ? JSON.parse(trimmed) : trimmed.split(`
+`).map((line) => JSON.parse(line));
+}
+async function services(stack) {
+  const [config, ps] = await Promise.all([output(stack, ["config", "--format", "json"]), output(stack, ["ps", "--all", "--format", "json"])]);
+  const parsed = config ? JSON.parse(config) : {};
+  const declared = parsed.services ?? {};
+  const project = stack.project ?? parsed.name ?? "";
+  const running = new Map(containers(ps).map((container) => [container.Service, container]));
+  return Object.entries(declared).map(([name, service]) => ({
+    stack,
+    project,
+    name,
+    state: running.get(name)?.State ?? "none",
+    status: running.get(name)?.Status ?? "",
+    ports: (service.ports ?? []).filter((port) => (port.published ?? "") !== "").map((port) => `${port.published}->${port.target}`).join(" "),
+    image: service.image ?? "built"
+  }));
+}
+async function allServices() {
+  const [listed, recorded] = await Promise.all([Promise.all(stacks().map(services)), recordedNearby()]);
+  const found = listed.flat();
+  const known = new Set(found.map((service) => service.project));
+  const others = recorded.filter((stack) => !known.has(stack.project));
+  return [...found, ...(await Promise.all(others.map(async (stack) => services(stackOf(stack))))).flat()];
+}
+function named(service) {
+  return service.stack.project === undefined ? service.name : `${service.stack.project}:${service.name}`;
+}
+function key(service) {
+  return service.stack.dir === "." ? named(service) : `${service.stack.dir}/${named(service)}`;
+}
+async function shellOf(service) {
+  return await output(service.stack, ["exec", "-T", service.name, "sh", "-c", "command -v bash"]) ? "bash" : "sh";
+}
+async function commandFor(service, action) {
+  const run = service.stack.run;
+  switch (action) {
+    case "shell":
+      return [...run, "exec", service.name, await shellOf(service)];
+    case "logs":
+      return [...run, "logs", "-f", "--tail=200", service.name];
+    case "restart":
+      return [...run, "restart", service.name];
+    case "up":
+      return [...run, "up", "-d", service.name];
+    case "stop":
+      return [...run, "stop", service.name];
+    case "build":
+      return [...run, "up", "-d", "--build", service.name];
+  }
+}
+function defaultAction(service) {
+  return service.state === "running" ? "shell" : "up";
+}
+function stateColor(state) {
+  if (state === "running")
+    return "green";
+  if (state === "exited" || state === "dead")
+    return "red";
+  return state === "none" ? "dim" : "yellow";
+}
+async function serviceNamed(dir, name, project) {
+  const [recorded] = project === "" ? [] : await labels(project);
+  const stack = recorded === undefined ? stackAt(dir) : labelledStack(dir, recorded);
+  return (await services(stack)).find((candidate) => candidate.name === name);
+}
+async function logsOf(stack, name) {
+  return output(stack, ["logs", "--tail=30", "--no-log-prefix", name]);
+}
+
+// src/sf.ts
+var usage2 = `sf [command] [args...]
+sf -
+
+Picks a Symfony console command with fzf and runs it, asking for each required argument it needs. The commands last run come first, per folder, and the picker opens on the list cached from the last run while the console answers.
+The console is the nearest bin/console up to the repository root, then those of the child folders (keyed \`api/cache:clear\`). It runs in the php service of the nearest compose stack when there is one, else with the local php; the container's working directory is taken to be the app.
+\`sf -\` runs the last command again with the arguments it ran with, \`sf <command> [args...]\` runs without the picker: a name the list does not hold goes to the console as is, which resolves \`c:c\` to \`cache:clear\` itself. Without fzf or a terminal it lists the commands instead.
+The hidden flags --list, --names, --rows, --show, --record and --emit are for term, tmux and the shell completions.
+
+Exits with the code of the console, 1 when there is no bin/console here.`;
+var colors = paint({ isTTY: true });
+var MARKUP = /<(info|comment|question|error)>(.*?)<\/\1>/gs;
+var TAGS = { info: "green", comment: "yellow", question: "cyan", error: "red" };
+var LINKS = /<\/?href[^>]*>/g;
+function marked2(text) {
+  return text.replace(MARKUP, (_, tag, inner) => colors[TAGS[tag]](inner)).replace(LINKS, "");
+}
+function argumentsOf(command) {
+  return Array.isArray(command.definition.arguments) ? [] : Object.values(command.definition.arguments);
+}
+function optionsOf(command) {
+  return Array.isArray(command.definition.options) ? [] : Object.values(command.definition.options);
+}
+function phpService(names) {
+  return names.find((name) => name === "php") ?? names.find((name) => name.includes("php"));
+}
+async function consoleAt(dir) {
+  const stack = nearestStack(dir);
+  const php = stack === undefined ? undefined : phpService((await services(stack)).map((service) => service.name));
+  if (stack !== undefined && php !== undefined)
+    return { dir, run: [...stack.run, "exec", php, "bin/console"], list: { ...stack.list, argv: [...stack.list.argv, "exec", "-T", php, "bin/console"] } };
+  return { dir, run: from(dir, ["php", "bin/console"]), list: { argv: ["php", "bin/console"], cwd: resolve2(dir), env: process10.env } };
+}
+async function consoles() {
+  const here = up(".").find((dir) => existsSync3(join4(dir, "bin/console")));
+  const dirs = [...here === undefined ? [] : [here], ...children().filter((dir) => existsSync3(join4(dir, "bin/console")))];
+  return Promise.all([...new Set(dirs)].map(consoleAt));
+}
+function cached(dir) {
+  return join4(process10.env.XDG_CACHE_HOME ?? join4(homedir3(), ".cache"), "sf", `${resolve2(dir).replaceAll("/", "%")}.json`);
+}
+function fromCache(dir) {
+  try {
+    return existsSync3(cached(dir)) ? JSON.parse(readFileSync3(cached(dir), "utf-8")) : undefined;
+  } catch {
+    return;
+  }
+}
+async function live(app) {
+  const proc = Bun.spawn([...app.list.argv, "list", "--format=json"], { cwd: app.list.cwd, env: app.list.env, stdout: "pipe", stderr: "pipe" });
+  const text = await new Response(proc.stdout).text();
+  if (await proc.exited !== 0)
+    return fromCache(app.dir) ?? [];
+  const commands = JSON.parse(text).commands.filter((command) => !command.hidden);
+  mkdirSync3(dirname4(cached(app.dir)), { recursive: true });
+  writeFileSync2(cached(app.dir), JSON.stringify(commands));
+  return commands;
+}
+async function entries(fresh) {
+  const found = await consoles();
+  const lists = await Promise.all(found.map(async (app) => fresh ? live(app) : fromCache(app.dir) ?? live(app)));
+  return found.flatMap((app, index) => lists[index].map((command) => ({ app, command })));
+}
+function key2(entry) {
+  return entry.app.dir === "." ? entry.command.name : `${entry.app.dir}/${entry.command.name}`;
+}
+function named2(name) {
+  const colon = name.lastIndexOf(":");
+  return colon === -1 ? name : `${colors.dim(name.slice(0, colon + 1))}${name.slice(colon + 1)}`;
+}
+function signature(command) {
+  return argumentsOf(command).map((argument) => `${argument.is_required ? "<" : "["}${argument.name}${argument.is_array ? "..." : ""}${argument.is_required ? ">" : "]"}`).join(" ");
+}
+function rows(found) {
+  return byRecency(found, runs("sf"), key2).map((entry) => ({
+    hidden: [entry.app.dir, entry.command.name],
+    cells: [entry.app.dir === "." ? named2(entry.command.name) : `${colors.dim(`${entry.app.dir}/`)}${named2(entry.command.name)}`, colors.cyan(signature(entry.command)), colors.dim(entry.command.description)]
+  }));
+}
+function preview(dir, name) {
+  const command = (fromCache(dir) ?? []).find((candidate) => candidate.name === name);
+  if (!command)
+    return;
+  const lines = [
+    colors.bold(command.description),
+    "",
+    colors.yellow("Usage:"),
+    ...command.usage.map((line) => `  ${line}`),
+    ...argumentsOf(command).length ? ["", colors.yellow("Arguments:"), ...argumentsOf(command).map((argument) => `  ${colors.green(argument.name.padEnd(20))} ${argument.description}`)] : [],
+    ...optionsOf(command).length ? ["", colors.yellow("Options:"), ...optionsOf(command).map((option) => `  ${colors.green(`--${option.name}${option.accept_value ? "=" : ""}`.padEnd(20))} ${option.description}`)] : [],
+    ...command.help ? ["", colors.yellow("Help:"), command.help] : []
+  ];
+  console.log(marked2(lines.join(`
+`)));
+}
+function commandFor2(entry, given) {
+  const prompts = argumentsOf(entry.command).filter((argument) => argument.is_required).slice(given.length);
+  return [...entry.app.run, entry.command.name, ...given.map((value) => ({ given: value })), ...prompts.map((argument) => ({ ask: argument.name }))];
+}
+async function answered(command, ask) {
+  const argv = [];
+  const given = [];
+  for (const word of command) {
+    if (typeof word === "string") {
+      argv.push(word);
+      continue;
+    }
+    const value = "given" in word ? word.given : await ask(word.ask);
+    if (value === undefined)
+      return;
+    argv.push(value);
+    given.push(value);
+  }
+  return { argv, given };
+}
+function interactive() {
+  return process10.stdin.isTTY && process10.stderr.isTTY;
+}
+async function execute(emitting, typed, recorded, command) {
+  if (emitting) {
+    emit("run", typed, recorded, command);
+    return 0;
+  }
+  if (!interactive() && command.some((word) => typeof word === "object" && ("ask" in word)))
+    fail("a required argument is missing and there is no terminal to ask for it", 1);
+  const done = await answered(command, async (name) => input2(`${name}:`));
+  if (done === undefined)
+    return 1;
+  if (recorded !== "")
+    record("sf", { id: recorded, args: done.given });
+  return Bun.spawn(done.argv, { stdio: ["inherit", "inherit", "inherit"] }).exited;
+}
+function listing(found) {
+  const sorted = byRecency(found, runs("sf"), key2);
+  const labels = sorted.map((entry) => [key2(entry), signature(entry.command)].filter(Boolean).join(" "));
+  const width = Math.max(...labels.map((label) => label.length));
+  return sorted.map((entry, index) => `${labels[index].padEnd(width)}  ${entry.command.description}`.trimEnd()).join(`
+`);
+}
+async function hidden(flag, rest) {
+  if (flag === "--show") {
+    preview(rest[0] ?? ".", rest[1] ?? "");
+    return 0;
+  }
+  if (flag === "--record") {
+    record("sf", { id: rest[0] ?? "", args: rest.slice(1) });
+    return 0;
+  }
+  if (flag === "--rows") {
+    console.log(table(rows(await entries(true))).join(`
+`));
+    return 0;
+  }
+  if (flag !== "--list" && flag !== "--names")
+    return;
+  const refreshed = flag === "--list" && (await consoles()).some((found) => fromCache(found.dir) !== undefined);
+  const found = await entries(false);
+  if (flag === "--names") {
+    console.log(found.map((entry) => `${key2(entry)}	${entry.command.description}`).join(`
+`));
+    return 0;
+  }
+  if (refreshed)
+    Bun.spawn([process10.execPath, process10.argv[1], "--rows"], { stdio: ["ignore", "ignore", "ignore"] }).unref();
+  list(byRecency(found, runs("sf"), key2).map((entry) => ({
+    label: [key2(entry), signature(entry.command)].filter(Boolean).join(" "),
+    hint: entry.command.description,
+    typed: key2(entry),
+    preview: ["--show", entry.app.dir, entry.command.name]
+  })));
+  return 0;
+}
+async function sf(args) {
+  const [flag = ""] = args;
+  const flagged = await hidden(flag, args.slice(1));
+  if (flagged !== undefined)
+    return flagged;
+  const emitting = flag === "--emit";
+  const words = emitting ? args.slice(1) : args;
+  const last = words[0] === "-";
+  const parsed = parse(last ? [] : words, usage2, {}, {
+    positionals: ["[command]"],
+    trailing: true,
+    replaces: "bin/console typed in the php container, with the command names and arguments looked up by hand",
+    examples: ["sf", ["sf cache:clear", "run it without the picker"], ["sf c:c --env=prod", "the console resolves abbreviations itself"], ["sf -", "the last command again, with its arguments"]]
+  });
+  const [command] = parsed.positionals;
+  const given = last ? words.slice(1) : parsed.rest ?? [];
+  const refreshed = command === undefined && !last && (await consoles()).some((found) => fromCache(found.dir) !== undefined);
+  const found = await entries(false);
+  if (last) {
+    const previous = runs("sf")[0];
+    const entry = previous && found.find((candidate) => key2(candidate) === previous.id);
+    if (entry === undefined)
+      fail(previous ? `${previous.id} is gone` : "nothing run here yet", 1);
+    return execute(emitting, key2(entry), key2(entry), commandFor2(entry, [...previous.args, ...given]));
+  }
+  if (command !== undefined) {
+    const entry = found.find((candidate) => key2(candidate) === command) ?? found.find((candidate) => candidate.command.name === command);
+    if (entry !== undefined)
+      return execute(emitting, key2(entry), key2(entry), commandFor2(entry, given));
+    const [first] = await consoles();
+    if (first === undefined)
+      fail("no bin/console here", 1);
+    return execute(emitting, command, "", [...first.run, command, ...given.map((value) => ({ given: value }))]);
+  }
+  if (found.length === 0)
+    fail("no bin/console here, or it listed no command", 1);
+  if (!interactive() || Bun.which("fzf") === null) {
+    if (emitting)
+      fail("the picker needs a terminal and fzf", 1);
+    if (interactive())
+      console.error("fzf is not installed, listing the commands instead");
+    console.log(listing(found));
+    return 0;
+  }
+  const self = `${process10.execPath} ${process10.argv[1]}`;
+  const picked = fzf(rows(found), {
+    prompt: "sf> ",
+    searched: 1,
+    preview: `${self} --show {1} {2}`,
+    bind: refreshed ? [`load:unbind(load)+reload-sync(${self} --rows)`] : []
+  });
+  const entry = picked && (await entries(false)).find((candidate) => candidate.app.dir === picked.hidden[0] && candidate.command.name === picked.hidden[1]);
+  return entry === undefined ? 1 : execute(emitting, key2(entry), key2(entry), commandFor2(entry, []));
+}
+
+// src/sf-cli.ts
+process11.exitCode = await runMain({ name: "sf", version, run: sf });