@kaynooo/cli-docker 0.5.1 → 0.6.0

package/dist/dlog-cli.js

@@ -2,13 +2,13 @@
 // @bun
 
 // src/dlog-cli.ts
-import process9 from "process";
+import process12 from "process";
 // ../kit/src/args.ts
-import process4 from "process";
+import process7 from "process";
 import { parseArgs } from "util";
 
 // ../kit/src/style.ts
-import process2 from "process";
+import process5 from "process";
 
 // ../../node_modules/.bun/@kaynooo+utils@2.31.2+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-mtetydvc.js
 function x(s) {
@@ -271,21 +271,209 @@ function le(i = {}) {
 }
 var t = le();
 
+// ../kit/src/theme.ts
+import { existsSync as existsSync2, readFileSync, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve as resolve2 } from "path";
+import process4 from "process";
+
+// ../kit/src/config.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import process2 from "process";
+function findUp(names, from = process2.cwd(), stop = () => false) {
+  const wanted = typeof names === "string" ? [names] : names;
+  for (let dir = resolve(from);; dir = dirname(dir)) {
+    const found = wanted.map((name) => join(dir, name)).find((path) => existsSync(path));
+    if (found !== undefined)
+      return found;
+    if (stop(dir) || dirname(dir) === dir)
+      return;
+  }
+}
+
+// ../kit/src/user-config.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+import process3 from "process";
+function configBase(where = {}) {
+  const xdg = where.xdg ?? (where.home === undefined ? process3.env.XDG_CONFIG_HOME : undefined);
+  return xdg !== undefined && xdg !== "" ? xdg : join2(where.home ?? homedir(), ".config");
+}
+function userConfigPath(bin, where = {}) {
+  return join2(configBase(where), "kaynooo-cli", `${bin}.json`);
+}
+
+// ../kit/src/theme.ts
+var DEFAULT = {
+  colors: { accent: "cyan", id: "yellow", path: "blue", label: "dim", value: "bold", ok: "green", warn: "yellow", problem: "red", note: "dim", passed: "green", failed: "red", running: "cyan", queued: "yellow", skipped: "dim" },
+  glyphs: { ok: "\u2713", warn: "\u25B2", problem: "\u2717", note: "\u203A", passed: "\u2713", failed: "\u2717", running: "\u25CF", queued: "\u25CB", skipped: "-", bar: "\u2501" },
+  accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
+  bins: {}
+};
+var BRIGHT = { accent: "cyanBright", id: "yellowBright", path: "blueBright", label: "white", value: "bold whiteBright", ok: "greenBright", warn: "yellowBright", problem: "redBright", note: "white", passed: "greenBright", failed: "redBright", running: "cyanBright", queued: "yellowBright", skipped: "white" };
+var MONO = { accent: "bold", id: "bold", path: "underline", label: "dim", value: "bold", ok: "bold", warn: "bold", problem: "bold", note: "dim", passed: "bold", failed: "bold", running: "bold", queued: "dim", skipped: "dim" };
+var ASCII = { ok: "+", warn: "!", problem: "x", note: ">", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#" };
+var PRESETS = {
+  default: {},
+  "high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"] },
+  mono: { colors: MONO, accents: ["bold"] },
+  ascii: { glyphs: ASCII }
+};
+var STYLES = new Set(["bold", "dim", "italic", "underline", "inverse", "strikethrough", "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray", "grey", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright"]);
+var HEX = /^#[0-9a-f]{6}$/i;
+var CONTROL = /\p{Cc}/u;
+var MAX_FILE_BYTES = 64 * 1024;
+var SPACES = /\s+/;
+function isColorSpec(spec) {
+  if (typeof spec === "number")
+    return Number.isInteger(spec) && spec >= 0 && spec <= 255;
+  return typeof spec === "string" && spec.trim() !== "" && spec.trim().split(SPACES).every((token) => STYLES.has(token) || HEX.test(token));
+}
+function tinted(colors, spec) {
+  if (typeof spec === "number")
+    return colors.ansi256(spec);
+  return spec.trim().split(SPACES).reduce((chain, token) => HEX.test(token) ? chain.hex(token) : chain[token] ?? chain, colors);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readThemeFile(path, warn) {
+  try {
+    const stat = statSync(path, { throwIfNoEntry: false });
+    if (stat === undefined)
+      return;
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) {
+      warn(`${path} is not a regular file under ${MAX_FILE_BYTES / 1024} KiB, theme ignored`);
+      return;
+    }
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (isRecord(parsed))
+      return parsed;
+    warn(`${path} is not a JSON object, theme ignored`);
+  } catch (error) {
+    warn(`${path} does not parse (${error instanceof Error ? error.message : String(error)}), theme ignored`);
+  }
+  return;
+}
+function applyPreset(theme, name, warn, where) {
+  if (name === undefined)
+    return;
+  if (typeof name !== "string" || !Object.hasOwn(PRESETS, name)) {
+    warn(`${where}: no preset ${String(name)}, one of ${Object.keys(PRESETS).join(", ")}`);
+    return;
+  }
+  const preset = PRESETS[name];
+  Object.assign(theme.colors, preset.colors);
+  Object.assign(theme.glyphs, preset.glyphs);
+  if (preset.accents !== undefined)
+    theme.accents = [...preset.accents];
+  return name;
+}
+function applyFile(theme, file, where, warn) {
+  if (isRecord(file.colors)) {
+    for (const [key, value] of Object.entries(file.colors)) {
+      if (!Object.hasOwn(DEFAULT.colors, key))
+        warn(`${where}: no colour ${key}, one of ${Object.keys(DEFAULT.colors).join(", ")}`);
+      else if (!isColorSpec(value))
+        warn(`${where}: colour ${key} is not an ANSI name, \`#rrggbb\` or a number up to 255`);
+      else
+        theme.colors[key] = value;
+    }
+  }
+  if (isRecord(file.glyphs)) {
+    for (const [key, value] of Object.entries(file.glyphs)) {
+      if (!Object.hasOwn(DEFAULT.glyphs, key))
+        warn(`${where}: no glyph ${key}, one of ${Object.keys(DEFAULT.glyphs).join(", ")}`);
+      else if (typeof value !== "string" || CONTROL.test(value) || Bun.stringWidth(value) !== 1)
+        warn(`${where}: glyph ${key} must be one visible character wide, with no control character`);
+      else
+        theme.glyphs[key] = value;
+    }
+  }
+  if (Array.isArray(file.accents) && file.accents.length > 0 && file.accents.every(isColorSpec))
+    theme.accents = [...file.accents];
+  else if (file.accents !== undefined)
+    warn(`${where}: accents must be a non-empty list of colours`);
+  if (isRecord(file.bins)) {
+    for (const [bin, value] of Object.entries(file.bins)) {
+      if (isColorSpec(value))
+        theme.bins[bin] = value;
+      else
+        warn(`${where}: bin ${bin} has no valid colour`);
+    }
+  }
+}
+function endsWalk(home) {
+  return (dir) => dir === resolve2(home) || existsSync2(join3(dir, ".git"));
+}
+var warned = new Set;
+function warnOnce(message) {
+  if (warned.has(message))
+    return;
+  warned.add(message);
+  console.error(`warning: theme ${message}`);
+}
+function isPath(chosen) {
+  return chosen.includes("/") || chosen.endsWith(".json");
+}
+function loadTheme({ env = process4.env, from = process4.cwd(), home = homedir2(), warn = warnOnce } = {}) {
+  const theme = { colors: { ...DEFAULT.colors }, glyphs: { ...DEFAULT.glyphs }, accents: [...DEFAULT.accents], bins: Object.create(null) };
+  const sources = [];
+  const chosen = env.KIT_THEME ?? "";
+  const wanted = chosen === "" ? [userConfigPath("theme", { home, xdg: env.XDG_CONFIG_HOME }), findUp(join3(".kaynooo", "theme.json"), from, endsWalk(home))] : [];
+  if (isPath(chosen))
+    wanted.push(resolve2(from, chosen));
+  const files = [];
+  for (const path of wanted) {
+    const file = path === undefined ? undefined : readThemeFile(path, warn);
+    if (path !== undefined && file !== undefined)
+      files.push({ path, file });
+  }
+  let preset = "default";
+  if (chosen !== "" && !isPath(chosen)) {
+    preset = applyPreset(theme, chosen, warn, "KIT_THEME") ?? preset;
+  } else {
+    const named = files.findLast(({ file }) => file.preset !== undefined);
+    if (named !== undefined)
+      preset = applyPreset(theme, named.file.preset, warn, named.path) ?? preset;
+  }
+  for (const { path, file } of files) {
+    applyFile(theme, file, path, warn);
+    sources.push(path);
+  }
+  return { theme, sources, preset };
+}
+var current;
+var currentKey = "";
+function activeTheme() {
+  const key = `${process4.cwd()}\x00${process4.env.KIT_THEME ?? ""}\x00${process4.env.XDG_CONFIG_HOME ?? ""}`;
+  if (current === undefined || key !== currentKey) {
+    current = loadTheme();
+    currentKey = key;
+  }
+  return current;
+}
+
 // ../kit/src/style.ts
-function takesControlCodes(stream, env = process2.env) {
+function takesControlCodes(stream, env = process5.env) {
   return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb";
 }
-function paint(stream, env = process2.env) {
+function paint(stream, env = process5.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 }
+function role(name, stream, env = process5.env) {
+  const colors = paint(stream, env);
+  return takesControlCodes(stream, env) ? tinted(colors, activeTheme().theme.colors[name]) : colors;
+}
+var STATUS_WORDS = {
+  passed: ["passed", "success", "succeeded", "ok"],
+  failed: ["failed", "failure", "error", "errored"],
+  running: ["running", "in_progress", "started"],
+  queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
+  skipped: ["skipped", "cancelled", "canceled", "manual"]
 };
-var STATUS_OF = new Map(Object.entries(STATUSES).flatMap(([status, { words }]) => words.map((word) => [word, status])));
+var STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
 
 // ../kit/src/format.ts
 function upTo(text, separator) {
@@ -298,27 +486,27 @@ function printJson(value) {
 }
 
 // ../kit/src/help.ts
-import process3 from "process";
+import process6 from "process";
 var OPTIONAL = /\[[^\]]+\]/g;
 var USAGE_PREFIX = /^usage:\s*/i;
 var FULL_STOP = /\.$/;
-function usageLine(usage, colors = paint(process3.stdout)) {
+function usageLine(usage, colors = paint(process6.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 = [] } = {}) {
+function helpText(usage, options, colors = paint(process6.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)) {
+function exitRows(exits, colors = paint(process6.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)) {
+function replacesRows(replaces, colors = paint(process6.stdout)) {
   return replaces === undefined ? [] : ["", `${colors.bold("Instead of:")} ${replaces}`];
 }
-function wantsHelpJson(env = process3.env) {
+function wantsHelpJson(env = process6.env) {
   return env.KIT_HELP === "json";
 }
 function description(usage, { examples = [], replaces, exits } = {}, options) {
@@ -337,12 +525,12 @@ function description(usage, { examples = [], replaces, exits } = {}, options) {
     ...options === undefined ? {} : { options: Object.entries(options).map(([name, { short, description }]) => ({ name, ...short === undefined ? {} : { short }, ...description === undefined ? {} : { description } })) }
   };
 }
-function exampleRows(examples, colors = paint(process3.stdout)) {
+function exampleRows(examples, colors = paint(process6.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)) {
+function optionRows(options, colors = paint(process6.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("|")}>`;
@@ -436,7 +624,7 @@ 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) {
+function applyOutput(color, plain, env = process7.env) {
   const when = plain === true ? "never" : color ?? "auto";
   if (when === "auto")
     return;
@@ -611,15 +799,15 @@ var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x
 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";
+import { readFileSync as readFileSync2, realpathSync } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+import process9 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";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, isAbsolute, join as join4 } from "path";
+import process8 from "process";
 
 // ../kit/src/logs.ts
 var DAY_MS = 24 * 60 * 60 * 1000;
@@ -633,14 +821,14 @@ var usageError;
 function noteUsageError(message) {
   usageError = message;
 }
-function stateHome(env = process5.env) {
+function stateHome(env = process8.env) {
   const dir = env.XDG_STATE_HOME;
-  return dir !== undefined && isAbsolute(dir) ? dir : join(homedir(), ".local", "state");
+  return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
 }
-function usagePath(env = process5.env) {
-  return join(stateHome(env), CLI_FOLDER, "usage.jsonl");
+function usagePath(env = process8.env) {
+  return join4(stateHome(env), CLI_FOLDER, "usage.jsonl");
 }
-function usageRecorded(env = process5.env) {
+function usageRecorded(env = process8.env) {
   const off = env.KAYNOOO_CLI_NO_USAGE;
   return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
 }
@@ -654,12 +842,12 @@ function usageEntry(bin, command, argv, code, now = new Date) {
   usageError = undefined;
   return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
 }
-function recordUsage(entry, env = process5.env) {
+function recordUsage(entry, env = process8.env) {
   if (!usageRecorded(env))
     return;
   try {
     const path = usagePath(env);
-    mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    mkdirSync(dirname2(path), { recursive: true, mode: 448 });
     appendFileSync(path, `${JSON.stringify(entry)}
 `, { mode: 384 });
   } catch {}
@@ -672,8 +860,8 @@ var LEVEL_OPTIONS = {
 };
 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 colors = paint(process9.stderr);
+  const styled = takesControlCodes(process9.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}`;
@@ -692,7 +880,7 @@ function reportThrown(prefix, error, redact = (text) => text, json = false) {
   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)
+  if (error instanceof Exit && error.code === 2)
     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);
@@ -756,17 +944,17 @@ async function printCandidates(found) {
   return 0;
 }
 function packageVersion(entry = Bun.main) {
-  for (let dir = dirname2(realpathSync(entry));; dir = dirname2(dir)) {
+  for (let dir = dirname3(realpathSync(entry));; dir = dirname3(dir)) {
     try {
-      const { version } = JSON.parse(readFileSync(join2(dir, "package.json"), "utf8"));
+      const { version } = JSON.parse(readFileSync2(join5(dir, "package.json"), "utf8"));
       if (typeof version === "string")
         return version;
     } catch {}
-    if (dirname2(dir) === dir)
+    if (dirname3(dir) === dir)
       return "0.0.0";
   }
 }
-async function runMain({ name, version, run, redact, usage }, argv = process6.argv.slice(2)) {
+async function runMain({ name, version, run, redact, usage }, argv = process9.argv.slice(2)) {
   if (argv[0] === COMPLETE)
     return printCandidates(leafCandidates(run, argv.slice(1)));
   if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
@@ -809,11 +997,11 @@ var {Glob } = globalThis.Bun;
 var SESSION_FILES = new Glob("*.json");
 var ACCOUNT_DIRS = new Glob("*/sessions");
 // src/dlog.ts
-import process8 from "process";
+import process11 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";
+import { basename, dirname as dirname4, join as join6 } from "path";
 
 // ../env/src/dotenv.ts
 var ASSIGNMENT = /^\s*(?:export\s+)?([A-Z_][\w.-]*)\s*=(.*)$/i;
@@ -1084,7 +1272,7 @@ async function envFilesBelow(folder, depth = 0) {
     return found;
   }
   for (const entry of children) {
-    const path = join3(folder, entry.name);
+    const path = join6(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))
@@ -1103,8 +1291,8 @@ async function loadKnown(folder = process.cwd(), extra = []) {
 }
 
 // src/stack.ts
-import { existsSync, readdirSync, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname4, join as join4, relative, resolve } from "path";
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname5, join as join7, relative, resolve as resolve3 } from "path";
 
 // ../env/src/redactor.ts
 var MAX_PENDING = 1 << 18;
@@ -1179,21 +1367,21 @@ function children(dir = ".") {
 }
 function up(dir) {
   const dirs = [];
-  for (let current = dir;; current = join4(current, "..")) {
+  for (let current = dir;; current = join7(current, "..")) {
     dirs.push(current);
-    const absolute = resolve(current);
-    if (existsSync(join4(current, ".git")) || dirname4(absolute) === absolute)
+    const absolute = resolve3(current);
+    if (existsSync3(join7(current, ".git")) || dirname5(absolute) === absolute)
       return dirs;
   }
 }
 function stackAt(dir) {
-  return { dir, run: from(dir, ["docker", "compose"]), list: { argv: ["docker", "compose"], cwd: resolve(dir), env: process.env } };
+  return { dir, run: from(dir, ["docker", "compose"]), list: { argv: ["docker", "compose"], cwd: resolve3(dir), env: process.env } };
 }
 function holdsStack(dir) {
-  if (COMPOSE_FILES.some((name) => existsSync(join4(dir, name))))
+  if (COMPOSE_FILES.some((name) => existsSync3(join7(dir, name))))
     return true;
   try {
-    return COMPOSE_FILE_VAR.test(readFileSync2(join4(dir, ".env"), "utf-8"));
+    return COMPOSE_FILE_VAR.test(readFileSync3(join7(dir, ".env"), "utf-8"));
   } catch {
     return false;
   }
@@ -1222,7 +1410,7 @@ async function labels(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)));
+  return labelled(await new Response(proc.stdout).text()).filter((stack) => [...stack.files, ...stack.envFiles].every((file) => existsSync3(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)])];
@@ -1237,7 +1425,7 @@ function stackOf(recorded) {
   return labelledStack(relative(".", recorded.workdir) || ".", recorded);
 }
 async function recordedNearby() {
-  const dirs = new Set([...up("."), ...children()].map((dir) => resolve(dir)));
+  const dirs = new Set([...up("."), ...children()].map((dir) => resolve3(dir)));
   return (await labels()).filter((stack) => dirs.has(stack.workdir));
 }
 async function attempt(stack, args) {
@@ -1410,13 +1598,13 @@ function withoutKeys(lines) {
   });
 }
 function line(report) {
-  const colors = paint(process8.stdout);
+  const colors = paint(process11.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);
+  const colors = paint(process11.stdout);
   for (const report of reports) {
     console.log(line(report));
     if (report.unreadable !== undefined)
@@ -1457,9 +1645,9 @@ async function dlog(args) {
     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(", ")}`));
+    console.error(paint(process11.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 });
+process12.exitCode = await runMain({ name: "dlog", run: dlog });