@kaynooo/cli-forgejo 0.30.2 → 0.30.7
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.
- package/README.md +6 -5
- package/dist/cli.js +1415 -485
- package/package.json +6 -6
package/dist/cli.js
CHANGED
|
@@ -1,21 +1,19 @@
|
|
|
1
1
|
#!/usr/bin/env -S bun --no-env-file --config=/dev/null
|
|
2
2
|
// @bun
|
|
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
|
+
};
|
|
3
14
|
|
|
4
|
-
//
|
|
5
|
-
|
|
6
|
-
// ../kit/src/args.ts
|
|
7
|
-
import process10 from "process";
|
|
8
|
-
import { parseArgs } from "util";
|
|
9
|
-
|
|
10
|
-
// ../kit/src/format.ts
|
|
11
|
-
import process7 from "process";
|
|
12
|
-
|
|
13
|
-
// ../../node_modules/.bun/@kaynooo+utils@3.0.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-rxztfxgv.js
|
|
14
|
-
var ct = /[aeiou]y$/;
|
|
15
|
-
var N = new Map;
|
|
16
|
-
var Ot = /(?:leaf|loaf|thief|wolf|half|calf|elf|sheaf|scarf|dwarf|hoof|wharf)$/;
|
|
17
|
-
var Gt = /(?:knife|life|wife)$/;
|
|
18
|
-
function K(t, e, { plural: r, zero: n = "singular" } = {}) {
|
|
15
|
+
// ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-rkhsft4a.js
|
|
16
|
+
function G(t, e, { plural: r, zero: n = "singular" } = {}) {
|
|
19
17
|
if (e === 1 || e === 0 && n === "singular")
|
|
20
18
|
return t;
|
|
21
19
|
if (r !== undefined)
|
|
@@ -28,12 +26,10 @@ function K(t, e, { plural: r, zero: n = "singular" } = {}) {
|
|
|
28
26
|
return `${t.slice(0, -1)}ves`;
|
|
29
27
|
return Gt.test(t) ? `${t.slice(0, -2)}ves` : `${t}s`;
|
|
30
28
|
}
|
|
31
|
-
function
|
|
32
|
-
return `${t} ${
|
|
29
|
+
function bo(t, e, { zero: r = "plural", ...n } = {}) {
|
|
30
|
+
return `${t} ${G(e, t, { ...n, zero: r })}`;
|
|
33
31
|
}
|
|
34
|
-
|
|
35
|
-
var Y = /\s/;
|
|
36
|
-
function ko(t, e, r = "...") {
|
|
32
|
+
function Ao(t, e, r = "...") {
|
|
37
33
|
let { suffix: n = "...", includeSuffix: s = false, wordBoundary: o = false } = typeof r === "string" ? { suffix: r } : r;
|
|
38
34
|
if (t.length <= e)
|
|
39
35
|
return t;
|
|
@@ -44,13 +40,25 @@ function ko(t, e, r = "...") {
|
|
|
44
40
|
c = c.trimEnd();
|
|
45
41
|
return s ? (c + n).slice(0, l) : c + n;
|
|
46
42
|
}
|
|
47
|
-
var
|
|
48
|
-
var
|
|
43
|
+
var ct, N, Ot, Gt, Nt, Y, be, W;
|
|
44
|
+
var init_chunk_rkhsft4a = __esm(() => {
|
|
45
|
+
ct = /[aeiou]y$/;
|
|
46
|
+
N = new Map;
|
|
47
|
+
Ot = /(?:leaf|loaf|thief|wolf|half|calf|elf|sheaf|scarf|dwarf|hoof|wharf)$/;
|
|
48
|
+
Gt = /(?:knife|life|wife)$/;
|
|
49
|
+
Nt = /\s+\S*$/;
|
|
50
|
+
Y = /\s/;
|
|
51
|
+
be = new Map(["\u20AC", "", "\u201A", "\u0192", "\u201E", "\u2026", "\u2020", "\u2021", "\u02C6", "\u2030", "\u0160", "\u2039", "\u0152", "", "\u017D", "", "", "\u2018", "\u2019", "\u201C", "\u201D", "\u2022", "\u2013", "\u2014", "\u02DC", "\u2122", "\u0161", "\u203A", "\u0153", "", "\u017E", "\u0178"].map((t, e) => [t, 128 + e]).filter(([t]) => t));
|
|
52
|
+
W = new Map;
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
// ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/text.js
|
|
56
|
+
var init_text = __esm(() => {
|
|
57
|
+
init_chunk_rkhsft4a();
|
|
58
|
+
});
|
|
49
59
|
|
|
50
60
|
// ../kit/src/mode.ts
|
|
51
61
|
import process2 from "process";
|
|
52
|
-
var MODES = new Set(["terminal", "ci", "agent", "pipe"]);
|
|
53
|
-
var AGENT_VARIABLES = ["CLAUDECODE", "AI_AGENT"];
|
|
54
62
|
function isSet(value) {
|
|
55
63
|
return value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false";
|
|
56
64
|
}
|
|
@@ -64,12 +72,16 @@ function outputMode(stream = process2.stdout, env = process2.env) {
|
|
|
64
72
|
return "terminal";
|
|
65
73
|
return isSet(env.CI) ? "ci" : "pipe";
|
|
66
74
|
}
|
|
75
|
+
function isInteractive(streams = process2) {
|
|
76
|
+
return streams.stdin?.isTTY === true && streams.stderr?.isTTY === true;
|
|
77
|
+
}
|
|
78
|
+
var MODES, AGENT_VARIABLES;
|
|
79
|
+
var init_mode = __esm(() => {
|
|
80
|
+
MODES = new Set(["terminal", "ci", "agent", "pipe"]);
|
|
81
|
+
AGENT_VARIABLES = ["CLAUDECODE", "AI_AGENT"];
|
|
82
|
+
});
|
|
67
83
|
|
|
68
|
-
//
|
|
69
|
-
import process6 from "process";
|
|
70
|
-
|
|
71
|
-
// ../../node_modules/.bun/@kaynooo+utils@3.0.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-x450vn3m.js
|
|
72
|
-
var G2 = /^[a-f0-9]+$/i;
|
|
84
|
+
// ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/chunk-x450vn3m.js
|
|
73
85
|
function b(r) {
|
|
74
86
|
let e = r.startsWith("#") ? r.slice(1) : r;
|
|
75
87
|
if (!G2.test(e))
|
|
@@ -80,11 +92,6 @@ function b(r) {
|
|
|
80
92
|
throw Error(`Invalid hex color length: ${e.length}`);
|
|
81
93
|
return [Number.parseInt(e.slice(0, 2), 16), Number.parseInt(e.slice(2, 4), 16), Number.parseInt(e.slice(4, 6), 16)];
|
|
82
94
|
}
|
|
83
|
-
var B2 = { 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") => {
|
|
84
|
-
let [l, n, c] = b(r);
|
|
85
|
-
return [`${e === "fg" ? 38 : 48};2;${l};${n};${c}`, e === "fg" ? 39 : 49];
|
|
86
|
-
}, ansi256: (r, e = "fg") => [`${e === "fg" ? 38 : 48};5;${r}`, e === "fg" ? 39 : 49] };
|
|
87
|
-
var h = new Set(["", "1", "2", "3", "true"]);
|
|
88
95
|
function C(r, e = globalThis.process?.env ?? {}) {
|
|
89
96
|
if (e.FORCE_COLOR !== undefined)
|
|
90
97
|
return h.has(e.FORCE_COLOR);
|
|
@@ -98,7 +105,7 @@ function f(r, e = []) {
|
|
|
98
105
|
l += `\x1B[${e[t][0]}m`, n = `\x1B[${e[t][1]}m${n}`;
|
|
99
106
|
let c = (t) => C(r.stream ?? globalThis.process?.stdout, r.env) ? l + t + n : t, g = new Map;
|
|
100
107
|
return new Proxy(c, { get(t, i) {
|
|
101
|
-
let a =
|
|
108
|
+
let a = B[i];
|
|
102
109
|
if (Array.isArray(a)) {
|
|
103
110
|
let s = g.get(i);
|
|
104
111
|
if (s === undefined)
|
|
@@ -121,13 +128,21 @@ function f(r, e = []) {
|
|
|
121
128
|
function Fe(r = {}) {
|
|
122
129
|
return f(r);
|
|
123
130
|
}
|
|
124
|
-
var
|
|
131
|
+
var G2, B, h, o;
|
|
132
|
+
var init_chunk_x450vn3m = __esm(() => {
|
|
133
|
+
G2 = /^[a-f0-9]+$/i;
|
|
134
|
+
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") => {
|
|
135
|
+
let [l, n, c] = b(r);
|
|
136
|
+
return [`${e === "fg" ? 38 : 48};2;${l};${n};${c}`, e === "fg" ? 39 : 49];
|
|
137
|
+
}, ansi256: (r, e = "fg") => [`${e === "fg" ? 38 : 48};5;${r}`, e === "fg" ? 39 : 49] };
|
|
138
|
+
h = new Set(["", "1", "2", "3", "true"]);
|
|
139
|
+
o = Fe();
|
|
140
|
+
});
|
|
125
141
|
|
|
126
|
-
//
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
import process5 from "process";
|
|
142
|
+
// ../../node_modules/.bun/@kaynooo+utils@3.1.0+4c7ddab9986847c5/node_modules/@kaynooo/utils/dist/tools/colors.js
|
|
143
|
+
var init_colors = __esm(() => {
|
|
144
|
+
init_chunk_x450vn3m();
|
|
145
|
+
});
|
|
131
146
|
|
|
132
147
|
// ../kit/src/config.ts
|
|
133
148
|
import { existsSync } from "fs";
|
|
@@ -143,15 +158,21 @@ function findUp(names, from = process3.cwd(), stop = () => false) {
|
|
|
143
158
|
return;
|
|
144
159
|
}
|
|
145
160
|
}
|
|
161
|
+
var init_config = __esm(() => {
|
|
162
|
+
init_args();
|
|
163
|
+
});
|
|
146
164
|
|
|
147
165
|
// ../kit/src/user-config.ts
|
|
148
166
|
import { existsSync as existsSync2, readFileSync } from "fs";
|
|
149
167
|
import { homedir } from "os";
|
|
150
|
-
import { join as join2 } from "path";
|
|
168
|
+
import { isAbsolute, join as join2 } from "path";
|
|
151
169
|
import process4 from "process";
|
|
170
|
+
function xdgFolder(value, fallback) {
|
|
171
|
+
return value !== undefined && isAbsolute(value) ? value : fallback;
|
|
172
|
+
}
|
|
152
173
|
function configBase(where = {}) {
|
|
153
174
|
const xdg = where.xdg ?? (where.home === undefined ? process4.env.XDG_CONFIG_HOME : undefined);
|
|
154
|
-
return xdg
|
|
175
|
+
return xdgFolder(xdg, join2(where.home ?? homedir(), ".config"));
|
|
155
176
|
}
|
|
156
177
|
function userConfigPath(bin, where = {}) {
|
|
157
178
|
return join2(configBase(where), "kaynooo-cli", `${bin}.json`);
|
|
@@ -178,13 +199,17 @@ function configuredNumber(bin, key, fallback, where = {}, legacy = []) {
|
|
|
178
199
|
const value = readUserConfig(bin, where, legacy)[key];
|
|
179
200
|
return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
|
|
180
201
|
}
|
|
202
|
+
var init_user_config = () => {};
|
|
181
203
|
|
|
182
204
|
// ../kit/src/theme.ts
|
|
205
|
+
import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "fs";
|
|
206
|
+
import { homedir as homedir2 } from "os";
|
|
207
|
+
import { join as join3, resolve as resolve2 } from "path";
|
|
208
|
+
import process5 from "process";
|
|
183
209
|
function toLinear(channel) {
|
|
184
210
|
const value = channel / 255;
|
|
185
211
|
return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
|
|
186
212
|
}
|
|
187
|
-
var fromLinear = (value) => Math.round(255 * Math.min(1, Math.max(0, value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055)));
|
|
188
213
|
function toOklab(hex) {
|
|
189
214
|
const [r, g, b] = [1, 3, 5].map((at) => toLinear(Number.parseInt(hex.slice(at, at + 2), 16)));
|
|
190
215
|
const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
|
|
@@ -199,7 +224,6 @@ function fromOklab([lightness, a, b]) {
|
|
|
199
224
|
const channels = [4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s, -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s, -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s];
|
|
200
225
|
return `#${channels.map((channel) => fromLinear(channel).toString(16).padStart(2, "0")).join("")}`;
|
|
201
226
|
}
|
|
202
|
-
var ENDS = new Map;
|
|
203
227
|
function gradientAt(theme, ratio) {
|
|
204
228
|
if (theme.gradient === undefined)
|
|
205
229
|
return;
|
|
@@ -213,33 +237,11 @@ function gradientAt(theme, ratio) {
|
|
|
213
237
|
const [from, to] = ends;
|
|
214
238
|
return fromOklab(from.map((start, index) => start + (to[index] - start) * at));
|
|
215
239
|
}
|
|
216
|
-
var DEFAULT = {
|
|
217
|
-
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" },
|
|
218
|
-
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" },
|
|
219
|
-
accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
|
|
220
|
-
bins: {},
|
|
221
|
-
gradient: ["#c084fc", "#67e8f9"]
|
|
222
|
-
};
|
|
223
|
-
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" };
|
|
224
|
-
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" };
|
|
225
|
-
var ASCII = { ok: "+", warn: "!", problem: "x", note: ">", plan: "?", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#", rule: "-", corner: "+", open: "*", leaf: "-", guide: "|" };
|
|
226
|
-
var PRESETS = {
|
|
227
|
-
default: {},
|
|
228
|
-
"high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"], gradient: ["#d8b4fe", "#a5f3fc"] },
|
|
229
|
-
mono: { colors: MONO, accents: ["bold"], gradient: undefined },
|
|
230
|
-
ascii: { glyphs: ASCII }
|
|
231
|
-
};
|
|
232
|
-
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"]);
|
|
233
|
-
var HEX = /^#[0-9a-f]{6}$/i;
|
|
234
|
-
var CONTROL = /\p{Cc}/u;
|
|
235
|
-
var MAX_FILE_BYTES = 64 * 1024;
|
|
236
|
-
var SPACES = /\s+/;
|
|
237
240
|
function isColorSpec(spec) {
|
|
238
241
|
if (typeof spec === "number")
|
|
239
242
|
return Number.isInteger(spec) && spec >= 0 && spec <= 255;
|
|
240
243
|
return typeof spec === "string" && spec.trim() !== "" && spec.trim().split(SPACES).every((token) => STYLES.has(token) || HEX.test(token));
|
|
241
244
|
}
|
|
242
|
-
var CUBE = [0, 95, 135, 175, 215, 255];
|
|
243
245
|
function cubeLevel(channel) {
|
|
244
246
|
return CUBE.reduce((best, value, level) => Math.abs(value - channel) < Math.abs(CUBE[best] - channel) ? level : best, 0);
|
|
245
247
|
}
|
|
@@ -347,7 +349,6 @@ function applyFile(theme, file, where, warn) {
|
|
|
347
349
|
function endsWalk(home) {
|
|
348
350
|
return (dir) => dir === resolve2(home) || existsSync3(join3(dir, ".git"));
|
|
349
351
|
}
|
|
350
|
-
var warned = new Set;
|
|
351
352
|
function warnOnce(message) {
|
|
352
353
|
if (warned.has(message))
|
|
353
354
|
return;
|
|
@@ -384,8 +385,6 @@ function loadTheme({ env = process5.env, from = process5.cwd(), home = homedir2(
|
|
|
384
385
|
}
|
|
385
386
|
return { theme, sources, preset };
|
|
386
387
|
}
|
|
387
|
-
var current;
|
|
388
|
-
var currentKey = "";
|
|
389
388
|
function activeTheme() {
|
|
390
389
|
const key = `${process5.cwd()}\x00${process5.env.KIT_THEME ?? ""}\x00${process5.env.XDG_CONFIG_HOME ?? ""}`;
|
|
391
390
|
if (current === undefined || key !== currentKey) {
|
|
@@ -394,9 +393,38 @@ function activeTheme() {
|
|
|
394
393
|
}
|
|
395
394
|
return current;
|
|
396
395
|
}
|
|
396
|
+
var fromLinear = (value) => Math.round(255 * Math.min(1, Math.max(0, value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055))), ENDS, DEFAULT, BRIGHT, MONO, ASCII, PRESETS, STYLES, HEX, CONTROL, MAX_FILE_BYTES, SPACES, CUBE, warned, current, currentKey = "";
|
|
397
|
+
var init_theme = __esm(() => {
|
|
398
|
+
init_config();
|
|
399
|
+
init_user_config();
|
|
400
|
+
ENDS = new Map;
|
|
401
|
+
DEFAULT = {
|
|
402
|
+
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" },
|
|
403
|
+
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" },
|
|
404
|
+
accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
|
|
405
|
+
bins: {},
|
|
406
|
+
gradient: ["#c084fc", "#67e8f9"]
|
|
407
|
+
};
|
|
408
|
+
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" };
|
|
409
|
+
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" };
|
|
410
|
+
ASCII = { ok: "+", warn: "!", problem: "x", note: ">", plan: "?", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#", rule: "-", corner: "+", open: "*", leaf: "-", guide: "|" };
|
|
411
|
+
PRESETS = {
|
|
412
|
+
default: {},
|
|
413
|
+
"high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"], gradient: ["#d8b4fe", "#a5f3fc"] },
|
|
414
|
+
mono: { colors: MONO, accents: ["bold"], gradient: undefined },
|
|
415
|
+
ascii: { glyphs: ASCII }
|
|
416
|
+
};
|
|
417
|
+
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"]);
|
|
418
|
+
HEX = /^#[0-9a-f]{6}$/i;
|
|
419
|
+
CONTROL = /\p{Cc}/u;
|
|
420
|
+
MAX_FILE_BYTES = 64 * 1024;
|
|
421
|
+
SPACES = /\s+/;
|
|
422
|
+
CUBE = [0, 95, 135, 175, 215, 255];
|
|
423
|
+
warned = new Set;
|
|
424
|
+
});
|
|
397
425
|
|
|
398
426
|
// ../kit/src/style.ts
|
|
399
|
-
|
|
427
|
+
import process6 from "process";
|
|
400
428
|
function takesControlCodes(stream, env = process6.env) {
|
|
401
429
|
return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb" && outputMode(stream, env) === "terminal";
|
|
402
430
|
}
|
|
@@ -425,14 +453,6 @@ function role(name, stream, env = process6.env) {
|
|
|
425
453
|
const colors = paint(stream, env);
|
|
426
454
|
return takesControlCodes(stream, env) ? tinted(colors, activeTheme().theme.colors[name], env) : colors;
|
|
427
455
|
}
|
|
428
|
-
var STATUS_WORDS = {
|
|
429
|
-
passed: ["passed", "success", "succeeded", "ok"],
|
|
430
|
-
failed: ["failed", "failure", "error", "errored"],
|
|
431
|
-
running: ["running", "in_progress", "started", "holding"],
|
|
432
|
-
queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
|
|
433
|
-
skipped: ["skipped", "cancelled", "canceled", "manual"]
|
|
434
|
-
};
|
|
435
|
-
var STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
|
|
436
456
|
function statusOf(word) {
|
|
437
457
|
return STATUS_OF.get(word.toLowerCase());
|
|
438
458
|
}
|
|
@@ -476,9 +496,24 @@ function section(title, count, stream = process6.stdout, env = process6.env, ton
|
|
|
476
496
|
function hyperlink(text, url, stream, env = process6.env) {
|
|
477
497
|
return takesControlCodes(stream, env) ? paint(stream, env).underline(link(text, url, stream, env)) : text;
|
|
478
498
|
}
|
|
499
|
+
var MARK_WORDS, STATUS_WORDS, STATUS_OF;
|
|
500
|
+
var init_style = __esm(() => {
|
|
501
|
+
init_colors();
|
|
502
|
+
init_mode();
|
|
503
|
+
init_theme();
|
|
504
|
+
MARK_WORDS = { ok: "ok:", warn: "warning:", problem: "error:", note: "note:", plan: "would:" };
|
|
505
|
+
STATUS_WORDS = {
|
|
506
|
+
passed: ["passed", "success", "succeeded", "ok"],
|
|
507
|
+
failed: ["failed", "failure", "error", "errored"],
|
|
508
|
+
running: ["running", "in_progress", "started", "holding"],
|
|
509
|
+
queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
|
|
510
|
+
skipped: ["skipped", "cancelled", "canceled", "manual"]
|
|
511
|
+
};
|
|
512
|
+
STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
|
|
513
|
+
});
|
|
479
514
|
|
|
480
515
|
// ../kit/src/format.ts
|
|
481
|
-
|
|
516
|
+
import process7 from "process";
|
|
482
517
|
function formatSeconds(total) {
|
|
483
518
|
let rest = Math.max(0, Math.round(total));
|
|
484
519
|
const amounts = UNITS.map(([unit, size]) => {
|
|
@@ -510,10 +545,8 @@ function formatAge(date, now = Date.now()) {
|
|
|
510
545
|
return seconds < 60 ? "just now" : `${upTo(formatSeconds(seconds), " ")} ago`;
|
|
511
546
|
}
|
|
512
547
|
function truncate(text, width) {
|
|
513
|
-
return
|
|
548
|
+
return Ao(text, width, { suffix: "\u2026", includeSuffix: true });
|
|
514
549
|
}
|
|
515
|
-
var LINE_BREAKS = /\s*\n\s*/g;
|
|
516
|
-
var ESCAPE = String.fromCharCode(27);
|
|
517
550
|
function textWidth(text) {
|
|
518
551
|
return Bun.stringWidth(text);
|
|
519
552
|
}
|
|
@@ -565,14 +598,40 @@ function printJson(value) {
|
|
|
565
598
|
function formatPercent(ratio, digits = 0) {
|
|
566
599
|
return `${(ratio * 100).toFixed(digits)}%`;
|
|
567
600
|
}
|
|
601
|
+
var UNITS, LINE_BREAKS, ESCAPE;
|
|
602
|
+
var init_format = __esm(() => {
|
|
603
|
+
init_text();
|
|
604
|
+
init_mode();
|
|
605
|
+
init_style();
|
|
606
|
+
UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
|
|
607
|
+
LINE_BREAKS = /\s*\n\s*/g;
|
|
608
|
+
ESCAPE = String.fromCharCode(27);
|
|
609
|
+
});
|
|
568
610
|
|
|
569
611
|
// ../kit/src/help.ts
|
|
570
612
|
import process8 from "process";
|
|
571
|
-
var OPTIONAL = /(?<!\x1B)\[[^\]]+\]/g;
|
|
572
|
-
var USAGE_PREFIX = /^usage:\s*/i;
|
|
573
|
-
var FULL_STOP = /\.$/;
|
|
574
613
|
function usageLine(usage, colors = paint(process8.stdout)) {
|
|
575
|
-
|
|
614
|
+
const lines = usage.replace(USAGE_PREFIX, "").split(`
|
|
615
|
+
`);
|
|
616
|
+
const blank = lines.indexOf("");
|
|
617
|
+
const synopses = blank === -1 ? lines : lines.slice(0, blank);
|
|
618
|
+
const details = blank === -1 ? [] : lines.slice(blank + 1);
|
|
619
|
+
const colon = synopses[0].indexOf(": ");
|
|
620
|
+
const inline = synopses[0].slice(colon + 2);
|
|
621
|
+
const summary = colon === -1 ? details.shift() : `${inline.charAt(0).toUpperCase()}${inline.slice(1)}`;
|
|
622
|
+
if (colon !== -1)
|
|
623
|
+
synopses[0] = synopses[0].slice(0, colon);
|
|
624
|
+
const head = `${colors.bold("Usage:")} ${synopses.map((line) => line.replaceAll(OPTIONAL, (part) => colors.dim(part))).join(`
|
|
625
|
+
`)}`;
|
|
626
|
+
const lead = summary === undefined ? [] : ["", colors.bold(prose(summary, colors))];
|
|
627
|
+
const rest = details.length === 0 ? [] : ["", ...details.map((line) => prose(line, colors))];
|
|
628
|
+
return [head, ...lead, ...rest].join(`
|
|
629
|
+
`);
|
|
630
|
+
}
|
|
631
|
+
function prose(line, colors) {
|
|
632
|
+
if (colors.cyan("x") === "x")
|
|
633
|
+
return line;
|
|
634
|
+
return line.replaceAll(PROSE_MARKS, (match, code, flag) => code === undefined ? colors.cyan(flag ?? match) : colors.bold(code));
|
|
576
635
|
}
|
|
577
636
|
function helpText(usage, options, colors = paint(process8.stdout), { examples = [], exits = [] } = {}) {
|
|
578
637
|
return [usageLine(usage, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exitRows(exits, colors), ...exampleRows(examples, colors)].join(`
|
|
@@ -607,7 +666,6 @@ function exampleRows(examples, colors = paint(process8.stdout)) {
|
|
|
607
666
|
return [];
|
|
608
667
|
return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? ` ${example}` : ` ${example[0]} ${colors.dim(`# ${example[1]}`)}`)];
|
|
609
668
|
}
|
|
610
|
-
var MAX_INLINE_CHOICES = 24;
|
|
611
669
|
function optionRows(options, colors = paint(process8.stdout)) {
|
|
612
670
|
const rows = Object.entries(options).map(([name, option]) => {
|
|
613
671
|
const short = option.short === undefined ? " " : `${colors.cyan(`-${option.short}`)}, `;
|
|
@@ -622,9 +680,17 @@ function optionRows(options, colors = paint(process8.stdout)) {
|
|
|
622
680
|
const width = Math.max(0, ...rows.map((row) => row.width));
|
|
623
681
|
return rows.map((row) => row.description === "" ? ` ${row.flag}` : ` ${row.flag}${" ".repeat(width - row.width)} ${colors.dim(row.description)}`);
|
|
624
682
|
}
|
|
683
|
+
var OPTIONAL, USAGE_PREFIX, FULL_STOP, PROSE_MARKS, MAX_INLINE_CHOICES = 24;
|
|
684
|
+
var init_help = __esm(() => {
|
|
685
|
+
init_mode();
|
|
686
|
+
init_style();
|
|
687
|
+
OPTIONAL = /(?<!\x1B)\[[^\]]+\]/g;
|
|
688
|
+
USAGE_PREFIX = /^usage:\s*/i;
|
|
689
|
+
FULL_STOP = /\.$/;
|
|
690
|
+
PROSE_MARKS = /`([^`\n]+)`|(?<![\w-])(--[a-z][\w-]*|-[a-z](?![\w-]))/gi;
|
|
691
|
+
});
|
|
625
692
|
|
|
626
693
|
// ../kit/src/text.ts
|
|
627
|
-
var ANSI = /\x1B(?:\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x7E]|\][^\x07\x1B]*(?:\x07|\x1B\\)|[\x40-\x5A\x5C-\x5F])/g;
|
|
628
694
|
function stripAnsi(text) {
|
|
629
695
|
return text.replace(ANSI, "");
|
|
630
696
|
}
|
|
@@ -653,9 +719,13 @@ function closest(name, names) {
|
|
|
653
719
|
const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
|
|
654
720
|
return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
|
|
655
721
|
}
|
|
722
|
+
var ANSI;
|
|
723
|
+
var init_text2 = __esm(() => {
|
|
724
|
+
ANSI = /\x1B(?:\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x7E]|\][^\x07\x1B]*(?:\x07|\x1B\\)|[\x40-\x5A\x5C-\x5F])/g;
|
|
725
|
+
});
|
|
726
|
+
|
|
656
727
|
// ../kit/src/input.ts
|
|
657
728
|
import process9 from "process";
|
|
658
|
-
var WHOLE = /^\d+$/;
|
|
659
729
|
function wholeNumber(value, name, fallback, min = 1) {
|
|
660
730
|
if (value === undefined)
|
|
661
731
|
return fallback;
|
|
@@ -664,8 +734,6 @@ function wholeNumber(value, name, fallback, min = 1) {
|
|
|
664
734
|
badUsage(`${name.startsWith("<") ? name : `--${name}`} takes a whole number from ${min}, not ${value}`);
|
|
665
735
|
return number;
|
|
666
736
|
}
|
|
667
|
-
var DURATION = /^(\d+(?:\.\d+)?)(ms|[smhd])?$/;
|
|
668
|
-
var UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
|
|
669
737
|
function duration(value, name, fallback, unit = "s") {
|
|
670
738
|
if (value === undefined)
|
|
671
739
|
return fallback;
|
|
@@ -686,44 +754,30 @@ async function readInput(path, { noStdin = "nothing is piped on stdin" } = {}) {
|
|
|
686
754
|
fail(`no file ${path}`);
|
|
687
755
|
return file.text();
|
|
688
756
|
}
|
|
757
|
+
var WHOLE, DURATION, UNIT_MS;
|
|
758
|
+
var init_input = __esm(() => {
|
|
759
|
+
init_args();
|
|
760
|
+
WHOLE = /^\d+$/;
|
|
761
|
+
DURATION = /^(\d+(?:\.\d+)?)(ms|[smhd])?$/;
|
|
762
|
+
UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
|
|
763
|
+
});
|
|
689
764
|
|
|
690
765
|
// ../kit/src/args.ts
|
|
691
|
-
|
|
766
|
+
import process10 from "process";
|
|
767
|
+
import { parseArgs } from "util";
|
|
692
768
|
function jsonOption(holds) {
|
|
693
769
|
return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
|
|
694
770
|
}
|
|
695
771
|
function copyOption(what) {
|
|
696
772
|
return { type: "boolean", description: `also copy ${what} to the clipboard` };
|
|
697
773
|
}
|
|
698
|
-
|
|
699
|
-
class Exit extends Error {
|
|
700
|
-
code;
|
|
701
|
-
hint;
|
|
702
|
-
constructor(message, code, hint) {
|
|
703
|
-
super(message);
|
|
704
|
-
this.code = code;
|
|
705
|
-
this.hint = hint;
|
|
706
|
-
}
|
|
707
|
-
}
|
|
708
774
|
function fail(message, code = 2, hint) {
|
|
709
775
|
throw new Exit(message, code, hint);
|
|
710
776
|
}
|
|
711
|
-
|
|
712
|
-
class UsageError extends Exit {
|
|
713
|
-
constructor(message, hint) {
|
|
714
|
-
super(message, 2, hint);
|
|
715
|
-
}
|
|
716
|
-
}
|
|
717
777
|
function badUsage(message) {
|
|
718
778
|
throw new UsageError(message);
|
|
719
779
|
}
|
|
720
780
|
|
|
721
|
-
class HelpShown extends Exit {
|
|
722
|
-
constructor() {
|
|
723
|
-
super("help shown", 0);
|
|
724
|
-
}
|
|
725
|
-
}
|
|
726
|
-
|
|
727
781
|
class Completing {
|
|
728
782
|
options;
|
|
729
783
|
positionals;
|
|
@@ -734,11 +788,6 @@ class Completing {
|
|
|
734
788
|
this.candidates = candidates;
|
|
735
789
|
}
|
|
736
790
|
}
|
|
737
|
-
var completion = { active: false };
|
|
738
|
-
var OUTPUT_OPTIONS = {
|
|
739
|
-
color: { type: "string", choices: ["auto", "always", "never"], description: "auto (the default) colours on a terminal alone" },
|
|
740
|
-
plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
|
|
741
|
-
};
|
|
742
791
|
function applyOutput(color, plain, env = process10.env) {
|
|
743
792
|
const when = plain === true ? "never" : color ?? "auto";
|
|
744
793
|
if (when === "auto")
|
|
@@ -892,7 +941,6 @@ function parseError(error) {
|
|
|
892
941
|
const message = upTo(error instanceof Error ? error.message : String(error), ". ");
|
|
893
942
|
return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
|
|
894
943
|
}
|
|
895
|
-
var UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
|
|
896
944
|
function nearestOption(message, options, allowNegative) {
|
|
897
945
|
const typed = UNKNOWN_OPTION.exec(message)?.[1];
|
|
898
946
|
if (typed === undefined)
|
|
@@ -908,6 +956,495 @@ function nearestOption(message, options, allowNegative) {
|
|
|
908
956
|
const meant = closest(word, known.map((flag) => flag.replace(DASHES, "")));
|
|
909
957
|
return meant === undefined ? undefined : `did you mean ${known.find((flag) => flag.replace(DASHES, "") === meant)}?`;
|
|
910
958
|
}
|
|
959
|
+
var DASHES, EXIT, Exit, UsageError, HelpShown, completion, OUTPUT_OPTIONS, UNKNOWN_OPTION;
|
|
960
|
+
var init_args = __esm(() => {
|
|
961
|
+
init_format();
|
|
962
|
+
init_help();
|
|
963
|
+
init_text2();
|
|
964
|
+
init_help();
|
|
965
|
+
init_input();
|
|
966
|
+
DASHES = /^-+/;
|
|
967
|
+
EXIT = Symbol.for("@kaynooo/cli-kit/Exit");
|
|
968
|
+
Exit = class Exit extends Error {
|
|
969
|
+
code;
|
|
970
|
+
hint;
|
|
971
|
+
[EXIT] = true;
|
|
972
|
+
constructor(message, code, hint) {
|
|
973
|
+
super(message);
|
|
974
|
+
this.code = code;
|
|
975
|
+
this.hint = hint;
|
|
976
|
+
}
|
|
977
|
+
static [Symbol.hasInstance](value) {
|
|
978
|
+
if (this !== Exit)
|
|
979
|
+
return Function.prototype[Symbol.hasInstance].call(this, value);
|
|
980
|
+
return typeof value === "object" && value !== null && value[EXIT] === true;
|
|
981
|
+
}
|
|
982
|
+
};
|
|
983
|
+
UsageError = class UsageError extends Exit {
|
|
984
|
+
constructor(message, hint) {
|
|
985
|
+
super(message, 2, hint);
|
|
986
|
+
}
|
|
987
|
+
};
|
|
988
|
+
HelpShown = class HelpShown extends Exit {
|
|
989
|
+
constructor() {
|
|
990
|
+
super("help shown", 0);
|
|
991
|
+
}
|
|
992
|
+
};
|
|
993
|
+
completion = { active: false };
|
|
994
|
+
OUTPUT_OPTIONS = {
|
|
995
|
+
color: { type: "string", choices: ["auto", "always", "never"], description: "auto (the default) colours on a terminal alone" },
|
|
996
|
+
plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
|
|
997
|
+
};
|
|
998
|
+
UNKNOWN_OPTION = /^unknown option '(-[^']+)'/;
|
|
999
|
+
});
|
|
1000
|
+
|
|
1001
|
+
// ../kit/src/folders.ts
|
|
1002
|
+
import { homedir as homedir3 } from "os";
|
|
1003
|
+
import { join as join4 } from "path";
|
|
1004
|
+
import process16 from "process";
|
|
1005
|
+
function cacheFolder({ home = homedir3(), env = process16.env } = {}) {
|
|
1006
|
+
return xdgFolder(env.XDG_CACHE_HOME, join4(home, ".cache"));
|
|
1007
|
+
}
|
|
1008
|
+
var SKIPPED_FOLDERS;
|
|
1009
|
+
var init_folders = __esm(() => {
|
|
1010
|
+
init_user_config();
|
|
1011
|
+
SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
|
|
1012
|
+
});
|
|
1013
|
+
|
|
1014
|
+
// ../kit/src/answers.ts
|
|
1015
|
+
import { mkdirSync, readFileSync as readFileSync5, writeFileSync } from "fs";
|
|
1016
|
+
import { dirname as dirname2, join as join5 } from "path";
|
|
1017
|
+
function answersFile() {
|
|
1018
|
+
return join5(cacheFolder(), "kaynooo-cli", "answers.json");
|
|
1019
|
+
}
|
|
1020
|
+
function stored() {
|
|
1021
|
+
try {
|
|
1022
|
+
const parsed = JSON.parse(readFileSync5(answersFile(), "utf-8"));
|
|
1023
|
+
if (typeof parsed !== "object" || parsed === null)
|
|
1024
|
+
return {};
|
|
1025
|
+
return Object.fromEntries(Object.entries(parsed).filter((entry) => Array.isArray(entry[1]) && entry[1].every((answer) => typeof answer === "string")));
|
|
1026
|
+
} catch {
|
|
1027
|
+
return {};
|
|
1028
|
+
}
|
|
1029
|
+
}
|
|
1030
|
+
function earlierAnswers(key) {
|
|
1031
|
+
return stored()[key] ?? [];
|
|
1032
|
+
}
|
|
1033
|
+
function rememberAnswer(key, answer) {
|
|
1034
|
+
const all = stored();
|
|
1035
|
+
const file = answersFile();
|
|
1036
|
+
all[key] = [answer, ...(all[key] ?? []).filter((earlier) => earlier !== answer)].slice(0, KEPT);
|
|
1037
|
+
try {
|
|
1038
|
+
mkdirSync(dirname2(file), { recursive: true });
|
|
1039
|
+
writeFileSync(file, JSON.stringify(all));
|
|
1040
|
+
} catch {}
|
|
1041
|
+
}
|
|
1042
|
+
var KEPT = 50;
|
|
1043
|
+
var init_answers = __esm(() => {
|
|
1044
|
+
init_folders();
|
|
1045
|
+
});
|
|
1046
|
+
|
|
1047
|
+
// ../kit/src/job.ts
|
|
1048
|
+
import process17 from "process";
|
|
1049
|
+
function stopJob() {
|
|
1050
|
+
process17.kill(0, "SIGTSTP");
|
|
1051
|
+
}
|
|
1052
|
+
var init_job = () => {};
|
|
1053
|
+
|
|
1054
|
+
// ../kit/src/picker/line.ts
|
|
1055
|
+
function isEditKey(key) {
|
|
1056
|
+
return EDIT_KEYS.has(key);
|
|
1057
|
+
}
|
|
1058
|
+
function endsKills(key) {
|
|
1059
|
+
return typeof key !== "object" && !isEditKey(key);
|
|
1060
|
+
}
|
|
1061
|
+
function isWord(char) {
|
|
1062
|
+
return char !== undefined && WORD_CHARACTER.test(char);
|
|
1063
|
+
}
|
|
1064
|
+
function wordStart(chars, from) {
|
|
1065
|
+
let at = from;
|
|
1066
|
+
while (at > 0 && !isWord(chars[at - 1]))
|
|
1067
|
+
at--;
|
|
1068
|
+
while (at > 0 && isWord(chars[at - 1]))
|
|
1069
|
+
at--;
|
|
1070
|
+
return at;
|
|
1071
|
+
}
|
|
1072
|
+
function wordEnd(chars, from) {
|
|
1073
|
+
let at = from;
|
|
1074
|
+
while (at < chars.length && !isWord(chars[at]))
|
|
1075
|
+
at++;
|
|
1076
|
+
while (at < chars.length && isWord(chars[at]))
|
|
1077
|
+
at++;
|
|
1078
|
+
return at;
|
|
1079
|
+
}
|
|
1080
|
+
function spacedStart(chars, from) {
|
|
1081
|
+
let at = from;
|
|
1082
|
+
while (at > 0 && SPACE.test(chars[at - 1] ?? ""))
|
|
1083
|
+
at--;
|
|
1084
|
+
while (at > 0 && !SPACE.test(chars[at - 1] ?? ""))
|
|
1085
|
+
at--;
|
|
1086
|
+
return at;
|
|
1087
|
+
}
|
|
1088
|
+
function cut(chars, from, to) {
|
|
1089
|
+
return { text: [...chars.slice(0, from), ...chars.slice(to)].join(""), caret: from };
|
|
1090
|
+
}
|
|
1091
|
+
function insert(chars, at, text) {
|
|
1092
|
+
const typed = [...text];
|
|
1093
|
+
return { text: [...chars.slice(0, at), ...typed, ...chars.slice(at)].join(""), caret: at + typed.length };
|
|
1094
|
+
}
|
|
1095
|
+
function editLine(line, key) {
|
|
1096
|
+
const { killed = "", chained = false } = line;
|
|
1097
|
+
const chars = [...line.text];
|
|
1098
|
+
const at = Math.min(Math.max(line.caret, 0), chars.length);
|
|
1099
|
+
const edited = edit(chars, at, key, killed);
|
|
1100
|
+
if (typeof key === "object" || !BACKWARD_KILLS.has(key) && !FORWARD_KILLS.has(key))
|
|
1101
|
+
return line.killed === undefined ? edited : { ...edited, killed };
|
|
1102
|
+
const taken = chars.slice(edited.caret, edited.caret + chars.length - [...edited.text].length).join("");
|
|
1103
|
+
if (taken === "")
|
|
1104
|
+
return { ...edited, killed, chained };
|
|
1105
|
+
if (!chained)
|
|
1106
|
+
return { ...edited, killed: taken, chained: true };
|
|
1107
|
+
return { ...edited, killed: BACKWARD_KILLS.has(key) ? taken + killed : killed + taken, chained: true };
|
|
1108
|
+
}
|
|
1109
|
+
function edit(chars, at, key, killed) {
|
|
1110
|
+
const text = chars.join("");
|
|
1111
|
+
if (typeof key === "object")
|
|
1112
|
+
return insert(chars, at, key.text);
|
|
1113
|
+
switch (key) {
|
|
1114
|
+
case "left":
|
|
1115
|
+
return { text, caret: Math.max(at - 1, 0) };
|
|
1116
|
+
case "right":
|
|
1117
|
+
return { text, caret: Math.min(at + 1, chars.length) };
|
|
1118
|
+
case "wordleft":
|
|
1119
|
+
return { text, caret: wordStart(chars, at) };
|
|
1120
|
+
case "wordright":
|
|
1121
|
+
return { text, caret: wordEnd(chars, at) };
|
|
1122
|
+
case "linestart":
|
|
1123
|
+
return { text, caret: 0 };
|
|
1124
|
+
case "lineend":
|
|
1125
|
+
return { text, caret: chars.length };
|
|
1126
|
+
case "erase":
|
|
1127
|
+
return cut(chars, Math.max(at - 1, 0), at);
|
|
1128
|
+
case "delete":
|
|
1129
|
+
return cut(chars, at, Math.min(at + 1, chars.length));
|
|
1130
|
+
case "word":
|
|
1131
|
+
return cut(chars, spacedStart(chars, at), at);
|
|
1132
|
+
case "killword":
|
|
1133
|
+
return cut(chars, wordStart(chars, at), at);
|
|
1134
|
+
case "killnext":
|
|
1135
|
+
return cut(chars, at, wordEnd(chars, at));
|
|
1136
|
+
case "clear":
|
|
1137
|
+
return cut(chars, 0, at);
|
|
1138
|
+
case "killend":
|
|
1139
|
+
return cut(chars, at, chars.length);
|
|
1140
|
+
case "yank":
|
|
1141
|
+
return insert(chars, at, killed);
|
|
1142
|
+
}
|
|
1143
|
+
}
|
|
1144
|
+
function visible({ text, caret }, room) {
|
|
1145
|
+
const chars = [...text];
|
|
1146
|
+
const at = Math.min(Math.max(caret, 0), chars.length);
|
|
1147
|
+
const cells = at === chars.length ? [...chars, " "] : chars;
|
|
1148
|
+
const widths = cells.map((char) => Bun.stringWidth(char));
|
|
1149
|
+
const width = (from, to) => widths.slice(from, to).reduce((sum, size) => sum + size, 0);
|
|
1150
|
+
const fits = (from, to) => (from > 0 ? 1 : 0) + width(from, to) + (to < cells.length ? 1 : 0) <= room;
|
|
1151
|
+
let start = at;
|
|
1152
|
+
let end = at + 1;
|
|
1153
|
+
while (start > 0 && fits(start - 1, end))
|
|
1154
|
+
start--;
|
|
1155
|
+
while (end < cells.length && fits(start, end + 1))
|
|
1156
|
+
end++;
|
|
1157
|
+
const left = start > 0 ? "\u2026" : "";
|
|
1158
|
+
const right = end < cells.length ? "\u2026" : "";
|
|
1159
|
+
return { before: left + chars.slice(start, at).join(""), at: chars[at], after: chars.slice(at + 1, end).join("") + right, column: left.length + width(start, at) };
|
|
1160
|
+
}
|
|
1161
|
+
var EDIT_KEYS, BACKWARD_KILLS, FORWARD_KILLS, WORD_CHARACTER, SPACE;
|
|
1162
|
+
var init_line = __esm(() => {
|
|
1163
|
+
EDIT_KEYS = new Set(["left", "right", "wordleft", "wordright", "linestart", "lineend", "erase", "delete", "word", "killword", "killnext", "clear", "killend", "yank"]);
|
|
1164
|
+
BACKWARD_KILLS = new Set(["word", "killword", "clear"]);
|
|
1165
|
+
FORWARD_KILLS = new Set(["killnext", "killend"]);
|
|
1166
|
+
WORD_CHARACTER = /[\p{L}\p{N}_]/u;
|
|
1167
|
+
SPACE = /\s/;
|
|
1168
|
+
});
|
|
1169
|
+
|
|
1170
|
+
// ../kit/src/picker/score.ts
|
|
1171
|
+
var BOUNDARY_AFTER, NONE;
|
|
1172
|
+
var init_score = __esm(() => {
|
|
1173
|
+
BOUNDARY_AFTER = new Set([" ", "/", "-", "_", ".", ":", "\\", "(", "[", ",", "\t"]);
|
|
1174
|
+
NONE = Number.NEGATIVE_INFINITY;
|
|
1175
|
+
});
|
|
1176
|
+
|
|
1177
|
+
// ../kit/src/picker/state.ts
|
|
1178
|
+
function repeat(value, count) {
|
|
1179
|
+
return Array.from({ length: count }).fill(value);
|
|
1180
|
+
}
|
|
1181
|
+
function parseKeys(input, paste = { active: false }, ctrls = []) {
|
|
1182
|
+
const codes = new Map(ctrls.map((name) => [String.fromCharCode(name.codePointAt(name.length - 1) - 96), name]));
|
|
1183
|
+
return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => {
|
|
1184
|
+
const wheel = MOUSE.exec(sequence)?.[1];
|
|
1185
|
+
if (wheel !== undefined)
|
|
1186
|
+
return repeat(wheel === "64" ? "up" : "down", wheel === "64" || wheel === "65" ? WHEEL_LINES : 0);
|
|
1187
|
+
const named = codes.get(sequence);
|
|
1188
|
+
const key = named === undefined ? KEYS[sequence] : { ctrl: named };
|
|
1189
|
+
if (sequence === PASTE_START || sequence === PASTE_END) {
|
|
1190
|
+
paste.active = sequence === PASTE_START;
|
|
1191
|
+
return [];
|
|
1192
|
+
}
|
|
1193
|
+
if (paste.active && (sequence === "\r" || sequence === `
|
|
1194
|
+
`))
|
|
1195
|
+
return [];
|
|
1196
|
+
if (key !== undefined)
|
|
1197
|
+
return [key];
|
|
1198
|
+
return IS_CONTROL.test(sequence) || sequence.startsWith("\x1B") ? [] : [{ text: sequence }];
|
|
1199
|
+
});
|
|
1200
|
+
}
|
|
1201
|
+
var IS_CONTROL, PASTE_START = "\x1B[200~", PASTE_END = "\x1B[201~", KEY_SEQUENCES, MOUSE, WHEEL_LINES = 3, KEYS;
|
|
1202
|
+
var init_state = __esm(() => {
|
|
1203
|
+
init_text2();
|
|
1204
|
+
init_line();
|
|
1205
|
+
init_score();
|
|
1206
|
+
IS_CONTROL = /[\x00-\x1F\x7F-\x9F]/;
|
|
1207
|
+
KEY_SEQUENCES = /\x1B\[<[0-9;]*[A-Za-z]|\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|\x1B[\s\S]|[\s\S]/gu;
|
|
1208
|
+
MOUSE = /^\x1B\[<(\d+);\d+;\d+[a-z]$/i;
|
|
1209
|
+
KEYS = {
|
|
1210
|
+
"\x1B[A": "up",
|
|
1211
|
+
"\x1BOA": "up",
|
|
1212
|
+
"\x10": "up",
|
|
1213
|
+
"\x1B[B": "down",
|
|
1214
|
+
"\x1BOB": "down",
|
|
1215
|
+
"\x0E": "down",
|
|
1216
|
+
"\x1B[5~": "pageup",
|
|
1217
|
+
"\x1B[6~": "pagedown",
|
|
1218
|
+
"\x1B[H": "home",
|
|
1219
|
+
"\x1B[1~": "home",
|
|
1220
|
+
"\x1BOH": "home",
|
|
1221
|
+
"\x1B[F": "end",
|
|
1222
|
+
"\x1B[4~": "end",
|
|
1223
|
+
"\x1BOF": "end",
|
|
1224
|
+
"\r": "enter",
|
|
1225
|
+
"\n": "enter",
|
|
1226
|
+
"\x03": "cancel",
|
|
1227
|
+
"\x1B": "cancel",
|
|
1228
|
+
"\x1B[D": "left",
|
|
1229
|
+
"\x1BOD": "left",
|
|
1230
|
+
"\x1B[C": "right",
|
|
1231
|
+
"\x1BOC": "right",
|
|
1232
|
+
"\x1B[1;5D": "wordleft",
|
|
1233
|
+
"\x1B[1;3D": "wordleft",
|
|
1234
|
+
"\x1Bb": "wordleft",
|
|
1235
|
+
"\x1B[1;5C": "wordright",
|
|
1236
|
+
"\x1B[1;3C": "wordright",
|
|
1237
|
+
"\x1Bf": "wordright",
|
|
1238
|
+
"\x01": "linestart",
|
|
1239
|
+
"\x05": "lineend",
|
|
1240
|
+
"\x7F": "erase",
|
|
1241
|
+
"\x1B[3~": "delete",
|
|
1242
|
+
"\b": "killword",
|
|
1243
|
+
"\x1B\x7F": "killword",
|
|
1244
|
+
"\x1B[3;5~": "killnext",
|
|
1245
|
+
"\x1Bd": "killnext",
|
|
1246
|
+
"\x15": "clear",
|
|
1247
|
+
"\v": "killend",
|
|
1248
|
+
"\x17": "word",
|
|
1249
|
+
"\x19": "yank",
|
|
1250
|
+
"\x1A": "suspend",
|
|
1251
|
+
"\t": "tab",
|
|
1252
|
+
"\x1F": "help",
|
|
1253
|
+
"\x1BOP": "help",
|
|
1254
|
+
"\x1B[11~": "help"
|
|
1255
|
+
};
|
|
1256
|
+
});
|
|
1257
|
+
|
|
1258
|
+
// ../kit/src/redraw.ts
|
|
1259
|
+
function overwrite(lines, columns) {
|
|
1260
|
+
return lines.map((line) => textWidth(line) % columns === 0 ? `\x1B[2K${line}` : `${line}\x1B[K`).join(`
|
|
1261
|
+
`);
|
|
1262
|
+
}
|
|
1263
|
+
function rowsTaken(lines, columns) {
|
|
1264
|
+
return lines.reduce((rows, line) => rows + Math.max(1, Math.ceil(textWidth(line) / columns)), 0);
|
|
1265
|
+
}
|
|
1266
|
+
var SYNC_START = "\x1B[?2026h", SYNC_END = "\x1B[?2026l";
|
|
1267
|
+
var init_redraw = __esm(() => {
|
|
1268
|
+
init_format();
|
|
1269
|
+
});
|
|
1270
|
+
|
|
1271
|
+
// ../kit/src/prompt.ts
|
|
1272
|
+
import process18 from "process";
|
|
1273
|
+
function readKeys(input, paste = { active: false }) {
|
|
1274
|
+
return parseKeys(input, paste).filter((key) => typeof key === "object" ? "text" in key : PROMPT_KEYS.has(key) || isEditKey(key));
|
|
1275
|
+
}
|
|
1276
|
+
function roomAfter(question, columns) {
|
|
1277
|
+
return Math.max(columns - textWidth(`? ${question} `) % columns - 1, 1);
|
|
1278
|
+
}
|
|
1279
|
+
function withCaret(colors, line, room, dim = false) {
|
|
1280
|
+
const { before, at, after } = visible(line, room);
|
|
1281
|
+
const tone = dim ? colors.dim : (text) => text;
|
|
1282
|
+
return `${tone(before)}${at === undefined ? colors.dim("\u2588") : colors.inverse(at)}${tone(after)}`;
|
|
1283
|
+
}
|
|
1284
|
+
function sharedStart(texts) {
|
|
1285
|
+
const [first = [], ...rest] = texts.map((text) => [...text]);
|
|
1286
|
+
let length = first.length;
|
|
1287
|
+
for (const chars of rest) {
|
|
1288
|
+
const differs = chars.findIndex((char, index) => char !== first[index]);
|
|
1289
|
+
length = Math.min(length, differs === -1 ? chars.length : differs);
|
|
1290
|
+
}
|
|
1291
|
+
return first.slice(0, length).join("");
|
|
1292
|
+
}
|
|
1293
|
+
function listed2(colors, found, columns) {
|
|
1294
|
+
const shared = sharedStart(found);
|
|
1295
|
+
const cut = Math.max(shared.lastIndexOf("/"), shared.lastIndexOf(" ")) + 1;
|
|
1296
|
+
const names = found.slice(0, MAX_LISTED).map((each) => each.slice(cut));
|
|
1297
|
+
const more = found.length > MAX_LISTED ? ` \u2026 ${found.length - MAX_LISTED} more` : "";
|
|
1298
|
+
return ` ${colors.dim(truncate(names.join(" ") + more, Math.max(columns - 3, 1)))}`;
|
|
1299
|
+
}
|
|
1300
|
+
async function input2(question, { default: fallback, mask = false, validate, history, complete, ...settings } = {}) {
|
|
1301
|
+
let line = { text: "", caret: 0 };
|
|
1302
|
+
let invalid;
|
|
1303
|
+
let completions = [];
|
|
1304
|
+
const remembered = history === undefined || mask ? undefined : history;
|
|
1305
|
+
const earlier = remembered === undefined ? [] : earlierAnswers(remembered);
|
|
1306
|
+
let recalled = -1;
|
|
1307
|
+
let draft = line;
|
|
1308
|
+
const taken = () => line.text === "" ? fallback ?? "" : line.text;
|
|
1309
|
+
const shown = () => mask ? "*".repeat([...taken()].length) : taken();
|
|
1310
|
+
const accepted = await ask(question, settings, (colors, state, { columns }) => {
|
|
1311
|
+
if (state !== "asking")
|
|
1312
|
+
return [answer(colors, question, state, shown())];
|
|
1313
|
+
const typed = line.text === "" ? { text: shown(), caret: [...shown()].length } : { text: shown(), caret: line.caret };
|
|
1314
|
+
return [`${colors.cyan("?")} ${question} ${withCaret(colors, typed, roomAfter(question, columns), line.text === "")}`, ...invalid === undefined ? [] : [` ${colors.red(invalid)}`], ...completions.length > 1 ? [listed2(colors, completions, columns)] : []];
|
|
1315
|
+
}, (key) => {
|
|
1316
|
+
if (key === "cancel")
|
|
1317
|
+
return "cancel";
|
|
1318
|
+
invalid = undefined;
|
|
1319
|
+
completions = [];
|
|
1320
|
+
if (line.chained === true && endsKills(key))
|
|
1321
|
+
line = { ...line, chained: false };
|
|
1322
|
+
if (key === "tab") {
|
|
1323
|
+
const chars = [...line.text];
|
|
1324
|
+
const before = chars.slice(0, line.caret).join("");
|
|
1325
|
+
const found = complete?.(before) ?? [];
|
|
1326
|
+
const filled = sharedStart(found);
|
|
1327
|
+
if ([...filled].length > [...before].length)
|
|
1328
|
+
line = { ...line, text: filled + chars.slice(line.caret).join(""), caret: [...filled].length };
|
|
1329
|
+
else
|
|
1330
|
+
completions = found;
|
|
1331
|
+
return;
|
|
1332
|
+
}
|
|
1333
|
+
if (key === "enter") {
|
|
1334
|
+
invalid = validate?.(taken());
|
|
1335
|
+
return invalid === undefined ? "enter" : undefined;
|
|
1336
|
+
}
|
|
1337
|
+
if (key === "up" || key === "down") {
|
|
1338
|
+
const to = Math.min(Math.max(recalled + (key === "up" ? 1 : -1), -1), earlier.length - 1);
|
|
1339
|
+
if (recalled === -1)
|
|
1340
|
+
draft = line;
|
|
1341
|
+
recalled = to;
|
|
1342
|
+
const shown = to === -1 ? draft : { text: earlier[to], caret: [...earlier[to]].length };
|
|
1343
|
+
line = { ...shown, killed: line.killed ?? "" };
|
|
1344
|
+
return;
|
|
1345
|
+
}
|
|
1346
|
+
const edit = { home: "linestart", end: "lineend" }[key] ?? key;
|
|
1347
|
+
if (typeof edit === "object" || isEditKey(edit))
|
|
1348
|
+
line = editLine(line, edit);
|
|
1349
|
+
return;
|
|
1350
|
+
});
|
|
1351
|
+
if (!accepted)
|
|
1352
|
+
return;
|
|
1353
|
+
if (remembered !== undefined && taken() !== "")
|
|
1354
|
+
rememberAnswer(remembered, taken());
|
|
1355
|
+
return taken();
|
|
1356
|
+
}
|
|
1357
|
+
function answer(colors, question, state, picked) {
|
|
1358
|
+
return state === "enter" ? `${colors.green("\u2713")} ${question} ${colors.cyan(picked)}` : `${colors.red("\u2717")} ${question} ${colors.dim("cancelled")}`;
|
|
1359
|
+
}
|
|
1360
|
+
async function ask(question, { hint, terminal = process18 }, render, press) {
|
|
1361
|
+
const { stdin, stderr } = terminal;
|
|
1362
|
+
if (!isInteractive(terminal))
|
|
1363
|
+
fail(`cannot ask "${question}" off a terminal`, 2, hint);
|
|
1364
|
+
const colors = paint(stderr);
|
|
1365
|
+
let current = "asking";
|
|
1366
|
+
let outcome;
|
|
1367
|
+
const columns = () => stderr.columns || 80;
|
|
1368
|
+
const draw = (state, last = false) => {
|
|
1369
|
+
const frame = render(colors, state, { columns: columns(), rows: stderr.rows || 24 });
|
|
1370
|
+
const rows = rowsTaken(frame, columns());
|
|
1371
|
+
stderr.write(`${SYNC_START}\r${overwrite(frame, columns())}\x1B[0J${last || rows < 2 ? "" : `\x1B[${rows - 1}A`}${last ? "" : "\r"}${SYNC_END}`);
|
|
1372
|
+
current = state;
|
|
1373
|
+
};
|
|
1374
|
+
const redraw = () => draw(current);
|
|
1375
|
+
const paste = { active: false };
|
|
1376
|
+
const stop = terminal.stop ?? (terminal === process18 ? stopJob : undefined);
|
|
1377
|
+
const suspend = () => {
|
|
1378
|
+
if (stop === undefined)
|
|
1379
|
+
return;
|
|
1380
|
+
stderr.write("\x1B[0J\x1B[?25h\x1B[?2004l");
|
|
1381
|
+
stdin.setRawMode(false);
|
|
1382
|
+
stop();
|
|
1383
|
+
stdin.setRawMode(true);
|
|
1384
|
+
stderr.write("\x1B[?25l\x1B[?2004h");
|
|
1385
|
+
};
|
|
1386
|
+
try {
|
|
1387
|
+
stderr.on?.("resize", redraw);
|
|
1388
|
+
stdin.setRawMode(true);
|
|
1389
|
+
stdin.resume();
|
|
1390
|
+
stderr.write("\x1B[?25l\x1B[?2004h");
|
|
1391
|
+
draw("asking");
|
|
1392
|
+
return await new Promise((resolve) => {
|
|
1393
|
+
function onData(data) {
|
|
1394
|
+
for (const key of readKeys(data.toString(), paste)) {
|
|
1395
|
+
if (key === "suspend") {
|
|
1396
|
+
suspend();
|
|
1397
|
+
continue;
|
|
1398
|
+
}
|
|
1399
|
+
const pressed = press(key);
|
|
1400
|
+
if (pressed !== undefined) {
|
|
1401
|
+
settle(pressed);
|
|
1402
|
+
return;
|
|
1403
|
+
}
|
|
1404
|
+
}
|
|
1405
|
+
draw("asking");
|
|
1406
|
+
}
|
|
1407
|
+
function onEnd() {
|
|
1408
|
+
settle("cancel");
|
|
1409
|
+
}
|
|
1410
|
+
function settle(settled) {
|
|
1411
|
+
outcome = settled;
|
|
1412
|
+
stdin.off("data", onData);
|
|
1413
|
+
stdin.off("end", onEnd);
|
|
1414
|
+
resolve(settled === "enter");
|
|
1415
|
+
}
|
|
1416
|
+
stdin.on("data", onData);
|
|
1417
|
+
stdin.on("end", onEnd);
|
|
1418
|
+
});
|
|
1419
|
+
} finally {
|
|
1420
|
+
stderr.off?.("resize", redraw);
|
|
1421
|
+
draw(outcome ?? "cancel", true);
|
|
1422
|
+
stderr.write(`
|
|
1423
|
+
\x1B[?25h\x1B[?2004l`);
|
|
1424
|
+
stdin.setRawMode(false);
|
|
1425
|
+
stdin.pause();
|
|
1426
|
+
}
|
|
1427
|
+
}
|
|
1428
|
+
var PROMPT_KEYS, MAX_LISTED = 12;
|
|
1429
|
+
var init_prompt = __esm(() => {
|
|
1430
|
+
init_answers();
|
|
1431
|
+
init_args();
|
|
1432
|
+
init_format();
|
|
1433
|
+
init_job();
|
|
1434
|
+
init_mode();
|
|
1435
|
+
init_line();
|
|
1436
|
+
init_state();
|
|
1437
|
+
init_redraw();
|
|
1438
|
+
init_style();
|
|
1439
|
+
PROMPT_KEYS = new Set(["up", "down", "pageup", "pagedown", "home", "end", "enter", "cancel", "suspend", "tab"]);
|
|
1440
|
+
});
|
|
1441
|
+
|
|
1442
|
+
// src/cli.ts
|
|
1443
|
+
import process35 from "process";
|
|
1444
|
+
|
|
1445
|
+
// ../kit/src/index.ts
|
|
1446
|
+
init_args();
|
|
1447
|
+
|
|
911
1448
|
// ../kit/src/argv.ts
|
|
912
1449
|
import { readFileSync as readFileSync3, realpathSync } from "fs";
|
|
913
1450
|
import { resolve as resolve3 } from "path";
|
|
@@ -933,6 +1470,10 @@ function scriptArgs(argv = process11.argv.slice(2), cmdline = commandLine(), scr
|
|
|
933
1470
|
return after[0] === "--" && after.length === argv.length + 1 && argv.every((word, index) => word === after[index + 1]) ? after : argv;
|
|
934
1471
|
}
|
|
935
1472
|
// ../kit/src/chart.ts
|
|
1473
|
+
init_format();
|
|
1474
|
+
init_mode();
|
|
1475
|
+
init_style();
|
|
1476
|
+
init_theme();
|
|
936
1477
|
import process12 from "process";
|
|
937
1478
|
var FILLED = "\u2501";
|
|
938
1479
|
var EMPTY = "\u2500";
|
|
@@ -946,15 +1487,22 @@ function bar(ratio, { width = 20, stream = process12.stdout, env = process12.env
|
|
|
946
1487
|
const { theme } = activeTheme();
|
|
947
1488
|
return `${shaded(theme, colors, theme.glyphs.bar, filled, width, env)}${colors.dim(theme.glyphs.bar.repeat(width - filled))}`;
|
|
948
1489
|
}
|
|
1490
|
+
// ../kit/src/ci.ts
|
|
1491
|
+
init_args();
|
|
1492
|
+
init_format();
|
|
1493
|
+
|
|
949
1494
|
// ../kit/src/progress.ts
|
|
1495
|
+
init_format();
|
|
950
1496
|
import process14 from "process";
|
|
951
1497
|
|
|
952
1498
|
// ../kit/src/process.ts
|
|
1499
|
+
import { readFileSync as readFileSync4 } from "fs";
|
|
953
1500
|
import { constants } from "os";
|
|
954
1501
|
import { resolve as resolve4 } from "path";
|
|
955
1502
|
import process13 from "process";
|
|
956
1503
|
var KILL_GRACE_MS = 2000;
|
|
957
1504
|
var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
|
|
1505
|
+
var GROUP_SIGNALS = new Set(["SIGINT", "SIGHUP"]);
|
|
958
1506
|
var SCHEME = /^[a-z][\w+.-]+:/i;
|
|
959
1507
|
var OPENERS = { darwin: ["open"], win32: ["cmd", "/c", "start", ""] };
|
|
960
1508
|
function exitCodeOf(code, signal) {
|
|
@@ -964,6 +1512,21 @@ function exitCodeOf(code, signal) {
|
|
|
964
1512
|
return 128 + signal;
|
|
965
1513
|
return signal === null ? 129 : 128 + constants.signals[signal];
|
|
966
1514
|
}
|
|
1515
|
+
function groupsOf(pid) {
|
|
1516
|
+
try {
|
|
1517
|
+
const stat = readFileSync4(`/proc/${pid}/stat`, "utf8");
|
|
1518
|
+
const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
|
|
1519
|
+
return { group: Number(fields[2]), foreground: Number(fields[5]) };
|
|
1520
|
+
} catch {
|
|
1521
|
+
return;
|
|
1522
|
+
}
|
|
1523
|
+
}
|
|
1524
|
+
function heardTheTerminal(child) {
|
|
1525
|
+
if (child.pid === undefined)
|
|
1526
|
+
return false;
|
|
1527
|
+
const own = groupsOf("self");
|
|
1528
|
+
return own !== undefined && own.group === own.foreground && groupsOf(child.pid)?.group === own.group;
|
|
1529
|
+
}
|
|
967
1530
|
function holdSignals(cleanup) {
|
|
968
1531
|
let received;
|
|
969
1532
|
let child;
|
|
@@ -982,7 +1545,8 @@ function holdSignals(cleanup) {
|
|
|
982
1545
|
function onSignal(signal) {
|
|
983
1546
|
received = signal;
|
|
984
1547
|
if (child !== undefined) {
|
|
985
|
-
|
|
1548
|
+
if (!GROUP_SIGNALS.has(signal) || !heardTheTerminal(child))
|
|
1549
|
+
child.kill(signal);
|
|
986
1550
|
return;
|
|
987
1551
|
}
|
|
988
1552
|
if (cleanup === undefined)
|
|
@@ -1021,10 +1585,10 @@ async function pipeInto(argv, text) {
|
|
|
1021
1585
|
return false;
|
|
1022
1586
|
}
|
|
1023
1587
|
}
|
|
1024
|
-
async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
|
|
1588
|
+
async function runCommand(argv, { cwd, env, stdin = "ignore", input, timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
|
|
1025
1589
|
const chunks = [];
|
|
1026
1590
|
const grouped = timeoutMs !== undefined || signal !== undefined || onStart !== undefined || onChunk !== undefined;
|
|
1027
|
-
const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe", ...grouped ? { detached: true } : {} });
|
|
1591
|
+
const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin: input === undefined ? stdin : new TextEncoder().encode(input), stdout: "pipe", stderr: "pipe", ...grouped ? { detached: true } : {} });
|
|
1028
1592
|
const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
|
|
1029
1593
|
const timers = [];
|
|
1030
1594
|
const killGroup = (killing) => {
|
|
@@ -1064,12 +1628,19 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
1064
1628
|
stop();
|
|
1065
1629
|
continue;
|
|
1066
1630
|
}
|
|
1631
|
+
if (state.truncated)
|
|
1632
|
+
continue;
|
|
1633
|
+
let kept = data;
|
|
1067
1634
|
if (state.kept + data.length > maxBytes) {
|
|
1635
|
+
let cut = maxBytes - state.kept;
|
|
1636
|
+
while (cut > 0 && ((data[cut] ?? 0) & 192) === 128)
|
|
1637
|
+
cut--;
|
|
1638
|
+
kept = data.subarray(0, cut);
|
|
1068
1639
|
state.truncated = true;
|
|
1069
|
-
continue;
|
|
1070
1640
|
}
|
|
1071
|
-
state.kept +=
|
|
1072
|
-
|
|
1641
|
+
state.kept += kept.length;
|
|
1642
|
+
if (kept.length > 0)
|
|
1643
|
+
chunks.push({ stream: name, data: kept });
|
|
1073
1644
|
}
|
|
1074
1645
|
};
|
|
1075
1646
|
try {
|
|
@@ -1086,6 +1657,7 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
1086
1657
|
const joined = () => Buffer.concat(chunks.map(({ data }) => data));
|
|
1087
1658
|
let output;
|
|
1088
1659
|
let text;
|
|
1660
|
+
let stdout;
|
|
1089
1661
|
return {
|
|
1090
1662
|
code: exitCodeOf(proc.exitCode, proc.signalCode),
|
|
1091
1663
|
chunks,
|
|
@@ -1096,11 +1668,16 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
|
|
|
1096
1668
|
},
|
|
1097
1669
|
get text() {
|
|
1098
1670
|
return text ??= (output ??= joined()).toString();
|
|
1671
|
+
},
|
|
1672
|
+
get stdout() {
|
|
1673
|
+
return stdout ??= Buffer.concat(chunks.filter((chunk) => chunk.stream === "stdout").map((chunk) => chunk.data)).toString();
|
|
1099
1674
|
}
|
|
1100
1675
|
};
|
|
1101
1676
|
}
|
|
1102
1677
|
|
|
1103
1678
|
// ../kit/src/progress.ts
|
|
1679
|
+
init_style();
|
|
1680
|
+
init_theme();
|
|
1104
1681
|
var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
|
|
1105
1682
|
var FRAME_MS = 200;
|
|
1106
1683
|
var CLEAR_BELOW = "\r\x1B[J";
|
|
@@ -1117,10 +1694,14 @@ function liveRegion(render, stream = process14.stderr, env = process14.env) {
|
|
|
1117
1694
|
}, print: (text) => void stream.write(`${text}
|
|
1118
1695
|
`), stop: () => {
|
|
1119
1696
|
return;
|
|
1697
|
+
}, pause: () => () => {
|
|
1698
|
+
return;
|
|
1120
1699
|
} };
|
|
1121
1700
|
const write = stream.write.bind(stream);
|
|
1122
1701
|
let frame = 0;
|
|
1123
1702
|
let drawn = false;
|
|
1703
|
+
let paused = false;
|
|
1704
|
+
let stopped = false;
|
|
1124
1705
|
const columns = () => {
|
|
1125
1706
|
const now = stream.getWindowSize?.()[0] ?? stream.columns;
|
|
1126
1707
|
return now === undefined || now === 0 ? 80 : now;
|
|
@@ -1131,6 +1712,8 @@ function liveRegion(render, stream = process14.stderr, env = process14.env) {
|
|
|
1131
1712
|
drawn = false;
|
|
1132
1713
|
};
|
|
1133
1714
|
const draw = () => {
|
|
1715
|
+
if (paused)
|
|
1716
|
+
return;
|
|
1134
1717
|
const width = columns() - 1;
|
|
1135
1718
|
const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
|
|
1136
1719
|
const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
|
|
@@ -1142,16 +1725,17 @@ function liveRegion(render, stream = process14.stderr, env = process14.env) {
|
|
|
1142
1725
|
`)}${lines.length > 1 ? `\x1B[${lines.length - 1}A` : ""}\r`);
|
|
1143
1726
|
drawn = true;
|
|
1144
1727
|
};
|
|
1145
|
-
|
|
1728
|
+
let timer = setInterval(draw, FRAME_MS);
|
|
1146
1729
|
stream.on?.("resize", draw);
|
|
1147
|
-
|
|
1148
|
-
|
|
1730
|
+
let restore = interceptOutput(clear);
|
|
1731
|
+
let release = swallowInput();
|
|
1149
1732
|
const onExit = () => {
|
|
1150
1733
|
clear();
|
|
1151
1734
|
release();
|
|
1152
1735
|
};
|
|
1153
1736
|
const signals = holdSignals(stop);
|
|
1154
1737
|
function stop() {
|
|
1738
|
+
stopped = true;
|
|
1155
1739
|
clearInterval(timer);
|
|
1156
1740
|
stream.off?.("resize", draw);
|
|
1157
1741
|
clear();
|
|
@@ -1160,6 +1744,29 @@ function liveRegion(render, stream = process14.stderr, env = process14.env) {
|
|
|
1160
1744
|
process14.off("exit", onExit);
|
|
1161
1745
|
signals.release();
|
|
1162
1746
|
}
|
|
1747
|
+
function pause() {
|
|
1748
|
+
if (paused || stopped)
|
|
1749
|
+
return () => {
|
|
1750
|
+
return;
|
|
1751
|
+
};
|
|
1752
|
+
paused = true;
|
|
1753
|
+
clearInterval(timer);
|
|
1754
|
+
stream.off?.("resize", draw);
|
|
1755
|
+
clear();
|
|
1756
|
+
restore();
|
|
1757
|
+
release();
|
|
1758
|
+
return () => {
|
|
1759
|
+
if (!paused || stopped)
|
|
1760
|
+
return;
|
|
1761
|
+
paused = false;
|
|
1762
|
+
timer = setInterval(draw, FRAME_MS);
|
|
1763
|
+
timer.unref();
|
|
1764
|
+
stream.on?.("resize", draw);
|
|
1765
|
+
restore = interceptOutput(clear);
|
|
1766
|
+
release = swallowInput();
|
|
1767
|
+
draw();
|
|
1768
|
+
};
|
|
1769
|
+
}
|
|
1163
1770
|
timer.unref();
|
|
1164
1771
|
process14.on("exit", onExit);
|
|
1165
1772
|
return {
|
|
@@ -1170,7 +1777,8 @@ function liveRegion(render, stream = process14.stderr, env = process14.env) {
|
|
|
1170
1777
|
`);
|
|
1171
1778
|
draw();
|
|
1172
1779
|
},
|
|
1173
|
-
stop
|
|
1780
|
+
stop,
|
|
1781
|
+
pause
|
|
1174
1782
|
};
|
|
1175
1783
|
}
|
|
1176
1784
|
function cutToWidth(line, width) {
|
|
@@ -1241,7 +1849,11 @@ function interceptOutput(clear) {
|
|
|
1241
1849
|
};
|
|
1242
1850
|
}
|
|
1243
1851
|
|
|
1852
|
+
// ../kit/src/ci.ts
|
|
1853
|
+
init_style();
|
|
1854
|
+
|
|
1244
1855
|
// ../kit/src/tool.ts
|
|
1856
|
+
init_format();
|
|
1245
1857
|
import process15 from "process";
|
|
1246
1858
|
var PERMANENT = /\bHTTP (?:401|403|404)\b|unauthorized|forbidden|not found|couldn't be found|token is required/i;
|
|
1247
1859
|
function cwdGone() {
|
|
@@ -1270,10 +1882,10 @@ function isPermanentFailure(error) {
|
|
|
1270
1882
|
return false;
|
|
1271
1883
|
return error instanceof SpawnError && error.missing || PERMANENT.test(error.message);
|
|
1272
1884
|
}
|
|
1273
|
-
async function runTool(label, argv, { timeoutMs, cwd, onStart } = {}) {
|
|
1885
|
+
async function runTool(label, argv, { timeoutMs, cwd, onStart, env } = {}) {
|
|
1274
1886
|
let ran;
|
|
1275
1887
|
try {
|
|
1276
|
-
ran = await runCommand(argv, { env: process15.env, ...timeoutMs === undefined ? {} : { timeoutMs }, ...cwd === undefined ? {} : { cwd }, ...onStart === undefined ? {} : { onStart } });
|
|
1888
|
+
ran = await runCommand(argv, { env: { ...process15.env, ...env }, ...timeoutMs === undefined ? {} : { timeoutMs }, ...cwd === undefined ? {} : { cwd }, ...onStart === undefined ? {} : { onStart } });
|
|
1277
1889
|
} catch (error) {
|
|
1278
1890
|
throw spawnFailure(label, error);
|
|
1279
1891
|
}
|
|
@@ -1365,9 +1977,120 @@ function ciHeader(spinner, label, startedAt, out) {
|
|
|
1365
1977
|
return `${spinner} ${label} ${paint(out).dim(formatElapsed(Date.now() - startedAt))}`;
|
|
1366
1978
|
}
|
|
1367
1979
|
// ../kit/src/cli.ts
|
|
1368
|
-
|
|
1369
|
-
import {
|
|
1370
|
-
import
|
|
1980
|
+
init_args();
|
|
1981
|
+
import { readFileSync as readFileSync6, realpathSync as realpathSync2 } from "fs";
|
|
1982
|
+
import { dirname as dirname4, join as join8 } from "path";
|
|
1983
|
+
import process22 from "process";
|
|
1984
|
+
|
|
1985
|
+
// ../kit/src/askpass.ts
|
|
1986
|
+
import { chmodSync, mkdtempSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
|
|
1987
|
+
import { tmpdir } from "os";
|
|
1988
|
+
import { join as join6 } from "path";
|
|
1989
|
+
import process19 from "process";
|
|
1990
|
+
var SOCKET_VARIABLE = "KAYNOOO_ASKPASS_SOCKET";
|
|
1991
|
+
var ECHOED = /username|yes\/no/i;
|
|
1992
|
+
var quoted = (text) => `'${text.replaceAll("'", `'\\''`)}'`;
|
|
1993
|
+
function askpass(pause = () => () => {
|
|
1994
|
+
return;
|
|
1995
|
+
}) {
|
|
1996
|
+
if (process19.stdin.isTTY !== true || process19.stderr.isTTY !== true || process19.argv[1] === undefined)
|
|
1997
|
+
return;
|
|
1998
|
+
const dir = mkdtempSync(join6(tmpdir(), "kaynooo-askpass-"));
|
|
1999
|
+
const socketPath = join6(dir, "socket");
|
|
2000
|
+
const script = join6(dir, "askpass");
|
|
2001
|
+
let turn = Promise.resolve();
|
|
2002
|
+
const answer = async ({ prompt, notice }) => {
|
|
2003
|
+
const resume = pause();
|
|
2004
|
+
try {
|
|
2005
|
+
if (notice === true) {
|
|
2006
|
+
process19.stderr.write(`${prompt.trim()}
|
|
2007
|
+
`);
|
|
2008
|
+
return {};
|
|
2009
|
+
}
|
|
2010
|
+
await Promise.resolve().then(() => init_prompt());
|
|
2011
|
+
return { answer: await input2(prompt.trim(), { mask: !ECHOED.test(prompt) }) };
|
|
2012
|
+
} finally {
|
|
2013
|
+
resume();
|
|
2014
|
+
}
|
|
2015
|
+
};
|
|
2016
|
+
const respond = async (socket, request) => {
|
|
2017
|
+
const { promise, resolve } = Promise.withResolvers();
|
|
2018
|
+
const previous = turn;
|
|
2019
|
+
let reply = {};
|
|
2020
|
+
turn = promise;
|
|
2021
|
+
await previous;
|
|
2022
|
+
try {
|
|
2023
|
+
reply = await answer(request);
|
|
2024
|
+
} catch {} finally {
|
|
2025
|
+
socket.end(`${JSON.stringify(reply)}
|
|
2026
|
+
`);
|
|
2027
|
+
resolve();
|
|
2028
|
+
}
|
|
2029
|
+
};
|
|
2030
|
+
const server = Bun.listen({
|
|
2031
|
+
unix: socketPath,
|
|
2032
|
+
socket: {
|
|
2033
|
+
open: (socket) => {
|
|
2034
|
+
socket.data = { buffered: "" };
|
|
2035
|
+
},
|
|
2036
|
+
data: (socket, chunk) => {
|
|
2037
|
+
const before = socket.data.buffered;
|
|
2038
|
+
socket.data.buffered += chunk.toString();
|
|
2039
|
+
if (before.includes(`
|
|
2040
|
+
`) || !socket.data.buffered.includes(`
|
|
2041
|
+
`))
|
|
2042
|
+
return;
|
|
2043
|
+
respond(socket, JSON.parse(socket.data.buffered));
|
|
2044
|
+
}
|
|
2045
|
+
}
|
|
2046
|
+
});
|
|
2047
|
+
writeFileSync2(script, `#!/bin/sh
|
|
2048
|
+
${SOCKET_VARIABLE}=${quoted(socketPath)} exec ${quoted(process19.execPath)} --no-env-file --config=/dev/null ${quoted(process19.argv[1])} "$@"
|
|
2049
|
+
`);
|
|
2050
|
+
chmodSync(script, 448);
|
|
2051
|
+
return {
|
|
2052
|
+
env: { GIT_ASKPASS: script, SSH_ASKPASS: script, SSH_ASKPASS_REQUIRE: "force" },
|
|
2053
|
+
close: () => {
|
|
2054
|
+
server.stop(true);
|
|
2055
|
+
rmSync(dir, { recursive: true, force: true });
|
|
2056
|
+
}
|
|
2057
|
+
};
|
|
2058
|
+
}
|
|
2059
|
+
async function askpassClient(argv) {
|
|
2060
|
+
const socketPath = process19.env[SOCKET_VARIABLE];
|
|
2061
|
+
if (socketPath === undefined)
|
|
2062
|
+
return;
|
|
2063
|
+
const request = { prompt: argv[0] ?? "", ...process19.env.SSH_ASKPASS_PROMPT === "none" ? { notice: true } : {} };
|
|
2064
|
+
const { promise, resolve } = Promise.withResolvers();
|
|
2065
|
+
let received = "";
|
|
2066
|
+
try {
|
|
2067
|
+
await Bun.connect({
|
|
2068
|
+
unix: socketPath,
|
|
2069
|
+
socket: {
|
|
2070
|
+
open: (socket) => void socket.write(`${JSON.stringify(request)}
|
|
2071
|
+
`),
|
|
2072
|
+
data: (_, chunk) => {
|
|
2073
|
+
received += chunk.toString();
|
|
2074
|
+
},
|
|
2075
|
+
close: () => resolve(received),
|
|
2076
|
+
error: () => resolve("")
|
|
2077
|
+
}
|
|
2078
|
+
});
|
|
2079
|
+
} catch {
|
|
2080
|
+
return 1;
|
|
2081
|
+
}
|
|
2082
|
+
const reply = await promise;
|
|
2083
|
+
if (reply === "")
|
|
2084
|
+
return 1;
|
|
2085
|
+
const { answer } = JSON.parse(reply);
|
|
2086
|
+
if (request.notice === true)
|
|
2087
|
+
return 0;
|
|
2088
|
+
if (answer === undefined)
|
|
2089
|
+
return 1;
|
|
2090
|
+
process19.stdout.write(`${answer}
|
|
2091
|
+
`);
|
|
2092
|
+
return 0;
|
|
2093
|
+
}
|
|
1371
2094
|
|
|
1372
2095
|
// ../kit/src/completions.ts
|
|
1373
2096
|
var COMPLETION_SHELLS = ["fish", "bash", "zsh"];
|
|
@@ -1430,34 +2153,42 @@ compdef __kaynooo_cli_complete ${bins.join(" ")}
|
|
|
1430
2153
|
}
|
|
1431
2154
|
|
|
1432
2155
|
// ../kit/src/notify.ts
|
|
1433
|
-
|
|
2156
|
+
init_format();
|
|
2157
|
+
init_mode();
|
|
2158
|
+
import process20 from "process";
|
|
1434
2159
|
var NOTIFY_AFTER_MS = 1e4;
|
|
1435
2160
|
var CANCELLED = 130;
|
|
1436
2161
|
function base64(text) {
|
|
1437
2162
|
return Buffer.from(text).toString("base64");
|
|
1438
2163
|
}
|
|
1439
|
-
function notification(title, body, env =
|
|
1440
|
-
const id = `kit${
|
|
2164
|
+
function notification(title, body, env = process20.env) {
|
|
2165
|
+
const id = `kit${process20.pid}`;
|
|
1441
2166
|
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\\`];
|
|
1442
2167
|
return codes.map((code) => env.TMUX === undefined || env.TMUX === "" ? code : `\x1BPtmux;${code.replaceAll("\x1B", "\x1B\x1B")}\x1B\\`).join("");
|
|
1443
2168
|
}
|
|
1444
|
-
function notifyEnd(command, code, ms, { stream =
|
|
2169
|
+
function notifyEnd(command, code, ms, { stream = process20.stderr, env = process20.env } = {}) {
|
|
1445
2170
|
if (ms < NOTIFY_AFTER_MS || code === CANCELLED || outputMode(stream, env) !== "terminal")
|
|
1446
2171
|
return;
|
|
1447
2172
|
stream.write(notification(command, code === 0 ? `done in ${formatDuration(ms)}` : `failed with exit ${code} after ${formatDuration(ms)}`, env));
|
|
1448
2173
|
}
|
|
1449
2174
|
|
|
2175
|
+
// ../kit/src/cli.ts
|
|
2176
|
+
init_style();
|
|
2177
|
+
init_text2();
|
|
2178
|
+
|
|
1450
2179
|
// ../kit/src/usage.ts
|
|
1451
|
-
import { appendFileSync, mkdirSync } from "fs";
|
|
1452
|
-
import { homedir as
|
|
1453
|
-
import { dirname as
|
|
1454
|
-
import
|
|
2180
|
+
import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
|
|
2181
|
+
import { homedir as homedir4 } from "os";
|
|
2182
|
+
import { dirname as dirname3, join as join7 } from "path";
|
|
2183
|
+
import process21 from "process";
|
|
1455
2184
|
|
|
1456
2185
|
// ../kit/src/logs.ts
|
|
2186
|
+
init_user_config();
|
|
1457
2187
|
var DAY_MS = 24 * 60 * 60 * 1000;
|
|
1458
2188
|
var CLI_FOLDER = "kaynooo-cli";
|
|
1459
2189
|
|
|
1460
2190
|
// ../kit/src/usage.ts
|
|
2191
|
+
init_user_config();
|
|
1461
2192
|
var UNKNOWN_OPTION2 = /unknown option '(--[a-z][a-z0-9-]*)[=']/;
|
|
1462
2193
|
var FLAG_NAME = /^(?:--[a-z][a-z0-9-]*|-[a-zA-Z])$/;
|
|
1463
2194
|
var LONGEST_NAME = 40;
|
|
@@ -1465,14 +2196,13 @@ var usageError;
|
|
|
1465
2196
|
function noteUsageError(message) {
|
|
1466
2197
|
usageError = message;
|
|
1467
2198
|
}
|
|
1468
|
-
function stateHome(env =
|
|
1469
|
-
|
|
1470
|
-
return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
|
|
2199
|
+
function stateHome(env = process21.env) {
|
|
2200
|
+
return xdgFolder(env.XDG_STATE_HOME, join7(homedir4(), ".local", "state"));
|
|
1471
2201
|
}
|
|
1472
|
-
function usagePath(env =
|
|
1473
|
-
return
|
|
2202
|
+
function usagePath(env = process21.env) {
|
|
2203
|
+
return join7(stateHome(env), CLI_FOLDER, "usage.jsonl");
|
|
1474
2204
|
}
|
|
1475
|
-
function usageRecorded(env =
|
|
2205
|
+
function usageRecorded(env = process21.env) {
|
|
1476
2206
|
const off = env.KAYNOOO_CLI_NO_USAGE;
|
|
1477
2207
|
return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
|
|
1478
2208
|
}
|
|
@@ -1481,17 +2211,17 @@ function flagNames(argv) {
|
|
|
1481
2211
|
const names = (end === -1 ? argv : argv.slice(0, end)).filter((word) => word.startsWith("-") && word !== "-").map((word) => word.includes("=") ? word.slice(0, word.indexOf("=")) : word);
|
|
1482
2212
|
return [...new Set(names)].filter((name) => name.length <= LONGEST_NAME && FLAG_NAME.test(name));
|
|
1483
2213
|
}
|
|
1484
|
-
function usageEntry(bin, command, argv, code, now = new Date) {
|
|
2214
|
+
function usageEntry(bin, command, argv, code, { ms, now = new Date } = {}) {
|
|
1485
2215
|
const unknown = code === 2 && usageError !== undefined ? UNKNOWN_OPTION2.exec(usageError)?.[1] : undefined;
|
|
1486
2216
|
usageError = undefined;
|
|
1487
|
-
return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
|
|
2217
|
+
return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown }, ...ms === undefined ? {} : { ms: Math.round(ms) } };
|
|
1488
2218
|
}
|
|
1489
|
-
function recordUsage(entry, env =
|
|
2219
|
+
function recordUsage(entry, env = process21.env) {
|
|
1490
2220
|
if (!usageRecorded(env))
|
|
1491
2221
|
return;
|
|
1492
2222
|
try {
|
|
1493
2223
|
const path = usagePath(env);
|
|
1494
|
-
|
|
2224
|
+
mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
|
|
1495
2225
|
appendFileSync(path, `${JSON.stringify(entry)}
|
|
1496
2226
|
`, { mode: 384 });
|
|
1497
2227
|
} catch {}
|
|
@@ -1541,6 +2271,10 @@ function takeOutputFlags(argv) {
|
|
|
1541
2271
|
async function resolveSummary(summary) {
|
|
1542
2272
|
return typeof summary === "string" ? summary : summary();
|
|
1543
2273
|
}
|
|
2274
|
+
function lookup({ commands, aliases }, word) {
|
|
2275
|
+
const name = aliases !== undefined && Object.hasOwn(aliases, word) ? aliases[word] ?? word : word;
|
|
2276
|
+
return Object.hasOwn(commands, name) ? commands[name] : undefined;
|
|
2277
|
+
}
|
|
1544
2278
|
function scopeOf(commands, extra, aliases) {
|
|
1545
2279
|
return { commands: typeof commands === "function" ? {} : commands, lazy: [...typeof commands === "function" ? [commands] : [], ...extra === undefined ? [] : [extra]], aliases };
|
|
1546
2280
|
}
|
|
@@ -1580,8 +2314,8 @@ async function help2({ path, header, summary: lazySummary, commands, defaultComm
|
|
|
1580
2314
|
`);
|
|
1581
2315
|
}
|
|
1582
2316
|
function printError(prefix, message, hint, cause) {
|
|
1583
|
-
const colors = paint(
|
|
1584
|
-
const styled = takesControlCodes(
|
|
2317
|
+
const colors = paint(process22.stderr);
|
|
2318
|
+
const styled = takesControlCodes(process22.stderr);
|
|
1585
2319
|
const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
|
|
1586
2320
|
const under = (label, text, tint) => text === undefined ? "" : `
|
|
1587
2321
|
${styled ? tint(label) : `${label}:`} ${text}`;
|
|
@@ -1591,8 +2325,8 @@ function runHint(command, effect) {
|
|
|
1591
2325
|
return `run \`${command}\`${effect === undefined ? "" : ` to ${effect}`}`;
|
|
1592
2326
|
}
|
|
1593
2327
|
function printHint(hint) {
|
|
1594
|
-
const colors = paint(
|
|
1595
|
-
console.error(` ${takesControlCodes(
|
|
2328
|
+
const colors = paint(process22.stderr);
|
|
2329
|
+
console.error(` ${takesControlCodes(process22.stderr) ? colors.yellow("hint") : "hint:"} ${hint}`);
|
|
1596
2330
|
}
|
|
1597
2331
|
function printJsonError(message, hint, cause) {
|
|
1598
2332
|
console.error(JSON.stringify({ error: message, ...hint === undefined ? {} : { hint }, ...cause === undefined ? {} : { cause } }));
|
|
@@ -1631,23 +2365,23 @@ async function dispatch(level, typed, { version, redact }) {
|
|
|
1631
2365
|
}
|
|
1632
2366
|
}
|
|
1633
2367
|
if (name === undefined && level.path.length > 1) {
|
|
1634
|
-
console.error(await help2(await expand(level, [...level.path.slice(1), ...argv]),
|
|
2368
|
+
console.error(await help2(await expand(level, [...level.path.slice(1), ...argv]), process22.stderr));
|
|
1635
2369
|
return 2;
|
|
1636
2370
|
}
|
|
1637
2371
|
if (name === undefined || name === "help" || name === "--help" || name === "-h") {
|
|
1638
|
-
console.log(await help2(await expand(level, [...level.path.slice(1), ...argv]),
|
|
2372
|
+
console.log(await help2(await expand(level, [...level.path.slice(1), ...argv]), process22.stdout));
|
|
1639
2373
|
return 0;
|
|
1640
2374
|
}
|
|
1641
2375
|
if (level.path.length === 1 && (name === "--version" || name === "-v")) {
|
|
1642
2376
|
console.log(version);
|
|
1643
2377
|
return 0;
|
|
1644
2378
|
}
|
|
1645
|
-
let command = level
|
|
2379
|
+
let command = lookup(level, name);
|
|
1646
2380
|
let rest = args;
|
|
1647
2381
|
let ran = name;
|
|
1648
2382
|
if (command === undefined && level.lazy.length > 0) {
|
|
1649
2383
|
level = await expand(level, [...level.path.slice(1), ...argv]);
|
|
1650
|
-
command = level
|
|
2384
|
+
command = lookup(level, name);
|
|
1651
2385
|
}
|
|
1652
2386
|
if (command === undefined && level.defaultCommand !== undefined) {
|
|
1653
2387
|
command = level.commands[level.defaultCommand];
|
|
@@ -1727,18 +2461,19 @@ async function leafCandidates(run, words) {
|
|
|
1727
2461
|
async function candidates(scope, defaultCommand, words, before = []) {
|
|
1728
2462
|
const [word = "", ...rest] = words;
|
|
1729
2463
|
const listing = rest.length === 0 && !word.startsWith("-");
|
|
1730
|
-
let { commands
|
|
1731
|
-
let command =
|
|
2464
|
+
let { commands } = scope;
|
|
2465
|
+
let command = lookup(scope, word);
|
|
1732
2466
|
if (listing || command === undefined) {
|
|
1733
|
-
|
|
1734
|
-
|
|
2467
|
+
const expanded = await expand(scope, [...before, ...words]);
|
|
2468
|
+
commands = expanded.commands;
|
|
2469
|
+
command = lookup(expanded, word);
|
|
1735
2470
|
}
|
|
1736
2471
|
if (listing) {
|
|
1737
2472
|
const own = await Promise.all(Object.entries(shown(commands)).map(async ([name, { summary }]) => `${name} ${await resolveSummary(summary)}`));
|
|
1738
2473
|
const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
|
|
1739
2474
|
const values = fallback !== undefined && "run" in fallback ? await leafCandidates(fallback.run, [word]) : [];
|
|
1740
2475
|
const valueOf = (line) => line.slice(0, line.includes("\t") ? line.indexOf("\t") : undefined);
|
|
1741
|
-
return [...own, ...values.filter((line) => line !== FILES && !(valueOf(line)
|
|
2476
|
+
return [...own, ...values.filter((line) => line !== FILES && !Object.hasOwn(commands, valueOf(line)))];
|
|
1742
2477
|
}
|
|
1743
2478
|
if (command === undefined) {
|
|
1744
2479
|
const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
|
|
@@ -1769,18 +2504,21 @@ function packageVersion(entry = Bun.main) {
|
|
|
1769
2504
|
try {
|
|
1770
2505
|
resolved = realpathSync2(entry);
|
|
1771
2506
|
} catch {}
|
|
1772
|
-
for (let dir =
|
|
2507
|
+
for (let dir = dirname4(resolved);; dir = dirname4(dir)) {
|
|
1773
2508
|
try {
|
|
1774
|
-
const { version } = JSON.parse(
|
|
2509
|
+
const { version } = JSON.parse(readFileSync6(join8(dir, "package.json"), "utf8"));
|
|
1775
2510
|
if (typeof version === "string")
|
|
1776
2511
|
return version;
|
|
1777
2512
|
} catch {}
|
|
1778
|
-
if (
|
|
2513
|
+
if (dirname4(dir) === dir)
|
|
1779
2514
|
return "0.0.0";
|
|
1780
2515
|
}
|
|
1781
2516
|
}
|
|
1782
2517
|
async function runCli(cli, argv = scriptArgs()) {
|
|
1783
2518
|
const version = cli.version ?? packageVersion();
|
|
2519
|
+
const answered = await askpassClient(argv);
|
|
2520
|
+
if (answered !== undefined)
|
|
2521
|
+
return answered;
|
|
1784
2522
|
if (argv[0] === COMPLETE)
|
|
1785
2523
|
return printCandidates(candidates(scopeOf(cli.commands, cli.extraCommands, cli.aliases), cli.defaultCommand, argv.slice(1)));
|
|
1786
2524
|
if (argv[0] === COMPLETIONS || argv[0]?.startsWith(`${COMPLETIONS}=`) === true)
|
|
@@ -1791,7 +2529,7 @@ async function runCli(cli, argv = scriptArgs()) {
|
|
|
1791
2529
|
notifyEnd(command === undefined ? cli.name : `${cli.name} ${command}`, code, performance.now() - started);
|
|
1792
2530
|
if (cli.usage !== false) {
|
|
1793
2531
|
try {
|
|
1794
|
-
recordUsage(usageEntry(cli.name, command, argv, code));
|
|
2532
|
+
recordUsage(usageEntry(cli.name, command, argv, code, { ms: performance.now() - started }));
|
|
1795
2533
|
} catch {}
|
|
1796
2534
|
}
|
|
1797
2535
|
return code;
|
|
@@ -1800,8 +2538,7 @@ function commandPath(scope, argv) {
|
|
|
1800
2538
|
const path = [];
|
|
1801
2539
|
let level = scope;
|
|
1802
2540
|
for (const word of argv.filter((each) => !each.startsWith("-"))) {
|
|
1803
|
-
const
|
|
1804
|
-
const command = Object.hasOwn(level.commands, name) ? level.commands[name] : undefined;
|
|
2541
|
+
const command = lookup(level, word);
|
|
1805
2542
|
if (command === undefined)
|
|
1806
2543
|
break;
|
|
1807
2544
|
path.push(word);
|
|
@@ -1811,7 +2548,12 @@ function commandPath(scope, argv) {
|
|
|
1811
2548
|
}
|
|
1812
2549
|
return path.length === 0 ? undefined : path.join(" ");
|
|
1813
2550
|
}
|
|
2551
|
+
|
|
2552
|
+
// ../kit/src/index.ts
|
|
2553
|
+
init_config();
|
|
2554
|
+
|
|
1814
2555
|
// ../kit/src/excerpt.ts
|
|
2556
|
+
init_text2();
|
|
1815
2557
|
var BUN_CHECK_BLOCK = /<error file=[\s\S]*?<\/error>/g;
|
|
1816
2558
|
var BUN_CHECK_SOURCE = /<source>[\s\S]*?<\/source>\n?/g;
|
|
1817
2559
|
var BUN_CHECK_ATTRIBUTE = /(\w+)="([^"]*)"/g;
|
|
@@ -1918,7 +2660,7 @@ function squeeze(lines) {
|
|
|
1918
2660
|
out.pop();
|
|
1919
2661
|
return out;
|
|
1920
2662
|
}
|
|
1921
|
-
function
|
|
2663
|
+
function cut2(shown) {
|
|
1922
2664
|
return shown.length > MAX_LINES ? [...shown.slice(0, MAX_LINES), `... ${shown.length - MAX_LINES} more lines`].join(`
|
|
1923
2665
|
`) : shown.join(`
|
|
1924
2666
|
`);
|
|
@@ -1928,13 +2670,17 @@ function recognised(lines, parsers) {
|
|
|
1928
2670
|
}
|
|
1929
2671
|
function toolExcerpt(lines) {
|
|
1930
2672
|
const found = recognised(lines.map((line) => stripAnsi(line)), TOOL_PARSERS);
|
|
1931
|
-
return found === undefined ? undefined :
|
|
2673
|
+
return found === undefined ? undefined : cut2(squeeze(found));
|
|
1932
2674
|
}
|
|
1933
|
-
|
|
1934
|
-
|
|
2675
|
+
|
|
2676
|
+
// ../kit/src/index.ts
|
|
2677
|
+
init_folders();
|
|
2678
|
+
init_format();
|
|
2679
|
+
|
|
1935
2680
|
// ../kit/src/git.ts
|
|
1936
|
-
|
|
1937
|
-
import
|
|
2681
|
+
init_args();
|
|
2682
|
+
import { basename, dirname as dirname5 } from "path";
|
|
2683
|
+
import process23 from "process";
|
|
1938
2684
|
var ORIGIN_PREFIX = /^origin\//;
|
|
1939
2685
|
var GIT_NETWORK_MS = 60000;
|
|
1940
2686
|
async function git(args, timeoutMs) {
|
|
@@ -1955,7 +2701,15 @@ async function resolveCommit(ref) {
|
|
|
1955
2701
|
async function fetchBranch(branch) {
|
|
1956
2702
|
if (branch.startsWith("-") || !await gitOk(["check-ref-format", "--branch", branch]))
|
|
1957
2703
|
fail(`${branch} is not a branch name`);
|
|
1958
|
-
|
|
2704
|
+
const ref = `refs/heads/${branch}`;
|
|
2705
|
+
const fetched = await runTool("git fetch", ["git", "fetch", "-q", "origin", ref], { timeoutMs: GIT_NETWORK_MS });
|
|
2706
|
+
if (fetched.code === 0)
|
|
2707
|
+
return true;
|
|
2708
|
+
const listed = await runTool("git ls-remote", ["git", "ls-remote", "--exit-code", "origin", ref], { timeoutMs: GIT_NETWORK_MS });
|
|
2709
|
+
if (listed.code !== 2)
|
|
2710
|
+
throw new Error(`git fetch -q origin ${ref}: ${fetched.stderr.trim() || `exit ${fetched.code}`}`);
|
|
2711
|
+
await gitOk(["update-ref", "-d", `refs/remotes/origin/${branch}`]);
|
|
2712
|
+
return false;
|
|
1959
2713
|
}
|
|
1960
2714
|
async function defaultBranch() {
|
|
1961
2715
|
const head = (await runTool("git symbolic-ref", ["git", "symbolic-ref", "--short", "-q", "refs/remotes/origin/HEAD"])).stdout.trim();
|
|
@@ -1964,9 +2718,10 @@ async function defaultBranch() {
|
|
|
1964
2718
|
async function leaveWorktree() {
|
|
1965
2719
|
const common = await git(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
|
|
1966
2720
|
if (basename(common) === ".git")
|
|
1967
|
-
|
|
2721
|
+
process23.chdir(dirname5(common));
|
|
1968
2722
|
}
|
|
1969
2723
|
// ../kit/src/limit.ts
|
|
2724
|
+
init_args();
|
|
1970
2725
|
function limitOptions(fallback) {
|
|
1971
2726
|
return {
|
|
1972
2727
|
limit: { type: "string", short: "n", description: `show at most this many rows, the rest counted (${fallback})` },
|
|
@@ -1987,35 +2742,45 @@ function capped(rows, limit) {
|
|
|
1987
2742
|
const more = rows.length - limit;
|
|
1988
2743
|
return more > 0 ? { shown: rows.slice(0, limit), footer: moreFooter(more) } : { shown: [...rows], footer: undefined };
|
|
1989
2744
|
}
|
|
2745
|
+
|
|
2746
|
+
// ../kit/src/index.ts
|
|
2747
|
+
init_mode();
|
|
2748
|
+
|
|
1990
2749
|
// ../kit/src/pool.ts
|
|
1991
|
-
async function pool(items, limit, task) {
|
|
2750
|
+
async function pool(items, limit, task, onDone) {
|
|
1992
2751
|
const results = Array.from({ length: items.length });
|
|
1993
2752
|
let next = 0;
|
|
2753
|
+
let done = 0;
|
|
1994
2754
|
async function worker() {
|
|
1995
2755
|
while (next < items.length) {
|
|
1996
2756
|
const index = next++;
|
|
1997
2757
|
results[index] = await task(items[index]);
|
|
2758
|
+
onDone?.(++done, items.length);
|
|
1998
2759
|
}
|
|
1999
2760
|
}
|
|
2000
2761
|
await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
|
|
2001
2762
|
return results;
|
|
2002
2763
|
}
|
|
2764
|
+
// ../kit/src/report.ts
|
|
2765
|
+
init_style();
|
|
2766
|
+
init_text2();
|
|
2003
2767
|
// ../kit/src/secrets.ts
|
|
2004
2768
|
var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
|
|
2769
|
+
var NOT_PASSWORDS = new Set(["compass", "encompass", "bypass", "overpass", "underpass", "surpass", "trespass"]);
|
|
2005
2770
|
// ../kit/src/sessions.ts
|
|
2006
|
-
import { homedir as
|
|
2007
|
-
import { join as
|
|
2008
|
-
import
|
|
2771
|
+
import { homedir as homedir5 } from "os";
|
|
2772
|
+
import { join as join9 } from "path";
|
|
2773
|
+
import process24 from "process";
|
|
2009
2774
|
var {Glob } = globalThis.Bun;
|
|
2010
2775
|
var SESSION_FILES = new Glob("*.json");
|
|
2011
2776
|
var ACCOUNT_DIRS = new Glob("*/sessions");
|
|
2012
2777
|
async function sessionDirs() {
|
|
2013
|
-
const home =
|
|
2014
|
-
const dirs = new Set([
|
|
2015
|
-
if (
|
|
2016
|
-
dirs.add(
|
|
2778
|
+
const home = homedir5();
|
|
2779
|
+
const dirs = new Set([join9(home, ".claude", "sessions")]);
|
|
2780
|
+
if (process24.env.CLAUDE_CONFIG_DIR !== undefined)
|
|
2781
|
+
dirs.add(join9(process24.env.CLAUDE_CONFIG_DIR, "sessions"));
|
|
2017
2782
|
try {
|
|
2018
|
-
for await (const dir of ACCOUNT_DIRS.scan({ cwd:
|
|
2783
|
+
for await (const dir of ACCOUNT_DIRS.scan({ cwd: join9(home, ".claude-accounts"), onlyFiles: false, absolute: true }))
|
|
2019
2784
|
dirs.add(dir);
|
|
2020
2785
|
} catch {}
|
|
2021
2786
|
return [...dirs];
|
|
@@ -2059,7 +2824,7 @@ async function liveSessions() {
|
|
|
2059
2824
|
}
|
|
2060
2825
|
async function currentSession(sessions) {
|
|
2061
2826
|
const byPid = new Map(sessions.map((session) => [session.pid, session]));
|
|
2062
|
-
let pid =
|
|
2827
|
+
let pid = process24.ppid;
|
|
2063
2828
|
for (let depth = 0;depth < 32 && pid > 1; depth++) {
|
|
2064
2829
|
const session = byPid.get(pid);
|
|
2065
2830
|
if (session !== undefined)
|
|
@@ -2071,8 +2836,18 @@ async function currentSession(sessions) {
|
|
|
2071
2836
|
}
|
|
2072
2837
|
return;
|
|
2073
2838
|
}
|
|
2839
|
+
|
|
2840
|
+
// ../kit/src/index.ts
|
|
2841
|
+
init_style();
|
|
2842
|
+
init_text2();
|
|
2843
|
+
init_theme();
|
|
2844
|
+
init_user_config();
|
|
2845
|
+
|
|
2074
2846
|
// ../kit/src/watch.ts
|
|
2075
|
-
|
|
2847
|
+
init_args();
|
|
2848
|
+
init_input();
|
|
2849
|
+
init_style();
|
|
2850
|
+
import process25 from "process";
|
|
2076
2851
|
import { format } from "util";
|
|
2077
2852
|
var CLEAR_SCREEN = "\x1B[H\x1B[2J";
|
|
2078
2853
|
var DEFAULT_SECONDS = 2;
|
|
@@ -2094,7 +2869,7 @@ function withoutWatch(args) {
|
|
|
2094
2869
|
}
|
|
2095
2870
|
return rest;
|
|
2096
2871
|
}
|
|
2097
|
-
async function watching(value, step, stream =
|
|
2872
|
+
async function watching(value, step, stream = process25.stdout, sleep = Bun.sleep, rounds = Number.POSITIVE_INFINITY) {
|
|
2098
2873
|
const interval = value === "" ? DEFAULT_SECONDS * 1000 : duration(value, "watch", DEFAULT_SECONDS * 1000);
|
|
2099
2874
|
if (!takesControlCodes(stream))
|
|
2100
2875
|
badUsage("--watch redraws the screen, so it needs a terminal");
|
|
@@ -2102,12 +2877,12 @@ async function watching(value, step, stream = process21.stdout, sleep = Bun.slee
|
|
|
2102
2877
|
for (let round = 0;round < rounds; round++) {
|
|
2103
2878
|
const held = [];
|
|
2104
2879
|
const { log, info } = console;
|
|
2105
|
-
const write =
|
|
2880
|
+
const write = process25.stdout.write.bind(process25.stdout);
|
|
2106
2881
|
const hold = (...parts) => void held.push(`${format(...parts)}
|
|
2107
2882
|
`);
|
|
2108
2883
|
console.log = hold;
|
|
2109
2884
|
console.info = hold;
|
|
2110
|
-
|
|
2885
|
+
process25.stdout.write = (text) => {
|
|
2111
2886
|
held.push(typeof text === "string" ? text : Buffer.from(text).toString());
|
|
2112
2887
|
return true;
|
|
2113
2888
|
};
|
|
@@ -2116,13 +2891,15 @@ async function watching(value, step, stream = process21.stdout, sleep = Bun.slee
|
|
|
2116
2891
|
} finally {
|
|
2117
2892
|
console.log = log;
|
|
2118
2893
|
console.info = info;
|
|
2119
|
-
|
|
2894
|
+
process25.stdout.write = write;
|
|
2120
2895
|
}
|
|
2121
2896
|
stream.write(`${CLEAR_SCREEN}${held.join("")}`);
|
|
2122
2897
|
await sleep(interval);
|
|
2123
2898
|
}
|
|
2124
2899
|
return code;
|
|
2125
2900
|
}
|
|
2901
|
+
// ../kit/src/workspace-root.ts
|
|
2902
|
+
init_user_config();
|
|
2126
2903
|
// src/args.ts
|
|
2127
2904
|
var repoOption = {
|
|
2128
2905
|
repo: { type: "string", short: "r", description: "owner/name of the repository, instead of the one origin points at" }
|
|
@@ -2144,7 +2921,7 @@ function issueNumbers(values, usage) {
|
|
|
2144
2921
|
|
|
2145
2922
|
// src/checklist.ts
|
|
2146
2923
|
var BOX = /^(\s*[-*+] \[)([ x])(\]\s)(.*?)\r?$/is;
|
|
2147
|
-
var FENCE = /^\s*(`{3,}|~{3,})/;
|
|
2924
|
+
var FENCE = /^\s*(`{3,}(?!.*`)|~{3,})/;
|
|
2148
2925
|
var LIST_ITEM = /^\s*(?:[-*+]|\d+[.)])\s/;
|
|
2149
2926
|
var INDENT_CODE = /^(?: {4}|\t)/;
|
|
2150
2927
|
function boxes(body) {
|
|
@@ -2175,23 +2952,48 @@ function boxes(body) {
|
|
|
2175
2952
|
return found;
|
|
2176
2953
|
}
|
|
2177
2954
|
var INDENT = /^\s*/;
|
|
2955
|
+
var LINE_END = /\r?\n/;
|
|
2956
|
+
var LINE_ENDS = /(\r?\n)/;
|
|
2957
|
+
function indentOf(line) {
|
|
2958
|
+
return INDENT.exec(line)?.[0].length ?? 0;
|
|
2959
|
+
}
|
|
2960
|
+
function lineEnding(body) {
|
|
2961
|
+
return body.includes(`\r
|
|
2962
|
+
`) ? `\r
|
|
2963
|
+
` : `
|
|
2964
|
+
`;
|
|
2965
|
+
}
|
|
2966
|
+
function afterBox(lines, line) {
|
|
2967
|
+
const depth = indentOf(lines[line] ?? "");
|
|
2968
|
+
let end = line + 1;
|
|
2969
|
+
for (let next = line + 1;next < lines.length; next++) {
|
|
2970
|
+
const text = lines[next] ?? "";
|
|
2971
|
+
if (text.trim() === "")
|
|
2972
|
+
continue;
|
|
2973
|
+
if (indentOf(text) <= depth)
|
|
2974
|
+
break;
|
|
2975
|
+
end = next + 1;
|
|
2976
|
+
}
|
|
2977
|
+
return end;
|
|
2978
|
+
}
|
|
2979
|
+
function insertLines(body, at, added) {
|
|
2980
|
+
const eol = lineEnding(body);
|
|
2981
|
+
const parts = body.split(LINE_ENDS);
|
|
2982
|
+
if (2 * at >= parts.length)
|
|
2983
|
+
return `${body}${eol}${added.join(eol)}`;
|
|
2984
|
+
parts.splice(2 * at, 0, added.map((line) => `${line}${eol}`).join(""));
|
|
2985
|
+
return parts.join("");
|
|
2986
|
+
}
|
|
2178
2987
|
function appendBoxes(body, texts) {
|
|
2179
|
-
const
|
|
2180
|
-
`) ? "\r" : "";
|
|
2988
|
+
const eol = lineEnding(body);
|
|
2181
2989
|
const last = boxes(body).at(-1);
|
|
2182
|
-
const lines = body.split(
|
|
2183
|
-
`);
|
|
2990
|
+
const lines = body.split(LINE_END);
|
|
2184
2991
|
const indent = last === undefined ? "" : INDENT.exec(lines[last.line] ?? "")?.[0] ?? "";
|
|
2185
|
-
const added = texts.map((text) => `${indent}- [ ] ${text}
|
|
2992
|
+
const added = texts.map((text) => `${indent}- [ ] ${text}`);
|
|
2186
2993
|
if (last === undefined)
|
|
2187
|
-
return body.trim() === "" ? added.join(`
|
|
2188
|
-
`) :
|
|
2189
|
-
|
|
2190
|
-
${added.join(`
|
|
2191
|
-
`)}`;
|
|
2192
|
-
lines.splice(last.line + 1, 0, ...added);
|
|
2193
|
-
return lines.join(`
|
|
2194
|
-
`);
|
|
2994
|
+
return body.trim() === "" ? added.join(eol) : `${body.trimEnd()}${eol}${eol}${added.join(eol)}${body.endsWith(`
|
|
2995
|
+
`) ? eol : ""}`;
|
|
2996
|
+
return insertLines(body, afterBox(lines, last.line), added);
|
|
2195
2997
|
}
|
|
2196
2998
|
function numberedBody(body) {
|
|
2197
2999
|
const lines = body.replaceAll(`\r
|
|
@@ -2253,8 +3055,10 @@ function tickReferences(body, wanted) {
|
|
|
2253
3055
|
}
|
|
2254
3056
|
|
|
2255
3057
|
// src/claims.ts
|
|
2256
|
-
var TAKEN =
|
|
2257
|
-
var RELEASED =
|
|
3058
|
+
var TAKEN = /^taken by session (.+)$/i;
|
|
3059
|
+
var RELEASED = /^released by session (.+)$/i;
|
|
3060
|
+
var WITHDRAWN = /^withdrawn by session (.+)$/i;
|
|
3061
|
+
var UNCLAIMABLE = /^\s|\s$|[\p{Cc}\u2028\u2029]|[,;:]\s/u;
|
|
2258
3062
|
var LANE = /^lane-([^-]+)-/;
|
|
2259
3063
|
function takenComment(name) {
|
|
2260
3064
|
return `Taken by session ${name}.`;
|
|
@@ -2262,28 +3066,65 @@ function takenComment(name) {
|
|
|
2262
3066
|
function releasedComment(name) {
|
|
2263
3067
|
return `Released by session ${name}.`;
|
|
2264
3068
|
}
|
|
3069
|
+
function withdrawnComment(name) {
|
|
3070
|
+
return `Withdrawn by session ${name}.`;
|
|
3071
|
+
}
|
|
3072
|
+
function claimable(name) {
|
|
3073
|
+
return name !== "" && !UNCLAIMABLE.test(name);
|
|
3074
|
+
}
|
|
3075
|
+
function named(sentence, body) {
|
|
3076
|
+
const name = sentence.exec(body.trim())?.[1];
|
|
3077
|
+
const bare = name?.endsWith(".") === true ? name.slice(0, -1) : name;
|
|
3078
|
+
return bare !== undefined && claimable(bare) ? bare : undefined;
|
|
3079
|
+
}
|
|
2265
3080
|
function isClaimant(comment, author) {
|
|
2266
3081
|
return author === undefined || comment.user === undefined || comment.user.login === author;
|
|
2267
3082
|
}
|
|
2268
|
-
function
|
|
2269
|
-
|
|
2270
|
-
|
|
2271
|
-
|
|
2272
|
-
|
|
2273
|
-
|
|
3083
|
+
function inOrder(comments) {
|
|
3084
|
+
return comments.toSorted((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
|
|
3085
|
+
}
|
|
3086
|
+
function claimEvents(comments, author) {
|
|
3087
|
+
const kept = [];
|
|
3088
|
+
for (const comment of comments.filter((each) => isClaimant(each, author))) {
|
|
3089
|
+
const withdrawn = named(WITHDRAWN, comment.body);
|
|
3090
|
+
if (withdrawn === undefined) {
|
|
3091
|
+
kept.push(comment);
|
|
2274
3092
|
continue;
|
|
2275
3093
|
}
|
|
2276
|
-
|
|
3094
|
+
const take = kept.findLastIndex((each) => named(TAKEN, each.body) === withdrawn);
|
|
3095
|
+
if (take !== -1)
|
|
3096
|
+
kept.splice(take, 1);
|
|
3097
|
+
}
|
|
3098
|
+
return kept;
|
|
3099
|
+
}
|
|
3100
|
+
function latestClaim(comments, author) {
|
|
3101
|
+
let claim;
|
|
3102
|
+
for (const comment of claimEvents(inOrder(comments), author)) {
|
|
3103
|
+
const taken = named(TAKEN, comment.body);
|
|
3104
|
+
if (taken !== undefined) {
|
|
3105
|
+
claim = { holder: taken, at: comment.created_at };
|
|
3106
|
+
continue;
|
|
3107
|
+
}
|
|
3108
|
+
if (claim !== undefined && named(RELEASED, comment.body) === claim.holder)
|
|
2277
3109
|
claim = undefined;
|
|
2278
3110
|
}
|
|
2279
3111
|
return claim;
|
|
2280
3112
|
}
|
|
3113
|
+
function firstClaimSince(comments, seen, author) {
|
|
3114
|
+
const fresh = new Set(inOrder(comments).slice(seen));
|
|
3115
|
+
for (const comment of claimEvents(inOrder(comments), author)) {
|
|
3116
|
+
const taken = fresh.has(comment) ? named(TAKEN, comment.body) : undefined;
|
|
3117
|
+
if (taken !== undefined)
|
|
3118
|
+
return taken;
|
|
3119
|
+
}
|
|
3120
|
+
return;
|
|
3121
|
+
}
|
|
2281
3122
|
function laneSuffix(session) {
|
|
2282
3123
|
const suffix = session.slice(session.lastIndexOf("-") + 1);
|
|
2283
3124
|
return session.includes("-") && suffix !== "" ? suffix : undefined;
|
|
2284
3125
|
}
|
|
2285
3126
|
function latestNote(comments) {
|
|
2286
|
-
return comments.filter((comment) =>
|
|
3127
|
+
return inOrder(comments.filter((comment) => [TAKEN, RELEASED, WITHDRAWN].every((sentence) => named(sentence, comment.body) === undefined))).at(-1);
|
|
2287
3128
|
}
|
|
2288
3129
|
function holderSession(holder, sessions) {
|
|
2289
3130
|
const own = sessions.find((session) => session.name === holder);
|
|
@@ -2294,9 +3135,9 @@ function holderSession(holder, sessions) {
|
|
|
2294
3135
|
}
|
|
2295
3136
|
|
|
2296
3137
|
// src/good.ts
|
|
2297
|
-
import
|
|
3138
|
+
import process27 from "process";
|
|
2298
3139
|
function good(text) {
|
|
2299
|
-
return role("ok",
|
|
3140
|
+
return role("ok", process27.stdout)(text);
|
|
2300
3141
|
}
|
|
2301
3142
|
|
|
2302
3143
|
// src/config.ts
|
|
@@ -2329,12 +3170,10 @@ async function loadSettings(home) {
|
|
|
2329
3170
|
}
|
|
2330
3171
|
|
|
2331
3172
|
// src/tea.ts
|
|
2332
|
-
import
|
|
3173
|
+
import process28 from "process";
|
|
2333
3174
|
|
|
2334
3175
|
// src/forge.ts
|
|
2335
|
-
import {
|
|
2336
|
-
import { join as join7 } from "path";
|
|
2337
|
-
import process24 from "process";
|
|
3176
|
+
import { join as join10 } from "path";
|
|
2338
3177
|
|
|
2339
3178
|
// src/remote.ts
|
|
2340
3179
|
var SCP_LIKE = /^(?:([^@/]+)@)?([^:/]+):(?!\/)(.+?)(?:\.git)?\/?$/;
|
|
@@ -2391,8 +3230,7 @@ function loginHosts(config) {
|
|
|
2391
3230
|
return hosts;
|
|
2392
3231
|
}
|
|
2393
3232
|
function teaConfigPath() {
|
|
2394
|
-
|
|
2395
|
-
return join7(base !== undefined && base !== "" ? base : join7(homedir5(), ".config"), "tea", "config.yml");
|
|
3233
|
+
return join10(configBase(), "tea", "config.yml");
|
|
2396
3234
|
}
|
|
2397
3235
|
async function readConfig() {
|
|
2398
3236
|
try {
|
|
@@ -2454,22 +3292,22 @@ function repoFlag(repo) {
|
|
|
2454
3292
|
return repo === undefined ? [] : ["--repo", repo];
|
|
2455
3293
|
}
|
|
2456
3294
|
function usesGt() {
|
|
2457
|
-
const PATH =
|
|
3295
|
+
const PATH = process28.env.PATH ?? "";
|
|
2458
3296
|
return Bun.which("tea", { PATH }) === null && Bun.which("gt", { PATH }) !== null;
|
|
2459
3297
|
}
|
|
2460
3298
|
var injected;
|
|
2461
3299
|
async function injectLogin(repo) {
|
|
2462
|
-
if (
|
|
3300
|
+
if (process28.env.GITEA_TOKEN !== undefined && process28.env.GITEA_TOKEN !== "")
|
|
2463
3301
|
return;
|
|
2464
3302
|
const login = await pickLogin(repo === undefined);
|
|
2465
3303
|
if (login === undefined)
|
|
2466
3304
|
return;
|
|
2467
3305
|
injected = login.token;
|
|
2468
|
-
|
|
2469
|
-
|
|
3306
|
+
process28.env.GITEA_TOKEN = login.token;
|
|
3307
|
+
process28.env.GITEA_CLI_HOST = login.url;
|
|
2470
3308
|
}
|
|
2471
3309
|
function scrub(text) {
|
|
2472
|
-
const token = injected ??
|
|
3310
|
+
const token = injected ?? process28.env.GITEA_TOKEN;
|
|
2473
3311
|
return token === undefined || token === "" ? text : text.replaceAll(token, "***");
|
|
2474
3312
|
}
|
|
2475
3313
|
function failureText(stdout, stderr, code) {
|
|
@@ -2527,8 +3365,12 @@ async function repoSend(method, path, fields, repo) {
|
|
|
2527
3365
|
const flags = Object.entries(fields).flatMap(([name, value]) => typeof value === "string" ? ["-f", `${name}=${value}`] : ["-F", `${name}=${JSON.stringify(value)}`]);
|
|
2528
3366
|
return runApi(full, ["-X", method, ...flags, full], repo);
|
|
2529
3367
|
}
|
|
3368
|
+
async function repoWriteOrEmpty(method, path, fields, repo) {
|
|
3369
|
+
const text = await repoSend(method, path, fields, repo);
|
|
3370
|
+
return text.trim() === "" ? undefined : parseJson(`repos/{owner}/{repo}/${path}`, text);
|
|
3371
|
+
}
|
|
2530
3372
|
async function repoWrite(method, path, fields, repo) {
|
|
2531
|
-
return parseJson(`repos/{owner}/{repo}/${path}`,
|
|
3373
|
+
return await repoWriteOrEmpty(method, path, fields, repo) ?? parseJson(`repos/{owner}/{repo}/${path}`, "");
|
|
2532
3374
|
}
|
|
2533
3375
|
async function repoApiText(path, repo) {
|
|
2534
3376
|
const full = `repos/{owner}/{repo}/${path}`;
|
|
@@ -2587,7 +3429,7 @@ function dueDate(milestone) {
|
|
|
2587
3429
|
}
|
|
2588
3430
|
function progress(milestone) {
|
|
2589
3431
|
const total = milestone.open_issues + milestone.closed_issues;
|
|
2590
|
-
return total === 0 ? "" : `${Math.
|
|
3432
|
+
return total === 0 ? "" : `${Math.floor(milestone.closed_issues * 100 / total)}%`;
|
|
2591
3433
|
}
|
|
2592
3434
|
async function createMilestone(title, description, due, repo) {
|
|
2593
3435
|
const fields = { title };
|
|
@@ -2885,12 +3727,12 @@ async function board(args) {
|
|
|
2885
3727
|
return 0;
|
|
2886
3728
|
}
|
|
2887
3729
|
async function me(as, sessions) {
|
|
2888
|
-
|
|
2889
|
-
|
|
2890
|
-
const session = await currentSession(sessions);
|
|
2891
|
-
if (session === undefined)
|
|
3730
|
+
const name = as ?? (await currentSession(sessions))?.name;
|
|
3731
|
+
if (name === undefined)
|
|
2892
3732
|
fail("not run from a Claude Code session: pass --as <name>");
|
|
2893
|
-
|
|
3733
|
+
if (!claimable(name))
|
|
3734
|
+
fail(`a claim cannot carry the name ${JSON.stringify(name)}, empty, padded or holding a line break: pass --as`);
|
|
3735
|
+
return name;
|
|
2894
3736
|
}
|
|
2895
3737
|
var takeUsage = `ft take <n>...
|
|
2896
3738
|
|
|
@@ -2954,9 +3796,16 @@ async function take(args) {
|
|
|
2954
3796
|
if (current.state === "away" && values["take-stale"] !== true)
|
|
2955
3797
|
fail(`#${number} was taken by ${current.claim.holder} ${formatAge(current.claim.at)}, which no session here answers to: it may run on another machine`, 1, runHint(`ft take ${number} --take-stale`, "take it over"));
|
|
2956
3798
|
await comment(number, takenComment(name), values.repo);
|
|
2957
|
-
const
|
|
2958
|
-
if (
|
|
2959
|
-
|
|
3799
|
+
const winner = firstClaimSince(await commentsOf(number, values.repo), comments.length, author);
|
|
3800
|
+
if (winner !== name) {
|
|
3801
|
+
const taken = `#${number} was taken by ${winner ?? "another session"} at the same moment`;
|
|
3802
|
+
try {
|
|
3803
|
+
await comment(number, withdrawnComment(name), values.repo);
|
|
3804
|
+
} catch (error) {
|
|
3805
|
+
fail(`${taken}, and withdrawing this claim failed: ${error instanceof Error ? error.message : String(error)}`, 1, runHint(`ft comment ${number} '${withdrawnComment(name)}'`, "withdraw it"));
|
|
3806
|
+
}
|
|
3807
|
+
fail(taken, 1);
|
|
3808
|
+
}
|
|
2960
3809
|
console.log(good(`took #${number} as ${name}: ${found.title}`));
|
|
2961
3810
|
});
|
|
2962
3811
|
}
|
|
@@ -3025,7 +3874,7 @@ async function drop(args) {
|
|
|
3025
3874
|
}
|
|
3026
3875
|
|
|
3027
3876
|
// src/commands/ci.ts
|
|
3028
|
-
import
|
|
3877
|
+
import process29 from "process";
|
|
3029
3878
|
|
|
3030
3879
|
// src/git.ts
|
|
3031
3880
|
async function tagsAt(commit) {
|
|
@@ -3175,16 +4024,25 @@ function overall(runs) {
|
|
|
3175
4024
|
return pending.status;
|
|
3176
4025
|
return statuses.has("success") ? "success" : "skipped";
|
|
3177
4026
|
}
|
|
4027
|
+
async function repoRunners(repo) {
|
|
4028
|
+
try {
|
|
4029
|
+
return await repoApi("actions/runners", repo);
|
|
4030
|
+
} catch {
|
|
4031
|
+
return;
|
|
4032
|
+
}
|
|
4033
|
+
}
|
|
3178
4034
|
async function stallReason(runs, repo) {
|
|
3179
4035
|
const queued = runs.filter((run) => QUEUED.has(run.status));
|
|
3180
4036
|
if (queued.length === 0)
|
|
3181
4037
|
return;
|
|
3182
|
-
let
|
|
4038
|
+
let instance;
|
|
3183
4039
|
try {
|
|
3184
|
-
|
|
4040
|
+
instance = await api("admin/actions/runners");
|
|
3185
4041
|
} catch {
|
|
3186
4042
|
return;
|
|
3187
4043
|
}
|
|
4044
|
+
const own = await repoRunners(repo);
|
|
4045
|
+
const runners = [...instance, ...own ?? []];
|
|
3188
4046
|
const online = runners.filter((runner) => runner.status !== "offline");
|
|
3189
4047
|
if (online.length === 0)
|
|
3190
4048
|
return { reason: runners.length === 0 ? "no runner is registered" : `every runner is offline (${runners.map((runner) => runner.name).join(", ")})`, certain: false };
|
|
@@ -3192,7 +4050,7 @@ async function stallReason(runs, repo) {
|
|
|
3192
4050
|
for (const job of await jobsOf(run.id, repo)) {
|
|
3193
4051
|
const labels = job.runs_on ?? [];
|
|
3194
4052
|
if (QUEUED.has(job.status) && !online.some((runner) => labels.every((label) => (runner.labels ?? []).includes(label))))
|
|
3195
|
-
return { reason: `job ${job.name} of ${run.workflow_id} runs on ${labels.join(", ")}, which no online runner carries (${online.map((runner) => `${runner.name}: ${(runner.labels ?? []).join(", ")}`).join("; ")})`, certain:
|
|
4053
|
+
return { reason: `job ${job.name} of ${run.workflow_id} runs on ${labels.join(", ")}, which no online runner carries (${online.map((runner) => `${runner.name}: ${(runner.labels ?? []).join(", ")}`).join("; ")})`, certain: own !== undefined };
|
|
3196
4054
|
}
|
|
3197
4055
|
}
|
|
3198
4056
|
return online.some((runner) => runner.status === "active") ? undefined : { reason: "no runner is working on anything: is it up?", certain: false };
|
|
@@ -3292,7 +4150,7 @@ async function ci2(args) {
|
|
|
3292
4150
|
return;
|
|
3293
4151
|
}
|
|
3294
4152
|
const json = values.json === true;
|
|
3295
|
-
const live = takesControlCodes(
|
|
4153
|
+
const live = takesControlCodes(process29.stderr) && takesControlCodes(process29.stdout) && !json && values.quiet !== true;
|
|
3296
4154
|
const runs = await waitForCi({
|
|
3297
4155
|
tool: "ft ci",
|
|
3298
4156
|
short,
|
|
@@ -3318,8 +4176,8 @@ async function ci2(args) {
|
|
|
3318
4176
|
return stall === undefined ? undefined : { message: `runs queued on ${short} are not moving: ${stall.reason}`, certain: stall.certain };
|
|
3319
4177
|
},
|
|
3320
4178
|
lines: (spinner, found, started) => [
|
|
3321
|
-
ciHeader(spinner, `CI on ${short}`, started,
|
|
3322
|
-
...(found ?? []).map((run) => ` ${runLine(run,
|
|
4179
|
+
ciHeader(spinner, `CI on ${short}`, started, process29.stderr),
|
|
4180
|
+
...(found ?? []).map((run) => ` ${runLine(run, process29.stderr, undefined, run.commit_sha.slice(0, 7))}`)
|
|
3323
4181
|
]
|
|
3324
4182
|
});
|
|
3325
4183
|
const status = overall(runs);
|
|
@@ -3336,7 +4194,7 @@ async function ci2(args) {
|
|
|
3336
4194
|
}
|
|
3337
4195
|
if (live) {
|
|
3338
4196
|
for (const run of runs)
|
|
3339
|
-
console.log(runLine(run,
|
|
4197
|
+
console.log(runLine(run, process29.stdout, undefined, run.commit_sha.slice(0, 7)));
|
|
3340
4198
|
}
|
|
3341
4199
|
if (status !== "failure") {
|
|
3342
4200
|
if (live)
|
|
@@ -3355,7 +4213,7 @@ run ${run.id} failed${run.commit_sha === sha ? "" : `, testing every commit from
|
|
|
3355
4213
|
}
|
|
3356
4214
|
|
|
3357
4215
|
// src/commands/digest.ts
|
|
3358
|
-
import
|
|
4216
|
+
import process30 from "process";
|
|
3359
4217
|
var RUNS_SCANNED = 50;
|
|
3360
4218
|
var TITLE_WIDTH2 = 70;
|
|
3361
4219
|
var SHOWN = 8;
|
|
@@ -3405,13 +4263,13 @@ async function quietly(read) {
|
|
|
3405
4263
|
}
|
|
3406
4264
|
}
|
|
3407
4265
|
async function staleTodos() {
|
|
3408
|
-
const bin = Bun.which("
|
|
4266
|
+
const bin = Bun.which("src", { PATH: process30.env.PATH ?? "" });
|
|
3409
4267
|
if (bin === null)
|
|
3410
4268
|
return [];
|
|
3411
4269
|
let found;
|
|
3412
4270
|
try {
|
|
3413
|
-
const ran = await runCommand([bin, "--stale", "--json"]);
|
|
3414
|
-
found = JSON.parse(
|
|
4271
|
+
const ran = await runCommand([bin, "todo-scan", "--stale", "--json"]);
|
|
4272
|
+
found = JSON.parse(ran.stdout);
|
|
3415
4273
|
} catch {
|
|
3416
4274
|
return [];
|
|
3417
4275
|
}
|
|
@@ -3427,8 +4285,8 @@ async function staleTodos() {
|
|
|
3427
4285
|
return [...byIssue.values()];
|
|
3428
4286
|
}
|
|
3429
4287
|
function claimLine(row, now) {
|
|
3430
|
-
const id = role("id",
|
|
3431
|
-
return [id(`#${row.number}`), row.holder, paint(
|
|
4288
|
+
const id = role("id", process30.stdout);
|
|
4289
|
+
return [id(`#${row.number}`), row.holder, paint(process30.stdout).dim(formatAge(row.since, now)), row.boxesTotal === 0 ? "" : `${row.boxesLeft}/${row.boxesTotal} left`, truncate(row.title, TITLE_WIDTH2)];
|
|
3432
4290
|
}
|
|
3433
4291
|
function capped2(lines) {
|
|
3434
4292
|
return lines.length > SHOWN ? [...lines.slice(0, SHOWN), `... ${lines.length - SHOWN} more`] : lines;
|
|
@@ -3439,13 +4297,13 @@ function renderDigest(digest, now = Date.now()) {
|
|
|
3439
4297
|
`) },
|
|
3440
4298
|
{ heading: "claimed, no live session here", tone: "warn", count: digest.away.length, lines: table(digest.away.map((row) => claimLine(row, now))).split(`
|
|
3441
4299
|
`) },
|
|
3442
|
-
{ heading: "CI on the default branch", tone: "failed", count: digest.ci.length, lines: digest.ci.map((run) => `${run.workflow} ${badge(run.status,
|
|
4300
|
+
{ heading: "CI on the default branch", tone: "failed", count: digest.ci.length, lines: digest.ci.map((run) => `${run.workflow} ${badge(run.status, process30.stdout)} (run ${run.id}) ${truncate(upTo(run.title, `
|
|
3443
4301
|
`), TITLE_WIDTH2)}`) },
|
|
3444
4302
|
{ heading: "unpushed commits", tone: "queued", count: digest.unpushed.length, lines: capped2(digest.unpushed) },
|
|
3445
|
-
{ heading: "dirty files", tone: "warn", count: digest.dirty.length, lines: capped2(digest.dirty.map((file) => `${file.status} ${role("path",
|
|
4303
|
+
{ heading: "dirty files", tone: "warn", count: digest.dirty.length, lines: capped2(digest.dirty.map((file) => `${file.status} ${role("path", process30.stdout)(file.path)}`)) },
|
|
3446
4304
|
{ heading: "stale TODO comments", tone: "skipped", count: digest.stale.length, lines: capped2(digest.stale.map((todo) => `${todo.issue} closed: ${todo.comments.map((each) => `${each.path}:${each.line}`).join(", ")}`)) }
|
|
3447
4305
|
].filter((each) => each.count > 0);
|
|
3448
|
-
return sections.length === 0 ? "nothing to pick up" : sections.map(({ heading, tone, count, lines }) => `${section(heading, count,
|
|
4306
|
+
return sections.length === 0 ? "nothing to pick up" : sections.map(({ heading, tone, count, lines }) => `${section(heading, count, process30.stdout, process30.env, tone)}
|
|
3449
4307
|
${lines.join(`
|
|
3450
4308
|
`).replace(LINE_START2, " ")}`).join(`
|
|
3451
4309
|
|
|
@@ -3481,6 +4339,212 @@ async function digest(args) {
|
|
|
3481
4339
|
return 0;
|
|
3482
4340
|
}
|
|
3483
4341
|
|
|
4342
|
+
// src/commands/dispatch.ts
|
|
4343
|
+
import process31 from "process";
|
|
4344
|
+
|
|
4345
|
+
// src/commands/watch.ts
|
|
4346
|
+
var usage4 = `ft watch [--after <id>]
|
|
4347
|
+
|
|
4348
|
+
Waits for runs to finish: those newer than run <id>, or else the ones in progress now.
|
|
4349
|
+
Prints nothing but failures and each run's final status with --quiet, and a JSON result with --json.`;
|
|
4350
|
+
var EXITS3 = [[0, "every one passed or was skipped"], [1, "one failed or was cancelled"], [2, "a timeout or a stalled queue"]];
|
|
4351
|
+
var options3 = {
|
|
4352
|
+
after: { type: "string", short: "a", description: "watch the runs newer than this run id, as `ft runs --json` gives it" },
|
|
4353
|
+
timeout: { type: "string", short: "t", description: "how long before giving up (15m), a bare number in minutes" },
|
|
4354
|
+
json: jsonOption("status, runs, failedJobs with their log excerpts and url; the progress goes to stderr"),
|
|
4355
|
+
quiet: { type: "boolean", short: "q", description: "print only the failures and each run's final status" },
|
|
4356
|
+
...repoOption
|
|
4357
|
+
};
|
|
4358
|
+
var timing = { poll: 1e4 };
|
|
4359
|
+
var LIMIT = 20;
|
|
4360
|
+
var STALLED2 = 3 * 60000;
|
|
4361
|
+
async function watchRuns(pick, timeout, repo, idle, out = process.stdout) {
|
|
4362
|
+
return (await followRuns(pick, timeout, repo, idle, out)).code;
|
|
4363
|
+
}
|
|
4364
|
+
async function followRuns(pick, timeout, repo, idle, out = process.stdout, mode = {}) {
|
|
4365
|
+
const { json = false, quiet = false } = mode;
|
|
4366
|
+
const started = Date.now();
|
|
4367
|
+
const latest = new Map;
|
|
4368
|
+
const seen = new Map;
|
|
4369
|
+
const line = (run) => runLine(run, out, seen.get(run.id) ?? Date.now());
|
|
4370
|
+
const region = takesControlCodes(out) && !quiet ? liveRegion((spinner) => [ciHeader(spinner, "CI", started, out), ...[...latest.values()].map((run) => ` ${line(run)}`)], out) : undefined;
|
|
4371
|
+
const followed = new Set;
|
|
4372
|
+
const failed = new Set;
|
|
4373
|
+
const failedJobs = [];
|
|
4374
|
+
let moving = started;
|
|
4375
|
+
async function poll() {
|
|
4376
|
+
const newest = await recentRuns(LIMIT, repo);
|
|
4377
|
+
const gone = await Promise.all([...followed].filter((id) => !newest.some((run) => run.id === id)).map(async (id) => runById(id, repo)));
|
|
4378
|
+
const runs = [...pick(newest), ...gone];
|
|
4379
|
+
for (const run of runs)
|
|
4380
|
+
followed.add(run.id);
|
|
4381
|
+
for (const run of runs) {
|
|
4382
|
+
if (!seen.has(run.id))
|
|
4383
|
+
seen.set(run.id, Date.now());
|
|
4384
|
+
if (region === undefined && !quiet && latest.get(run.id)?.status !== run.status)
|
|
4385
|
+
out.write(`${line(run)}
|
|
4386
|
+
`);
|
|
4387
|
+
latest.set(run.id, run);
|
|
4388
|
+
}
|
|
4389
|
+
region?.redraw();
|
|
4390
|
+
if (runs.length === 0) {
|
|
4391
|
+
if (idle !== undefined && Date.now() - started > idle) {
|
|
4392
|
+
if (!json)
|
|
4393
|
+
out.write(`no run started, so nothing was waited for
|
|
4394
|
+
`);
|
|
4395
|
+
return 0;
|
|
4396
|
+
}
|
|
4397
|
+
return;
|
|
4398
|
+
}
|
|
4399
|
+
for (const run of runs) {
|
|
4400
|
+
if (run.status === "failure" && !failed.has(run.id)) {
|
|
4401
|
+
const jobs = await failedJobsOf(run, repo);
|
|
4402
|
+
failedJobs.push(...jobs);
|
|
4403
|
+
if (!json)
|
|
4404
|
+
console.error(`
|
|
4405
|
+
${failureText2(jobs)}
|
|
4406
|
+
|
|
4407
|
+
${run.html_url}`);
|
|
4408
|
+
failed.add(run.id);
|
|
4409
|
+
}
|
|
4410
|
+
}
|
|
4411
|
+
if (runs.every((run) => FINISHED.has(run.status))) {
|
|
4412
|
+
const status = overall(runs);
|
|
4413
|
+
return status === "failure" || status === "cancelled" ? 1 : 0;
|
|
4414
|
+
}
|
|
4415
|
+
const stall = await stallReason(runs, repo);
|
|
4416
|
+
if (stall === undefined)
|
|
4417
|
+
moving = Date.now();
|
|
4418
|
+
else if (stall.certain || Date.now() - moving > STALLED2)
|
|
4419
|
+
fail(`queued runs are not moving: ${stall.reason}`);
|
|
4420
|
+
return;
|
|
4421
|
+
}
|
|
4422
|
+
async function settle() {
|
|
4423
|
+
for (;; ) {
|
|
4424
|
+
await Bun.sleep(timing.poll);
|
|
4425
|
+
if (Date.now() - started > timeout)
|
|
4426
|
+
fail(`the runs did not finish in ${formatDuration(timeout)}`);
|
|
4427
|
+
try {
|
|
4428
|
+
const code = await poll();
|
|
4429
|
+
if (code !== undefined)
|
|
4430
|
+
return code;
|
|
4431
|
+
} catch (error) {
|
|
4432
|
+
if (error instanceof Exit)
|
|
4433
|
+
throw error;
|
|
4434
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
4435
|
+
if (isPermanentFailure(error))
|
|
4436
|
+
fail(message);
|
|
4437
|
+
if (!quiet)
|
|
4438
|
+
warn(`ft watch: ${message}, polling again`);
|
|
4439
|
+
}
|
|
4440
|
+
}
|
|
4441
|
+
}
|
|
4442
|
+
try {
|
|
4443
|
+
return { code: await settle(), runs: [...latest.values()], failedJobs };
|
|
4444
|
+
} finally {
|
|
4445
|
+
region?.stop();
|
|
4446
|
+
if (region !== undefined || quiet) {
|
|
4447
|
+
for (const run of latest.values())
|
|
4448
|
+
out.write(`${line(run)}
|
|
4449
|
+
`);
|
|
4450
|
+
}
|
|
4451
|
+
}
|
|
4452
|
+
}
|
|
4453
|
+
async function watch2(args) {
|
|
4454
|
+
const parsed = parse(args, usage4, options3, { exits: EXITS3 });
|
|
4455
|
+
const { values } = parsed;
|
|
4456
|
+
const timeout = duration(values.timeout, "timeout", 15 * 60000, "m");
|
|
4457
|
+
const json = values.json === true;
|
|
4458
|
+
const mode = { json, quiet: values.quiet === true };
|
|
4459
|
+
async function follow(pick) {
|
|
4460
|
+
const followed = await followRuns(pick, timeout, values.repo, undefined, json ? process.stderr : process.stdout, mode);
|
|
4461
|
+
if (json)
|
|
4462
|
+
printJson(ciJson(followed.runs, followed.failedJobs));
|
|
4463
|
+
return followed.code;
|
|
4464
|
+
}
|
|
4465
|
+
if (values.after !== undefined) {
|
|
4466
|
+
const after = wholeNumber(values.after, "after", 0, 0);
|
|
4467
|
+
return follow((runs) => runs.filter((run) => run.id > after));
|
|
4468
|
+
}
|
|
4469
|
+
const active = new Set((await recentRuns(LIMIT, values.repo)).filter((run) => !FINISHED.has(run.status)).map((run) => run.id));
|
|
4470
|
+
if (active.size === 0) {
|
|
4471
|
+
if (json)
|
|
4472
|
+
printJson(ciJson([], []));
|
|
4473
|
+
else
|
|
4474
|
+
console.log("no run in progress");
|
|
4475
|
+
return 0;
|
|
4476
|
+
}
|
|
4477
|
+
return follow((runs) => runs.filter((run) => active.has(run.id)));
|
|
4478
|
+
}
|
|
4479
|
+
|
|
4480
|
+
// src/commands/dispatch.ts
|
|
4481
|
+
var usage5 = `ft dispatch <workflow> [--ref <branch>] [--input key=value]...
|
|
4482
|
+
|
|
4483
|
+
Starts a run of a workflow that declares \`on: workflow_dispatch\`, on the ref (the default branch's tip unless given), and prints the run's id and link.
|
|
4484
|
+
--wait then follows it to its end as \`ft watch\` does.`;
|
|
4485
|
+
var EXITS4 = [[0, "the run started, and with --wait it passed"], [1, "Forgejo refused it, or with --wait the run failed or was cancelled"], [2, "a usage error, or with --wait a timeout or a stalled queue"]];
|
|
4486
|
+
var options4 = {
|
|
4487
|
+
ref: { type: "string", description: "the branch, tag or commit sha to run, by default the repository's default branch" },
|
|
4488
|
+
input: { type: "string", short: "i", multiple: true, description: "an input the workflow declares, key=value, repeatable" },
|
|
4489
|
+
wait: { type: "boolean", short: "w", description: "follow the run to its end, exit 1 when it fails" },
|
|
4490
|
+
timeout: { type: "string", short: "t", description: "how long --wait waits before giving up (30m), a bare number in minutes" },
|
|
4491
|
+
quiet: { type: "boolean", short: "q", description: "with --wait, print only the failures and the run's final status" },
|
|
4492
|
+
json: jsonOption("{id, number, workflow, ref, url}; with --wait, ft watch --json's status, runs and failedJobs"),
|
|
4493
|
+
...repoOption
|
|
4494
|
+
};
|
|
4495
|
+
var WORKFLOW_FILE = /\.ya?ml$/;
|
|
4496
|
+
function parseInputs(given) {
|
|
4497
|
+
const inputs = {};
|
|
4498
|
+
for (const each of given) {
|
|
4499
|
+
const at = each.indexOf("=");
|
|
4500
|
+
if (at <= 0)
|
|
4501
|
+
badUsage(`--input takes key=value, not '${each}'`);
|
|
4502
|
+
inputs[each.slice(0, at)] = each.slice(at + 1);
|
|
4503
|
+
}
|
|
4504
|
+
return inputs;
|
|
4505
|
+
}
|
|
4506
|
+
async function dispatch2(args) {
|
|
4507
|
+
const { values, positionals } = parse(args, usage5, options4, {
|
|
4508
|
+
positionals: ["<workflow>"],
|
|
4509
|
+
exits: EXITS4,
|
|
4510
|
+
replaces: "tea api -X POST on a workflow's dispatches, then finding the run it started",
|
|
4511
|
+
examples: [["ft dispatch apps.yml", "on the default branch"], ["ft dispatch deploy.yml --ref v1.2.0 -i target=prod --wait", "a tag, an input, and wait for it"]]
|
|
4512
|
+
});
|
|
4513
|
+
const workflow = positionals[0] ?? badUsage(`a workflow file is needed
|
|
4514
|
+
|
|
4515
|
+
${usage5}`);
|
|
4516
|
+
if (!WORKFLOW_FILE.test(workflow))
|
|
4517
|
+
badUsage(`<workflow> is a file name under .forgejo/workflows, such as test.yml, not '${workflow}'`);
|
|
4518
|
+
if (values.wait !== true && (values.timeout !== undefined || values.quiet === true))
|
|
4519
|
+
badUsage("--timeout and --quiet go with --wait");
|
|
4520
|
+
const inputs = parseInputs(values.input ?? []);
|
|
4521
|
+
const timeout = duration(values.timeout, "timeout", 30 * 60000, "m");
|
|
4522
|
+
const ref = values.ref ?? (await api("repos/{owner}/{repo}", values.repo)).default_branch;
|
|
4523
|
+
const json = values.json === true;
|
|
4524
|
+
const wait = values.wait === true;
|
|
4525
|
+
const say = json ? console.error : console.log;
|
|
4526
|
+
const fields = { ref, ...Object.keys(inputs).length === 0 ? {} : { inputs }, return_run_info: true };
|
|
4527
|
+
const started = await repoWriteOrEmpty("POST", `actions/workflows/${encodeURIComponent(workflow)}/dispatches`, fields, values.repo);
|
|
4528
|
+
if (started === undefined) {
|
|
4529
|
+
const said = `${workflow} started on ${ref}, but Forgejo did not say which run`;
|
|
4530
|
+
if (wait || json)
|
|
4531
|
+
fail(`${said}, so it cannot be ${wait ? "followed" : "printed"}`, 1, `ft runs -w ${workflow} lists it`);
|
|
4532
|
+
console.error(`${said}: ft runs -w ${workflow} lists it`);
|
|
4533
|
+
return 0;
|
|
4534
|
+
}
|
|
4535
|
+
const run = await runById(started.id, values.repo);
|
|
4536
|
+
if (json && !wait)
|
|
4537
|
+
printJson({ id: run.id, number: started.run_number, workflow, ref, url: run.html_url });
|
|
4538
|
+
else
|
|
4539
|
+
say(`started ${workflow} run ${run.id} on ${ref}: ${run.html_url}`);
|
|
4540
|
+
if (!wait)
|
|
4541
|
+
return 0;
|
|
4542
|
+
const followed = await followRuns((runs) => runs.filter((each) => each.id === run.id), timeout, values.repo, undefined, json ? process31.stderr : process31.stdout, { json, quiet: values.quiet === true });
|
|
4543
|
+
if (json)
|
|
4544
|
+
printJson(ciJson(followed.runs, followed.failedJobs));
|
|
4545
|
+
return followed.code;
|
|
4546
|
+
}
|
|
4547
|
+
|
|
3484
4548
|
// src/commands/issue-target.ts
|
|
3485
4549
|
var ISSUE_REFERENCE = /^#?\d+$/;
|
|
3486
4550
|
async function chooseTarget(positionals, held, usage) {
|
|
@@ -3531,7 +4595,7 @@ var tickUsage = `ft tick [<n>] <box>...
|
|
|
3531
4595
|
Ticks checklist boxes of issue <n>, each given by its number from \`ft issue\` or by text matching exactly one box, then posts the -m or -F comment.
|
|
3532
4596
|
With --closed, ticks instead every box opening with \`#<issue>\` whose issue is closed, as a release plan lists them.
|
|
3533
4597
|
|
|
3534
|
-
Without <n>
|
|
4598
|
+
Without <n> it takes the one open issue this session holds (\`ft take\`); a first argument that is a number is always the issue.`;
|
|
3535
4599
|
var tickExits = [[0, "it ticked the boxes"], [1, "Forgejo refuses"], [2, "a usage error or a box matching none or several"]];
|
|
3536
4600
|
var tickOptions = {
|
|
3537
4601
|
undo: { type: "boolean", short: "u", description: "untick them instead" },
|
|
@@ -3582,9 +4646,9 @@ ${tickUsage}`);
|
|
|
3582
4646
|
}
|
|
3583
4647
|
var fixedUsage = `ft fixed [<n>] [commit]...
|
|
3584
4648
|
|
|
3585
|
-
Comments "Fixed in <
|
|
3586
|
-
Without a commit it takes those on origin's default branch
|
|
3587
|
-
|
|
4649
|
+
Comments "Fixed in <a>, <b> and <c>: <subject>" on issue <n> and closes it.
|
|
4650
|
+
Without a commit it takes those on origin's default branch naming #<n> in their message, or HEAD when none does, and says which; without <n> it takes the one open issue this session holds (\`ft take\`).
|
|
4651
|
+
An issue with boxes left is refused unless --tick ticks them first, and every open issue listing \`- [ ] #<n>\` gets that line ticked.`;
|
|
3588
4652
|
var fixedExits = [[0, "it closed the issue"], [1, "the issue is already closed, has boxes left or Forgejo refuses"], [2, "a usage error"]];
|
|
3589
4653
|
var fixedOptions = {
|
|
3590
4654
|
message: { type: "string", short: "m", description: 'the line after "Fixed in <sha>:"' },
|
|
@@ -3786,7 +4850,7 @@ var editOptions = {
|
|
|
3786
4850
|
milestone: { type: "string", short: "m", description: "move the issue to this milestone, a title or an id; an empty value takes it out of its milestone" },
|
|
3787
4851
|
...repoOption
|
|
3788
4852
|
};
|
|
3789
|
-
async function
|
|
4853
|
+
async function edit2(args) {
|
|
3790
4854
|
const parsed = parse(args, editUsage, editOptions, { exits: editExits });
|
|
3791
4855
|
const { values, positionals } = parsed;
|
|
3792
4856
|
const number = issueNumber(positionals[0], editUsage);
|
|
@@ -3948,12 +5012,12 @@ async function issue(args) {
|
|
|
3948
5012
|
}
|
|
3949
5013
|
|
|
3950
5014
|
// src/commands/logs.ts
|
|
3951
|
-
var
|
|
5015
|
+
var usage6 = `ft logs <run id>
|
|
3952
5016
|
|
|
3953
5017
|
Prints what the failed jobs of a run say went wrong: each failed bun test's output and the end of each failed step, cut to the errors when it is a tsc, eslint, vitest, playwright, phpstan or php-cs-fixer step.
|
|
3954
5018
|
With no failed job it prints every job's last lines; --full prints whole logs.`;
|
|
3955
|
-
var
|
|
3956
|
-
var
|
|
5019
|
+
var EXITS5 = [[0, "it printed the logs"], [1, "Forgejo cannot be read"], [2, "a usage error or a job the run lacks"]];
|
|
5020
|
+
var options5 = {
|
|
3957
5021
|
job: { type: "string", short: "j", description: "only this job, by name or id" },
|
|
3958
5022
|
full: { type: "boolean", short: "f", description: "the whole log, timestamps stripped" },
|
|
3959
5023
|
json: jsonOption("status, runs, failedJobs, url and the picked jobs with their log excerpts"),
|
|
@@ -3966,7 +5030,7 @@ function pickJobs(jobs, wanted) {
|
|
|
3966
5030
|
return failed.length > 0 ? failed : jobs;
|
|
3967
5031
|
}
|
|
3968
5032
|
async function logs2(args) {
|
|
3969
|
-
const parsed = parse(args,
|
|
5033
|
+
const parsed = parse(args, usage6, options5, { exits: EXITS5 });
|
|
3970
5034
|
const { values, positionals } = parsed;
|
|
3971
5035
|
if (positionals[0] === undefined)
|
|
3972
5036
|
fail("a run id is needed", 2, runHint("ft runs", "list them"));
|
|
@@ -3997,7 +5061,8 @@ ${await text(job)}`);
|
|
|
3997
5061
|
}
|
|
3998
5062
|
|
|
3999
5063
|
// src/commands/milestone.ts
|
|
4000
|
-
import
|
|
5064
|
+
import process32 from "process";
|
|
5065
|
+
init_text();
|
|
4001
5066
|
var TITLE_WIDTH3 = 60;
|
|
4002
5067
|
var LIST_LIMIT = 30;
|
|
4003
5068
|
var CONCURRENCY2 = 4;
|
|
@@ -4006,15 +5071,15 @@ function counts(milestone) {
|
|
|
4006
5071
|
}
|
|
4007
5072
|
function progressBar(milestone) {
|
|
4008
5073
|
const total = milestone.open_issues + milestone.closed_issues;
|
|
4009
|
-
return takesControlCodes(
|
|
5074
|
+
return takesControlCodes(process32.stdout) ? bar(total === 0 ? 0 : milestone.closed_issues / total, { width: 16 }) : "";
|
|
4010
5075
|
}
|
|
4011
5076
|
function milestoneCells(each, showState) {
|
|
4012
5077
|
const drawn = progressBar(each);
|
|
4013
5078
|
return [String(each.id), truncate(each.title, TITLE_WIDTH3), `${each.open_issues} open`, `${each.closed_issues} closed`, ...drawn === "" ? [] : [drawn], progress(each), dueDate(each) === "" ? "" : `due ${dueDate(each)}`, ...showState ? [each.state] : []];
|
|
4014
5079
|
}
|
|
4015
5080
|
async function printWithIssues(list, repo) {
|
|
4016
|
-
const colors = paint(
|
|
4017
|
-
const id = role("id",
|
|
5081
|
+
const colors = paint(process32.stdout);
|
|
5082
|
+
const id = role("id", process32.stdout);
|
|
4018
5083
|
const issuesOf = await pool(list, concurrencyOf(CONCURRENCY2), async (each) => Promise.all([openIssues(undefined, repo, each.id), closedIssues(each.id, repo)]));
|
|
4019
5084
|
const blocks = list.map((each, index) => {
|
|
4020
5085
|
const byNumber = (left, right) => left.number - right.number;
|
|
@@ -4025,7 +5090,7 @@ async function printWithIssues(list, repo) {
|
|
|
4025
5090
|
...open.map((issue) => ` ${id(`#${issue.number}`)} ${truncate(issue.title, TITLE_WIDTH3)}`),
|
|
4026
5091
|
...closed.map((issue) => colors.dim(` #${issue.number} ${truncate(issue.title, TITLE_WIDTH3)} (closed)`))
|
|
4027
5092
|
];
|
|
4028
|
-
return [section(`${each.title}${drawn === "" ? "" : ` ${drawn}`} ${facts}`, undefined,
|
|
5093
|
+
return [section(`${each.title}${drawn === "" ? "" : ` ${drawn}`} ${facts}`, undefined, process32.stdout, process32.env, "accent"), ...lines].join(`
|
|
4029
5094
|
`);
|
|
4030
5095
|
});
|
|
4031
5096
|
console.log(blocks.join(`
|
|
@@ -4113,7 +5178,7 @@ ${closeUsage2}`);
|
|
|
4113
5178
|
}
|
|
4114
5179
|
const open = await openIssues(undefined, values.repo, found.id);
|
|
4115
5180
|
if (open.length > 0 && values.force !== true)
|
|
4116
|
-
fail(`milestone ${found.title} has ${
|
|
5181
|
+
fail(`milestone ${found.title} has ${bo(open.length, "open issue")}:
|
|
4117
5182
|
${open.map((issue) => ` #${issue.number} ${truncate(issue.title, TITLE_WIDTH3)}`).join(`
|
|
4118
5183
|
`)}`, 1, `${runHint(`ft milestone close ${found.title} --force`, "close it with them open")}, or move them with \`ft edit <n> -m <milestone>\``);
|
|
4119
5184
|
await closeMilestone(found.id, values.repo);
|
|
@@ -4169,44 +5234,39 @@ function heading(line) {
|
|
|
4169
5234
|
}
|
|
4170
5235
|
function insertionPoint(lines, body, section) {
|
|
4171
5236
|
const all = boxes(body);
|
|
5237
|
+
const last = all.at(-1);
|
|
4172
5238
|
if (section === undefined)
|
|
4173
|
-
return
|
|
5239
|
+
return last === undefined ? undefined : afterBox(lines, last.line);
|
|
4174
5240
|
const title = heading(section);
|
|
4175
5241
|
const at = lines.findIndex((line) => heading(line) === title);
|
|
4176
5242
|
if (at === -1)
|
|
4177
5243
|
return;
|
|
4178
5244
|
const lineOfBox = new Set(all.map((box) => box.line));
|
|
4179
5245
|
let end = at + 1;
|
|
4180
|
-
|
|
4181
|
-
|
|
4182
|
-
|
|
4183
|
-
|
|
5246
|
+
let next = at + 1;
|
|
5247
|
+
while (next < lines.length) {
|
|
5248
|
+
if (lineOfBox.has(next)) {
|
|
5249
|
+
end = afterBox(lines, next);
|
|
5250
|
+
next = end;
|
|
5251
|
+
} else if (lines[next]?.trim() === "") {
|
|
5252
|
+
next++;
|
|
5253
|
+
} else {
|
|
4184
5254
|
break;
|
|
5255
|
+
}
|
|
4185
5256
|
}
|
|
4186
5257
|
return end;
|
|
4187
5258
|
}
|
|
4188
5259
|
function addLines(body, added, section) {
|
|
4189
5260
|
if (added.length === 0)
|
|
4190
5261
|
return body;
|
|
4191
|
-
const eol = body
|
|
4192
|
-
|
|
4193
|
-
|
|
4194
|
-
|
|
4195
|
-
|
|
4196
|
-
const fresh = added.map((line) => `${line}${eol}`);
|
|
4197
|
-
if (at !== undefined) {
|
|
4198
|
-
lines.splice(at, 0, ...fresh);
|
|
4199
|
-
return lines.join(`
|
|
4200
|
-
`);
|
|
4201
|
-
}
|
|
5262
|
+
const eol = lineEnding(body);
|
|
5263
|
+
const at = insertionPoint(body.split(`
|
|
5264
|
+
`), body, section);
|
|
5265
|
+
if (at !== undefined)
|
|
5266
|
+
return insertLines(body, at, added);
|
|
4202
5267
|
const text = body.trimEnd();
|
|
4203
|
-
return `${text}${text === "" ? "" : `${eol}
|
|
4204
|
-
|
|
4205
|
-
`}${section === undefined ? "" : `${section}${eol}
|
|
4206
|
-
`}${fresh.join(`
|
|
4207
|
-
`)}${body.endsWith(`
|
|
4208
|
-
`) ? `
|
|
4209
|
-
` : ""}`;
|
|
5268
|
+
return `${text}${text === "" ? "" : `${eol}${eol}`}${section === undefined ? "" : `${section}${eol}`}${added.join(eol)}${body.endsWith(`
|
|
5269
|
+
`) ? eol : ""}`;
|
|
4210
5270
|
}
|
|
4211
5271
|
function listedIssues(body) {
|
|
4212
5272
|
return new Set(referencedBoxes(body).map(({ issue }) => issue));
|
|
@@ -4228,7 +5288,7 @@ Copies the unticked \`#<n>\` lines of issue <from> into issue <to>, skipping tho
|
|
|
4228
5288
|
Lines go under --section, created at the end of the body when missing, or else after the checklist's last box.
|
|
4229
5289
|
The body is read again just before it is written, so an edit made meanwhile is kept.`;
|
|
4230
5290
|
var carryExits = [[0, "it copied the lines"], [1, "Forgejo refuses"], [2, "a usage error"]];
|
|
4231
|
-
var
|
|
5291
|
+
var options6 = {
|
|
4232
5292
|
section: { type: "string", short: "s", description: 'the heading the lines go under, e.g. "Bugs:"' },
|
|
4233
5293
|
...repoOption
|
|
4234
5294
|
};
|
|
@@ -4240,7 +5300,7 @@ var plan = {
|
|
|
4240
5300
|
}
|
|
4241
5301
|
};
|
|
4242
5302
|
async function add(args) {
|
|
4243
|
-
const parsed = parse(args, addUsage,
|
|
5303
|
+
const parsed = parse(args, addUsage, options6, { exits: addExits });
|
|
4244
5304
|
const { section, repo } = parsed.values;
|
|
4245
5305
|
const [target, ...listed] = parsed.positionals;
|
|
4246
5306
|
const planNumber = issueNumber(target, addUsage);
|
|
@@ -4261,7 +5321,7 @@ ${addUsage}`);
|
|
|
4261
5321
|
return 0;
|
|
4262
5322
|
}
|
|
4263
5323
|
async function carry(args) {
|
|
4264
|
-
const parsed = parse(args, carryUsage,
|
|
5324
|
+
const parsed = parse(args, carryUsage, options6, { exits: carryExits });
|
|
4265
5325
|
const { section, repo } = parsed.values;
|
|
4266
5326
|
const from = issueNumber(parsed.positionals[0], carryUsage);
|
|
4267
5327
|
const to = issueNumber(parsed.positionals[1], carryUsage);
|
|
@@ -4282,147 +5342,20 @@ function report2(plan, added, skipped) {
|
|
|
4282
5342
|
}
|
|
4283
5343
|
|
|
4284
5344
|
// src/commands/release.ts
|
|
4285
|
-
import { basename as basename3, join as
|
|
4286
|
-
import
|
|
5345
|
+
import { basename as basename3, join as join14 } from "path";
|
|
5346
|
+
import process34 from "process";
|
|
4287
5347
|
var {$: $2 } = globalThis.Bun;
|
|
4288
5348
|
|
|
4289
|
-
// src/commands/
|
|
4290
|
-
var
|
|
4291
|
-
|
|
4292
|
-
|
|
4293
|
-
Prints nothing but failures and each run's final status with --quiet, and a JSON result with --json.`;
|
|
4294
|
-
var EXITS4 = [[0, "every one passed or was skipped"], [1, "one failed or was cancelled"], [2, "a timeout or a stalled queue"]];
|
|
4295
|
-
var options5 = {
|
|
4296
|
-
after: { type: "string", short: "a", description: "watch the runs newer than this run id, as `ft runs --json` gives it" },
|
|
4297
|
-
timeout: { type: "string", short: "t", description: "how long before giving up (15m), a bare number in minutes" },
|
|
4298
|
-
json: jsonOption("status, runs, failedJobs with their log excerpts and url; the progress goes to stderr"),
|
|
4299
|
-
quiet: { type: "boolean", short: "q", description: "print only the failures and each run's final status" },
|
|
4300
|
-
...repoOption
|
|
4301
|
-
};
|
|
4302
|
-
var timing = { poll: 1e4 };
|
|
4303
|
-
var LIMIT = 20;
|
|
4304
|
-
var STALLED2 = 3 * 60000;
|
|
4305
|
-
async function watchRuns(pick, timeout, repo, idle, out = process.stdout) {
|
|
4306
|
-
return (await followRuns(pick, timeout, repo, idle, out)).code;
|
|
4307
|
-
}
|
|
4308
|
-
async function followRuns(pick, timeout, repo, idle, out = process.stdout, mode = {}) {
|
|
4309
|
-
const { json = false, quiet = false } = mode;
|
|
4310
|
-
const started = Date.now();
|
|
4311
|
-
const latest = new Map;
|
|
4312
|
-
const seen = new Map;
|
|
4313
|
-
const line = (run) => runLine(run, out, seen.get(run.id) ?? Date.now());
|
|
4314
|
-
const region = takesControlCodes(out) && !quiet ? liveRegion((spinner) => [ciHeader(spinner, "CI", started, out), ...[...latest.values()].map((run) => ` ${line(run)}`)], out) : undefined;
|
|
4315
|
-
const followed = new Set;
|
|
4316
|
-
const failed = new Set;
|
|
4317
|
-
const failedJobs = [];
|
|
4318
|
-
let moving = started;
|
|
4319
|
-
async function poll() {
|
|
4320
|
-
const newest = await recentRuns(LIMIT, repo);
|
|
4321
|
-
const gone = await Promise.all([...followed].filter((id) => !newest.some((run) => run.id === id)).map(async (id) => runById(id, repo)));
|
|
4322
|
-
const runs = [...pick(newest), ...gone];
|
|
4323
|
-
for (const run of runs)
|
|
4324
|
-
followed.add(run.id);
|
|
4325
|
-
for (const run of runs) {
|
|
4326
|
-
if (!seen.has(run.id))
|
|
4327
|
-
seen.set(run.id, Date.now());
|
|
4328
|
-
if (region === undefined && !quiet && latest.get(run.id)?.status !== run.status)
|
|
4329
|
-
out.write(`${line(run)}
|
|
4330
|
-
`);
|
|
4331
|
-
latest.set(run.id, run);
|
|
4332
|
-
}
|
|
4333
|
-
region?.redraw();
|
|
4334
|
-
if (runs.length === 0) {
|
|
4335
|
-
if (idle !== undefined && Date.now() - started > idle) {
|
|
4336
|
-
if (!json)
|
|
4337
|
-
out.write(`no run started, so nothing was waited for
|
|
4338
|
-
`);
|
|
4339
|
-
return 0;
|
|
4340
|
-
}
|
|
4341
|
-
return;
|
|
4342
|
-
}
|
|
4343
|
-
for (const run of runs) {
|
|
4344
|
-
if (run.status === "failure" && !failed.has(run.id)) {
|
|
4345
|
-
const jobs = await failedJobsOf(run, repo);
|
|
4346
|
-
failedJobs.push(...jobs);
|
|
4347
|
-
if (!json)
|
|
4348
|
-
console.error(`
|
|
4349
|
-
${failureText2(jobs)}
|
|
4350
|
-
|
|
4351
|
-
${run.html_url}`);
|
|
4352
|
-
failed.add(run.id);
|
|
4353
|
-
}
|
|
4354
|
-
}
|
|
4355
|
-
if (runs.every((run) => FINISHED.has(run.status))) {
|
|
4356
|
-
const status = overall(runs);
|
|
4357
|
-
return status === "failure" || status === "cancelled" ? 1 : 0;
|
|
4358
|
-
}
|
|
4359
|
-
const stall = await stallReason(runs, repo);
|
|
4360
|
-
if (stall === undefined)
|
|
4361
|
-
moving = Date.now();
|
|
4362
|
-
else if (stall.certain || Date.now() - moving > STALLED2)
|
|
4363
|
-
fail(`queued runs are not moving: ${stall.reason}`);
|
|
4364
|
-
return;
|
|
4365
|
-
}
|
|
4366
|
-
async function settle() {
|
|
4367
|
-
for (;; ) {
|
|
4368
|
-
await Bun.sleep(timing.poll);
|
|
4369
|
-
if (Date.now() - started > timeout)
|
|
4370
|
-
fail(`the runs did not finish in ${formatDuration(timeout)}`);
|
|
4371
|
-
try {
|
|
4372
|
-
const code = await poll();
|
|
4373
|
-
if (code !== undefined)
|
|
4374
|
-
return code;
|
|
4375
|
-
} catch (error) {
|
|
4376
|
-
if (error instanceof Exit)
|
|
4377
|
-
throw error;
|
|
4378
|
-
const message = error instanceof Error ? error.message : String(error);
|
|
4379
|
-
if (isPermanentFailure(error))
|
|
4380
|
-
fail(message);
|
|
4381
|
-
if (!quiet)
|
|
4382
|
-
warn(`ft watch: ${message}, polling again`);
|
|
4383
|
-
}
|
|
4384
|
-
}
|
|
4385
|
-
}
|
|
5349
|
+
// src/commands/release-checks.ts
|
|
5350
|
+
var limits = { pushMs: 5 * 60000 };
|
|
5351
|
+
async function pushToOrigin(refspecs, onStart) {
|
|
5352
|
+
const prompts = askpass();
|
|
4386
5353
|
try {
|
|
4387
|
-
return
|
|
5354
|
+
return await runTool("git push", ["git", "push", ...refspecs], { timeoutMs: limits.pushMs, onStart, env: prompts?.env });
|
|
4388
5355
|
} finally {
|
|
4389
|
-
|
|
4390
|
-
if (region !== undefined || quiet) {
|
|
4391
|
-
for (const run of latest.values())
|
|
4392
|
-
out.write(`${line(run)}
|
|
4393
|
-
`);
|
|
4394
|
-
}
|
|
4395
|
-
}
|
|
4396
|
-
}
|
|
4397
|
-
async function watch2(args) {
|
|
4398
|
-
const parsed = parse(args, usage5, options5, { exits: EXITS4 });
|
|
4399
|
-
const { values } = parsed;
|
|
4400
|
-
const timeout = duration(values.timeout, "timeout", 15 * 60000, "m");
|
|
4401
|
-
const json = values.json === true;
|
|
4402
|
-
const mode = { json, quiet: values.quiet === true };
|
|
4403
|
-
async function follow(pick) {
|
|
4404
|
-
const followed = await followRuns(pick, timeout, values.repo, undefined, json ? process.stderr : process.stdout, mode);
|
|
4405
|
-
if (json)
|
|
4406
|
-
printJson(ciJson(followed.runs, followed.failedJobs));
|
|
4407
|
-
return followed.code;
|
|
4408
|
-
}
|
|
4409
|
-
if (values.after !== undefined) {
|
|
4410
|
-
const after = wholeNumber(values.after, "after", 0, 0);
|
|
4411
|
-
return follow((runs) => runs.filter((run) => run.id > after));
|
|
4412
|
-
}
|
|
4413
|
-
const active = new Set((await recentRuns(LIMIT, values.repo)).filter((run) => !FINISHED.has(run.status)).map((run) => run.id));
|
|
4414
|
-
if (active.size === 0) {
|
|
4415
|
-
if (json)
|
|
4416
|
-
printJson(ciJson([], []));
|
|
4417
|
-
else
|
|
4418
|
-
console.log("no run in progress");
|
|
4419
|
-
return 0;
|
|
5356
|
+
prompts?.close();
|
|
4420
5357
|
}
|
|
4421
|
-
return follow((runs) => runs.filter((run) => active.has(run.id)));
|
|
4422
5358
|
}
|
|
4423
|
-
|
|
4424
|
-
// src/commands/release-checks.ts
|
|
4425
|
-
var limits = { pushMs: 5 * 60000 };
|
|
4426
5359
|
var NO_RUN2 = 3 * 60000;
|
|
4427
5360
|
var RUNS_LOOKED_AT = 20;
|
|
4428
5361
|
async function alreadyPassed(sha) {
|
|
@@ -4439,7 +5372,7 @@ async function testsPass(sha, branch, timeout, json = false) {
|
|
|
4439
5372
|
const held = holdSignals();
|
|
4440
5373
|
let push;
|
|
4441
5374
|
try {
|
|
4442
|
-
push = await
|
|
5375
|
+
push = await pushToOrigin(["origin", `${sha}:refs/heads/${branch}`], (child) => held.forward(child));
|
|
4443
5376
|
} finally {
|
|
4444
5377
|
held.release();
|
|
4445
5378
|
}
|
|
@@ -4459,7 +5392,7 @@ ${push.stderr.trim()}`, 1);
|
|
|
4459
5392
|
|
|
4460
5393
|
// src/commands/release-many.ts
|
|
4461
5394
|
import { readdir } from "fs/promises";
|
|
4462
|
-
import { join as
|
|
5395
|
+
import { join as join11 } from "path";
|
|
4463
5396
|
|
|
4464
5397
|
// src/commands/release-version.ts
|
|
4465
5398
|
var LEVELS = new Set(["patch", "minor", "major", "prepatch", "preminor", "premajor", "prerelease"]);
|
|
@@ -4508,11 +5441,11 @@ function parseTargets(spec, level) {
|
|
|
4508
5441
|
});
|
|
4509
5442
|
}
|
|
4510
5443
|
async function publishable() {
|
|
4511
|
-
const root =
|
|
5444
|
+
const root = join11(await git(["rev-parse", "--show-toplevel"]), "packages");
|
|
4512
5445
|
const folders = (await readdir(root, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).toSorted();
|
|
4513
5446
|
const found = [];
|
|
4514
5447
|
for (const folder of folders) {
|
|
4515
|
-
const file = Bun.file(
|
|
5448
|
+
const file = Bun.file(join11(root, folder, "package.json"));
|
|
4516
5449
|
if (await file.exists() && (await file.json()).private !== true)
|
|
4517
5450
|
found.push(folder);
|
|
4518
5451
|
}
|
|
@@ -4520,13 +5453,13 @@ async function publishable() {
|
|
|
4520
5453
|
}
|
|
4521
5454
|
|
|
4522
5455
|
// src/commands/release-plan.ts
|
|
4523
|
-
import { basename as basename2, join as
|
|
4524
|
-
import
|
|
5456
|
+
import { basename as basename2, join as join12, relative } from "path";
|
|
5457
|
+
import process33 from "process";
|
|
4525
5458
|
async function planOf({ level, dir, prefix }, registry) {
|
|
4526
|
-
const file = Bun.file(
|
|
5459
|
+
const file = Bun.file(join12(dir ?? ".", "package.json"));
|
|
4527
5460
|
const pkg = await file.exists() ? await file.json() : undefined;
|
|
4528
|
-
const name = pkg?.name ?? basename2(dir ??
|
|
4529
|
-
const where = dir === undefined ? "" : ` in ${relative(
|
|
5461
|
+
const name = pkg?.name ?? basename2(dir ?? process33.cwd());
|
|
5462
|
+
const where = dir === undefined ? "" : ` in ${relative(process33.cwd(), dir) || "."}`;
|
|
4530
5463
|
let version;
|
|
4531
5464
|
let bump;
|
|
4532
5465
|
if (level === undefined) {
|
|
@@ -4538,7 +5471,7 @@ async function planOf({ level, dir, prefix }, registry) {
|
|
|
4538
5471
|
console.log(`would release ${name} ${version}, tagged ${tag}`);
|
|
4539
5472
|
} else {
|
|
4540
5473
|
if (pkg?.version === undefined)
|
|
4541
|
-
fail(`no version in ${
|
|
5474
|
+
fail(`no version in ${join12(dir ?? ".", "package.json")}`);
|
|
4542
5475
|
version = nextVersion(pkg.version, level);
|
|
4543
5476
|
bump = dir === undefined ? `bun pm version ${level}, which commits and tags ${prefix}${version}` : `bun pm version ${level} --no-git-tag-version${where}, then commit it with bun.lock refreshed and tag ${prefix}${version}`;
|
|
4544
5477
|
console.log(`would release ${name} ${pkg.version} -> ${version}, tagged ${prefix}${version}`);
|
|
@@ -4565,25 +5498,26 @@ async function printPlan({ releases, branch, base, timeout, registry }) {
|
|
|
4565
5498
|
}
|
|
4566
5499
|
|
|
4567
5500
|
// src/commands/release-steps.ts
|
|
4568
|
-
import { join as
|
|
5501
|
+
import { join as join13, relative as relative2, resolve as resolve5 } from "path";
|
|
5502
|
+
init_text();
|
|
4569
5503
|
var {$ } = globalThis.Bun;
|
|
4570
5504
|
var registryWait = { tries: 12, poll: 5000 };
|
|
4571
5505
|
var REGISTRY_INFO_MS = 30000;
|
|
4572
5506
|
async function packageDir(value) {
|
|
4573
|
-
for (const dir of [resolve5(value),
|
|
4574
|
-
if (await Bun.file(
|
|
5507
|
+
for (const dir of [resolve5(value), join13(await git(["rev-parse", "--show-toplevel"]), "packages", value)]) {
|
|
5508
|
+
if (await Bun.file(join13(dir, "package.json")).exists())
|
|
4575
5509
|
return dir;
|
|
4576
5510
|
}
|
|
4577
5511
|
fail(`no package.json in ${value} nor in packages/${value}`);
|
|
4578
5512
|
}
|
|
4579
5513
|
async function commitPackageBump(dir, prefix) {
|
|
4580
|
-
const { version } = await Bun.file(
|
|
5514
|
+
const { version } = await Bun.file(join13(dir, "package.json")).json();
|
|
4581
5515
|
const root = await git(["rev-parse", "--show-toplevel"]);
|
|
4582
5516
|
const tag = `${prefix}${version}`;
|
|
4583
5517
|
const lock = await $`bun install --lockfile-only`.cwd(root).quiet().nothrow();
|
|
4584
5518
|
if (lock.exitCode !== 0)
|
|
4585
5519
|
fail(`bun install --lockfile-only after the bump: ${lock.stderr.toString().trim()}`);
|
|
4586
|
-
await git(["add",
|
|
5520
|
+
await git(["add", join13(dir, "package.json"), join13(root, "bun.lock")]);
|
|
4587
5521
|
await git(["commit", "-q", "-m", tag]);
|
|
4588
5522
|
await git(["tag", "-a", tag, "-m", tag]);
|
|
4589
5523
|
}
|
|
@@ -4607,11 +5541,11 @@ async function rollBack(preBump, dirs) {
|
|
|
4607
5541
|
try {
|
|
4608
5542
|
if (dirs.length > 0) {
|
|
4609
5543
|
const root = await git(["rev-parse", "--show-toplevel"]);
|
|
4610
|
-
const paths = [...dirs.map((dir) =>
|
|
5544
|
+
const paths = [...dirs.map((dir) => join13(dir, "package.json")), join13(root, "bun.lock")].map((path) => relative2(root, path));
|
|
4611
5545
|
const tracked = (await git(["ls-tree", "-r", "--full-tree", "--name-only", "HEAD", "--", ...paths])).split(`
|
|
4612
5546
|
`).filter((path) => path !== "");
|
|
4613
5547
|
if (tracked.length > 0)
|
|
4614
|
-
await git(["restore", "--source=HEAD", "--staged", "--worktree", "--", ...tracked.map((path) =>
|
|
5548
|
+
await git(["restore", "--source=HEAD", "--staged", "--worktree", "--", ...tracked.map((path) => join13(root, path))]);
|
|
4615
5549
|
}
|
|
4616
5550
|
for (const commit of (await git(["rev-list", `${preBump}..HEAD`])).split(`
|
|
4617
5551
|
`).filter(Boolean)) {
|
|
@@ -4630,7 +5564,7 @@ async function settleMilestone(version, tag, say = console.log) {
|
|
|
4630
5564
|
if (found === undefined)
|
|
4631
5565
|
return;
|
|
4632
5566
|
const [done, left] = await Promise.all([closedIssues(found.id), openIssues(undefined, undefined, found.id)]);
|
|
4633
|
-
say(`milestone ${found.title}: ${
|
|
5567
|
+
say(`milestone ${found.title}: ${bo(done.length, "closed issue")}${done.length === 0 ? "" : `
|
|
4634
5568
|
${done.map((issue) => ` #${issue.number} ${issue.title}`).join(`
|
|
4635
5569
|
`)}`}`);
|
|
4636
5570
|
if (left.length > 0)
|
|
@@ -4644,31 +5578,27 @@ ${done.map((issue) => ` #${issue.number} ${issue.title}`).join(`
|
|
|
4644
5578
|
|
|
4645
5579
|
// src/commands/release.ts
|
|
4646
5580
|
var SEVERAL = /[,:]/;
|
|
4647
|
-
var
|
|
5581
|
+
var usage7 = `ft release <patch|minor|major|x.y.z>
|
|
4648
5582
|
ft release <level> -p <a,b:minor,...>
|
|
4649
5583
|
ft release <level> --all
|
|
4650
5584
|
ft release --tagged
|
|
4651
5585
|
|
|
4652
|
-
Cuts a release from the default branch:
|
|
4653
|
-
|
|
4654
|
-
--package releases
|
|
4655
|
-
|
|
4656
|
-
|
|
4657
|
-
|
|
4658
|
-
--dry-run checks the same and prints the plan: the version bump, the tag, the pushes and the runs and registry it would wait for, changing nothing.
|
|
4659
|
-
--json prints {released, tag, package, version, status, runs, failedJobs, url} on stdout and the progress on stderr, an array of them with --package a,b or --all; it does not take --dry-run.`;
|
|
4660
|
-
var EXITS5 = [[0, "released or planned"], [1, "a run fails, origin refuses a push or the registry never serves the version"], [2, "a timeout, a stalled queue, a refusal before anything ran (another branch, uncommitted changes, origin ahead) or a usage error"]];
|
|
4661
|
-
var options6 = {
|
|
5586
|
+
Cuts a release from the default branch: waits for the runs on HEAD, bumps and tags with \`bun pm version\`, pushes, then waits for the runs and the registry.
|
|
5587
|
+
Failing tests stop it before anything is bumped or tagged, and a refused or interrupted push drops the bump commits and their tags; with --tagged the commit and tag are yours and stay.
|
|
5588
|
+
--package releases workspace packages tagged \`<folder>-v<version>\`, each with an optional level of its own (\`-p ft:minor,db\`), --all every published one, in one atomic push.
|
|
5589
|
+
Once released, an open milestone titled like the version has its closed issues listed and is closed; a failure there only warns.`;
|
|
5590
|
+
var EXITS6 = [[0, "released or planned"], [1, "a run fails, origin refuses a push or the registry never serves the version"], [2, "a timeout, a stalled queue, a refusal before anything ran (another branch, uncommitted changes, origin ahead) or a usage error"]];
|
|
5591
|
+
var options7 = {
|
|
4662
5592
|
tagged: { type: "boolean", description: "push the version commit and tag already at HEAD instead of bumping" },
|
|
4663
5593
|
package: { type: "string", short: "p", description: "workspace folder to release, a path or a name under packages/, several separated by commas" },
|
|
4664
5594
|
all: { type: "boolean", description: "release every published package of the workspace in one push" },
|
|
4665
5595
|
"no-registry": { type: "boolean", description: "do not wait for the registry to serve the new version" },
|
|
4666
5596
|
"dry-run": { type: "boolean", description: "print what the release would do, changing nothing" },
|
|
4667
5597
|
timeout: { type: "string", short: "t", description: "how long to wait for the runs (15m), a bare number in minutes" },
|
|
4668
|
-
json: jsonOption("
|
|
5598
|
+
json: jsonOption("{released, tag, package, version, status, runs, failedJobs, url} on stdout and the progress on stderr, an array with several packages; not with --dry-run")
|
|
4669
5599
|
};
|
|
4670
5600
|
async function release(args) {
|
|
4671
|
-
const parsed = parse(args,
|
|
5601
|
+
const parsed = parse(args, usage7, options7, { exits: EXITS6 });
|
|
4672
5602
|
const { values, positionals } = parsed;
|
|
4673
5603
|
const json = values.json === true;
|
|
4674
5604
|
const say = json ? console.error : console.log;
|
|
@@ -4679,7 +5609,7 @@ async function release(args) {
|
|
|
4679
5609
|
if (tagged === (level !== undefined))
|
|
4680
5610
|
fail(`give a level or --tagged
|
|
4681
5611
|
|
|
4682
|
-
${
|
|
5612
|
+
${usage7}`);
|
|
4683
5613
|
if (level !== undefined && !LEVELS.has(level) && !VERSION.test(level))
|
|
4684
5614
|
fail(`${level} is no level nor x.y.z version`);
|
|
4685
5615
|
const several = values.all === true || SEVERAL.test(values.package ?? "");
|
|
@@ -4698,8 +5628,7 @@ ${usage6}`);
|
|
|
4698
5628
|
fail(`a release is cut from ${branch}, not ${current || "a detached HEAD"}`, 2, runHint(`git switch ${branch}`));
|
|
4699
5629
|
if (await git(["status", "--porcelain"]) !== "")
|
|
4700
5630
|
fail("the tree has uncommitted changes", 2, runHint("gst", "see them, then commit them with gc"));
|
|
4701
|
-
await fetchBranch(branch)
|
|
4702
|
-
if ((await $2`git merge-base --is-ancestor ${`origin/${branch}`} HEAD`.quiet().nothrow()).exitCode !== 0)
|
|
5631
|
+
if (await fetchBranch(branch) && (await $2`git merge-base --is-ancestor ${`origin/${branch}`} HEAD`.quiet().nothrow()).exitCode !== 0)
|
|
4703
5632
|
fail(`origin/${branch} has commits HEAD lacks`, 2, runHint(`git pull --rebase origin ${branch}`));
|
|
4704
5633
|
const base = await git(["rev-parse", tagged ? "HEAD~1" : "HEAD"]);
|
|
4705
5634
|
if (values["dry-run"] === true)
|
|
@@ -4733,7 +5662,7 @@ ${usage6}`);
|
|
|
4733
5662
|
const tags = bumped.map((each) => each.tag);
|
|
4734
5663
|
let push;
|
|
4735
5664
|
try {
|
|
4736
|
-
push = await
|
|
5665
|
+
push = await pushToOrigin(["--atomic", "origin", `HEAD:refs/heads/${branch}`, ...tags.map((tag) => `refs/tags/${tag}`)], (child) => held.forward(child));
|
|
4737
5666
|
} catch (error) {
|
|
4738
5667
|
isPushUnknown = true;
|
|
4739
5668
|
fail(`${error instanceof Error ? error.message : String(error)}, so ${tags.join(", ")} and ${tags.length === 1 ? "its commit are" : "their commits are"} kept: the push may have landed`, 2, tags.length === 1 ? `git ls-remote origin refs/tags/${tags[0]} tells; if it is there, ft release --tagged waits for its runs` : `git ls-remote --tags origin tells; if they are there, ft watch --after ${before} waits for their runs`);
|
|
@@ -4752,7 +5681,7 @@ ${push.stderr.trim()}`, signal === undefined ? 1 : exitCodeOf(null, signal));
|
|
|
4752
5681
|
}
|
|
4753
5682
|
const heads = new Set(bumped.map((each) => each.head));
|
|
4754
5683
|
const manifests = await Promise.all(bumped.map(async (each) => {
|
|
4755
|
-
const file = Bun.file(
|
|
5684
|
+
const file = Bun.file(join14(each.dir ?? ".", "package.json"));
|
|
4756
5685
|
return await file.exists() ? await file.json() : undefined;
|
|
4757
5686
|
}));
|
|
4758
5687
|
const released = new Set;
|
|
@@ -4771,7 +5700,7 @@ ${push.stderr.trim()}`, signal === undefined ? 1 : exitCodeOf(null, signal));
|
|
|
4771
5700
|
if (late !== undefined)
|
|
4772
5701
|
fail(`interrupted by ${late} after ${bumped.map((each) => each.tag).join(", ")} ${bumped.length === 1 ? "was pushed: its runs are" : "were pushed: their runs are"} not waited for`, exitCodeOf(null, late));
|
|
4773
5702
|
say(`pushed ${branch} and ${bumped.map((each) => each.tag).join(", ")}, waiting for their runs`);
|
|
4774
|
-
followed = await followRuns((runs) => runs.filter((run) => run.id > before && heads.has(run.commit_sha)), timeout, undefined, NO_RUN2, json ?
|
|
5703
|
+
followed = await followRuns((runs) => runs.filter((run) => run.id > before && heads.has(run.commit_sha)), timeout, undefined, NO_RUN2, json ? process34.stderr : process34.stdout, { json });
|
|
4775
5704
|
if (followed.code !== 0) {
|
|
4776
5705
|
report();
|
|
4777
5706
|
return followed.code;
|
|
@@ -4800,15 +5729,15 @@ ${push.stderr.trim()}`, signal === undefined ? 1 : exitCodeOf(null, signal));
|
|
|
4800
5729
|
}
|
|
4801
5730
|
|
|
4802
5731
|
// src/commands/remote.ts
|
|
4803
|
-
import { lookup } from "dns/promises";
|
|
5732
|
+
import { lookup as lookup2 } from "dns/promises";
|
|
4804
5733
|
var {$: $3 } = globalThis.Bun;
|
|
4805
|
-
var
|
|
5734
|
+
var usage8 = `ft remote [--fix]
|
|
4806
5735
|
|
|
4807
5736
|
Checks that origin's URLs name the Forgejo host itself: tea only finds the repository when origin's host is the login's ssh_host, never through an ssh alias such as \`forgejo\` or \`gitea\`.
|
|
4808
5737
|
--fix switches every alias URL to \`git@<host>:<owner>/<repo>.git\` and proves it with \`git ls-remote\`.
|
|
4809
5738
|
The host comes from --host, else \`remoteHost\` in ~/.config/kaynooo-cli/ft.json; with neither, it checks nothing.`;
|
|
4810
|
-
var
|
|
4811
|
-
var
|
|
5739
|
+
var EXITS7 = [[0, "origin names the Forgejo host (or was switched) or no host is set"], [1, "it does not or a switch is still to run"], [2, "a usage error"]];
|
|
5740
|
+
var options8 = {
|
|
4812
5741
|
host: { type: "string", description: "the Forgejo ssh host, instead of remoteHost in ~/.config/kaynooo-cli/ft.json" },
|
|
4813
5742
|
fix: { type: "boolean", description: "rewrite the alias URLs" }
|
|
4814
5743
|
};
|
|
@@ -4824,7 +5753,7 @@ async function sshHostname(alias) {
|
|
|
4824
5753
|
}
|
|
4825
5754
|
async function addresses(name) {
|
|
4826
5755
|
try {
|
|
4827
|
-
return (await
|
|
5756
|
+
return (await lookup2(name, { all: true })).map((entry) => entry.address);
|
|
4828
5757
|
} catch {
|
|
4829
5758
|
return [];
|
|
4830
5759
|
}
|
|
@@ -4841,7 +5770,7 @@ function originHost2(url) {
|
|
|
4841
5770
|
return parseSshRemote(url)?.host ?? (URL.canParse(url) ? new URL(url).hostname : undefined);
|
|
4842
5771
|
}
|
|
4843
5772
|
async function remote(args, home) {
|
|
4844
|
-
const { values } = parse(args,
|
|
5773
|
+
const { values } = parse(args, usage8, options8, { exits: EXITS7 });
|
|
4845
5774
|
const host = values.host ?? (await loadSettings(home)).remoteHost;
|
|
4846
5775
|
if (host === undefined) {
|
|
4847
5776
|
note(`no Forgejo host to check origin against: pass --host, or set "remoteHost" in ${settingsPath(home)}`);
|
|
@@ -4897,14 +5826,14 @@ async function remote(args, home) {
|
|
|
4897
5826
|
}
|
|
4898
5827
|
|
|
4899
5828
|
// src/commands/runs.ts
|
|
4900
|
-
var
|
|
5829
|
+
var usage9 = `ft runs [--sha <ref>]
|
|
4901
5830
|
|
|
4902
5831
|
Lists recent runs with what tea's own listing leaves empty: workflow, ref, duration and age, ten by default with the count of the rest (--full for all of them; --json is never cut unless --limit is given).
|
|
4903
5832
|
|
|
4904
5833
|
--open also opens the newest run listed in the browser.`;
|
|
4905
|
-
var
|
|
5834
|
+
var EXITS8 = [[0, "it listed them"], [1, "Forgejo or git cannot be read"], [2, "a usage error"]];
|
|
4906
5835
|
var DEFAULT_LIMIT = 10;
|
|
4907
|
-
var
|
|
5836
|
+
var options9 = {
|
|
4908
5837
|
...limitOptions(DEFAULT_LIMIT),
|
|
4909
5838
|
sha: { type: "string", short: "s", description: "only the runs of this commit" },
|
|
4910
5839
|
workflow: { type: "string", short: "w", description: "only this workflow file, e.g. test.yml" },
|
|
@@ -4918,7 +5847,7 @@ async function onCommit(sha, repo) {
|
|
|
4918
5847
|
return { runs: found, total: found.length };
|
|
4919
5848
|
}
|
|
4920
5849
|
async function runs(args) {
|
|
4921
|
-
const parsed = parse(args,
|
|
5850
|
+
const parsed = parse(args, usage9, options9, { exits: EXITS8 });
|
|
4922
5851
|
const { values } = parsed;
|
|
4923
5852
|
const limit = limitOf(values, DEFAULT_LIMIT);
|
|
4924
5853
|
const { runs: found, total } = values.sha === undefined ? await runsListing(limit, values.repo, values.workflow) : await onCommit(values.sha, values.repo);
|
|
@@ -4946,7 +5875,7 @@ async function runs(args) {
|
|
|
4946
5875
|
}
|
|
4947
5876
|
|
|
4948
5877
|
// src/cli.ts
|
|
4949
|
-
|
|
5878
|
+
process35.exitCode = await runCli({
|
|
4950
5879
|
name: "ft",
|
|
4951
5880
|
about: "Forgejo tools over tea, run from a repository whose origin is on Forgejo",
|
|
4952
5881
|
replaces: "tea api calls piped through jq, and sleep loops waiting on CI",
|
|
@@ -4955,6 +5884,7 @@ process31.exitCode = await runCli({
|
|
|
4955
5884
|
runs: { run: runs, summary: "recent runs with workflow, ref, duration and age", group: "CI and release" },
|
|
4956
5885
|
ci: { run: ci2, summary: "wait for the runs covering a commit, printing what failed", group: "CI and release" },
|
|
4957
5886
|
watch: { run: watch2, summary: "wait for runs newer than an id, or those in progress", group: "CI and release" },
|
|
5887
|
+
dispatch: { run: dispatch2, summary: "start a workflow_dispatch run, --wait to follow it to its end", group: "CI and release" },
|
|
4958
5888
|
logs: { run: logs2, summary: "what the failed jobs of a run say went wrong", group: "CI and release" },
|
|
4959
5889
|
release: { run: release, summary: "bump, push branch and tag atomically, wait for runs and registry", group: "CI and release" },
|
|
4960
5890
|
board: { run: board, summary: "open issues: available, taken by a live session, or claimed by one gone", group: "Issues and claims" },
|
|
@@ -4963,7 +5893,7 @@ process31.exitCode = await runCli({
|
|
|
4963
5893
|
drop: { run: drop, summary: "give back an issue this session took", group: "Issues and claims" },
|
|
4964
5894
|
issue: { run: issue, summary: "an issue's claim, description and numbered boxes, -c comments", group: "Issues and claims" },
|
|
4965
5895
|
new: { run: newIssue, summary: "create an issue from -t and a description file or stdin", group: "Issues and claims" },
|
|
4966
|
-
edit: { run:
|
|
5896
|
+
edit: { run: edit2, summary: "replace an issue's title or description, from a file or stdin", group: "Issues and claims" },
|
|
4967
5897
|
tick: { run: tick, summary: "tick checklist boxes of an issue, -m to comment too", group: "Issues and claims" },
|
|
4968
5898
|
comment: { run: commentOn, summary: "comment on an issue, from stdin when no text is given", group: "Issues and claims" },
|
|
4969
5899
|
fixed: { run: fixed, summary: 'comment "Fixed in <sha>" and close an issue', group: "Issues and claims" },
|