@coffre/cli 0.1.13 → 0.1.15

package/dist/templates/node/README.md

@@ -62,8 +62,10 @@ With AWS KMS instead of a key of your own, the vault also needs a
 To do the same by hand, see
 [deploy.md](https://github.com/erwinkn/coffre/blob/main/docs/deploy.md#appendix-the-database-by-hand).
 
-Run `pnpm migrate`, with the administrator's URL in `DATABASE_URL`, after
-every package upgrade, before starting either process.
+To upgrade: `coffre update` here, restart both processes, then `coffre migrate`
+([upgrading](https://github.com/erwinkn/coffre/blob/main/docs/deploy.md#upgrading)).
+For automation, `pnpm migrate`, with the administrator's URL in
+`DATABASE_URL`, does the last step.
 
 For tests and local development only, both URLs may instead name the same
 absolute SQLite file, e.g. `file:/tmp/coffre-local.db`; migrate that URL once

package/dist/templates/node/package.json

@@ -1,6 +1,7 @@
 {
   "name": "coffre-node",
   "private": true,
+  "packageManager": "pnpm@11.8.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -13,11 +14,11 @@
     "conformance": "coffre-conformance node"
   },
   "dependencies": {
-    "@coffre/server": "0.1.13",
-    "@coffre/vault": "0.1.13"
+    "@coffre/server": "0.1.15",
+    "@coffre/vault": "0.1.15"
   },
   "devDependencies": {
-    "@coffre/conformance": "0.1.13",
+    "@coffre/conformance": "0.1.15",
     "@types/node": "26.1.1",
     "typescript": "5.9.3"
   }

package/dist/templates/workers/README.md

@@ -76,8 +76,10 @@ pnpm exec wrangler secret put APP_KEY -c app/wrangler.jsonc
 pnpm exec wrangler secret put GITHUB_CLIENT_SECRET -c app/wrangler.jsonc
 ```
 
-Run `pnpm migrate`, with the administrator's URL in `DATABASE_URL`, after
-every upgrade of `@coffre/server`, before deploying it.
+To upgrade: `coffre update` here, deploy, then `coffre migrate`
+([upgrading](https://github.com/erwinkn/coffre/blob/main/docs/deploy.md#upgrading)).
+For automation, `pnpm migrate`, with the administrator's URL in
+`DATABASE_URL`, does the last step.
 
 Keep older vault keys after a rotation, for good: what they wrapped still
 needs them, and so does what the vault signed under them before it. With AWS KMS

package/dist/templates/workers/package.json

@@ -1,6 +1,7 @@
 {
   "name": "coffre-workers",
   "private": true,
+  "packageManager": "pnpm@11.8.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -14,13 +15,13 @@
     "conformance": "coffre-conformance workers"
   },
   "dependencies": {
-    "@coffre/server": "0.1.13",
-    "@coffre/ui": "0.1.13",
-    "@coffre/vault": "0.1.13"
+    "@coffre/server": "0.1.15",
+    "@coffre/ui": "0.1.15",
+    "@coffre/vault": "0.1.15"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "5.20260920.1",
-    "@coffre/conformance": "0.1.13",
+    "@coffre/conformance": "0.1.15",
     "typescript": "5.9.3",
     "wrangler": "4.118.0"
   }

package/dist/tty-BDa14JX2.js

@@ -0,0 +1,283 @@
+import { openSync } from "node:fs";
+import { emitKeypressEvents } from "node:readline";
+import tty from "node:tty";
+//#region src/tty.ts
+const plain = (text) => text;
+/**
+* The web UI's accent, green and red, at the depth the terminal takes:
+* 24-bit, 256 colours or the 16 named ones. NO_COLOR (and FORCE_COLOR) are
+* the stream's own `hasColors`; bold and dim stay, being no colour.
+*/
+function style(stream) {
+	if (stream.isTTY !== true) return {
+		ansi: false,
+		bold: plain,
+		dim: plain,
+		accent: plain,
+		green: plain,
+		red: plain
+	};
+	const terminal = stream;
+	const depth = typeof terminal.hasColors === "function" && terminal.hasColors() ? terminal.getColorDepth() : 1;
+	const sgr = (open, close) => (text) => `\x1b[${open}m${text}\x1b[${close}m`;
+	const colour = (rgb, index256, index16) => depth >= 24 ? sgr(`38;2;${rgb.join(";")}`, "39") : depth >= 8 ? sgr(`38;5;${index256}`, "39") : depth >= 4 ? sgr(String(index16), "39") : plain;
+	return {
+		ansi: true,
+		bold: sgr("1", "22"),
+		dim: sgr("2", "22"),
+		accent: colour([
+			91,
+			141,
+			239
+		], 69, 94),
+		green: colour([
+			63,
+			174,
+			111
+		], 71, 32),
+		red: colour([
+			229,
+			83,
+			75
+		], 167, 31)
+	};
+}
+const ESCAPE = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07]*\x07/g;
+/** Columns `text` takes on screen: its characters, less its escape codes. */
+function width(text) {
+	return [...text.replace(ESCAPE, "")].length;
+}
+/** `text` cut to `columns` on screen, escape codes kept, an ellipsis where it was cut. */
+function truncate(text, columns) {
+	if (width(text) <= columns) return text;
+	let out = "";
+	let used = 0;
+	for (let i = 0; i < text.length;) {
+		ESCAPE.lastIndex = i;
+		const code = text[i] === "\x1B" ? ESCAPE.exec(text) : null;
+		if (code !== null && code.index === i) {
+			out += code[0];
+			i += code[0].length;
+			continue;
+		}
+		const char = String.fromCodePoint(text.codePointAt(i));
+		if (used === columns - 1) return `${out}…${text.includes("\x1B") ? "\x1B[0m" : ""}`;
+		out += char;
+		used += 1;
+		i += char.length;
+	}
+	return out;
+}
+/** Plain `text` in lines of at most `columns`, broken at spaces, or anywhere in a word longer than a line. */
+function wrap(text, columns) {
+	const lines = [];
+	let line = "";
+	for (const word of text.split(" ")) {
+		let rest = word;
+		while (width(rest) > columns) {
+			if (line !== "") lines.push(line);
+			line = "";
+			lines.push([...rest].slice(0, columns).join(""));
+			rest = [...rest].slice(columns).join("");
+		}
+		if (line === "") line = rest;
+		else if (width(line) + 1 + width(rest) <= columns) line += ` ${rest}`;
+		else {
+			lines.push(line);
+			line = rest;
+		}
+	}
+	return [...lines, line];
+}
+/** `text` wrapped to the stream's width, each line indented by `indent` spaces. */
+function paragraph(out, text, indent = 2) {
+	const pad = " ".repeat(indent);
+	return wrap(text, Math.max(20, (out.columns || 80) - indent - 1)).map((line) => `${pad}${line}`).join("\n");
+}
+/** "a, b or c". */
+function listed(items, last) {
+	return items.length < 2 ? items.join("") : `${items.slice(0, -1).join(", ")} ${last} ${items.at(-1)}`;
+}
+/** A labelled row: `label` in a column of `column`, `text` wrapped beside it with a hanging indent. */
+function row(out, s, label, text, indent = 4, column = 10) {
+	const lines = wrap(text, Math.max(20, (out.columns || 80) - indent - column - 1));
+	const pad = " ".repeat(indent);
+	return lines.map((line, i) => `${pad}${i === 0 ? s.dim(label.padEnd(column)) : " ".repeat(column)}${line}`).join("\n");
+}
+/**
+* The keyboard: stdin when it is a terminal, otherwise the terminal itself,
+* as `less` reads it when its input is piped. Null without one.
+*/
+function keyboard() {
+	if (process.stdin.isTTY) return process.stdin;
+	try {
+		return new tty.ReadStream(openSync("/dev/tty", "r"));
+	} catch {
+		return null;
+	}
+}
+/** Where a screen is drawn and read from: stdout, and the keyboard. Null unless both are a terminal. */
+function openTerminal() {
+	if (!process.stdout.isTTY) return null;
+	const keys = keyboard();
+	return keys === null ? null : {
+		keys,
+		out: process.stdout
+	};
+}
+/** Release a keyboard `keyboard()` opened: stdin stays, /dev/tty closes. */
+function release(keys) {
+	keys.setRawMode?.(false);
+	keys.pause();
+	if (keys !== process.stdin) keys.destroy?.();
+}
+/**
+* Every key pressed, in raw mode, until `until` returns true, or `signal`
+* aborts the reading. Raw mode is on when this returns: a prompt shown after
+* it gets every key, none echoed or edited by the terminal first.
+*/
+function readKeys(keys, until, signal) {
+	emitKeypressEvents(keys);
+	keys.setRawMode?.(true);
+	keys.resume();
+	return new Promise((resolve, reject) => {
+		let busy = Promise.resolve();
+		const stop = () => {
+			keys.off("keypress", onKey);
+			signal?.removeEventListener("abort", stop);
+			keys.setRawMode?.(false);
+			keys.pause();
+			resolve();
+		};
+		const onKey = (sequence, key) => {
+			busy = busy.then(async () => {
+				if (await until(key ?? { sequence }, sequence ?? key?.sequence ?? "")) stop();
+			}).catch(reject);
+		};
+		keys.on("keypress", onKey);
+		if (signal?.aborted) stop();
+		else signal?.addEventListener("abort", stop);
+	});
+}
+/** What a typed key does to a line: its new text, or `submit`, or `cancel`. */
+function edit(text, key, sequence) {
+	if (key.ctrl && key.name === "c") return "cancel";
+	if (key.name === "return" || key.name === "enter") return "submit";
+	if (key.name === "backspace") return text.slice(0, -1);
+	if (key.ctrl && key.name === "u") return "";
+	if (!key.ctrl && !key.meta && sequence.length > 0 && !sequence.startsWith("\x1B") && sequence >= " ") return text + sequence;
+	return text;
+}
+/**
+* A question answered by typing, shown as typed, `initial` to start from;
+* `note`, dim under it while it is asked; `check` says why an answer will
+* not do, under it. Once given, the question becomes one line: what was
+* asked, and the answer. Ctrl-C cancels.
+*/
+async function textLine(keys, out, s, question, hint, options = {}) {
+	const columns = Math.max(20, (out.columns || 80) - 1);
+	let typed = options.initial ?? "";
+	let error = null;
+	const draw = () => {
+		const below = [...error === null ? [] : [s.red(error)], ...options.note === void 0 ? [] : wrap(options.note, columns - 4).map(s.dim)].map((line) => `\n${truncate(`    ${line}`, columns)}`);
+		out.write(`\r\x1b[J${below.join("")}${below.length > 0 ? `\x1b[${below.length}A` : ""}\r${truncate(`    ${s.accent("›")} ${typed}`, columns)}`);
+	};
+	let cancelled = false;
+	const answered = readKeys(keys, async (key, sequence) => {
+		const next = edit(typed, key, sequence);
+		if (next === "cancel") cancelled = true;
+		else if (next === "submit") {
+			if (typed.trim() === "") return false;
+			error = await options.check?.(typed.trim()) ?? null;
+			if (error === null) return true;
+		} else {
+			typed = next;
+			error = null;
+		}
+		if (cancelled) return true;
+		draw();
+		return false;
+	});
+	out.write(`${truncate(`  ${s.accent("?")} ${s.bold(question)} ${s.dim(hint)}`, columns)}\n`);
+	draw();
+	await answered;
+	out.write("\r\x1B[J\x1B[1A\x1B[2K");
+	if (cancelled) throw new Cancelled();
+	out.write(`${truncate(`  ${s.green("✓")} ${s.dim(question)}  ${typed.trim()}`, columns)}\n`);
+	return typed.trim();
+}
+/** One of `options`, chosen with the arrows and Enter; then one line, as `textLine` leaves. Ctrl-C cancels. */
+async function select(keys, out, s, question, options) {
+	const columns = Math.max(20, (out.columns || 80) - 1);
+	let at = 0;
+	let drawn = 0;
+	const draw = () => {
+		const lines = [`  ${s.accent("?")} ${s.bold(question)} ${s.dim("↑↓ then Enter")}`, ...options.map((option, i) => i === at ? `    ${s.accent("›")} ${s.accent(option)}` : `      ${option}`)];
+		out.write(`${drawn > 0 ? `\x1b[${drawn}F` : ""}${lines.map((line) => `${truncate(line, columns)}\x1b[K\n`).join("")}`);
+		drawn = lines.length;
+	};
+	let cancelled = false;
+	const chosen = readKeys(keys, (key) => {
+		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") at = (at - 1 + options.length) % options.length;
+		else if (key.name === "down" || key.name === "j" || key.name === "tab") at = (at + 1) % options.length;
+		if (cancelled) return true;
+		draw();
+		return false;
+	});
+	draw();
+	await chosen;
+	out.write(`\x1b[${drawn}F\x1b[J`);
+	if (cancelled) throw new Cancelled();
+	out.write(`${truncate(`  ${s.green("✓")} ${s.dim(question)}  ${options[at]}`, columns)}\n`);
+	return at;
+}
+var Cancelled = class extends Error {
+	constructor() {
+		super("cancelled");
+	}
+};
+/**
+* A line typed without echo: a bullet for each character, so that a paste
+* shows it arrived. The question, its hint and the bullets go once it is
+* given. Ctrl-C cancels.
+*/
+async function hiddenLine(keys, out, s, question, hint) {
+	const columns = Math.max(20, (out.columns || 80) - 1);
+	let typed = "";
+	const draw = () => {
+		const count = typed.length > 0 ? s.dim(`  ${typed.length} characters`) : "";
+		out.write(`\r\x1b[2K${truncate(`    ${s.accent("›")} ${"•".repeat(typed.length)}`, columns - width(count))}${count}`);
+	};
+	let cancelled = false;
+	const typedIn = readKeys(keys, (key, sequence) => {
+		const next = edit(typed, key, sequence);
+		if (next === "cancel") cancelled = true;
+		else if (next === "submit") return true;
+		else typed = next;
+		if (cancelled) return true;
+		draw();
+		return false;
+	});
+	out.write(`${truncate(`  ${s.accent("?")} ${s.bold(question)}`, columns)}\n${truncate(`    ${s.dim(hint)}`, columns)}\n`);
+	draw();
+	await typedIn;
+	out.write("\r\x1B[2K\x1B[1A\x1B[2K\x1B[1A\x1B[2K");
+	if (cancelled) throw new Cancelled();
+	return typed.trim();
+}
+/** One key: y for yes, anything else for no. Ctrl-C cancels. */
+async function yes(keys) {
+	let answer = false;
+	let cancelled = false;
+	await readKeys(keys, (key) => {
+		if (key.ctrl && key.name === "c") cancelled = true;
+		answer = key.name === "y";
+		return true;
+	});
+	if (cancelled) throw new Cancelled();
+	return answer;
+}
+//#endregion
+export { openTerminal as a, release as c, style as d, textLine as f, yes as g, wrap as h, listed as i, row as l, width as m, edit as n, paragraph as o, truncate as p, hiddenLine as r, readKeys as s, Cancelled as t, select as u };