@kaynooo/cli-stack 0.7.2 → 0.8.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/README.md +2 -19
  2. package/dist/cli.js +351 -598
  3. package/package.json +7 -7
package/dist/cli.js CHANGED
@@ -1,19 +1,19 @@
1
1
  #!/usr/bin/env -S bun --no-env-file --config=/dev/null
2
2
  // @bun
3
-
4
- // src/cli.ts
5
- import process17 from "process";
6
- // ../kit/src/args.ts
7
- import process9 from "process";
8
- import { parseArgs } from "util";
9
-
10
- // ../kit/src/format.ts
11
- import process7 from "process";
3
+ var __esm = (fn, res, err) => () => {
4
+ if (fn)
5
+ try {
6
+ res = fn(fn = 0);
7
+ } catch (e) {
8
+ err = [e];
9
+ }
10
+ if (err)
11
+ throw err[0];
12
+ return res;
13
+ };
12
14
 
13
15
  // ../kit/src/mode.ts
14
16
  import process2 from "process";
15
- var MODES = new Set(["terminal", "ci", "agent", "pipe"]);
16
- var AGENT_VARIABLES = ["CLAUDECODE", "AI_AGENT"];
17
17
  function isSet(value) {
18
18
  return value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false";
19
19
  }
@@ -27,12 +27,13 @@ function outputMode(stream = process2.stdout, env = process2.env) {
27
27
  return "terminal";
28
28
  return isSet(env.CI) ? "ci" : "pipe";
29
29
  }
30
+ var MODES, AGENT_VARIABLES;
31
+ var init_mode = __esm(() => {
32
+ MODES = new Set(["terminal", "ci", "agent", "pipe"]);
33
+ AGENT_VARIABLES = ["CLAUDECODE", "AI_AGENT"];
34
+ });
30
35
 
31
- // ../kit/src/style.ts
32
- import process6 from "process";
33
-
34
- // ../../node_modules/.bun/@kaynooo+utils@3.0.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-x450vn3m.js
35
- var G = /^[a-f0-9]+$/i;
36
+ // ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-x450vn3m.js
36
37
  function b(r) {
37
38
  let e = r.startsWith("#") ? r.slice(1) : r;
38
39
  if (!G.test(e))
@@ -43,11 +44,6 @@ function b(r) {
43
44
  throw Error(`Invalid hex color length: ${e.length}`);
44
45
  return [Number.parseInt(e.slice(0, 2), 16), Number.parseInt(e.slice(2, 4), 16), Number.parseInt(e.slice(4, 6), 16)];
45
46
  }
46
- var B = { 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, 39], red: [31, 39], green: [32, 39], yellow: [33, 39], blue: [34, 39], magenta: [35, 39], cyan: [36, 39], white: [37, 39], gray: [90, 39], grey: [90, 39], blackBright: [90, 39], redBright: [91, 39], greenBright: [92, 39], yellowBright: [93, 39], blueBright: [94, 39], magentaBright: [95, 39], cyanBright: [96, 39], whiteBright: [97, 39], bgBlack: [40, 49], bgRed: [41, 49], bgGreen: [42, 49], bgYellow: [43, 49], bgBlue: [44, 49], bgMagenta: [45, 49], bgCyan: [46, 49], bgWhite: [47, 49], bgBlackBright: [100, 49], bgRedBright: [101, 49], bgGreenBright: [102, 49], bgYellowBright: [103, 49], bgBlueBright: [104, 49], bgMagentaBright: [105, 49], bgCyanBright: [106, 49], bgWhiteBright: [107, 49], rgb: (r, e, l, n = "fg") => [`${n === "fg" ? 38 : 48};2;${r};${e};${l}`, n === "fg" ? 39 : 49], hex: (r, e = "fg") => {
47
- let [l, n, c] = b(r);
48
- return [`${e === "fg" ? 38 : 48};2;${l};${n};${c}`, e === "fg" ? 39 : 49];
49
- }, ansi256: (r, e = "fg") => [`${e === "fg" ? 38 : 48};5;${r}`, e === "fg" ? 39 : 49] };
50
- var h = new Set(["", "1", "2", "3", "true"]);
51
47
  function C(r, e = globalThis.process?.env ?? {}) {
52
48
  if (e.FORCE_COLOR !== undefined)
53
49
  return h.has(e.FORCE_COLOR);
@@ -84,13 +80,21 @@ function f(r, e = []) {
84
80
  function Fe(r = {}) {
85
81
  return f(r);
86
82
  }
87
- var o = Fe();
83
+ var G, B, h, o;
84
+ var init_chunk_x450vn3m = __esm(() => {
85
+ G = /^[a-f0-9]+$/i;
86
+ B = { 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, 39], red: [31, 39], green: [32, 39], yellow: [33, 39], blue: [34, 39], magenta: [35, 39], cyan: [36, 39], white: [37, 39], gray: [90, 39], grey: [90, 39], blackBright: [90, 39], redBright: [91, 39], greenBright: [92, 39], yellowBright: [93, 39], blueBright: [94, 39], magentaBright: [95, 39], cyanBright: [96, 39], whiteBright: [97, 39], bgBlack: [40, 49], bgRed: [41, 49], bgGreen: [42, 49], bgYellow: [43, 49], bgBlue: [44, 49], bgMagenta: [45, 49], bgCyan: [46, 49], bgWhite: [47, 49], bgBlackBright: [100, 49], bgRedBright: [101, 49], bgGreenBright: [102, 49], bgYellowBright: [103, 49], bgBlueBright: [104, 49], bgMagentaBright: [105, 49], bgCyanBright: [106, 49], bgWhiteBright: [107, 49], rgb: (r, e, l, n = "fg") => [`${n === "fg" ? 38 : 48};2;${r};${e};${l}`, n === "fg" ? 39 : 49], hex: (r, e = "fg") => {
87
+ let [l, n, c] = b(r);
88
+ return [`${e === "fg" ? 38 : 48};2;${l};${n};${c}`, e === "fg" ? 39 : 49];
89
+ }, ansi256: (r, e = "fg") => [`${e === "fg" ? 38 : 48};5;${r}`, e === "fg" ? 39 : 49] };
90
+ h = new Set(["", "1", "2", "3", "true"]);
91
+ o = Fe();
92
+ });
88
93
 
89
- // ../kit/src/theme.ts
90
- import { existsSync as existsSync2, readFileSync, statSync } from "fs";
91
- import { homedir as homedir2 } from "os";
92
- import { join as join3, resolve as resolve2 } from "path";
93
- import process5 from "process";
94
+ // ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/tools/colors.js
95
+ var init_colors = __esm(() => {
96
+ init_chunk_x450vn3m();
97
+ });
94
98
 
95
99
  // ../kit/src/config.ts
96
100
  import { existsSync } from "fs";
@@ -106,48 +110,36 @@ function findUp(names, from = process3.cwd(), stop = () => false) {
106
110
  return;
107
111
  }
108
112
  }
113
+ var init_config = __esm(() => {
114
+ init_args();
115
+ });
109
116
 
110
117
  // ../kit/src/user-config.ts
111
118
  import { homedir } from "os";
112
- import { join as join2 } from "path";
119
+ import { isAbsolute, join as join2 } from "path";
113
120
  import process4 from "process";
121
+ function xdgFolder(value, fallback) {
122
+ return value !== undefined && isAbsolute(value) ? value : fallback;
123
+ }
114
124
  function configBase(where = {}) {
115
125
  const xdg = where.xdg ?? (where.home === undefined ? process4.env.XDG_CONFIG_HOME : undefined);
116
- return xdg !== undefined && xdg !== "" ? xdg : join2(where.home ?? homedir(), ".config");
126
+ return xdgFolder(xdg, join2(where.home ?? homedir(), ".config"));
117
127
  }
118
128
  function userConfigPath(bin, where = {}) {
119
129
  return join2(configBase(where), "kaynooo-cli", `${bin}.json`);
120
130
  }
131
+ var init_user_config = () => {};
121
132
 
122
133
  // ../kit/src/theme.ts
123
- var ENDS = new Map;
124
- var DEFAULT = {
125
- colors: { accent: "cyan", id: "yellow", path: "blue", label: "dim", value: "bold", ok: "green", warn: "yellow", problem: "red", note: "dim", plan: "magenta", passed: "green", failed: "red", running: "cyan", queued: "yellow", skipped: "dim" },
126
- glyphs: { ok: "\u2713", warn: "\u25B2", problem: "\u2717", note: "\u203A", plan: "\u25C7", passed: "\u2713", failed: "\u2717", running: "\u25CF", queued: "\u25CB", skipped: "-", bar: "\u2501", rule: "\u2500", corner: "\u256D", open: "\u2022", leaf: "\xB7", guide: "\u2502" },
127
- accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
128
- bins: {},
129
- gradient: ["#c084fc", "#67e8f9"]
130
- };
131
- var BRIGHT = { accent: "cyanBright", id: "yellowBright", path: "blueBright", label: "white", value: "bold whiteBright", ok: "greenBright", warn: "yellowBright", problem: "redBright", note: "white", plan: "magentaBright", passed: "greenBright", failed: "redBright", running: "cyanBright", queued: "yellowBright", skipped: "white" };
132
- var MONO = { accent: "bold", id: "bold", path: "underline", label: "dim", value: "bold", ok: "bold", warn: "bold", problem: "bold", note: "dim", plan: "dim", passed: "bold", failed: "bold", running: "bold", queued: "dim", skipped: "dim" };
133
- var ASCII = { ok: "+", warn: "!", problem: "x", note: ">", plan: "?", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#", rule: "-", corner: "+", open: "*", leaf: "-", guide: "|" };
134
- var PRESETS = {
135
- default: {},
136
- "high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"], gradient: ["#d8b4fe", "#a5f3fc"] },
137
- mono: { colors: MONO, accents: ["bold"], gradient: undefined },
138
- ascii: { glyphs: ASCII }
139
- };
140
- 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"]);
141
- var HEX = /^#[0-9a-f]{6}$/i;
142
- var CONTROL = /\p{Cc}/u;
143
- var MAX_FILE_BYTES = 64 * 1024;
144
- var SPACES = /\s+/;
134
+ import { existsSync as existsSync2, readFileSync, statSync } from "fs";
135
+ import { homedir as homedir2 } from "os";
136
+ import { join as join3, resolve as resolve2 } from "path";
137
+ import process5 from "process";
145
138
  function isColorSpec(spec) {
146
139
  if (typeof spec === "number")
147
140
  return Number.isInteger(spec) && spec >= 0 && spec <= 255;
148
141
  return typeof spec === "string" && spec.trim() !== "" && spec.trim().split(SPACES).every((token) => STYLES.has(token) || HEX.test(token));
149
142
  }
150
- var CUBE = [0, 95, 135, 175, 215, 255];
151
143
  function cubeLevel(channel) {
152
144
  return CUBE.reduce((best, value, level) => Math.abs(value - channel) < Math.abs(CUBE[best] - channel) ? level : best, 0);
153
145
  }
@@ -252,7 +244,6 @@ function applyFile(theme, file, where, warn) {
252
244
  function endsWalk(home) {
253
245
  return (dir) => dir === resolve2(home) || existsSync2(join3(dir, ".git"));
254
246
  }
255
- var warned = new Set;
256
247
  function warnOnce(message) {
257
248
  if (warned.has(message))
258
249
  return;
@@ -289,8 +280,6 @@ function loadTheme({ env = process5.env, from = process5.cwd(), home = homedir2(
289
280
  }
290
281
  return { theme, sources, preset };
291
282
  }
292
- var current;
293
- var currentKey = "";
294
283
  function activeTheme() {
295
284
  const key = `${process5.cwd()}\x00${process5.env.KIT_THEME ?? ""}\x00${process5.env.XDG_CONFIG_HOME ?? ""}`;
296
285
  if (current === undefined || key !== currentKey) {
@@ -299,9 +288,38 @@ function activeTheme() {
299
288
  }
300
289
  return current;
301
290
  }
291
+ var ENDS, DEFAULT, BRIGHT, MONO, ASCII, PRESETS, STYLES, HEX, CONTROL, MAX_FILE_BYTES, SPACES, CUBE, warned, current, currentKey = "";
292
+ var init_theme = __esm(() => {
293
+ init_config();
294
+ init_user_config();
295
+ ENDS = new Map;
296
+ DEFAULT = {
297
+ colors: { accent: "cyan", id: "yellow", path: "blue", label: "dim", value: "bold", ok: "green", warn: "yellow", problem: "red", note: "dim", plan: "magenta", passed: "green", failed: "red", running: "cyan", queued: "yellow", skipped: "dim" },
298
+ glyphs: { ok: "\u2713", warn: "\u25B2", problem: "\u2717", note: "\u203A", plan: "\u25C7", passed: "\u2713", failed: "\u2717", running: "\u25CF", queued: "\u25CB", skipped: "-", bar: "\u2501", rule: "\u2500", corner: "\u256D", open: "\u2022", leaf: "\xB7", guide: "\u2502" },
299
+ accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
300
+ bins: {},
301
+ gradient: ["#c084fc", "#67e8f9"]
302
+ };
303
+ BRIGHT = { accent: "cyanBright", id: "yellowBright", path: "blueBright", label: "white", value: "bold whiteBright", ok: "greenBright", warn: "yellowBright", problem: "redBright", note: "white", plan: "magentaBright", passed: "greenBright", failed: "redBright", running: "cyanBright", queued: "yellowBright", skipped: "white" };
304
+ MONO = { accent: "bold", id: "bold", path: "underline", label: "dim", value: "bold", ok: "bold", warn: "bold", problem: "bold", note: "dim", plan: "dim", passed: "bold", failed: "bold", running: "bold", queued: "dim", skipped: "dim" };
305
+ ASCII = { ok: "+", warn: "!", problem: "x", note: ">", plan: "?", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#", rule: "-", corner: "+", open: "*", leaf: "-", guide: "|" };
306
+ PRESETS = {
307
+ default: {},
308
+ "high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"], gradient: ["#d8b4fe", "#a5f3fc"] },
309
+ mono: { colors: MONO, accents: ["bold"], gradient: undefined },
310
+ ascii: { glyphs: ASCII }
311
+ };
312
+ 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"]);
313
+ HEX = /^#[0-9a-f]{6}$/i;
314
+ CONTROL = /\p{Cc}/u;
315
+ MAX_FILE_BYTES = 64 * 1024;
316
+ SPACES = /\s+/;
317
+ CUBE = [0, 95, 135, 175, 215, 255];
318
+ warned = new Set;
319
+ });
302
320
 
303
321
  // ../kit/src/style.ts
304
- var MARK_WORDS = { ok: "ok:", warn: "warning:", problem: "error:", note: "note:", plan: "would:" };
322
+ import process6 from "process";
305
323
  function takesControlCodes(stream, env = process6.env) {
306
324
  return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb" && outputMode(stream, env) === "terminal";
307
325
  }
@@ -320,17 +338,24 @@ function marked(mark, text, stream, detail, env = process6.env) {
320
338
  function warn(text, detail) {
321
339
  console.error(marked("warn", text, process6.stderr, detail));
322
340
  }
323
- var STATUS_WORDS = {
324
- passed: ["passed", "success", "succeeded", "ok"],
325
- failed: ["failed", "failure", "error", "errored"],
326
- running: ["running", "in_progress", "started", "holding"],
327
- queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
328
- skipped: ["skipped", "cancelled", "canceled", "manual"]
329
- };
330
- var STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
341
+ var MARK_WORDS, STATUS_WORDS, STATUS_OF;
342
+ var init_style = __esm(() => {
343
+ init_colors();
344
+ init_mode();
345
+ init_theme();
346
+ MARK_WORDS = { ok: "ok:", warn: "warning:", problem: "error:", note: "note:", plan: "would:" };
347
+ STATUS_WORDS = {
348
+ passed: ["passed", "success", "succeeded", "ok"],
349
+ failed: ["failed", "failure", "error", "errored"],
350
+ running: ["running", "in_progress", "started", "holding"],
351
+ queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
352
+ skipped: ["skipped", "cancelled", "canceled", "manual"]
353
+ };
354
+ STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
355
+ });
331
356
 
332
357
  // ../kit/src/format.ts
333
- var UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
358
+ import process7 from "process";
334
359
  function formatSeconds(total) {
335
360
  let rest = Math.max(0, Math.round(total));
336
361
  const amounts = UNITS.map(([unit, size]) => {
@@ -351,21 +376,44 @@ function upTo(text, separator) {
351
376
  const end = text.indexOf(separator);
352
377
  return end === -1 ? text : text.slice(0, end);
353
378
  }
354
- var ESCAPE = String.fromCharCode(27);
355
379
  function jsonText(value, replacer, { stream = process7.stdout, env = process7.env } = {}) {
356
380
  return JSON.stringify(value, replacer, outputMode(stream, env) === "agent" ? undefined : 2);
357
381
  }
358
382
  function printJson(value) {
359
383
  console.log(jsonText(value));
360
384
  }
385
+ var UNITS, ESCAPE;
386
+ var init_format = __esm(() => {
387
+ init_mode();
388
+ init_style();
389
+ UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
390
+ ESCAPE = String.fromCharCode(27);
391
+ });
361
392
 
362
393
  // ../kit/src/help.ts
363
394
  import process8 from "process";
364
- var OPTIONAL = /(?<!\x1B)\[[^\]]+\]/g;
365
- var USAGE_PREFIX = /^usage:\s*/i;
366
- var FULL_STOP = /\.$/;
367
395
  function usageLine(usage, colors = paint(process8.stdout)) {
368
- return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
396
+ const lines = usage.replace(USAGE_PREFIX, "").split(`
397
+ `);
398
+ const blank = lines.indexOf("");
399
+ const synopses = blank === -1 ? lines : lines.slice(0, blank);
400
+ const details = blank === -1 ? [] : lines.slice(blank + 1);
401
+ const colon = synopses[0].indexOf(": ");
402
+ const inline = synopses[0].slice(colon + 2);
403
+ const summary = colon === -1 ? details.shift() : `${inline.charAt(0).toUpperCase()}${inline.slice(1)}`;
404
+ if (colon !== -1)
405
+ synopses[0] = synopses[0].slice(0, colon);
406
+ const head = `${colors.bold("Usage:")} ${synopses.map((line) => line.replaceAll(OPTIONAL, (part) => colors.dim(part))).join(`
407
+ `)}`;
408
+ const lead = summary === undefined ? [] : ["", colors.bold(prose(summary, colors))];
409
+ const rest = details.length === 0 ? [] : ["", ...details.map((line) => prose(line, colors))];
410
+ return [head, ...lead, ...rest].join(`
411
+ `);
412
+ }
413
+ function prose(line, colors) {
414
+ if (colors.cyan("x") === "x")
415
+ return line;
416
+ return line.replaceAll(PROSE_MARKS, (match, code, flag) => code === undefined ? colors.cyan(flag ?? match) : colors.bold(code));
369
417
  }
370
418
  function helpText(usage, options, colors = paint(process8.stdout), { examples = [], exits = [] } = {}) {
371
419
  return [usageLine(usage, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exitRows(exits, colors), ...exampleRows(examples, colors)].join(`
@@ -400,7 +448,6 @@ function exampleRows(examples, colors = paint(process8.stdout)) {
400
448
  return [];
401
449
  return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? ` ${example}` : ` ${example[0]} ${colors.dim(`# ${example[1]}`)}`)];
402
450
  }
403
- var MAX_INLINE_CHOICES = 24;
404
451
  function optionRows(options, colors = paint(process8.stdout)) {
405
452
  const rows = Object.entries(options).map(([name, option]) => {
406
453
  const short = option.short === undefined ? " " : `${colors.cyan(`-${option.short}`)}, `;
@@ -415,6 +462,15 @@ function optionRows(options, colors = paint(process8.stdout)) {
415
462
  const width = Math.max(0, ...rows.map((row) => row.width));
416
463
  return rows.map((row) => row.description === "" ? ` ${row.flag}` : ` ${row.flag}${" ".repeat(width - row.width)} ${colors.dim(row.description)}`);
417
464
  }
465
+ var OPTIONAL, USAGE_PREFIX, FULL_STOP, PROSE_MARKS, MAX_INLINE_CHOICES = 24;
466
+ var init_help = __esm(() => {
467
+ init_mode();
468
+ init_style();
469
+ OPTIONAL = /(?<!\x1B)\[[^\]]+\]/g;
470
+ USAGE_PREFIX = /^usage:\s*/i;
471
+ FULL_STOP = /\.$/;
472
+ PROSE_MARKS = /`([^`\n]+)`|(?<![\w-])(--[a-z][\w-]*|-[a-z](?![\w-]))/gi;
473
+ });
418
474
 
419
475
  // ../kit/src/text.ts
420
476
  function distance(a, b) {
@@ -442,8 +498,9 @@ function closest(name, names) {
442
498
  const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
443
499
  return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
444
500
  }
501
+ var init_text = () => {};
502
+
445
503
  // ../kit/src/input.ts
446
- var WHOLE = /^\d+$/;
447
504
  function wholeNumber(value, name, fallback, min = 1) {
448
505
  if (value === undefined)
449
506
  return fallback;
@@ -452,40 +509,25 @@ function wholeNumber(value, name, fallback, min = 1) {
452
509
  badUsage(`${name.startsWith("<") ? name : `--${name}`} takes a whole number from ${min}, not ${value}`);
453
510
  return number;
454
511
  }
512
+ var WHOLE;
513
+ var init_input = __esm(() => {
514
+ init_args();
515
+ WHOLE = /^\d+$/;
516
+ });
455
517
 
456
518
  // ../kit/src/args.ts
457
- var DASHES = /^-+/;
519
+ import process9 from "process";
520
+ import { parseArgs } from "util";
458
521
  function jsonOption(holds) {
459
522
  return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
460
523
  }
461
- class Exit extends Error {
462
- code;
463
- hint;
464
- constructor(message, code, hint) {
465
- super(message);
466
- this.code = code;
467
- this.hint = hint;
468
- }
469
- }
470
524
  function fail(message, code = 2, hint) {
471
525
  throw new Exit(message, code, hint);
472
526
  }
473
-
474
- class UsageError extends Exit {
475
- constructor(message, hint) {
476
- super(message, 2, hint);
477
- }
478
- }
479
527
  function badUsage(message) {
480
528
  throw new UsageError(message);
481
529
  }
482
530
 
483
- class HelpShown extends Exit {
484
- constructor() {
485
- super("help shown", 0);
486
- }
487
- }
488
-
489
531
  class Completing {
490
532
  options;
491
533
  positionals;
@@ -496,11 +538,6 @@ class Completing {
496
538
  this.candidates = candidates;
497
539
  }
498
540
  }
499
- var completion = { active: false };
500
- var OUTPUT_OPTIONS = {
501
- color: { type: "string", choices: ["auto", "always", "never"], description: "auto (the default) colours on a terminal alone" },
502
- plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
503
- };
504
541
  function applyOutput(color, plain, env = process9.env) {
505
542
  const when = plain === true ? "never" : color ?? "auto";
506
543
  if (when === "auto")
@@ -654,7 +691,6 @@ function parseError(error) {
654
691
  const message = upTo(error instanceof Error ? error.message : String(error), ". ");
655
692
  return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
656
693
  }
657
- var UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
658
694
  function nearestOption(message, options, allowNegative) {
659
695
  const typed = UNKNOWN_OPTION.exec(message)?.[1];
660
696
  if (typed === undefined)
@@ -670,6 +706,61 @@ function nearestOption(message, options, allowNegative) {
670
706
  const meant = closest(word, known.map((flag) => flag.replace(DASHES, "")));
671
707
  return meant === undefined ? undefined : `did you mean ${known.find((flag) => flag.replace(DASHES, "") === meant)}?`;
672
708
  }
709
+ var DASHES, EXIT, Exit, UsageError, HelpShown, completion, OUTPUT_OPTIONS, UNKNOWN_OPTION;
710
+ var init_args = __esm(() => {
711
+ init_format();
712
+ init_help();
713
+ init_text();
714
+ init_help();
715
+ init_input();
716
+ DASHES = /^-+/;
717
+ EXIT = Symbol.for("@kaynooo/cli-kit/Exit");
718
+ Exit = class Exit extends Error {
719
+ code;
720
+ hint;
721
+ [EXIT] = true;
722
+ constructor(message, code, hint) {
723
+ super(message);
724
+ this.code = code;
725
+ this.hint = hint;
726
+ }
727
+ static [Symbol.hasInstance](value) {
728
+ if (this !== Exit)
729
+ return Function.prototype[Symbol.hasInstance].call(this, value);
730
+ return typeof value === "object" && value !== null && value[EXIT] === true;
731
+ }
732
+ };
733
+ UsageError = class UsageError extends Exit {
734
+ constructor(message, hint) {
735
+ super(message, 2, hint);
736
+ }
737
+ };
738
+ HelpShown = class HelpShown extends Exit {
739
+ constructor() {
740
+ super("help shown", 0);
741
+ }
742
+ };
743
+ completion = { active: false };
744
+ OUTPUT_OPTIONS = {
745
+ color: { type: "string", choices: ["auto", "always", "never"], description: "auto (the default) colours on a terminal alone" },
746
+ plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
747
+ };
748
+ UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
749
+ });
750
+
751
+ // ../kit/src/folders.ts
752
+ var SKIPPED_FOLDERS;
753
+ var init_folders = __esm(() => {
754
+ init_user_config();
755
+ SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
756
+ });
757
+
758
+ // src/cli.ts
759
+ import process16 from "process";
760
+
761
+ // ../kit/src/index.ts
762
+ init_args();
763
+
673
764
  // ../kit/src/argv.ts
674
765
  import { readFileSync as readFileSync2, realpathSync } from "fs";
675
766
  import { resolve as resolve3 } from "path";
@@ -694,15 +785,78 @@ function scriptArgs(argv = process10.argv.slice(2), cmdline = commandLine(), scr
694
785
  const after = at === -1 ? [] : cmdline.slice(at + 1);
695
786
  return after[0] === "--" && after.length === argv.length + 1 && argv.every((word, index) => word === after[index + 1]) ? after : argv;
696
787
  }
788
+ // ../kit/src/chart.ts
789
+ init_format();
790
+ init_mode();
791
+ init_style();
792
+ init_theme();
793
+ // ../kit/src/ci.ts
794
+ init_args();
795
+ init_format();
796
+
797
+ // ../kit/src/progress.ts
798
+ init_format();
799
+
800
+ // ../kit/src/process.ts
801
+ var GROUP_SIGNALS = new Set(["SIGINT", "SIGHUP"]);
802
+
697
803
  // ../kit/src/progress.ts
804
+ init_style();
805
+ init_theme();
698
806
  var ESC = String.fromCharCode(27);
699
807
  var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, "y");
700
808
  var RESET_STYLE = `${ESC}[0m`;
701
809
  var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
810
+
811
+ // ../kit/src/ci.ts
812
+ init_style();
813
+
814
+ // ../kit/src/tool.ts
815
+ init_format();
702
816
  // ../kit/src/cli.ts
817
+ init_args();
703
818
  import { readFileSync as readFileSync3, realpathSync as realpathSync2 } from "fs";
704
819
  import { dirname as dirname3, join as join5 } from "path";
705
- import process13 from "process";
820
+ import process14 from "process";
821
+
822
+ // ../kit/src/askpass.ts
823
+ import process11 from "process";
824
+ var SOCKET_VARIABLE = "KAYNOOO_ASKPASS_SOCKET";
825
+ async function askpassClient(argv) {
826
+ const socketPath = process11.env[SOCKET_VARIABLE];
827
+ if (socketPath === undefined)
828
+ return;
829
+ const request = { prompt: argv[0] ?? "", ...process11.env.SSH_ASKPASS_PROMPT === "none" ? { notice: true } : {} };
830
+ const { promise, resolve } = Promise.withResolvers();
831
+ let received = "";
832
+ try {
833
+ await Bun.connect({
834
+ unix: socketPath,
835
+ socket: {
836
+ open: (socket) => void socket.write(`${JSON.stringify(request)}
837
+ `),
838
+ data: (_, chunk) => {
839
+ received += chunk.toString();
840
+ },
841
+ close: () => resolve(received),
842
+ error: () => resolve("")
843
+ }
844
+ });
845
+ } catch {
846
+ return 1;
847
+ }
848
+ const reply = await promise;
849
+ if (reply === "")
850
+ return 1;
851
+ const { answer } = JSON.parse(reply);
852
+ if (request.notice === true)
853
+ return 0;
854
+ if (answer === undefined)
855
+ return 1;
856
+ process11.stdout.write(`${answer}
857
+ `);
858
+ return 0;
859
+ }
706
860
 
707
861
  // ../kit/src/completions.ts
708
862
  var COMPLETION_SHELLS = ["fish", "bash", "zsh"];
@@ -765,34 +919,42 @@ compdef __kaynooo_cli_complete ${bins.join(" ")}
765
919
  }
766
920
 
767
921
  // ../kit/src/notify.ts
768
- import process11 from "process";
922
+ init_format();
923
+ init_mode();
924
+ import process12 from "process";
769
925
  var NOTIFY_AFTER_MS = 1e4;
770
926
  var CANCELLED = 130;
771
927
  function base64(text) {
772
928
  return Buffer.from(text).toString("base64");
773
929
  }
774
- function notification(title, body, env = process11.env) {
775
- const id = `kit${process11.pid}`;
930
+ function notification(title, body, env = process12.env) {
931
+ const id = `kit${process12.pid}`;
776
932
  const codes = [`\x1B]99;i=${id}:d=0:o=unfocused:e=1;${base64(title)}\x1B\\`, `\x1B]99;i=${id}:p=body:e=1;${base64(body)}\x1B\\`];
777
933
  return codes.map((code) => env.TMUX === undefined || env.TMUX === "" ? code : `\x1BPtmux;${code.replaceAll("\x1B", "\x1B\x1B")}\x1B\\`).join("");
778
934
  }
779
- function notifyEnd(command, code, ms, { stream = process11.stderr, env = process11.env } = {}) {
935
+ function notifyEnd(command, code, ms, { stream = process12.stderr, env = process12.env } = {}) {
780
936
  if (ms < NOTIFY_AFTER_MS || code === CANCELLED || outputMode(stream, env) !== "terminal")
781
937
  return;
782
938
  stream.write(notification(command, code === 0 ? `done in ${formatDuration(ms)}` : `failed with exit ${code} after ${formatDuration(ms)}`, env));
783
939
  }
784
940
 
941
+ // ../kit/src/cli.ts
942
+ init_style();
943
+ init_text();
944
+
785
945
  // ../kit/src/usage.ts
786
946
  import { appendFileSync, mkdirSync } from "fs";
787
947
  import { homedir as homedir3 } from "os";
788
- import { dirname as dirname2, isAbsolute, join as join4 } from "path";
789
- import process12 from "process";
948
+ import { dirname as dirname2, join as join4 } from "path";
949
+ import process13 from "process";
790
950
 
791
951
  // ../kit/src/logs.ts
952
+ init_user_config();
792
953
  var DAY_MS = 24 * 60 * 60 * 1000;
793
954
  var CLI_FOLDER = "kaynooo-cli";
794
955
 
795
956
  // ../kit/src/usage.ts
957
+ init_user_config();
796
958
  var UNKNOWN_OPTION2 = /unknown option '(--[a-z][a-z0-9-]*)[=']/;
797
959
  var FLAG_NAME = /^(?:--[a-z][a-z0-9-]*|-[a-zA-Z])$/;
798
960
  var LONGEST_NAME = 40;
@@ -800,14 +962,13 @@ var usageError;
800
962
  function noteUsageError(message) {
801
963
  usageError = message;
802
964
  }
803
- function stateHome(env = process12.env) {
804
- const dir = env.XDG_STATE_HOME;
805
- return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
965
+ function stateHome(env = process13.env) {
966
+ return xdgFolder(env.XDG_STATE_HOME, join4(homedir3(), ".local", "state"));
806
967
  }
807
- function usagePath(env = process12.env) {
968
+ function usagePath(env = process13.env) {
808
969
  return join4(stateHome(env), CLI_FOLDER, "usage.jsonl");
809
970
  }
810
- function usageRecorded(env = process12.env) {
971
+ function usageRecorded(env = process13.env) {
811
972
  const off = env.KAYNOOO_CLI_NO_USAGE;
812
973
  return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
813
974
  }
@@ -816,12 +977,12 @@ function flagNames(argv) {
816
977
  const names = (end === -1 ? argv : argv.slice(0, end)).filter((word) => word.startsWith("-") && word !== "-").map((word) => word.includes("=") ? word.slice(0, word.indexOf("=")) : word);
817
978
  return [...new Set(names)].filter((name) => name.length <= LONGEST_NAME && FLAG_NAME.test(name));
818
979
  }
819
- function usageEntry(bin, command, argv, code, now = new Date) {
980
+ function usageEntry(bin, command, argv, code, { ms, now = new Date } = {}) {
820
981
  const unknown = code === 2 && usageError !== undefined ? UNKNOWN_OPTION2.exec(usageError)?.[1] : undefined;
821
982
  usageError = undefined;
822
- return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
983
+ return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown }, ...ms === undefined ? {} : { ms: Math.round(ms) } };
823
984
  }
824
- function recordUsage(entry, env = process12.env) {
985
+ function recordUsage(entry, env = process13.env) {
825
986
  if (!usageRecorded(env))
826
987
  return;
827
988
  try {
@@ -876,6 +1037,10 @@ function takeOutputFlags(argv) {
876
1037
  async function resolveSummary(summary) {
877
1038
  return typeof summary === "string" ? summary : summary();
878
1039
  }
1040
+ function lookup({ commands, aliases }, word) {
1041
+ const name = aliases !== undefined && Object.hasOwn(aliases, word) ? aliases[word] ?? word : word;
1042
+ return Object.hasOwn(commands, name) ? commands[name] : undefined;
1043
+ }
879
1044
  function scopeOf(commands, extra, aliases) {
880
1045
  return { commands: typeof commands === "function" ? {} : commands, lazy: [...typeof commands === "function" ? [commands] : [], ...extra === undefined ? [] : [extra]], aliases };
881
1046
  }
@@ -915,8 +1080,8 @@ async function help2({ path, header, summary: lazySummary, commands, defaultComm
915
1080
  `);
916
1081
  }
917
1082
  function printError(prefix, message, hint, cause) {
918
- const colors = paint(process13.stderr);
919
- const styled = takesControlCodes(process13.stderr);
1083
+ const colors = paint(process14.stderr);
1084
+ const styled = takesControlCodes(process14.stderr);
920
1085
  const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
921
1086
  const under = (label, text, tint) => text === undefined ? "" : `
922
1087
  ${styled ? tint(label) : `${label}:`} ${text}`;
@@ -959,23 +1124,23 @@ async function dispatch(level, typed, { version, redact }) {
959
1124
  }
960
1125
  }
961
1126
  if (name === undefined && level.path.length > 1) {
962
- console.error(await help2(await expand(level, [...level.path.slice(1), ...argv]), process13.stderr));
1127
+ console.error(await help2(await expand(level, [...level.path.slice(1), ...argv]), process14.stderr));
963
1128
  return 2;
964
1129
  }
965
1130
  if (name === undefined || name === "help" || name === "--help" || name === "-h") {
966
- console.log(await help2(await expand(level, [...level.path.slice(1), ...argv]), process13.stdout));
1131
+ console.log(await help2(await expand(level, [...level.path.slice(1), ...argv]), process14.stdout));
967
1132
  return 0;
968
1133
  }
969
1134
  if (level.path.length === 1 && (name === "--version" || name === "-v")) {
970
1135
  console.log(version);
971
1136
  return 0;
972
1137
  }
973
- let command = level.commands[level.aliases?.[name] ?? name];
1138
+ let command = lookup(level, name);
974
1139
  let rest = args;
975
1140
  let ran = name;
976
1141
  if (command === undefined && level.lazy.length > 0) {
977
1142
  level = await expand(level, [...level.path.slice(1), ...argv]);
978
- command = level.commands[level.aliases?.[name] ?? name];
1143
+ command = lookup(level, name);
979
1144
  }
980
1145
  if (command === undefined && level.defaultCommand !== undefined) {
981
1146
  command = level.commands[level.defaultCommand];
@@ -1055,18 +1220,19 @@ async function leafCandidates(run, words) {
1055
1220
  async function candidates(scope, defaultCommand, words, before = []) {
1056
1221
  const [word = "", ...rest] = words;
1057
1222
  const listing = rest.length === 0 && !word.startsWith("-");
1058
- let { commands, aliases } = scope;
1059
- let command = commands[aliases?.[word] ?? word];
1223
+ let { commands } = scope;
1224
+ let command = lookup(scope, word);
1060
1225
  if (listing || command === undefined) {
1061
- ({ commands, aliases } = await expand(scope, [...before, ...words]));
1062
- command = commands[aliases?.[word] ?? word];
1226
+ const expanded = await expand(scope, [...before, ...words]);
1227
+ commands = expanded.commands;
1228
+ command = lookup(expanded, word);
1063
1229
  }
1064
1230
  if (listing) {
1065
1231
  const own = await Promise.all(Object.entries(shown(commands)).map(async ([name, { summary }]) => `${name} ${await resolveSummary(summary)}`));
1066
1232
  const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
1067
1233
  const values = fallback !== undefined && "run" in fallback ? await leafCandidates(fallback.run, [word]) : [];
1068
1234
  const valueOf = (line) => line.slice(0, line.includes("\t") ? line.indexOf("\t") : undefined);
1069
- return [...own, ...values.filter((line) => line !== FILES && !(valueOf(line) in commands))];
1235
+ return [...own, ...values.filter((line) => line !== FILES && !Object.hasOwn(commands, valueOf(line)))];
1070
1236
  }
1071
1237
  if (command === undefined) {
1072
1238
  const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
@@ -1109,6 +1275,9 @@ function packageVersion(entry = Bun.main) {
1109
1275
  }
1110
1276
  async function runCli(cli, argv = scriptArgs()) {
1111
1277
  const version = cli.version ?? packageVersion();
1278
+ const answered = await askpassClient(argv);
1279
+ if (answered !== undefined)
1280
+ return answered;
1112
1281
  if (argv[0] === COMPLETE)
1113
1282
  return printCandidates(candidates(scopeOf(cli.commands, cli.extraCommands, cli.aliases), cli.defaultCommand, argv.slice(1)));
1114
1283
  if (argv[0] === COMPLETIONS || argv[0]?.startsWith(`${COMPLETIONS}=`) === true)
@@ -1119,7 +1288,7 @@ async function runCli(cli, argv = scriptArgs()) {
1119
1288
  notifyEnd(command === undefined ? cli.name : `${cli.name} ${command}`, code, performance.now() - started);
1120
1289
  if (cli.usage !== false) {
1121
1290
  try {
1122
- recordUsage(usageEntry(cli.name, command, argv, code));
1291
+ recordUsage(usageEntry(cli.name, command, argv, code, { ms: performance.now() - started }));
1123
1292
  } catch {}
1124
1293
  }
1125
1294
  return code;
@@ -1128,8 +1297,7 @@ function commandPath(scope, argv) {
1128
1297
  const path = [];
1129
1298
  let level = scope;
1130
1299
  for (const word of argv.filter((each) => !each.startsWith("-"))) {
1131
- const name = level.aliases !== undefined && Object.hasOwn(level.aliases, word) ? level.aliases[word] ?? word : word;
1132
- const command = Object.hasOwn(level.commands, name) ? level.commands[name] : undefined;
1300
+ const command = lookup(level, word);
1133
1301
  if (command === undefined)
1134
1302
  break;
1135
1303
  path.push(word);
@@ -1139,465 +1307,59 @@ function commandPath(scope, argv) {
1139
1307
  }
1140
1308
  return path.length === 0 ? undefined : path.join(" ");
1141
1309
  }
1142
- // ../kit/src/compose.ts
1143
- async function captureOutput(argv, { cwd, env } = {}) {
1144
- const run = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, env: { ...process.env, ...env }, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
1145
- const [stdout, stderr, code] = await Promise.all([new Response(run.stdout).text(), new Response(run.stderr).text(), run.exited]);
1146
- return { code, stdout, stderr };
1147
- }
1148
- async function compose(args, { flags = [], ...options } = {}) {
1149
- return captureOutput(["docker", "compose", ...flags, ...args], options);
1150
- }
1151
- function composeError({ code, stderr }) {
1152
- const last = stderr.trim().split(`
1153
- `).at(-1) ?? "";
1154
- return last === "" ? `exit ${code}` : last;
1155
- }
1156
- // ../kit/src/folders.ts
1157
- var SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
1158
- // ../kit/src/limit.ts
1159
- function limitOptions(fallback) {
1160
- return {
1161
- limit: { type: "string", short: "n", description: `show at most this many rows, the rest counted (${fallback})` },
1162
- full: { type: "boolean", description: "show every row" }
1163
- };
1164
- }
1165
- function limitOf(values, fallback) {
1166
- if (values.full === true && values.limit !== undefined)
1167
- badUsage("--limit and --full exclude each other");
1168
- if (values.full === true || values.json === true && values.limit === undefined)
1169
- return Number.POSITIVE_INFINITY;
1170
- return wholeNumber(values.limit, "limit", fallback);
1171
- }
1172
- function moreFooter(more) {
1173
- return `${more} more, rerun with --full`;
1174
- }
1175
- function capped(rows, limit) {
1176
- const more = rows.length - limit;
1177
- return more > 0 ? { shown: rows.slice(0, limit), footer: moreFooter(more) } : { shown: [...rows], footer: undefined };
1178
- }
1179
- // ../kit/src/secrets.ts
1180
- var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
1181
- // ../kit/src/sessions.ts
1182
- var {Glob } = globalThis.Bun;
1183
- var SESSION_FILES = new Glob("*.json");
1184
- var ACCOUNT_DIRS = new Glob("*/sessions");
1185
- // src/commands/audit.ts
1186
- import { homedir as homedir4 } from "os";
1187
- import { resolve as resolve5 } from "path";
1188
- import process16 from "process";
1189
1310
 
1190
- // src/audit/compose.ts
1191
- import { join as join6 } from "path";
1192
- var dockerCompose = async (root, files) => {
1193
- const result = await compose(["config", "--no-interpolate", "--format", "json"], { flags: ["--project-directory", root, ...files.flatMap((file) => ["-f", join6(root, file)])], env: { COMPOSE_FILE: "" } });
1194
- if (result.code !== 0)
1195
- throw new Error(composeError(result));
1196
- return JSON.parse(result.stdout);
1197
- };
1311
+ // ../kit/src/index.ts
1312
+ init_config();
1198
1313
 
1199
- // src/audit/render.ts
1200
- import { basename } from "path";
1201
- import process15 from "process";
1202
- var line = (finding) => ` ${marked(finding.level === "error" ? "problem" : "warn", `[${finding.check}] ${finding.message}`, process15.stdout)}`;
1203
- function errorsOf(result) {
1204
- return result.findings.filter((finding) => finding.level === "error");
1205
- }
1206
- function section2(heading, findings, limit) {
1207
- const { shown, footer } = capped(findings, limit);
1208
- return findings.length === 0 ? [] : [heading, ...shown.map(line), ...footer === undefined ? [] : [` ${footer}`], ""];
1209
- }
1210
- function render(result, limit = Number.POSITIVE_INFINITY) {
1211
- const errors = errorsOf(result);
1212
- const warnings = result.findings.filter((finding) => finding.level === "warn");
1213
- if (result.findings.length === 0)
1214
- return marked("ok", `${basename(result.root)}: compose ${result.composeFiles.join(", ")} and release.config.ts agree.`, process15.stdout);
1215
- return [
1216
- ...section2("Errors", errors, limit),
1217
- ...section2("Warnings", warnings, limit),
1218
- `${errors.length} error(s), ${warnings.length} warning(s)`
1219
- ].join(`
1220
- `);
1221
- }
1314
+ // ../kit/src/excerpt.ts
1315
+ init_text();
1222
1316
 
1223
- // src/audit/run.ts
1224
- import { existsSync as existsSync5 } from "fs";
1225
- import { join as join9 } from "path";
1317
+ // ../kit/src/index.ts
1318
+ init_folders();
1319
+ init_format();
1226
1320
 
1227
- // src/audit/checks.ts
1228
- import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
1229
- import { isAbsolute as isAbsolute2, join as join7, relative, resolve as resolve4 } from "path";
1230
- var ENV_REF = /(?<!\$)\$(?:\{([A-Z_]\w*)(\s*:?[-?+][^}]*)?\}|([A-Z_]\w*))/gi;
1231
- var REQUIRED_OPERATOR = /^\s*:?\?/;
1232
- var COMMENT_START = /(?:^|\s)#.*$/;
1233
- var QUOTES = /['"]/g;
1234
- var YAML_FILE = /\.ya?ml$/;
1235
- var LEADING_DOT_SLASH = /^\.\//;
1236
- var SERVICES_KEY = /^services:/m;
1237
- var EXEC_SERVICE = /\{compose\}(?:\s+--\S+)*\s+(?:exec|run)\s+(?:-\S+\s+)*([\w-]+)/;
1238
- var services = (model) => Object.entries(model?.services ?? {});
1239
- function before(text, separator) {
1240
- const at = text.indexOf(separator);
1241
- return at < 0 ? text : text.slice(0, at);
1242
- }
1243
- var stripDotSlash = (file) => file.replace(LEADING_DOT_SLASH, "");
1244
- function composeLayout(root, config) {
1245
- const composeFiles = (config.deploySyncFiles ?? []).map(stripDotSlash).filter((file) => YAML_FILE.test(file) && existsSync3(join7(root, file)));
1246
- const [base] = composeFiles.toSorted((a, b) => a.length - b.length);
1247
- return { composeFiles, base, overlays: composeFiles.filter((file) => file !== base) };
1248
- }
1249
- function syncFindings(root, config) {
1250
- return (config.deploySyncFiles ?? []).filter((file) => !existsSync3(join7(root, stripDotSlash(file)))).map((file) => ({ level: "error", check: "sync", message: `deploySyncFiles entry does not exist: ${file}` }));
1251
- }
1252
- function buildFindings(root, releases, env, home) {
1253
- const findings = [];
1254
- const missing = (release, key) => {
1255
- const path = release[key];
1256
- if (path !== undefined && path !== "" && !existsSync3(join7(root, path)))
1257
- findings.push({ level: "error", check: "build", message: `${release.slug}: ${key} does not exist: ${path}` });
1258
- };
1259
- for (const release of releases) {
1260
- missing(release, "sourceDir");
1261
- missing(release, "buildContext");
1262
- missing(release, "dockerfile");
1263
- for (const secret of release.buildSecrets ?? []) {
1264
- if (secret.src !== undefined && secret.src !== "") {
1265
- const path = secret.src.startsWith("~") ? join7(home, secret.src.slice(1)) : resolve4(root, secret.src);
1266
- if (!existsSync3(path))
1267
- findings.push({ level: "error", check: "build", message: `${release.slug}: buildSecret "${secret.id}" src does not exist: ${secret.src}` });
1268
- }
1269
- if (secret.env !== undefined && secret.env !== "" && (env[secret.env] ?? "") === "")
1270
- findings.push({ level: "warn", check: "build", message: `${release.slug}: buildSecret "${secret.id}" reads $${secret.env}, unset in this shell` });
1271
- }
1272
- }
1273
- return findings;
1274
- }
1275
- function withoutComment(line) {
1276
- const comment = COMMENT_START.exec(line);
1277
- if (comment === null || (line.slice(0, comment.index).match(QUOTES)?.length ?? 0) % 2 === 1)
1278
- return line;
1279
- return line.slice(0, comment.index);
1280
- }
1281
- function envRefs(root, composeFiles) {
1282
- return composeFiles.flatMap((file) => {
1283
- const text = readFileSync4(join7(root, file), "utf8").split(`
1284
- `).map(withoutComment).join(`
1285
- `);
1286
- return [...text.matchAll(ENV_REF)].map((match) => ({ name: match[1] ?? match[3], defaulted: match[2] !== undefined && !REQUIRED_OPERATOR.test(match[2]), file }));
1287
- });
1288
- }
1289
- function envFindings(refs, required) {
1290
- const findings = [];
1291
- const level = required.length > 0 ? "error" : "warn";
1292
- for (const name of new Set(refs.filter((ref) => !ref.defaulted).map((ref) => ref.name))) {
1293
- if (!name.endsWith("_VERSION") && !required.includes(name))
1294
- findings.push({ level, check: "env", message: `\${${name}} has no default in ${refs.find((ref) => ref.name === name)?.file} and is not in requiredServerEnv` });
1295
- }
1296
- for (const name of required) {
1297
- if (!refs.some((ref) => ref.name === name))
1298
- findings.push({ level: "warn", check: "env", message: `requiredServerEnv lists ${name}, which no compose file references` });
1299
- }
1300
- return findings;
1301
- }
1302
- function versionFindings(refs, releases) {
1303
- const findings = [];
1304
- const inCompose = new Set(refs.filter((ref) => ref.name.endsWith("_VERSION")).map((ref) => ref.name));
1305
- const inConfig = new Set(releases.map((release) => release.versionEnv).filter((name) => typeof name === "string" && name !== ""));
1306
- for (const name of inConfig) {
1307
- if (!inCompose.has(name))
1308
- findings.push({ level: "error", check: "version", message: `versionEnv ${name} is never interpolated by a compose file` });
1309
- }
1310
- for (const name of inCompose) {
1311
- if (!inConfig.has(name))
1312
- findings.push({ level: "error", check: "version", message: `compose interpolates \${${name}}, which no release declares as versionEnv` });
1313
- }
1314
- return findings;
1315
- }
1316
- function imageFindings(config, releases, model) {
1317
- const registry = config.registry ?? "";
1318
- if (registry === "")
1319
- return [];
1320
- const declared = new Set(releases.filter((release) => release.image !== undefined && release.image !== "").map((release) => `${registry}/${release.image}`));
1321
- const findings = [];
1322
- for (const [name, service] of services(model)) {
1323
- const repo = service.image === undefined ? undefined : before(service.image, ":");
1324
- if (repo !== undefined && repo.startsWith(registry) && !declared.has(repo))
1325
- findings.push({ level: "warn", check: "image", message: `service "${name}" pulls ${repo}, which no release in this config builds` });
1326
- }
1327
- return findings;
1328
- }
1329
- function restartFindings(config, releases, model, base) {
1330
- if (model === undefined)
1331
- return [];
1332
- const known = new Set(Object.keys(model.services ?? {}));
1333
- const findings = [];
1334
- for (const release of releases) {
1335
- for (const service of release.restartServices ?? []) {
1336
- if (!known.has(service))
1337
- findings.push({ level: "error", check: "restart", message: `${release.slug}: restartServices names "${service}", absent from ${base}` });
1338
- }
1339
- }
1340
- for (const server of config.servers ?? []) {
1341
- for (const [slug, override] of Object.entries(server.releaseOverrides ?? {})) {
1342
- for (const service of override.restartServices ?? []) {
1343
- if (!known.has(service))
1344
- findings.push({ level: "error", check: "restart", message: `server ${server.name}: releaseOverrides.${slug} names service "${service}", absent from ${base}` });
1345
- }
1346
- }
1347
- }
1348
- return findings;
1349
- }
1350
- function postDeployFindings(releases, model, base) {
1351
- if (model === undefined)
1352
- return [];
1353
- const known = new Set(Object.keys(model.services ?? {}));
1354
- const findings = [];
1355
- for (const release of releases) {
1356
- for (const command of release.postDeployCommands ?? []) {
1357
- const target = EXEC_SERVICE.exec(command)?.[1];
1358
- if (target !== undefined && !known.has(target))
1359
- findings.push({ level: "warn", check: "post-deploy", message: `${release.slug}: post-deploy command targets service "${target}", absent from ${base}` });
1360
- }
1361
- }
1362
- return findings;
1363
- }
1364
- var gatedServices = (releases) => new Set(releases.flatMap((release) => release.restartServices ?? []));
1365
- function healthFindings(gated, model) {
1366
- return [...gated].filter((name) => {
1367
- const service = model?.services?.[name];
1368
- return service !== undefined && (service.healthcheck === undefined || service.healthcheck === null);
1369
- }).map((name) => ({ level: "warn", check: "health", message: `service "${name}" is restarted by a release but declares no healthcheck, so --wait will not gate it` }));
1370
- }
1371
- function routingFindings(config, gated, model, base, overlays) {
1372
- if (overlays.length === 0)
1373
- return [];
1374
- const findings = [];
1375
- for (const name of gated) {
1376
- const service = model?.services?.[name];
1377
- if (service === undefined)
1378
- continue;
1379
- if (service.ports !== undefined && service.ports.length > 0)
1380
- findings.push({ level: "error", check: "routing", message: `service "${name}" publishes ports in ${base}; publishing belongs in an overlay` });
1381
- if (Object.keys(service.labels ?? {}).some((key) => key.startsWith("traefik.")))
1382
- findings.push({ level: "error", check: "routing", message: `service "${name}" carries traefik labels in ${base}; routing belongs in an overlay` });
1383
- }
1384
- const composeArgs = config.composeArgs ?? [];
1385
- if (composeArgs.length > 0)
1386
- findings.push({ level: "error", check: "routing", message: `composeArgs is set (${composeArgs.join(" ")}) while ${overlays.length} overlay(s) exist: -f overrides each server's COMPOSE_FILE and drops them` });
1387
- for (const server of config.servers ?? []) {
1388
- if (server.composeArgs !== undefined && server.composeArgs.length > 0)
1389
- findings.push({ level: "warn", check: "routing", message: `server ${server.name} sets composeArgs; prefer its own COMPOSE_FILE` });
1390
- }
1391
- return findings;
1392
- }
1393
- var SOURCE_END = /:(?![-+?=])/;
1394
- var DEFAULTED_VARIABLE = /\$\{[A-Z_]\w*:?-([^}$]*)\}/gi;
1395
- function relativeSource(root, written) {
1396
- const source = written?.replaceAll(DEFAULTED_VARIABLE, "$1");
1397
- if (source === undefined || source.includes("$"))
1398
- return;
1399
- if (source.startsWith("."))
1400
- return source;
1401
- const inRoot = relative(resolve4(root), source);
1402
- return isAbsolute2(source) && inRoot !== "" && !inRoot.startsWith("..") ? `./${inRoot}` : undefined;
1403
- }
1404
- function layoutFindings(root, base, model) {
1405
- if (base === undefined)
1406
- return [];
1407
- const header = readFileSync4(join7(root, base), "utf8").split(SERVICES_KEY)[0] ?? "";
1408
- const findings = [];
1409
- for (const [name, service] of services(model)) {
1410
- for (const volume of service.volumes ?? []) {
1411
- const source = relativeSource(root, typeof volume === "string" ? volume.split(SOURCE_END)[0] : volume.source);
1412
- if (source !== undefined && !header.includes(stripDotSlash(source)))
1413
- findings.push({ level: "warn", check: "layout", message: `service "${name}" bind-mounts ${source}, absent from the header's expected server layout` });
1414
- }
1415
- }
1416
- return findings;
1417
- }
1418
- function gitignoreFindings(root) {
1419
- const path = join7(root, ".gitignore");
1420
- const text = existsSync3(path) ? readFileSync4(path, "utf8") : "";
1421
- return [".release-logs", ".release-worktrees"].filter((entry) => !text.includes(entry)).map((entry) => ({ level: "warn", check: "gitignore", message: `${entry}/ is not in .gitignore` }));
1422
- }
1321
+ // ../kit/src/git.ts
1322
+ init_args();
1323
+ // ../kit/src/limit.ts
1324
+ init_args();
1423
1325
 
1424
- // src/audit/nuxt.ts
1425
- import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
1426
- import { basename as basename2, join as join8 } from "path";
1427
- var CAMEL_BOUNDARY = /([a-z0-9])([A-Z])/g;
1428
- var KEY = /([A-Z_]\w*)\s*(?:\?\s*)?:/gi;
1429
- var OPENS_BRACE = /^\s*\{/;
1430
- var envVarFor = (key) => key.replace(CAMEL_BOUNDARY, "$1_$2").toUpperCase();
1431
- function braceBody(text, from) {
1432
- const open = text.indexOf("{", from);
1433
- if (open < 0)
1434
- return;
1435
- let depth = 0;
1436
- for (let i = open;i < text.length; i++) {
1437
- if (text[i] === "{")
1438
- depth++;
1439
- else if (text[i] === "}" && --depth === 0)
1440
- return { body: text.slice(open + 1, i), end: i };
1441
- }
1442
- return;
1443
- }
1444
- function leafPaths(body, prefix = []) {
1445
- const paths = [];
1446
- const key = new RegExp(KEY);
1447
- for (let match = key.exec(body);match !== null; match = key.exec(body)) {
1448
- const name = match[1];
1449
- const after = match.index + match[0].length;
1450
- if (OPENS_BRACE.test(body.slice(after))) {
1451
- const inner = braceBody(body, after);
1452
- if (inner === undefined)
1453
- continue;
1454
- paths.push(...leafPaths(inner.body, [...prefix, name]));
1455
- key.lastIndex = inner.end + 1;
1456
- } else {
1457
- paths.push([...prefix, name]);
1458
- }
1459
- }
1460
- return paths;
1461
- }
1462
- function schemaEnvNames(schema, iface, prefix) {
1463
- const at = schema.indexOf(`interface ${iface}`);
1464
- const body = at < 0 ? undefined : braceBody(schema, at);
1465
- return body === undefined ? [] : leafPaths(body.body).map((path) => prefix + path.map(envVarFor).join("_"));
1466
- }
1467
- function nuxtFindings(root, releases, model) {
1468
- const findings = [];
1469
- const dirs = [...new Set(releases.map((release) => release.buildContext).filter((context) => context !== undefined && context !== ""))].map((dir) => join8(root, dir)).filter((dir) => existsSync4(join8(dir, "nuxt.config.ts")));
1470
- for (const dir of dirs) {
1471
- const schemaPath = [join8(dir, ".nuxt/types/schema.d.ts"), join8(dir, ".nuxt/types/runtime-config.d.ts")].find((path) => existsSync4(path));
1472
- let allowed;
1473
- let level = "error";
1474
- let source;
1475
- if (schemaPath !== undefined) {
1476
- const schema = readFileSync5(schemaPath, "utf8");
1477
- allowed = new Set([
1478
- ...schemaEnvNames(schema, "SharedRuntimeConfig", "NUXT_"),
1479
- ...schemaEnvNames(schema, "SharedPublicRuntimeConfig", "NUXT_PUBLIC_")
1480
- ]);
1481
- source = `${basename2(dir)}/${schemaPath.slice(dir.length + 1)}`;
1482
- } else {
1483
- const config = readFileSync5(join8(dir, "nuxt.config.ts"), "utf8");
1484
- const at = config.indexOf("runtimeConfig:");
1485
- const block = at < 0 ? undefined : braceBody(config, at);
1486
- if (block === undefined)
1487
- continue;
1488
- allowed = new Set(leafPaths(block.body).map((path) => path[0] === "public" ? `NUXT_PUBLIC_${path.slice(1).map(envVarFor).join("_")}` : `NUXT_${path.map(envVarFor).join("_")}`));
1489
- level = "warn";
1490
- source = `${basename2(dir)}/nuxt.config.ts (run \`nuxt prepare\` in ${basename2(dir)} for the resolved config, modules included)`;
1491
- }
1492
- for (const [name, service] of Object.entries(model?.services ?? {})) {
1493
- for (const key of Object.keys(service.environment ?? {})) {
1494
- if (key.startsWith("NUXT_") && !allowed.has(key))
1495
- findings.push({ level, check: "nuxt", message: `service "${name}" sets ${key}, which matches no runtimeConfig key in ${source}` });
1496
- }
1497
- }
1498
- }
1499
- return findings;
1500
- }
1326
+ // ../kit/src/index.ts
1327
+ init_mode();
1501
1328
 
1502
- // src/audit/run.ts
1503
- var CONFIG_FILE = "release.config.ts";
1504
- var DEFINE_CONFIG_IMPORT = /import\s*\{[^}]*\bdefineConfig\b[^}]*\}\s*from\s*['"]([^'"]+)['"]/;
1505
- function installed(specifier, root) {
1329
+ // ../kit/src/port.ts
1330
+ function isListening(port) {
1506
1331
  try {
1507
- Bun.resolveSync(specifier, root);
1508
- return true;
1509
- } catch {
1332
+ Bun.listen({ hostname: "0.0.0.0", port, socket: { data: () => {
1333
+ return;
1334
+ } } }).stop(true);
1510
1335
  return false;
1336
+ } catch (error) {
1337
+ return error.code === "EADDRINUSE";
1511
1338
  }
1512
1339
  }
1513
- async function loadConfig(root) {
1514
- const specifier = DEFINE_CONFIG_IMPORT.exec(await Bun.file(join9(root, CONFIG_FILE)).text())?.[1];
1515
- if (specifier !== undefined && !installed(specifier, root)) {
1516
- Bun.plugin({
1517
- name: "release-stand-in",
1518
- setup(build) {
1519
- build.module(specifier, () => ({ exports: { defineConfig: (config) => config }, loader: "object" }));
1520
- }
1521
- });
1522
- }
1523
- const config = (await import(join9(root, CONFIG_FILE))).default;
1524
- if (config === undefined)
1525
- fail(`${CONFIG_FILE} has no default export`);
1526
- return config;
1527
- }
1528
- async function composeModels(options, base, overlays) {
1529
- const findings = [];
1530
- const load = async (files) => {
1531
- try {
1532
- return await options.loadCompose(options.root, files);
1533
- } catch (error) {
1534
- findings.push({ level: "error", check: "compose", message: `docker compose config failed for ${files.join(" + ")}: ${error instanceof Error ? error.message : String(error)}` });
1535
- return;
1536
- }
1537
- };
1538
- if (base === undefined) {
1539
- findings.push({ level: "warn", check: "compose", message: "no compose file among deploySyncFiles, so every check that reads the compose model was skipped" });
1540
- return { model: undefined, findings };
1541
- }
1542
- const model = await load([base]);
1543
- for (const overlay of overlays)
1544
- await load([base, overlay]);
1545
- return { model, findings };
1546
- }
1547
- async function audit(config, options) {
1548
- const { root } = options;
1549
- const releases = config.releases ?? [];
1550
- const required = config.requiredServerEnv ?? [];
1551
- const { composeFiles, base, overlays } = composeLayout(root, config);
1552
- const compose = await composeModels(options, base, overlays);
1553
- const refs = envRefs(root, composeFiles);
1554
- const gated = gatedServices(releases);
1555
- const findings = [
1556
- ...syncFindings(root, config),
1557
- ...buildFindings(root, releases, options.env, options.home),
1558
- ...compose.findings,
1559
- ...envFindings(refs, required),
1560
- ...versionFindings(refs, releases),
1561
- ...imageFindings(config, releases, compose.model),
1562
- ...restartFindings(config, releases, compose.model, base),
1563
- ...postDeployFindings(releases, compose.model, base),
1564
- ...healthFindings(gated, compose.model),
1565
- ...routingFindings(config, gated, compose.model, base, overlays),
1566
- ...layoutFindings(root, base, compose.model),
1567
- ...nuxtFindings(root, releases, compose.model),
1568
- ...gitignoreFindings(root)
1569
- ];
1570
- return { root, composeFiles, findings };
1571
- }
1572
- var hasConfig = (root) => existsSync5(join9(root, CONFIG_FILE));
1573
-
1574
- // src/commands/audit.ts
1575
- var usage2 = `stack audit [dir]
1340
+ // ../kit/src/report.ts
1341
+ init_style();
1342
+ init_text();
1343
+ // ../kit/src/secrets.ts
1344
+ var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
1345
+ var NOT_PASSWORDS = new Set(["compass", "encompass", "bypass", "overpass", "underpass", "surpass", "trespass"]);
1346
+ // ../kit/src/sessions.ts
1347
+ var {Glob } = globalThis.Bun;
1348
+ var SESSION_FILES = new Glob("*.json");
1349
+ var ACCOUNT_DIRS = new Glob("*/sessions");
1576
1350
 
1577
- Cross-checks ${CONFIG_FILE} in dir (the current directory) against the compose files it syncs: sync files and build inputs exist, env variables are required or defaulted, versionEnv matches the compose interpolation, restart and post-deploy services exist, healthchecks, routing in overlays, bind mounts documented in the header, Nuxt runtimeConfig keys and .gitignore.
1578
- Lists at most 25 errors and 25 warnings, the count of the rest after them (--limit <n>, --full for all); --json is never cut.
1579
- Needs docker for \`docker compose config\`.
1580
-
1581
- Exits 0 when it finds no error, 1 when it finds one, 2 when there is no ${CONFIG_FILE}.`;
1582
- var AUDIT_LIMIT = 25;
1583
- var options = {
1584
- ...limitOptions(AUDIT_LIMIT),
1585
- json: jsonOption("{ root, composeFiles, findings }")
1586
- };
1587
- async function audit2(args, overrides = {}) {
1588
- const parsed = parse(args, usage2, options);
1589
- const root = resolve5(parsed.positionals[0] ?? ".");
1590
- if (!hasConfig(root)) {
1591
- fail(`no ${CONFIG_FILE} in ${root}`);
1592
- }
1593
- const result = await audit(await loadConfig(root), { root, loadCompose: dockerCompose, env: process16.env, home: homedir4(), ...overrides });
1594
- if (parsed.values.json === true)
1595
- printJson(result);
1596
- else
1597
- console.log(render(result, limitOf(parsed.values, AUDIT_LIMIT)));
1598
- return errorsOf(result).length > 0 ? 1 : 0;
1599
- }
1351
+ // ../kit/src/index.ts
1352
+ init_style();
1353
+ init_text();
1354
+ init_theme();
1355
+ init_user_config();
1600
1356
 
1357
+ // ../kit/src/watch.ts
1358
+ init_args();
1359
+ init_input();
1360
+ init_style();
1361
+ // ../kit/src/workspace-root.ts
1362
+ init_user_config();
1601
1363
  // src/port.ts
1602
1364
  var MIN_PORT = 1024;
1603
1365
  var MAX_PORT = 65535;
@@ -1610,36 +1372,28 @@ function stringToPort(name, min = MIN_PORT, max = DEFAULT_MAX_PORT) {
1610
1372
  }
1611
1373
  return min + hash % (max - min + 1);
1612
1374
  }
1613
- function isListening(port) {
1614
- try {
1615
- Bun.listen({ hostname: "0.0.0.0", port, socket: { data: () => {
1616
- return;
1617
- } } }).stop(true);
1618
- return false;
1619
- } catch (error) {
1620
- return error.code === "EADDRINUSE";
1621
- }
1622
- }
1623
1375
 
1624
1376
  // src/commands/port.ts
1625
- var usage3 = `stack port <name>
1377
+ var usage2 = `stack port <name>
1626
1378
 
1627
1379
  Prints the port a name always hashes to (32-bit FNV-1a, ${MIN_PORT}-${DEFAULT_MAX_PORT} by default, below Linux's ephemeral range), so a service keeps the same port on every machine.
1628
1380
  Says on stderr when something already listens on it; the exit code stays 0.
1629
1381
 
1630
1382
  Exits 0 when it printed the port, 2 on a usage error.`;
1631
- var options2 = {
1383
+ var options = {
1632
1384
  min: { type: "string", description: `lowest port (${MIN_PORT}, nothing lower is allowed)` },
1633
- max: { type: "string", description: `highest port (${DEFAULT_MAX_PORT}, up to ${MAX_PORT})` },
1385
+ max: { type: "string", description: `highest port (${DEFAULT_MAX_PORT}, or ${MAX_PORT} when --min reaches it, up to ${MAX_PORT})` },
1634
1386
  json: jsonOption("{name, port, listening}")
1635
1387
  };
1636
- async function port(args) {
1637
- const parsed = parse(args, usage3, options2);
1388
+ async function port2(args) {
1389
+ const parsed = parse(args, usage2, options);
1638
1390
  const [name] = parsed.positionals;
1639
1391
  if (name === undefined)
1640
1392
  fail("a name is needed");
1641
1393
  const min = wholeNumber(parsed.values.min, "min", MIN_PORT, MIN_PORT);
1642
- const max = wholeNumber(parsed.values.max, "max", Math.max(DEFAULT_MAX_PORT, min), min);
1394
+ if (min > MAX_PORT)
1395
+ fail(`--min goes up to ${MAX_PORT}, not ${min}`);
1396
+ const max = wholeNumber(parsed.values.max, "max", min < DEFAULT_MAX_PORT ? DEFAULT_MAX_PORT : MAX_PORT, min);
1643
1397
  if (max > MAX_PORT)
1644
1398
  fail(`--max goes up to ${MAX_PORT}, not ${max}`);
1645
1399
  const number = stringToPort(name, min, max);
@@ -1654,13 +1408,12 @@ async function port(args) {
1654
1408
  }
1655
1409
 
1656
1410
  // src/cli.ts
1657
- process17.exitCode = await runCli({
1411
+ process16.exitCode = await runCli({
1658
1412
  name: "stack",
1659
- about: "a stable port per service name, and a compose release audit",
1660
- replaces: "picking a free host port by hand, and reading compose files against release.config.ts",
1661
- examples: ["stack port api", ["stack audit", "this folder's release setup"]],
1413
+ about: "a stable port per service name",
1414
+ replaces: "picking a free host port by hand",
1415
+ examples: ["stack port api", ["stack port api --json", "the port and whether something listens on it"]],
1662
1416
  commands: {
1663
- port: { run: port, summary: "the port a name always hashes to, with a warning when something already listens on it" },
1664
- audit: { run: audit2, summary: "cross-check release.config.ts against its compose files" }
1417
+ port: { run: port2, summary: "the port a name always hashes to, with a warning when something already listens on it" }
1665
1418
  }
1666
1419
  });