@coffre/cli 0.1.13 → 0.1.14

package/dist/init-mO8V087p.js

@@ -0,0 +1,71 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/init.ts
+const KINDS = ["workers", "node"];
+/** Where a template lives: in the package when published, else in the repository. */
+function templateDir(kind) {
+	const packed = fileURLToPath(new URL(`./templates/${kind}/`, import.meta.url));
+	if (existsSync(packed)) return packed;
+	return fileURLToPath(new URL(`../../../examples/${kind}/`, import.meta.url));
+}
+/**
+* A template's files, relative and sorted: everything but what its own
+* `.gitignore` names, such as installed packages, local state and secrets.
+* Patterns are file or directory names, `*` standing for any run of
+* characters.
+*/
+function templateFiles(dir) {
+	const ignoreFile = [join(dir, ".gitignore"), join(dir, "gitignore")].find((path) => existsSync(path));
+	const ignored = (ignoreFile === void 0 ? "" : readFileSync(ignoreFile, "utf8")).split("\n").map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#")).map((glob) => new RegExp(`^${glob.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`));
+	const files = [];
+	const walk = (relative) => {
+		for (const entry of readdirSync(join(dir, relative), { withFileTypes: true })) {
+			if (ignored.some((pattern) => pattern.test(entry.name))) continue;
+			const path = relative === "" ? entry.name : `${relative}/${entry.name}`;
+			if (entry.isDirectory()) walk(path);
+			else files.push(path);
+		}
+	};
+	walk("");
+	return files.sort();
+}
+/** The name a template file has in a project. */
+function projectPath(templatePath) {
+	return templatePath === "gitignore" ? ".gitignore" : templatePath;
+}
+/** A package name from a directory's, e.g. `Acme Secrets` → `acme-secrets`. */
+function packageName(dir) {
+	const name = basename(dir).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[-._]+|-+$/g, "");
+	return name === "" ? "coffre" : name;
+}
+/** The template's package.json, for this project and this version of coffre. */
+function manifest(source, name, version) {
+	const pkg = JSON.parse(source);
+	pkg.name = name;
+	for (const field of ["dependencies", "devDependencies"]) {
+		const deps = pkg[field];
+		for (const dep of Object.keys(deps ?? {})) if (dep.startsWith("@coffre/")) deps[dep] = version;
+	}
+	return `${JSON.stringify(pkg, null, 2)}\n`;
+}
+/** Whether a directory holds nothing yet, or nothing but `.git`: a repository made first, then cloned. */
+function isEmpty(dir) {
+	return !existsSync(dir) || readdirSync(dir).every((entry) => entry === ".git");
+}
+/** Write a new deployment into `target`, which must be empty (`isEmpty`) or absent. Returns the files written. */
+function init(kind, target, version) {
+	if (!isEmpty(target)) throw new Error(`${target} is not empty; give \`coffre init\` a new directory`);
+	const source = templateDir(kind);
+	const written = [];
+	for (const file of templateFiles(source)) {
+		const path = projectPath(file);
+		const content = readFileSync(join(source, file), "utf8");
+		mkdirSync(dirname(join(target, path)), { recursive: true });
+		writeFileSync(join(target, path), path === "package.json" ? manifest(content, packageName(target), version) : content);
+		written.push(path);
+	}
+	return written;
+}
+//#endregion
+export { init as n, isEmpty as r, KINDS as t };

package/dist/{keys-BCKUEb-Y.js → keys-DDdMwm0N.js}

@@ -1,78 +1,7 @@
+import { a as openTerminal, c as release, d as style, h as wrap, l as row, m as width, o as paragraph, p as truncate, s as readKeys } from "./tty-BDa14JX2.js";
 import { parseArgs } from "node:util";
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, openSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { randomBytes } from "node:crypto";
-import { emitKeypressEvents } from "node:readline";
-import tty from "node:tty";
-//#region src/init.ts
-const KINDS = ["workers", "node"];
-/** Where a template lives: in the package when published, else in the repository. */
-function templateDir(kind) {
-	const packed = fileURLToPath(new URL(`./templates/${kind}/`, import.meta.url));
-	if (existsSync(packed)) return packed;
-	return fileURLToPath(new URL(`../../../examples/${kind}/`, import.meta.url));
-}
-/**
-* A template's files, relative and sorted: everything but what its own
-* `.gitignore` names, such as installed packages, local state and secrets.
-* Patterns are file or directory names, `*` standing for any run of
-* characters.
-*/
-function templateFiles(dir) {
-	const ignoreFile = [join(dir, ".gitignore"), join(dir, "gitignore")].find((path) => existsSync(path));
-	const ignored = (ignoreFile === void 0 ? "" : readFileSync(ignoreFile, "utf8")).split("\n").map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#")).map((glob) => new RegExp(`^${glob.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`));
-	const files = [];
-	const walk = (relative) => {
-		for (const entry of readdirSync(join(dir, relative), { withFileTypes: true })) {
-			if (ignored.some((pattern) => pattern.test(entry.name))) continue;
-			const path = relative === "" ? entry.name : `${relative}/${entry.name}`;
-			if (entry.isDirectory()) walk(path);
-			else files.push(path);
-		}
-	};
-	walk("");
-	return files.sort();
-}
-/** The name a template file has in a project. */
-function projectPath(templatePath) {
-	return templatePath === "gitignore" ? ".gitignore" : templatePath;
-}
-/** A package name from a directory's, e.g. `Acme Secrets` → `acme-secrets`. */
-function packageName(dir) {
-	const name = basename(dir).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[-._]+|-+$/g, "");
-	return name === "" ? "coffre" : name;
-}
-/** The template's package.json, for this project and this version of coffre. */
-function manifest(source, name, version) {
-	const pkg = JSON.parse(source);
-	pkg.name = name;
-	for (const field of ["dependencies", "devDependencies"]) {
-		const deps = pkg[field];
-		for (const dep of Object.keys(deps ?? {})) if (dep.startsWith("@coffre/")) deps[dep] = version;
-	}
-	return `${JSON.stringify(pkg, null, 2)}\n`;
-}
-/** Whether a directory holds nothing yet, or nothing but `.git`: a repository made first, then cloned. */
-function isEmpty(dir) {
-	return !existsSync(dir) || readdirSync(dir).every((entry) => entry === ".git");
-}
-/** Write a new deployment into `target`, which must be empty (`isEmpty`) or absent. Returns the files written. */
-function init(kind, target, version) {
-	if (!isEmpty(target)) throw new Error(`${target} is not empty; give \`coffre init\` a new directory`);
-	const source = templateDir(kind);
-	const written = [];
-	for (const file of templateFiles(source)) {
-		const path = projectPath(file);
-		const content = readFileSync(join(source, file), "utf8");
-		mkdirSync(dirname(join(target, path)), { recursive: true });
-		writeFileSync(join(target, path), path === "package.json" ? manifest(content, packageName(target), version) : content);
-		written.push(path);
-	}
-	return written;
-}
-//#endregion
 //#region src/clipboard.ts
 const CLEAR_AFTER_MS = 3e4;
 /** The system's clipboard tool, by platform and display server; null for none known. */
@@ -200,285 +129,6 @@ function read([command, ...args]) {
 	});
 }
 //#endregion
-//#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
 //#region src/secrets.ts
 function initialState() {
 	return {
@@ -878,4 +528,4 @@ async function keys(args) {
 	].join("\n"));
 }
 //#endregion
-export { yes as C, isEmpty as E, wrap as S, init as T, select as _, keys as a, truncate as b, Cancelled as c, listed as d, openTerminal as f, row as g, release as h, keyValues as i, edit as l, readKeys as m, jsonWarning as n, needsTerminal as o, paragraph as p, keyGuide as r, showSecrets as s, generateKeys as t, hiddenLine as u, style as v, KINDS as w, width as x, textLine as y };
+export { keys as a, keyValues as i, jsonWarning as n, needsTerminal as o, keyGuide as r, showSecrets as s, generateKeys as t };

package/dist/main.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
-import { T as init, _ as select, a as keys, c as Cancelled, f as openTerminal, h as release, u as hiddenLine, v as style, w as KINDS } from "./keys-BCKUEb-Y.js";
+import { n as init, t as KINDS } from "./init-mO8V087p.js";
+import { a as keys } from "./keys-DDdMwm0N.js";
+import { a as openTerminal, c as release, d as style, r as hiddenLine, t as Cancelled, u as select } from "./tty-BDa14JX2.js";
 import { i as isRole, r as assignableToEnvironment, t as ROLES } from "./access-CO1kGjWW.js";
 import { inspect, parseArgs, promisify } from "node:util";
 import { execFile, spawn } from "node:child_process";
@@ -7,6 +9,37 @@ import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync,
 import { homedir, hostname } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { createCipheriv, createDecipheriv, createHash, hkdfSync, randomBytes, timingSafeEqual } from "node:crypto";
+/**
+* The line to show, or null: nothing pending, or nothing told. An instance
+* older than this notice has no `instance` on `/me` at all.
+*/
+function noticeFor(origin, instance) {
+	if (instance === null || instance === void 0 || !Array.isArray(instance.migrations?.known)) return null;
+	const pending = instance.migrations.known.slice(instance.migrations.applied);
+	if (pending.length === 0) return null;
+	return `${pending.length === 1 ? "1 migration" : `${pending.length} migrations`} pending on ${origin} (${pending.join(", ")}): run \`coffre migrate\``;
+}
+/**
+* The notice for `origin`, at most once a day: null without asking when it
+* was asked less than a day ago; otherwise `me` is asked, and the time kept,
+* whatever the answer. A failure to ask says nothing, and is not kept.
+*/
+async function dailyNotice(origin, now, checked, me) {
+	const last = checked.read()[origin];
+	if (last !== void 0 && now - last < 864e5) return null;
+	let instance;
+	try {
+		({instance} = await me());
+	} catch {
+		return null;
+	}
+	checked.write({
+		...checked.read(),
+		[origin]: now
+	});
+	return noticeFor(origin, instance);
+}
+//#endregion
 //#region ../client/dist/index.js
 /** The API's error shape, `{ error, message }`, with the HTTP status. */
 const COFFRE_ERROR = Symbol.for("@coffre/client:CoffreError");
@@ -1797,8 +1830,59 @@ function client(to = target()) {
 		transport: (request) => send(request, to)
 	});
 }
+/** Whether this run has asked about pending migrations yet: once, before its first request. */
+let noticed = false;
+/** The commands that say nothing of pending migrations: migrate says as much itself; login has no session yet; verify sends only what it checks. */
+const QUIET = /* @__PURE__ */ new Set([
+	"migrate",
+	"login",
+	"verify"
+]);
+/**
+* A line on stderr, at most once a day per instance, when its database is
+* behind the code it runs (`notice.ts`). Not for a machine's credential:
+* only owners are told. Whatever goes wrong here, the command goes on.
+*/
+async function noticePending(to) {
+	if (noticed) return;
+	noticed = true;
+	if (QUIET.has(command ?? "") || process.env.COFFRE_TOKEN?.trim() || to.credential.kind === "access-service-token") return;
+	const line = await dailyNotice(to.origin, Date.now(), checkedFile, async () => {
+		const response = await fetch(`${to.origin}/api/me`, {
+			headers: await headersFor(to),
+			redirect: "manual"
+		});
+		if (!response.ok || !isJsonContentType(response.headers.get("content-type"))) throw new Error("no answer");
+		return await response.json();
+	}).catch(() => null);
+	if (line !== null) {
+		const s = style(process.stderr);
+		process.stderr.write(`${s.dim(`coffre: ${line}`)}\n`);
+	}
+}
+const CHECKED_PATH = join(homedir(), ".coffre", "checked.json");
+/** When each instance was last asked about its migrations: nothing secret, beside the credentials. */
+const checkedFile = {
+	read() {
+		try {
+			return JSON.parse(readFileSync(CHECKED_PATH, "utf8"));
+		} catch {
+			return {};
+		}
+	},
+	write(checked) {
+		try {
+			mkdirSync(dirname(CHECKED_PATH), {
+				recursive: true,
+				mode: 448
+			});
+			writeFileSync(CHECKED_PATH, `${JSON.stringify(checked)}\n`, { mode: 384 });
+		} catch {}
+	}
+};
 /** One request; every way it can fail is explained in terms of what to do next. */
 async function send(request, to) {
+	await noticePending(to);
 	let response;
 	try {
 		response = await fetch(request, { redirect: "manual" });
@@ -2392,6 +2476,30 @@ function initProject(args) {
 	const at = dir === process.cwd() ? null : positionals[0] ?? null;
 	process.stdout.write(`\nA ${kind === "workers" ? "Cloudflare Workers" : "Node"} deployment of coffre ${version}${at === null ? " here" : ` in ${at}`}. README.md takes it from there:\n\n${at === null ? "" : `  cd ${/\s/.test(at) ? `'${at}'` : at}\n`}  pnpm install\n`);
 }
+/**
+* The instance `coffre migrate` works on: the current one, or the one
+* `--url` names, with the session saved for it.
+*/
+function migrateTarget(url) {
+	if (url !== void 0) process.env.COFFRE_API_URL = url;
+	const to = target();
+	const api = client(to);
+	return {
+		origin: to.origin,
+		me: () => api.me(),
+		ready: async () => {
+			try {
+				return await (await fetch(`${to.origin}/readyz`, { redirect: "manual" })).json();
+			} catch {
+				return {
+					ok: false,
+					heartbeatAgeSeconds: null,
+					checkpointed: false
+				};
+			}
+		}
+	};
+}
 const USAGE = `coffre - secrets, with an audit log
 
   New deployment
@@ -2403,6 +2511,11 @@ const USAGE = `coffre - secrets, with an audit log
                                             Cloudflare too, and in an empty directory, the deployment
     coffre keys [--json]                    the app key, vault key and vault ID alone, shown the same way
 
+  Upgrade
+    coffre update [--yes]                   this CLI, and in a deployment, its coffre packages
+    coffre migrate [--url <url>] [--yes]    the instance's database, to the schema its version ships,
+                                            with the owner's connection string, asked for hidden
+
   Session
     coffre login [<url>] [--no-browser]     sign in, and make <url> the current instance
     coffre logout [<url>]
@@ -2453,7 +2566,13 @@ switch (command) {
 		await keys(rest);
 		break;
 	case "setup":
-		await (await import("./setup-BMmFAR3N.js")).setup(rest);
+		await (await import("./setup-qGoLPykX.js")).setup(rest);
+		break;
+	case "update":
+		await (await import("./update-DwGbG-eM.js")).update(rest);
+		break;
+	case "migrate":
+		await (await import("./migrate-ERNNgYO0.js")).migrate(rest, migrateTarget);
 		break;
 	case "login":
 		await login(rest);