@kaynooo/cli-docker 0.3.0 → 0.5.0

package/dist/dlog-cli.js

@@ -0,0 +1,1465 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/dlog-cli.ts
+import process9 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, exits = [] } = {}) {
+  return [usageLine(usage, colors), ...replacesRows(replaces, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exitRows(exits, colors), ...exampleRows(examples, colors)].join(`
+`);
+}
+function exitRows(exits, colors = paint(process3.stdout)) {
+  if (exits.length === 0)
+    return [];
+  const width = Math.max(...exits.map(([code]) => String(code).length));
+  return ["", colors.bold("Exits:"), ...exits.map(([code, meaning]) => `  ${colors.cyan(String(code).padEnd(width))}  ${meaning}`)];
+}
+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, exits } = {}, options) {
+  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] }),
+    ...exits === undefined ? {} : { exits: exits.map(([code, meaning]) => ({ code, meaning })) },
+    ...options === undefined ? {} : { options: Object.entries(options).map(([name, { short, description }]) => ({ name, ...short === undefined ? {} : { short }, ...description === undefined ? {} : { description } })) }
+  };
+}
+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/input.ts
+var WHOLE = /^\d+$/;
+function wholeNumber(value, name, fallback, min = 1) {
+  if (value === undefined)
+    return fallback;
+  const number = Number(value);
+  if (!WHOLE.test(value) || !Number.isSafeInteger(number) || number < min)
+    badUsage(`${name.startsWith("<") ? name : `--${name}`} takes a whole number from ${min}, not ${value}`);
+  return number;
+}
+
+// ../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(withAliases(own, all), 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, listing)) : 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 withAliases(args, options) {
+  const named = new Map(Object.entries(options).flatMap(([name, { aliases = [] }]) => aliases.map((alias) => [`--${alias}`, `--${name}`])));
+  if (named.size === 0)
+    return args;
+  const separator = args.indexOf("--");
+  const own = separator === -1 ? args : args.slice(0, separator);
+  return [...own.map((arg) => {
+    const at = arg.indexOf("=");
+    const current = named.get(at === -1 ? arg : arg.slice(0, at));
+    return current === undefined ? arg : `${current}${at === -1 ? "" : arg.slice(at)}`;
+  }), ...separator === -1 ? [] : args.slice(separator)];
+}
+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 { readFileSync, realpathSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+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;
+}
+function packageVersion(entry = Bun.main) {
+  for (let dir = dirname2(realpathSync(entry));; dir = dirname2(dir)) {
+    try {
+      const { version } = JSON.parse(readFileSync(join2(dir, "package.json"), "utf8"));
+      if (typeof version === "string")
+        return version;
+    } catch {}
+    if (dirname2(dir) === dir)
+      return "0.0.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 ?? packageVersion());
+    return 0;
+  }
+  let code;
+  try {
+    code = await run(argv);
+  } catch (error) {
+    code = reportThrown(name, error, redact, wantsJson(argv));
+  }
+  if (usage !== false) {
+    try {
+      recordUsage(usageEntry(name, undefined, argv, code));
+    } catch {}
+  }
+  return code;
+}
+// ../kit/src/compose.ts
+async function captureOutput(argv, { cwd, env } = {}) {
+  const run = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, env: { ...process.env, ...env }, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, code] = await Promise.all([run.stdout.text(), run.stderr.text(), run.exited]);
+  return { code, stdout, stderr };
+}
+function composeError({ code, stderr }) {
+  const last = stderr.trim().split(`
+`).at(-1) ?? "";
+  return last === "" ? `exit ${code}` : last;
+}
+// ../kit/src/secrets.ts
+var SECRET_PART = /token|secret|passw|credential|private|dsn|apikey|accesskey|key$/i;
+var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
+var WORD_BREAKS = /[^a-zA-Z\d]+|(?<=[a-z\d])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/;
+function isSecretName(name) {
+  return SECRET_PART.test(name) || name.split(WORD_BREAKS).some((word) => SECRET_WORDS.has(word.toLowerCase()));
+}
+// ../kit/src/sessions.ts
+var {Glob } = globalThis.Bun;
+var SESSION_FILES = new Glob("*.json");
+var ACCOUNT_DIRS = new Glob("*/sessions");
+// src/dlog.ts
+import process8 from "process";
+
+// ../env/src/files.ts
+import { chmod, chown, readdir, realpath, rename, rm, stat, writeFile } from "fs/promises";
+import { basename, dirname as dirname3, join as join3 } from "path";
+
+// ../env/src/dotenv.ts
+var ASSIGNMENT = /^\s*(?:export\s+)?([A-Z_][\w.-]*)\s*=(.*)$/i;
+var INLINE_COMMENT = /\s+#.*$/;
+var CARRIAGE_RETURN = /\r$/;
+var ESCAPES = { n: `
+`, r: "\r", t: "\t", '"': '"', "\\": "\\", $: "$" };
+function closingQuote(text, quote) {
+  for (let index = 0;index < text.length; index++) {
+    if (quote === '"' && text[index] === "\\")
+      index++;
+    else if (text[index] === quote)
+      return index;
+  }
+  return -1;
+}
+function unescapeDollar(text) {
+  return text.replaceAll("\\$", "$");
+}
+function unescapeDouble(text) {
+  let out = "";
+  for (let index = 0;index < text.length; index++) {
+    const next = text[index + 1];
+    if (text[index] === "\\" && next !== undefined && next in ESCAPES) {
+      out += ESCAPES[next];
+      index++;
+    } else {
+      out += text[index];
+    }
+  }
+  return out;
+}
+function parseDotenv(text) {
+  const physical = text.split(`
+`);
+  const lines = [];
+  for (let index = 0;index < physical.length; index++) {
+    const line = physical[index] ?? "";
+    const match = ASSIGNMENT.exec(line.replace(CARRIAGE_RETURN, ""));
+    if (match === null) {
+      lines.push({ raw: line });
+      continue;
+    }
+    const [, key = "", rest = ""] = match;
+    const start = rest.trimStart();
+    const quote = start[0];
+    if (quote !== '"' && quote !== "'" && quote !== "`") {
+      lines.push({ raw: line, key, value: unescapeDollar(start.replace(INLINE_COMMENT, "").trim()) });
+      continue;
+    }
+    let body = start.slice(1);
+    let raw = line;
+    let end = closingQuote(body, quote);
+    while (end === -1 && index + 1 < physical.length) {
+      index++;
+      body += `
+${(physical[index] ?? "").replace(CARRIAGE_RETURN, "")}`;
+      raw += `
+${physical[index] ?? ""}`;
+      end = closingQuote(body, quote);
+    }
+    const inner = end === -1 ? body : body.slice(0, end);
+    lines.push({ raw, key, value: quote === '"' ? unescapeDouble(inner) : unescapeDollar(inner) });
+  }
+  return { lines };
+}
+function entries(file) {
+  const map = new Map;
+  for (const line of file.lines) {
+    if (line.key !== undefined)
+      map.set(line.key, line.value ?? "");
+  }
+  return map;
+}
+
+// ../env/src/mask.ts
+var MIN_KNOWN_LENGTH = 4;
+var KEY_MASK = "*** private key redacted ***";
+var PLAIN_VALUE = /^(?:true|false|null|none|nil|yes|no|on|off|undefined)$/i;
+var PLACEHOLDER = /^[$%{<(*/]/;
+var URL_PASSWORD = /(?<![a-z0-9+.-])[a-z][a-z0-9+.-]{0,31}:\/\/[^\s:/@]*:([^\s'"]{1,1024})@/dgi;
+var PORT = /^\d{1,5}$/;
+var ESCAPE2 = /[.*+?^${}()|[\]\\]/g;
+function isPlaceholder(value) {
+  return PLACEHOLDER.test(value) || PLAIN_VALUE.test(value);
+}
+var TOKEN_FORMATS = [
+  { kind: "GitHub token", pattern: /\b(?:gh[pousr]_|github_pat_)\w{20,}/dg },
+  { kind: "GitLab token", pattern: /\bglpat-[\w-]{20,}/dg },
+  { kind: "API key", pattern: /\bsk-[\w-]{20,}/dg },
+  { kind: "Slack token", pattern: /\bx(?:ox[abprs]|app)-[\w-]{10,}/dg },
+  { kind: "JWT", pattern: /\beyJ[\w-]+\.[\w-]+\.[\w-]+/dg },
+  { kind: "AWS access key", pattern: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/dg },
+  { kind: "npm token", pattern: /\bnpm_[A-Za-z0-9]{30,}/dg },
+  { kind: "Stripe key", pattern: /\b[sr]k_(?:live|test)_[A-Za-z0-9]{10,}/dg },
+  { kind: "Google API key", pattern: /\bAIza[\w-]{35}/dg },
+  { kind: "SendGrid key", pattern: /\bSG\.[\w-]{16,}\.[\w-]{16,}/dg },
+  { kind: "Authorization header", pattern: /\bAuthorization["']?\s*[:=]\s*["']?(?:Bearer|Basic|Token|Digest)\s+([^\s"',;]{8,})/dgi, skip: isPlaceholder },
+  { kind: "Bearer token", pattern: /\bBearer\s+((?=[\w.~+/=-]*\d)[\w.~+/=-]{20,})/dg },
+  { kind: "password", pattern: /(?<![\w-])(?:[\w-]{0,30}[_-])?(?:password|passwd|secret|api[_-]?key)(?:[_-][\w-]{0,30})?=([^\s"'&;,]{4,})/dgi, skip: isPlaceholder },
+  { kind: "password", pattern: /(?<![\w-])["']?(?:[\w-]{0,30}[_-])?(?:password|passwd|secret|api[_-]?key)(?:[_-][\w-]{0,30})?["']?\s*[:=]\s*(["'])((?:\\.|(?!\1)[^\\\n]){4,})\1/dgi, skip: isPlaceholder }
+];
+var PEM_BEGIN = /-----BEGIN [A-Z ]*PRIVATE KEY(?: BLOCK)?-----/;
+var PEM_END = /-----END [A-Z ]*PRIVATE KEY(?: BLOCK)?-----/;
+var PEM_BODY = /(?<=-----BEGIN [A-Z ]*PRIVATE KEY(?: BLOCK)?-----)(?:(?!-----END [A-Z ]*PRIVATE KEY(?: BLOCK)?-----)[\s\S])+/dg;
+var PEM_BEGIN_ALL = /-----BEGIN [A-Z ]*PRIVATE KEY(?: BLOCK)?-----/g;
+var URL_PARTS = /(?<![a-z0-9+.-])[a-z][a-z0-9+.-]{0,31}:\/\/([^\s/?#'"<>`]*)([^\s?#'"<>`]*)(?:\?([^\s#'"<>`]*))?/dgi;
+var PATH_SEGMENT = /[^/]+/g;
+var SECRET_PARAM = /^(?:token|[a-z]+_token|key|api[_-]?key|access[_-]?key|secret|[a-z]+_secret|password|passwd|pwd|sig|signature|auth|authorization)$/i;
+var WEBHOOK_FORMATS = [
+  ["Discord webhook", /(?:^|\.)discord(?:app)?\.com\/api\/(?:v\d+\/)?webhooks\/\d+\/([\w-]+)/di],
+  ["Slack webhook", /^hooks\.slack\.com\/(?:services|workflows)\/(?:[\w-]+\/)*([\w-]+)/di],
+  ["Uptime Kuma push URL", /\/api\/push\/([\w-]+)/di],
+  ["healthchecks.io ping URL", /^hc-ping\.com\/([\w-]+)/di]
+];
+var OPAQUE_SEGMENT = /^(?:(?=[\w-]{20,}$)(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[\w-]+|(?=[A-Za-z\d]{32,}$)(?=.*[A-Za-z])(?=.*\d).+)$/;
+function hint(value) {
+  const shown = Math.min(3, Math.floor(value.length / 4));
+  return `${value.slice(0, shown)}***(${value.length})`;
+}
+function forms(value) {
+  return [...new Set([value, encodeURIComponent(value), JSON.stringify(value).slice(1, -1)])];
+}
+function knownSecrets(pairs) {
+  const keys = new Map;
+  for (const [key, value] of pairs) {
+    if (value.length < MIN_KNOWN_LENGTH || PLAIN_VALUE.test(value))
+      continue;
+    for (const form of forms(value)) {
+      if (!keys.has(form))
+        keys.set(form, key);
+    }
+  }
+  if (keys.size === 0)
+    return { pattern: undefined, keys };
+  const alternatives = [...keys.keys()].sort((a, b) => b.length - a.length).map((value) => value.replace(ESCAPE2, "\\$&"));
+  return { pattern: new RegExp(`(?<!\\w)(?:${alternatives.join("|")})(?!\\w)`, "g"), keys };
+}
+function passwordSpans(text) {
+  const spans = [];
+  for (const url of text.matchAll(URL_PASSWORD)) {
+    const [start, end] = url.indices?.[1] ?? [];
+    const password = url[1] ?? "";
+    const slash = password.indexOf("/");
+    if (start !== undefined && end !== undefined && !(slash !== -1 && PORT.test(password.slice(0, slash))))
+      spans.push([start, end]);
+  }
+  return spans;
+}
+function urlPasswords(text) {
+  return passwordSpans(text).map(([start, end]) => text.slice(start, end));
+}
+function urlTokens(line) {
+  const found = [];
+  const add = (kind, start, value) => {
+    found.push({ start, end: start + value.length, kind, mask: hint(value) });
+  };
+  for (const url of line.matchAll(URL_PARTS)) {
+    const [authority, path = "", query] = [url[1] ?? "", url[2] ?? "", url[3]];
+    const authorityStart = url.indices?.[1]?.[0];
+    const pathStart = url.indices?.[2]?.[0];
+    const queryStart = url.indices?.[3]?.[0];
+    if (authorityStart === undefined || pathStart === undefined)
+      continue;
+    const hostAt = authority.lastIndexOf("@") + 1;
+    const target = authority.slice(hostAt) + path;
+    for (const [kind, pattern] of WEBHOOK_FORMATS) {
+      const [start, end] = pattern.exec(target)?.indices?.[1] ?? [];
+      if (start !== undefined && end !== undefined)
+        add(kind, authorityStart + hostAt + start, target.slice(start, end));
+    }
+    for (const segment of path.matchAll(PATH_SEGMENT)) {
+      if (OPAQUE_SEGMENT.test(segment[0]))
+        add("URL token", pathStart + segment.index, segment[0]);
+    }
+    if (query === undefined || queryStart === undefined)
+      continue;
+    let offset = 0;
+    for (const param of query.split("&")) {
+      const equals = param.indexOf("=");
+      if (equals > 0 && equals < param.length - 1 && SECRET_PARAM.test(param.slice(0, equals)))
+        add("URL token", queryStart + offset + equals + 1, param.slice(equals + 1));
+      offset += param.length + 1;
+    }
+  }
+  return found.filter((match) => match.end > match.start);
+}
+function findSecrets(line, known) {
+  const found = [];
+  for (const [start, end] of passwordSpans(line))
+    found.push({ start, end, kind: "URL password", mask: "***" });
+  for (const body of line.matchAll(PEM_BODY)) {
+    const [start, end] = body.indices?.[0] ?? [];
+    if (start !== undefined && end !== undefined)
+      found.push({ start, end, kind: "private key", mask: KEY_MASK });
+  }
+  for (const { kind, pattern, skip } of TOKEN_FORMATS) {
+    for (const token of line.matchAll(pattern)) {
+      const [start, end] = token.indices?.at(-1) ?? [];
+      if (start === undefined || end === undefined)
+        continue;
+      const value = line.slice(start, end);
+      if (!skip?.(value))
+        found.push({ start, end, kind, mask: hint(value) });
+    }
+  }
+  found.push(...urlTokens(line));
+  if (known?.pattern !== undefined) {
+    for (const value of line.matchAll(known.pattern))
+      found.push({ start: value.index, end: value.index + value[0].length, kind: `value of ${known.keys.get(value[0])}`, mask: hint(value[0]) });
+  }
+  found.sort((a, b) => a.start - b.start || b.end - a.end);
+  const kept = [];
+  for (const match of found) {
+    if (match.start >= (kept.at(-1)?.end ?? 0))
+      kept.push(match);
+  }
+  return kept;
+}
+function openKeyBody(line) {
+  const last = [...line.matchAll(PEM_BEGIN_ALL)].at(-1);
+  if (last === undefined)
+    return;
+  const after = line.slice(last.index + last[0].length);
+  return PEM_END.test(after) ? undefined : after.trim();
+}
+function maskLine(line, known) {
+  let out = "";
+  let at = 0;
+  for (const match of findSecrets(line, known)) {
+    out += line.slice(at, match.start) + match.mask;
+    at = match.end;
+  }
+  return out + line.slice(at);
+}
+
+// ../env/src/files.ts
+var ENV_FILE = /^(?:\.env(?:\..+)?|.+\.env|\.envrc)$/;
+var KNOWN_DEPTH = 3;
+var SKIPPED = new Set(["node_modules", ".git", "vendor"]);
+async function isFileEntry(entry, path) {
+  if (entry.isFile())
+    return true;
+  if (!entry.isSymbolicLink())
+    return false;
+  try {
+    return (await stat(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+function secretPairs(file) {
+  const pairs = [];
+  for (const [key, value] of entries(file)) {
+    if (isSecretName(key))
+      pairs.push([key, value]);
+    else
+      pairs.push(...urlPasswords(value).map((password) => [key, password]));
+  }
+  return pairs;
+}
+async function envFilesBelow(folder, depth = 0) {
+  const found = [];
+  let children;
+  try {
+    children = await readdir(folder, { withFileTypes: true });
+  } catch {
+    return found;
+  }
+  for (const entry of children) {
+    const path = join3(folder, entry.name);
+    if (entry.isDirectory() && depth < KNOWN_DEPTH && !SKIPPED.has(entry.name))
+      found.push(...await envFilesBelow(path, depth + 1));
+    else if (ENV_FILE.test(entry.name) && await isFileEntry(entry, path))
+      found.push(path);
+  }
+  return found;
+}
+async function loadKnown(folder = process.cwd(), extra = []) {
+  const pairs = extra.flatMap(secretPairs);
+  for (const path of await envFilesBelow(folder)) {
+    try {
+      pairs.push(...secretPairs(parseDotenv(await Bun.file(path).text())));
+    } catch {}
+  }
+  return knownSecrets(pairs);
+}
+
+// src/stack.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname4, join as join4, relative, resolve } from "path";
+
+// ../env/src/redactor.ts
+var MAX_PENDING = 1 << 18;
+var OVERLAP = 1 << 13;
+
+class Redactor {
+  known;
+  pending = "";
+  inKey = false;
+  hidden = false;
+  constructor(known) {
+    this.known = known;
+  }
+  push(chunk) {
+    const end = chunk.lastIndexOf(`
+`);
+    this.pending += chunk;
+    if (end === -1)
+      return this.pending.length > MAX_PENDING ? this.cut() : "";
+    const split = this.pending.length - chunk.length + end + 1;
+    const complete = this.pending.slice(0, split);
+    this.pending = this.pending.slice(split);
+    return complete.split(`
+`).slice(0, -1).map((line) => this.line(line)).filter((line) => line !== undefined).map((line) => `${line}
+`).join("");
+  }
+  cut() {
+    const limit = this.pending.length - OVERLAP;
+    const space = this.pending.lastIndexOf(" ", limit);
+    const at = space > 0 ? space + 1 : limit;
+    const head = this.pending.slice(0, at);
+    this.pending = this.pending.slice(at);
+    return this.line(head) ?? "";
+  }
+  end() {
+    const rest = this.pending;
+    this.pending = "";
+    return rest === "" ? "" : this.line(rest) ?? "";
+  }
+  line(line) {
+    if (this.inKey) {
+      const end = PEM_END.exec(line);
+      if (end === null) {
+        if (this.hidden)
+          return;
+        this.hidden = true;
+        return KEY_MASK;
+      }
+      this.inKey = false;
+      return (end.index > 0 && !this.hidden ? KEY_MASK : "") + this.line(line.slice(end.index));
+    }
+    const body = openKeyBody(line);
+    if (body !== undefined) {
+      this.inKey = true;
+      this.hidden = body !== "";
+    }
+    return maskLine(line, this.known);
+  }
+}
+
+// src/stack.ts
+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 SKIPPED2 = 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(".") && !SKIPPED2.has(child.name)).map((child) => child.name).sort();
+}
+function up(dir) {
+  const dirs = [];
+  for (let current = dir;; current = join4(current, "..")) {
+    dirs.push(current);
+    const absolute = resolve(current);
+    if (existsSync(join4(current, ".git")) || dirname4(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) => existsSync(join4(dir, name))))
+    return true;
+  try {
+    return COMPOSE_FILE_VAR.test(readFileSync2(join4(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) => existsSync(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 result = await captureOutput([...stack.list.argv, ...args], { cwd: stack.list.cwd, env: stack.list.env });
+  return result.code === 0 ? { text: result.stdout, error: undefined } : { text: "", error: composeError(result) };
+}
+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";
+}
+var LOGS_TAIL = 200;
+async function commandFor(service, action, logs = {}) {
+  const run = service.stack.run;
+  switch (action) {
+    case "shell":
+      return [...run, "exec", service.name, await shellOf(service)];
+    case "logs":
+      return [...run, "logs", ...logs.follow === false ? [] : ["-f"], `--tail=${logs.tail ?? LOGS_TAIL}`, 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);
+}
+function maskLog(text, known) {
+  const redactor = new Redactor(known);
+  return redactor.push(text) + redactor.end();
+}
+async function logsOf(stack, name) {
+  return maskLog(await output(stack, ["logs", "--tail=30", "--no-log-prefix", name]), await loadKnown());
+}
+
+// src/dlog.ts
+var usage2 = `dlog [service...]
+
+One line per compose service with its state and health, then the last distinct error lines of the services that log some or are not healthy, repeats collapsed to one line with a count and secrets masked as redact does.
+With service names, only those are read. The stacks are the ones dx lists: this folder's, its child folders' and the ones only their containers tell of.
+\`--level warn\` keeps warnings too, \`--grep <regex>\` keeps the lines matching a case insensitive regex instead of the error words. What fails the exit is \`--fail-on\`: by default a service down, unhealthy or still starting, an error line or logs compose could not read, so it can gate a script; \`--fail-on down\` leaves out an old error line that \`--since\` has not aged out yet. A service that exited with code 0 (a migration, an init) is not down.`;
+var EXITS = [[0, "nothing the --fail-on list names: every service is up and quiet"], [1, "a service is down, unhealthy or still starting, logged a matching line or has logs compose could not read (as --fail-on keeps them), or there is no compose service here"], [2, "a usage error"]];
+var FAIL_ON = ["down", "unhealthy", "errors"];
+var options = {
+  lines: { type: "string", short: "n", default: "5", description: "error lines kept per service" },
+  since: { type: "string", default: "1h", description: "how far back the logs are read (compose --since: 30m, 2h, a timestamp)" },
+  level: { type: "string", choices: ["error", "warn"], default: "error", description: "lowest level of the lines kept: error (the default) or warn, warnings too" },
+  grep: { type: "string", description: "keep the lines matching this regex, case insensitive, instead of the --level words" },
+  "fail-on": { type: "string", multiple: true, choices: FAIL_ON, description: "what makes the exit 1, repeatable: down, unhealthy or errors (all three)" },
+  all: { type: "boolean", short: "a", description: "the last log lines of a service with no error too" },
+  json: jsonOption("[{ key, state, health, status, errors: [{ line, count }], tail, down, unhealthy }]")
+};
+var ERROR = /\b(?:error|err|fatal|exception|panic|critical|crit|traceback|failed|failure|refused|denied|timeout|timed out|oom|killed)\b/i;
+var WARNING = /\b(?:warn|warning|deprecated|deprecation)\b/i;
+var LEVELS = { error: ERROR, warn: new RegExp(`${ERROR.source}|${WARNING.source}`, "i") };
+var TAIL = 500;
+var MAX_WIDTH = 220;
+var TIMESTAMP = /\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:[.,]\d+)?(?:Z|[+-]\d{2}:?\d{2})?|\d{2}[/-][A-Za-z]{3}[/-]\d{4}:\d{2}:\d{2}:\d{2}(?: [+-]\d{4})?|\d{2}:\d{2}:\d{2}(?:[.,]\d+)?/g;
+var IDENTIFIER = /\b(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|0x[0-9a-f]+|[0-9a-f]{12,})\b/gi;
+var NUMBER = /\d+/g;
+var STATUS_HEALTH = /\((healthy|unhealthy|health: starting)\)/;
+var LEADING_BRACKETS = /^(?:\[\s*\]|\s)+/;
+function shape(line) {
+  return line.replace(TIMESTAMP, "").replace(IDENTIFIER, "#").replace(NUMBER, "#").replace(LEADING_BRACKETS, "").trim();
+}
+function clip(line) {
+  return line.length > MAX_WIDTH ? `${line.slice(0, MAX_WIDTH - 1)}\u2026` : line;
+}
+function errorLines(log, limit, known, matches = ERROR) {
+  const seen = new Map;
+  for (const raw of log.split(`
+`)) {
+    const line = stripAnsi(raw).trim();
+    if (line === "" || !matches.test(line))
+      continue;
+    const shared = shape(line);
+    const before = seen.get(shared);
+    seen.delete(shared);
+    seen.set(shared, { line: clip(maskLine(line, known)), count: (before?.count ?? 0) + 1 });
+  }
+  return [...seen.values()].slice(-limit);
+}
+function isUp(state, container) {
+  return state === "running" || state === "exited" && container?.ExitCode === 0;
+}
+function healthOf(state, container) {
+  const health = (container?.Health ?? "") || (STATUS_HEALTH.exec(container?.Status ?? "")?.[1]?.replace("health: ", "") ?? "");
+  return { health, fine: isUp(state, container) && (health === "" || health === "healthy") };
+}
+function needsLook(report, failOn) {
+  return failOn.has("down") && (report.down || report.unreadable !== undefined) || failOn.has("unhealthy") && report.unhealthy || failOn.has("errors") && (report.errors.length > 0 || report.unreadable !== undefined);
+}
+function matcherOf(level, grep) {
+  if (grep === undefined)
+    return LEVELS[level];
+  try {
+    return new RegExp(grep, "i");
+  } catch {
+    return badUsage(`--grep takes a regex, ${grep} is not one`);
+  }
+}
+async function read(service, since) {
+  const [ps, logs] = await Promise.all([
+    attempt(service.stack, ["ps", "--all", "--format", "json", service.name]),
+    attempt(service.stack, ["logs", "--no-color", "--no-log-prefix", `--tail=${TAIL}`, `--since=${since}`, service.name])
+  ]);
+  return { log: logs.text, container: containers(ps.text)[0], unreadable: ps.error ?? logs.error };
+}
+function withoutKeys(lines) {
+  let inKey = false;
+  return lines.filter((text) => {
+    const opens = PEM_BEGIN.test(text);
+    const hidden = inKey || opens;
+    inKey = (inKey || opens) && !PEM_END.test(text);
+    return !hidden;
+  });
+}
+function line(report) {
+  const colors = paint(process8.stdout);
+  const status = report.status.replace(STATUS_HEALTH, "").trim();
+  const detail = [report.health, status].filter(Boolean).join(" \xB7 ");
+  return `${report.key.padEnd(24)} ${colors[stateColor(report.state)](report.state.padEnd(9))} ${colors.dim(detail)}`.trimEnd();
+}
+function show(reports) {
+  const colors = paint(process8.stdout);
+  for (const report of reports) {
+    console.log(line(report));
+    if (report.unreadable !== undefined)
+      console.log(`  ${colors.red(`logs unavailable: ${report.unreadable}`)}`);
+    for (const { line: text, count } of report.errors)
+      console.log(`  ${colors.red(text)}${count > 1 ? colors.dim(` \xD7${count}`) : ""}`);
+    for (const text of report.tail)
+      console.log(`  ${colors.dim(text)}`);
+  }
+}
+async function dlog(args) {
+  const parsed = parse(args, usage2, options, { exits: EXITS, replaces: "docker compose ps, logs --tail | grep -i error and docker inspect for health", examples: ["dlog", ["dlog php db", "only those services"], ["dlog -n 10 --since 15m", "ten error lines of the last quarter of an hour"], ["dlog --level warn", "warnings too"], ['dlog --grep "timeout|5\\d\\d"', "the lines matching a regex"], ["dlog --fail-on down --fail-on unhealthy", "a gate that ignores old errors"], ["dlog --json", "the report as JSON"]] });
+  const limit = wholeNumber(parsed.values.lines, "lines", 5);
+  const matches = matcherOf(parsed.values.level === "warn" ? "warn" : "error", parsed.values.grep);
+  const failOn = new Set((parsed.values["fail-on"] ?? []).length > 0 ? parsed.values["fail-on"] ?? FAIL_ON : FAIL_ON);
+  const known = await loadKnown();
+  const services = await allServices();
+  if (services.length === 0)
+    fail("no compose service here", 1);
+  const wanted = parsed.positionals;
+  const unknown = wanted.filter((name) => !services.some((service) => key(service) === name || service.name === name));
+  if (unknown.length > 0)
+    fail(`no service named ${unknown.join(", ")}`, 1);
+  const chosen = wanted.length === 0 ? services : services.filter((service) => wanted.includes(key(service)) || wanted.includes(service.name));
+  const reports = await Promise.all(chosen.map(async (service) => {
+    const { log, container, unreadable } = await read(service, parsed.values.since);
+    const { health, fine } = healthOf(service.state, container);
+    const lines = withoutKeys(log.split(`
+`));
+    const errors = errorLines(lines.join(`
+`), limit, known, matches);
+    const tail = parsed.values.all === true && errors.length === 0 ? lines.map((text) => clip(maskLine(stripAnsi(text).trim(), known))).filter(Boolean).slice(-limit) : [];
+    return { key: key(service), state: service.state, health, status: service.status, errors, tail, unreadable, fine, down: !isUp(service.state, container), unhealthy: isUp(service.state, container) && !fine };
+  }));
+  if (parsed.values.json === true)
+    printJson(reports);
+  else
+    show(reports);
+  const down = reports.filter((report) => needsLook(report, failOn));
+  if (parsed.values.json !== true && down.length > 0)
+    console.error(paint(process8.stderr).dim(`${down.length} of ${reports.length} services need a look: ${down.map((report) => report.key).join(", ")}`));
+  return down.length > 0 ? 1 : 0;
+}
+
+// src/dlog-cli.ts
+process9.exitCode = await runMain({ name: "dlog", run: dlog });