@kaynooo/cli-docker 0.0.0-stage → 0.2.0

package/dist/dx-cli.js

@@ -0,0 +1,1123 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/dx-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 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.2.0";
+
+// src/dx.ts
+import process10 from "process";
+
+// src/history.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 historyFile() {
+  return join2(process8.env.XDG_CACHE_HOME ?? join2(homedir2(), ".cache"), "dx", "history.json");
+}
+function history() {
+  try {
+    const file = historyFile();
+    return existsSync(file) ? JSON.parse(readFileSync(file, "utf-8")) : {};
+  } catch {
+    return {};
+  }
+}
+function runs() {
+  return history()[process8.cwd()] ?? [];
+}
+function record(run) {
+  const all = history();
+  const file = historyFile();
+  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)))];
+}
+
+// src/picker.ts
+import process9 from "process";
+
+// 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 output(stack, args) {
+  const proc = Bun.spawn([...stack.list.argv, ...args], { cwd: stack.list.cwd, env: stack.list.env, stdout: "pipe", stderr: "pipe" });
+  return await proc.exited === 0 ? new Response(proc.stdout).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/picker.ts
+var KEYS = { "ctrl-l": "logs", "ctrl-r": "restart", "ctrl-x": "stop", "ctrl-b": "build" };
+var KEY_LABELS = { "ctrl-l": "Logs", "ctrl-r": "Restart", "ctrl-x": "Stop", "ctrl-b": "Rebuild" };
+function row(service) {
+  const colors = paint(process9.stderr);
+  const dir = service.stack.dir;
+  const project = service.stack.project;
+  const name = project === undefined ? service.name : `${colors.dim(`${project}:`)}${service.name}`;
+  return {
+    hidden: [dir, service.name, key(service), project ?? ""],
+    cells: [dir === "." ? name : `${colors.dim(`${dir}/`)}${name}`, colors[stateColor(service.state)](service.state), colors.cyan(service.ports), colors.dim(service.image)]
+  };
+}
+function table(rows) {
+  const widths = rows[0]?.cells.map((_, index) => Math.max(...rows.map((each) => Bun.stringWidth(each.cells[index])))) ?? [];
+  return rows.map((each) => [
+    ...each.hidden,
+    ...each.cells.map((cell, index) => index === each.cells.length - 1 ? cell.trimEnd() : `${cell}${" ".repeat(widths[index] + 1 - Bun.stringWidth(cell))}`)
+  ].join("\t")).join(`
+`);
+}
+function pickService(services) {
+  const proc = Bun.spawnSync([
+    "fzf",
+    "--prompt",
+    "dx> ",
+    "--header",
+    "enter shell or up, ctrl-l logs, ctrl-r restart, ctrl-x stop, ctrl-b rebuild",
+    "--expect",
+    Object.keys(KEYS).join(","),
+    "--ansi",
+    "--reverse",
+    "--height",
+    String(Math.max(15, Math.ceil((services.length + 4) / 0.6))),
+    "--delimiter",
+    "\t",
+    "--with-nth",
+    "5..",
+    "--nth",
+    "1",
+    "--tabstop",
+    "1",
+    "--tiebreak",
+    "chunk,index",
+    "--preview",
+    `${process9.execPath} ${process9.argv[1]} --show {1} {2} {4}`,
+    "--preview-window",
+    "down,40%"
+  ], { stdin: new TextEncoder().encode(table(services.map(row))), stdout: "pipe", stderr: "inherit" });
+  const [pressed = "", line] = proc.stdout.toString().split(`
+`);
+  const keyed = line?.split("\t")[2];
+  const service = services.find((candidate) => key(candidate) === keyed);
+  return service === undefined ? undefined : { service, key: pressed };
+}
+
+// src/dx.ts
+var usage2 = `dx [service] [action]
+dx -
+
+Without a service, picks one with fzf when it is installed and a terminal is attached: enter opens its shell (or brings a stopped service up), ctrl-l follows its logs, ctrl-r restarts, ctrl-x stops and ctrl-b rebuilds it. The services last acted on come first, per folder. Without fzf or a terminal it lists them instead.
+\`dx -\` does the last action again, \`dx <service> [action]\` acts without the picker: \`shell\` (bash when the container has it), \`logs\` (follows the last 200 lines), \`restart\`, \`up\`, \`stop\` or \`build\` (up with a rebuild).
+The services are the stack of this folder or its nearest parent, the ones of the child folders (keyed \`api/php\`), and stacks found only through their containers (keyed \`<project>:php\`).
+
+Exits with the code of the command it ran, 1 when there is no compose service here or none by that name.`;
+var options = {
+  json: jsonOption("[{ key, project, name, state, status, ports, image }]")
+};
+function table2(services) {
+  const colors = paint(process10.stdout);
+  const keys = services.map(key);
+  const width = Math.max(...keys.map((name) => name.length));
+  const states = Math.max(...services.map((service) => service.state.length));
+  return services.map((service, index) => [
+    keys[index].padEnd(width),
+    colors[stateColor(service.state)](service.state.padEnd(states)),
+    colors.cyan(service.ports),
+    colors.dim(service.image)
+  ].join("  ").trimEnd()).join(`
+`);
+}
+function find(services, named) {
+  const found = services.find((service) => key(service) === named) ?? services.find((service) => service.name === named);
+  if (found !== undefined)
+    return found;
+  const nearest = closest(named, services.map(key));
+  return fail(`no service named ${named}${nearest === undefined ? "" : `, did you mean ${nearest}?`}`, 1);
+}
+function listed2(services) {
+  return byRecency(services, runs(), key).map((service) => ({
+    label: key(service),
+    hint: [service.state, service.ports, service.image].filter(Boolean).join(" \xB7 "),
+    typed: key(service),
+    preview: ["--show", service.stack.dir, service.name, service.stack.project ?? ""],
+    actions: Object.entries(KEYS).map(([pressed, action]) => ({ label: KEY_LABELS[pressed] ?? action, key: pressed, typed: `${key(service)} ${action}` }))
+  }));
+}
+async function hidden(flag, rest, services) {
+  if (flag === "--list") {
+    console.log(JSON.stringify(listed2(services)));
+    return 0;
+  }
+  if (flag === "--names") {
+    console.log(services.map((service) => `${key(service)}	${service.state}`).join(`
+`));
+    return 0;
+  }
+  if (flag === "--show") {
+    const [dir = ".", name = "", project = ""] = rest;
+    const service = await serviceNamed(dir, name, project);
+    if (service === undefined)
+      return 0;
+    const colors = paint(process10.stdout);
+    console.log(`${colors[stateColor(service.state)](service.status || service.state)}  ${colors.dim(service.image)}${service.ports ? `  ${colors.cyan(service.ports)}` : ""}
+`);
+    console.log(await logsOf(service.stack, name));
+    return 0;
+  }
+  return;
+}
+async function dx(args) {
+  const [flag = ""] = args;
+  if (flag === "--show" || flag === "--list" || flag === "--names") {
+    const services = flag === "--show" ? [] : await allServices();
+    if (services.length === 0 && flag !== "--show")
+      fail("no compose service here", 1);
+    return await hidden(flag, args.slice(1), services) ?? 0;
+  }
+  const emit = flag === "--emit";
+  const parsed = parse(emit ? args.slice(1) : args, usage2, options, { replaces: "docker compose exec <service> bash, logs -f and restart typed per service", examples: ["dx", ["dx php", "a shell in php, or php brought up when stopped"], ["dx php logs", "follow its logs"], ["dx -", "the last action again"]] });
+  const [named, asked] = parsed.positionals;
+  const services = await allServices();
+  if (services.length === 0)
+    fail("no compose service here", 1);
+  let service;
+  let action;
+  if (named === undefined) {
+    const interactive = process10.stdin.isTTY && process10.stderr.isTTY && parsed.values.json !== true;
+    if (!interactive || Bun.which("fzf") === null) {
+      if (emit)
+        fail("the picker needs a terminal and fzf", 1);
+      if (interactive)
+        console.error("fzf is not installed, listing the services instead");
+      if (parsed.values.json === true)
+        printJson(services.map((each) => ({ key: key(each), project: each.project, name: each.name, state: each.state, status: each.status, ports: each.ports, image: each.image })));
+      else
+        console.log(table2(services));
+      return 0;
+    }
+    const picked = pickService(byRecency(services, runs(), key));
+    if (picked === undefined)
+      return 1;
+    service = picked.service;
+    action = KEYS[picked.key];
+  } else if (named === "-") {
+    const last = runs()[0];
+    service = last && services.find((candidate) => key(candidate) === last.id);
+    if (service === undefined)
+      fail(last ? `${last.id} is gone` : "nothing done here yet", 1);
+    action = last.args[0];
+  } else {
+    service = find(services, named);
+    if (asked !== undefined && !ACTIONS.includes(asked))
+      fail(`no action ${asked}, one of ${ACTIONS.join(", ")}`);
+    action = asked;
+  }
+  const chosen = action ?? defaultAction(service);
+  const command = await commandFor(service, chosen);
+  record({ id: key(service), args: [chosen] });
+  if (emit) {
+    console.log(["run", action === undefined ? key(service) : `${key(service)} ${action}`, "", ...command.map((word) => `=${word}`)].join(`
+`));
+    return 0;
+  }
+  return Bun.spawn(command, { stdio: ["inherit", "inherit", "inherit"] }).exited;
+}
+
+// src/dx-cli.ts
+process11.exitCode = await runMain({ name: "dx", version, run: dx });