@coffre/cli 0.1.13 → 0.1.15

package/dist/update-eYzLTNoL.js

@@ -0,0 +1,334 @@
+import { i as templateDir } from "./init-2xGelVG1.js";
+import { a as openTerminal, c as release, d as style, i as listed, t as Cancelled } from "./tty-BDa14JX2.js";
+import { n as StepFailed, r as Steps, t as cliVersion } from "./version-CPk6zTTK.js";
+import { c as minimumReleaseAge, f as removeCleared, i as deploymentKind, l as pinPackageManager, n as bumpPins, o as excludeUntil, r as coffrePins, s as install, t as HeldBack } from "./deployment-Di8BG9qY.js";
+import { createRequire } from "node:module";
+import { parseArgs } from "node:util";
+import { spawn, spawnSync } from "node:child_process";
+import { readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, join, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+* Every migration this version ships, oldest first, per engine: read from
+* the journals at build time, so a Worker, which has no files, knows them
+* too. A database that has applied fewer is behind this code, whatever
+* `REQUIRED_MIGRATIONS` lets it run on.
+*/
+const KNOWN_MIGRATIONS = {
+	postgres: [{
+		"idx": 0,
+		"version": "7",
+		"when": 1790930587507,
+		"tag": "0000_baseline",
+		"breakpoints": true
+	}, {
+		"idx": 1,
+		"version": "7",
+		"when": 1791062292678,
+		"tag": "0001_remove_syncs",
+		"breakpoints": true
+	}].map((entry) => entry.tag),
+	sqlite: [{
+		"idx": 0,
+		"version": "6",
+		"when": 1790874462505,
+		"tag": "0000_baseline",
+		"breakpoints": true
+	}, {
+		"idx": 1,
+		"version": "6",
+		"when": 1791062293531,
+		"tag": "0001_remove_syncs",
+		"breakpoints": true
+	}].map((entry) => entry.tag)
+};
+//#endregion
+//#region src/update.ts
+const PACKAGE = "@coffre/cli";
+/**
+* How the CLI at `path` was installed: under npx's cache, a global root
+* (`npm root -g`, `pnpm root -g`), a project's node_modules, or a checkout.
+*/
+function installOf(path, roots) {
+	if (path.includes(`${sep}_npx${sep}`)) return { kind: "npx" };
+	if (roots.pnpm !== null && path.startsWith(dirname(roots.pnpm) + sep)) return { kind: "pnpm" };
+	if (roots.npm !== null && path.startsWith(roots.npm + sep)) return { kind: "npm" };
+	const modules = path.lastIndexOf(`${sep}node_modules${sep}`);
+	if (modules !== -1) return {
+		kind: "project",
+		dir: path.slice(0, modules)
+	};
+	if (path.includes(`${sep}packages${sep}cli${sep}`)) return { kind: "checkout" };
+	return { kind: "unknown" };
+}
+/** The migrations a deployment's installed coffre ships, through its server's own @coffre/db; null before an install. */
+function deploymentMigrations(dir) {
+	try {
+		const server = createRequire(realpathSync(join(dir, "node_modules", "@coffre", "server", "package.json")));
+		return journalTags(join(dirname(server.resolve("@coffre/db/package.json")), "dist", "migrations", "postgres"));
+	} catch {
+		return null;
+	}
+}
+function journalTags(folder) {
+	return JSON.parse(readFileSync(join(folder, "meta", "_journal.json"), "utf8")).entries.map((entry) => entry.tag);
+}
+/**
+* What moving from version `from` to `to` asks of the database, said once it
+* is installed: the migrations `after` has and `before` did not.
+*/
+function migrationsAdded(from, to, before, after) {
+	const added = after.filter((tag) => !before.includes(tag));
+	if (added.length === 0) return `coffre ${to} adds no migration to ${from}'s: deploying it is all.`;
+	return `coffre ${to} adds ${added.length === 1 ? "1 migration" : `${added.length} migrations`} to ${from}'s (${listed(added, "and")}): after deploying, run \`coffre migrate\`.`;
+}
+/** coffre's latest release, as the registry has it. */
+async function latestVersion() {
+	const registry = (process.env.npm_config_registry ?? "https://registry.npmjs.org/").replace(/\/?$/, "/");
+	const response = await fetch(`${registry}${PACKAGE}/latest`, { headers: { accept: "application/json" } });
+	if (!response.ok) throw new Error(`${registry} answered ${response.status} for ${PACKAGE}`);
+	return (await response.json()).version;
+}
+function globalRoot(manager) {
+	const ran = spawnSync(manager, ["root", "-g"], {
+		encoding: "utf8",
+		timeout: 1e4
+	});
+	const root = ran.status === 0 ? ran.stdout.trim() : "";
+	if (root === "") return null;
+	try {
+		return realpathSync(root);
+	} catch {
+		return root;
+	}
+}
+/** A command, its output kept to explain a failure. */
+function command(name, args, cwd) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(name, args, {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				COREPACK_ENABLE_DOWNLOAD_PROMPT: "0"
+			}
+		});
+		let output = "";
+		child.stdout.setEncoding("utf8").on("data", (chunk) => output += chunk);
+		child.stderr.setEncoding("utf8").on("data", (chunk) => output += chunk);
+		child.on("error", () => reject(/* @__PURE__ */ new Error(`${name} is not installed`)));
+		child.on("close", (code) => {
+			if (code === 0) return resolve();
+			if (/minimumReleaseAge|minimum-release-age/i.test(output)) return reject(/* @__PURE__ */ new Error(`${name} holds back releases newer than its minimumReleaseAge, and this one is new: wait, or allow @coffre/* (minimumReleaseAgeExclude), as a deployment coffre init writes does`));
+			reject(/* @__PURE__ */ new Error(`${name} ${args.join(" ")} failed: ${output.trim().split("\n").slice(-3).join(" ")}`));
+		});
+	});
+}
+async function update(args) {
+	let yes;
+	try {
+		({yes} = parseArgs({
+			args,
+			options: { yes: {
+				type: "boolean",
+				default: false
+			} },
+			strict: true
+		}).values);
+	} catch {
+		process.stderr.write("usage: coffre update [--yes]\n");
+		process.exit(2);
+	}
+	const terminal = openTerminal();
+	const out = terminal?.out ?? process.stderr;
+	const s = style(out);
+	const keys = () => terminal?.keys ?? null;
+	const ask = async (question, step) => {
+		if (yes) return true;
+		if (keys() === null) throw new Error("nothing here to confirm on: run coffre update on a terminal, or pass --yes");
+		return step.ask(question);
+	};
+	const current = cliVersion();
+	const self = realpathSync(fileURLToPath(import.meta.url));
+	const how = installOf(self, {
+		npm: globalRoot("npm"),
+		pnpm: globalRoot("pnpm")
+	});
+	const dir = process.cwd();
+	const kind = deploymentKind(dir);
+	const deployment = kind === "workers" || kind === "node" ? dir : null;
+	const pins = deployment === null ? {} : coffrePins(deployment);
+	const pinned = [...new Set(Object.values(pins))];
+	if (s.ansi) out.write(`\n  ${s.bold("coffre update")}  ${s.dim(`this CLI${deployment === null ? "" : ", and this deployment"}`)}\n\n`);
+	const steps = new Steps(out, [
+		"Look up coffre's latest release",
+		"Update this CLI",
+		...deployment === null ? [] : ["Update this deployment's coffre packages"]
+	], keys, (error) => error instanceof Error ? error.message : String(error));
+	let before = (deployment === null ? null : deploymentMigrations(deployment)) ?? KNOWN_MIGRATIONS.postgres;
+	const from = deployment !== null && pinned.length === 1 ? pinned[0] : current;
+	let after = null;
+	let latest = current;
+	try {
+		await steps.run(0, async () => {
+			latest = await latestVersion();
+			return `coffre ${latest} is the latest release; this CLI is ${current}`;
+		});
+		await steps.run(1, async (step) => {
+			if (current === latest) return `This CLI is up to date, at ${current}`;
+			switch (how.kind) {
+				case "npx": return {
+					text: "Nothing to update: npx runs the version it is given",
+					details: [`npx ${PACKAGE}@${latest} … runs ${latest}`]
+				};
+				case "checkout": return {
+					text: "Nothing to update here: this CLI runs from a checkout of coffre",
+					details: ["git pull, then pnpm install and pnpm build"]
+				};
+				case "project": return how.dir === deployment ? {
+					text: `This CLI is one of the deployment's packages, updated with them below`,
+					details: []
+				} : {
+					text: `Nothing updated: this CLI is a dependency of ${how.dir}`,
+					details: [`update it there: its @coffre/cli pin, to ${latest}`]
+				};
+				case "unknown": return {
+					text: "Nothing updated: where this CLI was installed from is unclear",
+					details: [`npm install -g ${PACKAGE}@${latest}, or pnpm add -g ${PACKAGE}@${latest}`]
+				};
+				default: {
+					const run = how.kind === "npm" ? ["npm", [
+						"install",
+						"-g",
+						`${PACKAGE}@${latest}`
+					]] : ["pnpm", [
+						"add",
+						"-g",
+						`${PACKAGE}@${latest}`
+					]];
+					if (!await ask(`Update this CLI from ${current} to ${latest}, with ${run[0]} ${run[1].join(" ")}?`, step)) return {
+						text: `This CLI stays at ${current}`,
+						details: []
+					};
+					step.note(`Updating this CLI, with ${run[0]}`);
+					await command(run[0], [...run[1]], dir);
+					after ??= journalTags(join(dirname(self), "migrations", "postgres"));
+					return `Updated this CLI from ${current} to ${latest}, with ${run[0]}`;
+				}
+			}
+		});
+		if (deployment !== null) await steps.run(2, async (step) => {
+			const details = [];
+			const cleared = removeCleared(deployment, /* @__PURE__ */ new Date());
+			if (cleared.length > 0) details.push(`No longer excluded from minimumReleaseAge, now old enough: ${listed(cleared, "and")}`);
+			const pnpm = templatePackageManager(kind);
+			const repin = pnpm !== null && coffrePackageManager(deployment) !== pnpm;
+			const current = pinned.length === 1 && pinned[0] === latest;
+			if (current && !repin) return {
+				text: `This deployment's coffre packages are at ${latest} already`,
+				details
+			};
+			const was = pinned.length === 1 ? pinned[0] : listed(pinned, "and");
+			const on = pnpm?.replace("@", " ");
+			const question = current ? `Pin this deployment to ${on}, as coffre installs with, and install it?` : `Move this deployment from ${was} to ${latest}${repin ? `, on ${on},` : ""} and install it?`;
+			if (!await ask(question, step)) return {
+				text: `This deployment stays as it is, at ${was}`,
+				details
+			};
+			before = deploymentMigrations(deployment) ?? before;
+			const manifest = join(deployment, "package.json");
+			const saved = readFileSync(manifest, "utf8");
+			bumpPins(deployment, latest);
+			if (repin) {
+				const replaced = pinPackageManager(deployment, pnpm);
+				details.push(`Pinned ${pnpm}${replaced ? `, not ${replaced}` : ""}: every install, here, in CI and on Workers Builds, holds minimumReleaseAge alike`);
+			}
+			step.note(`Installing coffre ${latest}'s packages, with pnpm`);
+			try {
+				await install(deployment);
+			} catch (error) {
+				if (!(error instanceof HeldBack)) throw error;
+				const age = minimumReleaseAge(deployment);
+				const clears = error.held.map(({ spec, publishedAt }) => ({
+					spec,
+					clears: new Date(publishedAt.getTime() + age * 6e4)
+				})).sort((x, y) => x.clears.getTime() - y.clears.getTime());
+				const last = clears.at(-1).clears;
+				const lines = clears.map(({ spec, clears: at }) => `${spec}, old enough from ${when(at)}`);
+				const held = `pnpm holds back ${clears.length === 1 ? "1 package" : `${clears.length} packages`} younger than this deployment's minimumReleaseAge, ${days(age)}`;
+				if (yes || keys() === null) {
+					writeFileSync(manifest, saved);
+					throw new Error(`${held}: ${lines.join("; ")}. Run coffre update after ${when(last)}, or on a terminal to exclude them until then`);
+				}
+				step.under(lines);
+				const choice = await step.choose(held, [`Wait: stay at ${was}, and run coffre update again after ${when(last)}`, `Proceed: let ${clears.length === 1 ? "it" : "these"} through until each is old enough, named in pnpm-workspace.yaml`]);
+				step.under([]);
+				if (choice === 0) {
+					writeFileSync(manifest, saved);
+					return {
+						text: `This deployment stays at ${was}, until ${when(last)}`,
+						details: [
+							...details,
+							...lines,
+							`Run coffre update again after ${when(last)}`
+						]
+					};
+				}
+				excludeUntil(deployment, clears, `for coffre ${latest}`);
+				step.note(`Installing coffre ${latest}'s packages, with pnpm`);
+				await install(deployment);
+				details.push("Let through until each is old enough, named in pnpm-workspace.yaml:", ...clears.map(({ spec, clears: at }) => `  ${spec}, until ${when(at)}`), `The first coffre update after ${when(last)} removes them`);
+			}
+			after = deploymentMigrations(deployment) ?? after;
+			return {
+				text: current ? `Pinned ${pnpm}, and installed it` : `Moved this deployment from ${was} to ${latest}, and installed it`,
+				details
+			};
+		});
+	} catch (error) {
+		if (error instanceof Cancelled) finish(out, `${s.red("✗")} cancelled; nothing after the last step done was changed`, 130);
+		if (error instanceof StepFailed) finish(out, "", 1);
+		finish(out, `${s.red("✗")} ${error instanceof Error ? error.message : String(error)}`, 1);
+	} finally {
+		steps.end();
+		if (terminal !== null) release(terminal.keys);
+	}
+	out.write("\n");
+	if (after !== null) {
+		out.write(`  ${migrationsAdded(from, latest, before, after)}\n`);
+		if (deployment !== null) {
+			const deploy = kind === "workers" ? "`pnpm run deploy`, or a push for Workers Builds" : "restarting the server";
+			out.write(`  ${s.dim(`Deploy it as you do: ${deploy}.`)}\n`);
+		}
+		out.write("\n");
+	}
+}
+/** The pnpm coffre installs with, as the template of a deployment of `kind` pins it. */
+function templatePackageManager(kind) {
+	try {
+		return JSON.parse(readFileSync(join(templateDir(kind), "package.json"), "utf8")).packageManager ?? null;
+	} catch {
+		return null;
+	}
+}
+function coffrePackageManager(dir) {
+	return JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).packageManager;
+}
+/** A moment, to the minute, in UTC: when a package is old enough. */
+function when(date) {
+	return `${date.toISOString().slice(0, 16).replace("T", " ")} UTC`;
+}
+function days(minutes) {
+	const d = minutes / 1440;
+	return Number.isInteger(d) ? `${d} day${d === 1 ? "" : "s"}` : `${minutes} minutes`;
+}
+function finish(out, message, code) {
+	if (message !== "") out.write(`${message}\n`);
+	process.exit(code);
+}
+//#endregion
+export { update };

package/dist/version-CPk6zTTK.js

@@ -0,0 +1,317 @@
+import { d as style, g as yes, h as wrap, m as width, n as edit, p as truncate, s as readKeys, t as Cancelled } from "./tty-BDa14JX2.js";
+import { readFileSync } from "node:fs";
+//#region src/steps.ts
+const SPINNER = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const FRAME_MS = 80;
+/** A step failed, and its line says why: nothing more to show. */
+var StepFailed = class extends Error {};
+var Steps = class {
+	#out;
+	#s;
+	#steps;
+	#keys;
+	#describe;
+	#frame = 0;
+	#drawn = 0;
+	/** The first step still redrawn: those above it have settled, and been printed for good. */
+	#from = 0;
+	#timer = null;
+	/** Whether the failed step has been printed, where nothing is redrawn. */
+	#reported = false;
+	#restoreCursor = () => this.#out.write("\x1B[?25h");
+	/** Ctrl-C while a step runs, the terminal in its usual mode: the cursor back, then out, with nothing more to show. */
+	#interrupt = () => {
+		this.#stop();
+		this.end();
+		this.#out.write("\n");
+		process.exit(130);
+	};
+	/**
+	* `titles`, what each step does while it runs; `keys`, the keyboard for
+	* questions; `describe`, an error as it may be shown, a secret it quotes
+	* taken out.
+	*/
+	constructor(out, titles, keys, describe) {
+		this.#out = out;
+		this.#s = style(out);
+		this.#keys = keys;
+		this.#describe = describe;
+		this.#steps = titles.map((text) => ({
+			text,
+			status: "pending",
+			details: [],
+			under: [],
+			input: null,
+			choice: null
+		}));
+		if (this.#s.ansi) {
+			out.write("\x1B[?25l");
+			process.once("exit", this.#restoreCursor);
+			process.on("SIGINT", this.#interrupt);
+			this.#draw();
+		}
+	}
+	/**
+	* Run step `i`: its line is the outcome `work` returns, or the error it
+	* throws, which comes out as StepFailed, unless it is Cancelled.
+	*/
+	async run(i, work) {
+		const state = this.#steps[i];
+		state.status = "running";
+		this.#tick();
+		const step = {
+			note: (text) => {
+				state.text = text;
+				this.#draw();
+			},
+			under: (lines) => {
+				state.under = lines;
+				this.#draw();
+			},
+			ask: (question) => this.#ask(state, question),
+			choose: (question, options) => this.#choose(state, question, options),
+			paste: (prompt, accept, signal) => this.#paste(state, prompt, accept, signal)
+		};
+		try {
+			const outcome = await work(step);
+			Object.assign(state, typeof outcome === "string" ? {
+				text: outcome,
+				details: []
+			} : outcome, {
+				status: "done",
+				under: [],
+				input: null
+			});
+		} catch (error) {
+			Object.assign(state, {
+				under: [],
+				input: null,
+				choice: null
+			});
+			state.status = "failed";
+			state.details = error instanceof Cancelled ? [] : [this.#describe(error)];
+			if (error instanceof Cancelled) state.text = `${state.text}: cancelled`;
+			this.#stop();
+			throw error instanceof Cancelled ? error : new StepFailed(state.details[0]);
+		}
+		this.#stop();
+		if (!this.#s.ansi) this.#out.write(`✓ ${state.text}\n${state.details.map((line) => `  ${line}\n`).join("")}`);
+		else if (this.#steps.every((each) => each.status === "done")) this.end();
+	}
+	/**
+	* Lines that stay, such as an address to open, printed whole, so that a
+	* terminal can wrap them, and they can be copied or clicked. They go
+	* under the steps done, above the one running: those done are printed
+	* for good first, and only the rest is redrawn from then on.
+	*/
+	print(text) {
+		if (!this.#s.ansi) {
+			this.#out.write(`${text}\n`);
+			return;
+		}
+		const running = this.#steps.findIndex((each, i) => i >= this.#from && each.status !== "done");
+		const settled = this.#lines(this.#from, running === -1 ? this.#steps.length : running);
+		this.#from = running === -1 ? this.#steps.length : running;
+		const up = this.#drawn > 0 ? `\x1b[${this.#drawn}F` : "";
+		this.#out.write(`${up}\x1b[J${settled.map((line) => `${line}\n`).join("")}${text}\n`);
+		this.#drawn = 0;
+		this.#draw();
+	}
+	/** A remark that stays, dim, wrapped to the terminal's width. */
+	aside(text) {
+		this.print(this.#s.dim(wrap(text, Math.max(20, (this.#out.columns ?? 80) - 3)).map((line) => `  ${line}`).join("\n")));
+	}
+	/**
+	* An address to open, after what it is for: on one line when both fit;
+	* otherwise the address on a line of its own, from the first column, so
+	* that the terminal wraps it in one piece, to copy whole.
+	*/
+	link(label, address) {
+		const fits = width(`  ${label} ${address}`) < (this.#out.columns ?? 80);
+		this.print(fits ? `  ${this.#s.dim(label)} ${address}` : `  ${this.#s.dim(label)}\n${address}`);
+	}
+	/** Leave the list as it stands, the cursor below it. */
+	end() {
+		this.#stop();
+		this.#release();
+	}
+	/** The cursor back, and Ctrl-C the terminal's again. */
+	#release() {
+		if (this.#s.ansi) {
+			this.#restoreCursor();
+			process.off("exit", this.#restoreCursor);
+			process.off("SIGINT", this.#interrupt);
+		}
+	}
+	async #ask(state, question) {
+		const keys = this.#keys();
+		if (keys === null) return false;
+		this.#stop();
+		const before = state.text;
+		state.text = `${question} ${this.#s.dim("y/N")}`;
+		state.status = "asking";
+		this.#draw();
+		try {
+			return await yes(keys);
+		} finally {
+			state.text = before;
+			state.status = "running";
+			this.#tick();
+		}
+	}
+	async #choose(state, question, options) {
+		const keys = this.#keys();
+		if (keys === null) return 0;
+		this.#stop();
+		const before = state.text;
+		Object.assign(state, {
+			text: `${question} ${this.#s.dim("↑↓ then Enter")}`,
+			status: "asking",
+			choice: {
+				options,
+				at: 0
+			}
+		});
+		let cancelled = false;
+		try {
+			const chosen = readKeys(keys, (key) => {
+				const choice = state.choice;
+				if (key.ctrl && key.name === "c") cancelled = true;
+				else if (key.name === "return" || key.name === "enter") return true;
+				else if (key.name === "up" || key.name === "k") choice.at = (choice.at - 1 + options.length) % options.length;
+				else if (key.name === "down" || key.name === "j" || key.name === "tab") choice.at = (choice.at + 1) % options.length;
+				if (cancelled) return true;
+				this.#draw();
+				return false;
+			});
+			this.#draw();
+			await chosen;
+			if (cancelled) throw new Cancelled();
+			return state.choice.at;
+		} finally {
+			Object.assign(state, {
+				text: before,
+				status: "running",
+				choice: null
+			});
+			this.#tick();
+		}
+	}
+	async #paste(state, prompt, accept, signal) {
+		const keys = this.#keys();
+		if (keys === null) {
+			await new Promise((resolve) => signal.aborted ? resolve() : signal.addEventListener("abort", () => resolve()));
+			return null;
+		}
+		state.input = {
+			prompt,
+			typed: "",
+			error: null
+		};
+		let taken = null;
+		let cancelled = false;
+		try {
+			const pasted = readKeys(keys, async (key, sequence) => {
+				const input = state.input;
+				const next = edit(input.typed, key, sequence);
+				if (next === "cancel") cancelled = true;
+				else if (next === "submit" && input.typed.trim() !== "") {
+					const text = input.typed.trim();
+					input.typed = "";
+					input.error = await accept(text);
+					if (input.error === null) taken = text;
+				} else if (next !== "submit") {
+					input.typed = next;
+					input.error = null;
+				}
+				this.#draw();
+				return cancelled || taken !== null;
+			}, signal);
+			this.#draw();
+			await pasted;
+		} finally {
+			state.input = null;
+			this.#draw();
+		}
+		if (cancelled) throw new Cancelled();
+		return taken;
+	}
+	#tick() {
+		this.#draw();
+		if (this.#s.ansi && this.#timer === null) this.#timer = setInterval(() => {
+			this.#frame = (this.#frame + 1) % SPINNER.length;
+			this.#draw();
+		}, FRAME_MS).unref();
+	}
+	#stop() {
+		if (this.#timer !== null) clearInterval(this.#timer);
+		this.#timer = null;
+		this.#draw();
+		if (!this.#s.ansi) {
+			const failed = this.#steps.find((each) => each.status === "failed");
+			if (failed !== void 0 && !this.#reported) {
+				this.#reported = true;
+				this.#out.write(`✗ ${failed.text}\n${failed.details.map((line) => `  ${line}\n`).join("")}`);
+			}
+		} else if (this.#steps.some((each) => each.status === "failed")) this.#release();
+	}
+	#draw() {
+		if (!this.#s.ansi) return;
+		const lines = this.#lines(this.#from, this.#steps.length);
+		const up = this.#drawn > 0 ? `\x1b[${this.#drawn}F` : "";
+		this.#out.write(`${up}${lines.map((line) => `${line}\x1b[K\n`).join("")}\x1b[J`);
+		this.#drawn = lines.length;
+	}
+	/** Steps `from` to `to`, as lines cut to the terminal's width. */
+	#lines(from, to) {
+		const s = this.#s;
+		const columns = Math.max(20, (this.#out.columns ?? 80) - 1);
+		return this.#steps.slice(from, to).flatMap(({ text, status, details, under, input, choice }) => {
+			const icon = {
+				pending: s.dim("·"),
+				running: s.accent(SPINNER[this.#frame]),
+				asking: s.accent("?"),
+				done: s.green("✓"),
+				failed: s.red("✗")
+			}[status];
+			const line = status === "pending" ? s.dim(text) : status === "failed" ? s.red(text) : text;
+			const below = status === "failed" ? details.flatMap((detail) => wrap(detail, columns - 4)) : details.map(s.dim);
+			const live = [
+				...under.map((text) => `    ${s.dim(text)}`),
+				...choice === null ? [] : choice.options.map((option, i) => i === choice.at ? `    ${s.accent("›")} ${s.accent(option)}` : `      ${option}`),
+				...input === null ? [] : [
+					`    ${input.prompt}`,
+					`    ${s.accent("›")} ${"•".repeat(input.typed.length)}`,
+					...input.error === null ? [] : [`    ${s.red(input.error)}`]
+				]
+			];
+			return [
+				`  ${icon} ${line}`,
+				...below.map((detail) => `    ${detail}`),
+				...live
+			];
+		}).map((line) => truncate(line, columns));
+	}
+};
+//#endregion
+//#region src/version.ts
+/**
+* This CLI's version: the schema it migrates to, the version of coffre a
+* deployment it makes runs, and the one `coffre migrate` expects to find.
+*/
+function cliVersion() {
+	return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+}
+//#endregion
+export { StepFailed as n, Steps as r, cliVersion as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffre/cli",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "The coffre command line: secrets in your shell, and `coffre init` for a new deployment.",
   "license": "MIT",
   "repository": {
@@ -10,7 +10,7 @@
   },
   "type": "module",
   "engines": {
-    "node": ">=24"
+    "node": ">=20"
   },
   "files": [
     "dist"
@@ -28,9 +28,9 @@
     "pg": "8.16.3",
     "tsdown": "0.23.0",
     "typescript": "5.9.3",
-    "@coffre/db": "0.1.13",
-    "@coffre/core": "0.1.13",
-    "@coffre/client": "0.1.13"
+    "@coffre/core": "0.1.15",
+    "@coffre/db": "0.1.15",
+    "@coffre/client": "0.1.15"
   },
   "scripts": {
     "build": "tsdown && node scripts/copy-templates.ts && node scripts/copy-migrations.ts",