@coffre/cli 0.1.13 → 0.1.14

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.14",
   "description": "The coffre command line: secrets in your shell, and `coffre init` for a new deployment.",
   "license": "MIT",
   "repository": {
@@ -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/client": "0.1.14",
+    "@coffre/db": "0.1.14",
+    "@coffre/core": "0.1.14"
   },
   "scripts": {
     "build": "tsdown && node scripts/copy-templates.ts && node scripts/copy-migrations.ts",

package/dist/{connect-tekAM4hC.js → connect-C4wevMJ5.js}

@@ -4,8 +4,8 @@ import { D as customType, O as boolean, V as SQL, W as sql, b as text, ct as is,
 import { r as drizzle } from "./node-postgres-BHgGDfvg.js";
 import { a as trackCommits, i as relationsOf, n as asPostgresDatabase, r as ACTIVE_SUBJECT } from "./portable-9wWdi5e1.js";
 import { resolve } from "node:path";
-import { AsyncLocalStorage } from "node:async_hooks";
 import { checkServerIdentity } from "node:tls";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/checks.js
 var CheckBuilder = class {
 	constructor(name, value) {
@@ -126,6 +126,39 @@ function uniqueIndex(name) {
 	return new IndexBuilderOn(true, name);
 }
 //#endregion
+//#region ../../node_modules/.pnpm/pg-connection-string@2.14.0/node_modules/pg-connection-string/esm/index.mjs
+var import_pg_connection_string = /* @__PURE__ */ __toESM(require_pg_connection_string(), 1);
+import_pg_connection_string.default.parse;
+import_pg_connection_string.default.parse;
+import_pg_connection_string.default.toClientConfig;
+const parseIntoClientConfig = import_pg_connection_string.default.parseIntoClientConfig;
+//#endregion
+//#region ../db/dist/postgres-Bmar8y0q.js
+/** Keep libpq's system-root shortcut from being read as a certificate filename by pg. */
+function postgresConnection(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new Error("invalid Postgres URL");
+	}
+	const parameters = parsed.searchParams;
+	if (parameters.getAll("sslrootcert").at(-1) !== "system") return { connectionString: url };
+	const mode = parameters.getAll("sslmode").at(-1);
+	if (mode !== void 0 && mode !== "verify-full") throw new Error("sslrootcert=system requires sslmode=verify-full");
+	parameters.delete("sslrootcert");
+	parameters.set("sslmode", "verify-full");
+	const config = parseIntoClientConfig(parsed.toString());
+	const host = config.host;
+	if (!host) throw new Error("sslrootcert=system requires a Postgres hostname");
+	config.ssl = {
+		...config.ssl,
+		rejectUnauthorized: true,
+		checkServerIdentity: (_hostname, certificate) => checkServerIdentity(host, certificate)
+	};
+	return config;
+}
+//#endregion
 //#region ../db/dist/rolldown-runtime-D7D4PA-g.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -562,39 +595,6 @@ function createDatabase(pool) {
 	return trackCommits(db);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/pg-connection-string@2.14.0/node_modules/pg-connection-string/esm/index.mjs
-var import_pg_connection_string = /* @__PURE__ */ __toESM(require_pg_connection_string(), 1);
-import_pg_connection_string.default.parse;
-import_pg_connection_string.default.parse;
-import_pg_connection_string.default.toClientConfig;
-const parseIntoClientConfig = import_pg_connection_string.default.parseIntoClientConfig;
-//#endregion
-//#region ../db/dist/postgres-Bmar8y0q.js
-/** Keep libpq's system-root shortcut from being read as a certificate filename by pg. */
-function postgresConnection(url) {
-	let parsed;
-	try {
-		parsed = new URL(url);
-	} catch {
-		throw new Error("invalid Postgres URL");
-	}
-	const parameters = parsed.searchParams;
-	if (parameters.getAll("sslrootcert").at(-1) !== "system") return { connectionString: url };
-	const mode = parameters.getAll("sslmode").at(-1);
-	if (mode !== void 0 && mode !== "verify-full") throw new Error("sslrootcert=system requires sslmode=verify-full");
-	parameters.delete("sslrootcert");
-	parameters.set("sslmode", "verify-full");
-	const config = parseIntoClientConfig(parsed.toString());
-	const host = config.host;
-	if (!host) throw new Error("sslrootcert=system requires a Postgres hostname");
-	config.ssl = {
-		...config.ssl,
-		rejectUnauthorized: true,
-		checkServerIdentity: (_hostname, certificate) => checkServerIdentity(host, certificate)
-	};
-	return config;
-}
-//#endregion
 //#region ../db/dist/connect.js
 /**
 * Open a database from its URL, on a Node server: