hollware 0.2.0 → 0.3.0

package/dist/{d1-Bd-sdoDd.mjs → d1-Dobi7CSp.mjs}

@@ -136,13 +136,17 @@ function parseDatabase(value) {
 	if (!DATABASE.test(value)) throw new UsageError(`invalid --database ${shown(value)}: use the name or the binding of a D1 database (letters, digits, "_", "-" and ".", not starting with "-").`);
 	return value;
 }
-/** The statement that finds an owner. */
+/** The statement that finds an owner: a member of a site with the role owner (ADR-026). */
 function ownerQuery() {
-	return "SELECT id FROM users WHERE role = 'owner' LIMIT 1";
+	return "SELECT user_id AS id FROM members WHERE role = 'owner' LIMIT 1";
 }
 /** One statement for the sites of the database and one for its first owner. */
 function sitesAndOwnerQuery() {
-	return "SELECT id FROM sites ORDER BY id; SELECT id FROM users WHERE role = 'owner' ORDER BY created_at, id LIMIT 1;";
+	return "SELECT id FROM sites ORDER BY id; SELECT user_id AS id FROM members WHERE role = 'owner' ORDER BY created_at, user_id LIMIT 1;";
+}
+/** The owner of a site: the member with the role owner who came first. */
+function ownerOfSiteQuery(site) {
+	return `SELECT user_id AS id FROM members WHERE site_id = ${quote(site)} AND role = 'owner' ORDER BY created_at, user_id LIMIT 1;`;
 }
 /** The sites of the database. */
 function sitesQuery() {
@@ -153,18 +157,25 @@ function insertToken(token) {
 	return `INSERT INTO tokens (id, site_id, user_id, label, hash, scopes, expires_at, created_at, updated_at) VALUES (${quote(token.id)}, ${quote(token.site)}, ${quote(token.userId)}, ${quote(token.label)}, ${quote(token.hash)}, ${quote(JSON.stringify(token.scopes))}, ${quote(token.expiresAt)}, ${quote(token.now)}, ${quote(token.now)});`;
 }
 /**
-* What `init` writes, in one script: the site (left alone if it is already there), its owner
-* and the owner's first token.
+* What `init` writes, in one script: the site (left alone if it is already there), its owner, a
+* member of the site with the role owner, and the owner's first token. `users.role` gets the
+* owner too, the one name of a role that its CHECK and `members` share.
 */
-function initScript({ site, ownerId, ownerName, token }) {
+function initScript({ site, ownerId, memberId, ownerName, token }) {
 	const name = ownerName === void 0 ? "NULL" : quote(ownerName);
 	return [
 		`INSERT INTO sites (id, created_at, updated_at) VALUES (${quote(site)}, ${quote(token.now)}, ${quote(token.now)}) ON CONFLICT (id) DO NOTHING;`,
 		`INSERT INTO users (id, name, role, created_at, updated_at) VALUES (${quote(ownerId)}, ${name}, 'owner', ${quote(token.now)}, ${quote(token.now)});`,
+		`INSERT INTO members (id, site_id, user_id, role, created_at, updated_at) VALUES (${quote(memberId)}, ${quote(site)}, ${quote(ownerId)}, 'owner', ${quote(token.now)}, ${quote(token.now)});`,
 		insertToken(token),
 		""
 	].join("\n");
 }
+/** The row of an invitation (ADR-026): the owner's setup link, or an invitation with a role. */
+function insertInvitation(invitation) {
+	const user = invitation.userId === null ? "NULL" : quote(invitation.userId);
+	return `INSERT INTO invitations (id, site_id, hash, role, user_id, expires_at, used_at, created_at, updated_at) VALUES (${quote(invitation.id)}, ${quote(invitation.site)}, ${quote(invitation.hash)}, ${quote(invitation.role)}, ${user}, ${quote(invitation.expiresAt)}, NULL, ${quote(invitation.now)}, ${quote(invitation.now)});`;
+}
 /** The tokens of a site. It never selects the hash. */
 function listTokens(site) {
 	return `SELECT id, label, scopes, expires_at, revoked_at, last_used_at, created_at FROM tokens WHERE site_id = ${quote(site)} ORDER BY created_at, id;`;
@@ -266,16 +277,24 @@ function readAnswer(result, database, target) {
 		}
 		throw new CliError(`wrangler could not run the SQL: ${reason}`);
 	}
-	let json;
-	try {
-		json = JSON.parse(result.stdout);
-	} catch {
-		throw new CliError(`wrangler did not answer with JSON: ${failureReason(result)}`);
-	}
+	const json = jsonOf(result.stdout);
+	if (json === void 0) throw new CliError(`wrangler did not answer with JSON: ${failureReason(result)}`);
 	const answer = Answer.safeParse(json);
 	if (!answer.success) throw new CliError("wrangler answered with JSON that has an unexpected shape.");
 	if (answer.data.some((statement) => !statement.success)) throw new CliError("wrangler reported that a statement did not succeed.");
 	return answer.data.map((statement) => statement.results);
 }
+/**
+* The JSON of an answer of `wrangler d1 execute --json`: all of stdout, or, when wrangler printed a
+* warning before it (a config it finds incomplete, an update that is out), what follows the first
+* line that opens the array. `undefined` when there is no JSON. Reading past a warning matters:
+* `hollware init` prints its token only after the SQL answered, so a failure here loses it.
+*/
+function jsonOf(stdout) {
+	const attempts = [stdout, ...stdout.split("\n").flatMap((line, index, lines) => line.trimStart().startsWith("[") ? [lines.slice(index).join("\n")] : [])];
+	for (const text of attempts) try {
+		return JSON.parse(text);
+	} catch {}
+}
 //#endregion
-export { sitesAndOwnerQuery as _, runFile as a, listTokens as c, parseLabel as d, parseOwnerName as f, revokeToken as g, parseTokenId as h, resolveDatabase as i, ownerQuery as l, parseSiteKey as m, describeDatabase as n, initScript as o, parseScopes as p, query as r, insertToken as s, chooseTarget as t, parseExpiresInDays as u, sitesQuery as v };
+export { parseTokenId as _, runFile as a, sitesQuery as b, insertToken as c, ownerQuery as d, parseExpiresInDays as f, parseSiteKey as g, parseScopes as h, resolveDatabase as i, listTokens as l, parseOwnerName as m, describeDatabase as n, initScript as o, parseLabel as p, query as r, insertInvitation as s, chooseTarget as t, ownerOfSiteQuery as u, revokeToken as v, parseJsonc as x, sitesAndOwnerQuery as y };

package/dist/{entropy-CIYbTHkj.mjs → entropy-CuRnfwXT.mjs}

@@ -13,5 +13,11 @@ const DAY_MS = 864e5;
 function inDays(from, days) {
 	return new Date(from.getTime() + days * DAY_MS).toISOString();
 }
+/** A new invitation secret (`hw_inv_` and 43 base64url characters) from the random source of `io`. */
+function newInvitationSecret(io) {
+	let binary = "";
+	for (const byte of io.randomBytes(32)) binary += String.fromCharCode(byte);
+	return `hw_inv_${btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")}`;
+}
 //#endregion
-export { newId as n, newPersonalToken as r, inDays as t };
+export { newPersonalToken as i, newId as n, newInvitationSecret as r, inDays as t };

package/dist/{import-Dlpn_w3s.mjs → import-JnPkrGFE.mjs}

@@ -195,7 +195,8 @@ const IMPORT_USAGE = [
 	"  --dry-run            Only validate: write nothing, publish nothing",
 	"  --help               Show this help",
 	"",
-	"The token needs content:read and content:write, and content:publish for --publish."
+	"The token needs content:read and content:write, and content:publish for --publish: without it,",
+	"publish asks for a review of one entry, and refuses a group."
 ].join("\n");
 async function importContent(argv, io) {
 	const { values, positionals } = parseFlags({
@@ -263,7 +264,7 @@ async function importFiles({ io, token, endpoint, directory, root, publish: publ
 		if (drafts.failed > 0) throw new CliError(`${count(drafts.failed, "file")} could not be imported (see above).${publishToo ? " Nothing was published." : ""} Fix ${drafts.failed === 1 ? "it" : "them"} and run the import again: what is already there stays unchanged.`);
 		if (!publishToo) return 0;
 		const published = await publishAll(session, drafts.entries.filter((imported) => imported.summary.hasUnpublishedChanges), out);
-		out(`Publishing: ${published.published} published, ${published.needsAcknowledgement} need acknowledgement, ${published.blocked} blocked${published.other === 0 ? "" : `, ${published.other} failed`}.`);
+		out(`Publishing: ${published.published} published, ${published.needsAcknowledgement} need acknowledgement, ${published.blocked} blocked${published.reviews === 0 ? "" : `, ${published.reviews} asked for review`}${published.other === 0 ? "" : `, ${published.other} failed`}.`);
 		const problems = published.needsAcknowledgement + published.blocked + published.other;
 		if (problems > 0) throw new CliError(`${count(problems, "entry", "entries")} not published: warnings are never acknowledged here, and errors block publishing. Fix the content and run the import again with --publish: what is already published is skipped.`);
 		return 0;
@@ -442,50 +443,76 @@ function draftLine(kind, label, entry, verdict) {
 	const notes = [errors > 0 ? count(errors, "error") : void 0, warnings > 0 ? count(warnings, "warning") : void 0].filter((note) => note !== void 0);
 	return `${kind.padEnd(9)}  ${label}  ${entry.id}  v${entry.version}${notes.length === 0 ? "" : ` (${notes.join(", ")})`}`;
 }
+/** The most entries one publish takes: the entry and a group of 99 (ADR-024). */
+const GROUP_SIZE = 100;
 /**
-* Phase two: publishes each imported entry that has unpublished changes, at the version phase
-* one left it. It acknowledges no warning: an entry with warnings is reported, not published.
+* Phase two: publishes the imported entries that have unpublished changes, at the version phase
+* one left them, as one group (in groups of 100), so that entries that link to each other are
+* published together (ADR-024). When an entry stops its group, it is reported and taken out, and
+* the rest is published again without it. It acknowledges no warning: an entry with warnings is
+* reported, not published. A token without content:publish gets a review of a lone entry
+* (`pending_review`), and its group is refused, which reports every entry of it as failed.
 */
 async function publishAll(session, entries, out) {
 	const result = {
 		published: 0,
 		needsAcknowledgement: 0,
 		blocked: 0,
+		reviews: 0,
 		other: 0
 	};
-	for (const { file, summary } of entries) {
-		const label = printable(file.path.replace(/\.md$/, ""));
-		const line = (outcome, details = []) => [`${outcome.padEnd(21)}  ${label}  ${summary.id}`, ...details.map((detail) => `    ${detail}`)].join("\n");
-		try {
-			const answer = await session.call(publish, {
-				id: summary.id,
-				version: summary.version
-			});
+	const labelOf = ({ file }) => printable(file.path.replace(/\.md$/, ""));
+	const line = (imported, outcome, details = []) => [`${outcome.padEnd(21)}  ${labelOf(imported)}  ${imported.summary.id}`, ...details.map((detail) => `    ${detail}`)].join("\n");
+	for (let start = 0; start < entries.length; start += GROUP_SIZE) {
+		let pending = entries.slice(start, start + GROUP_SIZE);
+		while (pending.length > 0) {
+			const [first, ...rest] = pending;
+			if (first === void 0) break;
+			let answer;
+			try {
+				answer = await session.call(publish, {
+					id: first.summary.id,
+					version: first.summary.version,
+					group: rest.map(({ summary }) => ({
+						id: summary.id,
+						version: summary.version
+					}))
+				});
+			} catch (error) {
+				if (!(error instanceof ToolFailure)) throw error;
+				for (const imported of pending) out(line(imported, "failed", [error.message]));
+				result.other += pending.length;
+				break;
+			}
+			if (answer.outcome === "published" || answer.outcome === "scheduled") {
+				for (const imported of pending) out(line(imported, "published"));
+				result.published += pending.length;
+				break;
+			}
+			if (answer.outcome === "pending_review") {
+				for (const imported of pending) out(line(imported, "pending_review"));
+				result.reviews += pending.length;
+				break;
+			}
+			const failed = pending.find(({ summary }) => summary.id === answer.failedEntry) ?? first;
 			switch (answer.outcome) {
-				case "published":
-					result.published += 1;
-					out(line("published"));
-					break;
 				case "needs_acknowledgement":
 					result.needsAcknowledgement += 1;
-					out(line("needs_acknowledgement", (answer.verdict?.warnings ?? []).map(violationLine)));
+					out(line(failed, "needs_acknowledgement", (answer.verdict?.warnings ?? []).map(violationLine)));
 					break;
 				case "blocked":
 					result.blocked += 1;
-					out(line("blocked", (answer.verdict?.errors ?? []).map(violationLine)));
+					out(line(failed, "blocked", (answer.verdict?.errors ?? []).map(violationLine)));
 					break;
 				case "conflict":
 					result.other += 1;
-					out(line("conflict", ["someone changed the entry after it was imported"]));
+					out(line(failed, "conflict", ["someone changed the entry after it was imported"]));
 					break;
 				case "not_found":
 					result.other += 1;
-					out(line("not_found", ["the entry is gone"]));
+					out(line(failed, "not_found", ["the entry is gone"]));
 			}
-		} catch (error) {
-			if (!(error instanceof ToolFailure)) throw error;
-			result.other += 1;
-			out(line("failed", [error.message]));
+			pending = pending.filter((imported) => imported !== failed);
 		}
 	}
 	return result;

package/dist/index.mjs

@@ -20,6 +20,10 @@ const COMMANDS = [
 		name: "token",
 		summary: "Create, list and revoke personal tokens"
 	},
+	{
+		name: "invite",
+		summary: "Invite a person to the admin, as an editor or an author"
+	},
 	{
 		name: "import",
 		summary: "Import Markdown files over MCP"
@@ -41,7 +45,7 @@ const USAGE = [
 	"  --version  Print the version",
 	"",
 	"Run \"hollware <command> --help\" for the options of a command.",
-	"init, migrate and token work on the project in the current directory, through its wrangler."
+	"init, migrate, token and invite work on the project in the current directory, through its wrangler."
 ].join("\n");
 const TOKEN_COMMANDS = [
 	"create",
@@ -72,6 +76,7 @@ async function main(argv, io) {
 		"init",
 		"migrate",
 		"token",
+		"invite",
 		"import"
 	].includes(first)) {
 		io.err(`hollware: unknown command or flag "${printable(first)}"\n\n${USAGE}`);
@@ -89,10 +94,11 @@ async function main(argv, io) {
 }
 async function run(command, args, io) {
 	switch (command) {
-		case "init": return (await import("./init-Cl9Epsbp.mjs")).init(args, io);
-		case "migrate": return (await import("./migrate-CLHWuUje.mjs")).migrate(args, io);
-		case "token": return (await import("./token-BLkrPLio.mjs")).token(args, io);
-		default: return (await import("./import-Dlpn_w3s.mjs")).importContent(args, io);
+		case "init": return (await import("./init-BqlTvCVM.mjs")).init(args, io);
+		case "migrate": return (await import("./migrate-CPtQl8vj.mjs")).migrate(args, io);
+		case "token": return (await import("./token-B9r6vkEy.mjs")).token(args, io);
+		case "invite": return (await import("./invite-CXNAswZJ.mjs")).invite(args, io);
+		default: return (await import("./import-JnPkrGFE.mjs")).importContent(args, io);
 	}
 }
 function isEntryPoint() {

package/dist/{init-Cl9Epsbp.mjs → init-BqlTvCVM.mjs}

@@ -1,16 +1,18 @@
 import { i as UsageError, r as CliError } from "./format-BpRYEsGB.mjs";
 import { t as parseFlags } from "./args-CljWh-kZ.mjs";
-import { a as runFile, f as parseOwnerName, i as resolveDatabase, l as ownerQuery, m as parseSiteKey, n as describeDatabase, o as initScript, r as query, t as chooseTarget } from "./d1-Bd-sdoDd.mjs";
-import { n as newId, r as newPersonalToken, t as inDays } from "./entropy-CIYbTHkj.mjs";
+import { a as runFile, d as ownerQuery, g as parseSiteKey, i as resolveDatabase, m as parseOwnerName, n as describeDatabase, o as initScript, r as query, s as insertInvitation, t as chooseTarget } from "./d1-Dobi7CSp.mjs";
+import { i as newPersonalToken, n as newId, r as newInvitationSecret, t as inDays } from "./entropy-CuRnfwXT.mjs";
+import { n as setupLink, t as publicUrlOf } from "./public-url-CwFcgWHr.mjs";
 import { rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { PERSONAL_TOKEN_TTL_DAYS, SCOPES, hashPersonalToken } from "@hollware/core";
 //#region src/commands/init.ts
 const INIT_USAGE = [
-	"Usage: hollware init --site <key> [--local | --remote] [--owner-name <name>] [--database <name>]",
+	"Usage: hollware init --site <key> [--local | --remote] [--owner-name <name>] [--database <name>] [--url <url>]",
 	"",
 	"Creates a site, its owner and the owner's first personal token in the project's D1 database,",
-	"in one step, and prints the token once. It does nothing when the database already has an owner.",
+	"in one step, and prints the token once, with a link to set up the passkey of the admin (valid",
+	"for 7 days). It does nothing when the database already has an owner.",
 	"Run \"hollware migrate\" first: the database needs its tables.",
 	"",
 	"Options:",
@@ -19,6 +21,7 @@ const INIT_USAGE = [
 	"  --remote             Use the database in Cloudflare",
 	"  --owner-name <name>  The name of the owner",
 	"  --database <name>    The D1 database, by name or binding (default: the binding \"DB\" of wrangler.jsonc)",
+	"  --url <url>          The public URL of Hollware, for the link (default: HOLLWARE_PUBLIC_URL of wrangler.jsonc)",
 	"  --help               Show this help"
 ].join("\n");
 /** The label of the token `init` creates. */
@@ -33,6 +36,7 @@ async function init(argv, io) {
 			remote: { type: "boolean" },
 			"owner-name": { type: "string" },
 			database: { type: "string" },
+			url: { type: "string" },
 			help: { type: "boolean" }
 		}
 	});
@@ -45,6 +49,7 @@ async function init(argv, io) {
 	const ownerName = values["owner-name"] === void 0 ? void 0 : parseOwnerName(values["owner-name"]);
 	const target = chooseTarget(values);
 	const database = resolveDatabase(io.cwd, values.database);
+	const url = publicUrlOf(io.cwd, values.url);
 	const [owners = []] = await query(io.wrangler, database, target, ownerQuery());
 	const [existing] = owners;
 	if (existing !== void 0) {
@@ -57,9 +62,22 @@ async function init(argv, io) {
 	const tokenId = newId(io, "token");
 	const secret = newPersonalToken(io);
 	const expiresAt = inDays(now, PERSONAL_TOKEN_TTL_DAYS);
+	const setupSecret = newInvitationSecret(io);
+	const setupExpiresAt = inDays(now, 7);
+	const setup = insertInvitation({
+		id: newId(io, "invitation"),
+		site,
+		hash: await hashPersonalToken(setupSecret),
+		role: "owner",
+		userId: ownerId,
+		expiresAt: setupExpiresAt,
+		now: timestamp
+	});
+	const memberId = newId(io, "member");
 	const script = initScript({
 		site,
 		ownerId,
+		memberId,
 		ownerName,
 		token: {
 			id: tokenId,
@@ -71,7 +89,7 @@ async function init(argv, io) {
 			expiresAt,
 			now: timestamp
 		}
-	});
+	}).concat(`${setup}\n`);
 	const directory = io.tempDir();
 	try {
 		const file = join(directory, "init.sql");
@@ -96,6 +114,9 @@ async function init(argv, io) {
 		"",
 		secret,
 		"",
+		`Set up your passkey for the admin, once, by ${setupExpiresAt}:`,
+		`  ${setupLink(url, setupSecret)}`,
+		"",
 		"Next:",
 		"  Save the token in a file only you can read, then import content:",
 		"    hollware import <directory> --url <your Hollware URL> --token-file <file>",

package/dist/invite-CXNAswZJ.mjs

@@ -0,0 +1,88 @@
+import { i as UsageError, r as CliError } from "./format-BpRYEsGB.mjs";
+import { t as parseFlags } from "./args-CljWh-kZ.mjs";
+import { b as sitesQuery, f as parseExpiresInDays, g as parseSiteKey, i as resolveDatabase, r as query, s as insertInvitation, t as chooseTarget, u as ownerOfSiteQuery } from "./d1-Dobi7CSp.mjs";
+import { n as newId, r as newInvitationSecret, t as inDays } from "./entropy-CuRnfwXT.mjs";
+import { n as setupLink, t as publicUrlOf } from "./public-url-CwFcgWHr.mjs";
+import { o as WHERE_OPTIONS, s as chooseSite } from "./token-BjTgNwWV.mjs";
+import { hashPersonalToken } from "@hollware/core";
+//#region src/commands/invite.ts
+const INVITE_USAGE = [
+	"Usage: hollware invite (--role <editor | author> | --owner) [--days <n>] [--url <url>]",
+	"                       [--site <key>] [--local | --remote] [--database <name>]",
+	"",
+	"Invites a person to the admin (ADR-026): prints a link, valid once and for 7 days by default,",
+	"where they set up a passkey. An editor reads, writes and publishes; an author reads and writes,",
+	"and what an author publishes goes through review. With --owner, the link is for the owner of",
+	"the site, to set up a passkey: on a deployment that was made before the admin existed, or on a",
+	"new device.",
+	"",
+	"Options:",
+	"  --role <role>      editor or author",
+	"  --owner            A setup link for the owner of the site, instead of a new person",
+	"  --days <n>         Days until the link expires, 1 to 365 (default: 7)",
+	"  --url <url>        The public URL of Hollware (default: HOLLWARE_PUBLIC_URL of wrangler.jsonc)",
+	"  --site <key>       The site (default: the only site of the database)",
+	"  --local            Use the local database (the default)",
+	"  --remote           Use the database in Cloudflare",
+	"  --database <name>  The D1 database, by name or binding (default: the binding \"DB\" of wrangler.jsonc)",
+	"  --help             Show this help"
+].join("\n");
+/** The role of `--role`: editor or author, and nothing else. */
+function roleOf(value) {
+	if (value === "editor" || value === "author") return value;
+	throw new UsageError("--role is required, and it is editor or author.");
+}
+async function invite(argv, io) {
+	const { values } = parseFlags({
+		args: [...argv],
+		allowPositionals: false,
+		options: {
+			...WHERE_OPTIONS,
+			role: { type: "string" },
+			owner: { type: "boolean" },
+			days: { type: "string" },
+			url: { type: "string" }
+		}
+	});
+	if (values.help === true) {
+		io.out(INVITE_USAGE);
+		return 0;
+	}
+	const forOwner = values.owner === true;
+	if (forOwner && values.role !== void 0) throw new UsageError("--owner and --role cannot be used together: choose one.");
+	const role = forOwner ? "owner" : roleOf(values.role);
+	const days = values.days === void 0 ? 7 : parseExpiresInDays(values.days);
+	const siteFlag = values.site === void 0 ? void 0 : parseSiteKey(values.site);
+	const target = chooseTarget(values);
+	const database = resolveDatabase(io.cwd, values.database);
+	const url = publicUrlOf(io.cwd, values.url);
+	const [siteRows = []] = await query(io.wrangler, database, target, sitesQuery());
+	const site = chooseSite(siteRows, siteFlag);
+	let userId = null;
+	if (forOwner) {
+		const [owners = []] = await query(io.wrangler, database, target, ownerOfSiteQuery(site));
+		const [owner] = owners;
+		if (owner === void 0 || typeof owner["id"] !== "string") throw new CliError(`the site "${site}" has no owner. Run "hollware init" to make one.`);
+		userId = owner["id"];
+	}
+	const now = io.now();
+	const secret = newInvitationSecret(io);
+	const expiresAt = inDays(now, days);
+	await query(io.wrangler, database, target, insertInvitation({
+		id: newId(io, "invitation"),
+		site,
+		hash: await hashPersonalToken(secret),
+		role,
+		userId,
+		expiresAt,
+		now: now.toISOString()
+	}));
+	io.out([
+		userId === null ? `Invited an ${role} to the site "${site}". The link works once, until ${expiresAt}:` : `A setup link for the owner (${userId}) of the site "${site}", to set up a passkey. It works once, until ${expiresAt}:`,
+		"",
+		`  ${setupLink(url, secret)}`
+	].join("\n"));
+	return 0;
+}
+//#endregion
+export { invite };

package/dist/{migrate-CLHWuUje.mjs → migrate-CPtQl8vj.mjs}

@@ -1,7 +1,7 @@
 import { r as CliError } from "./format-BpRYEsGB.mjs";
 import { n as failureReason, r as stripAnsi } from "./wrangler-BLIfwbcu.mjs";
 import { t as parseFlags } from "./args-CljWh-kZ.mjs";
-import { i as resolveDatabase, n as describeDatabase, t as chooseTarget } from "./d1-Bd-sdoDd.mjs";
+import { i as resolveDatabase, n as describeDatabase, t as chooseTarget } from "./d1-Dobi7CSp.mjs";
 import { existsSync, mkdirSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 //#region src/commands/migrate.ts

package/dist/public-url-CwFcgWHr.mjs

@@ -0,0 +1,32 @@
+import { i as UsageError } from "./format-BpRYEsGB.mjs";
+import { x as parseJsonc } from "./d1-Dobi7CSp.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+//#region src/public-url.ts
+/**
+* The public URL of the project's Hollware, for the links the CLI prints: `--url` when given,
+* else `vars.HOLLWARE_PUBLIC_URL` of the project's `wrangler.jsonc`, else `undefined`.
+*/
+function publicUrlOf(cwd, flag) {
+	if (flag !== void 0) {
+		if (!URL.canParse(flag)) throw new UsageError(`--url is no URL: ${flag}`);
+		return new URL(flag).origin;
+	}
+	const file = ["wrangler.jsonc", "wrangler.json"].map((name) => join(cwd, name)).find(existsSync);
+	if (file === void 0) return void 0;
+	let config;
+	try {
+		config = parseJsonc(readFileSync(file, "utf8"));
+	} catch {
+		return;
+	}
+	const vars = typeof config === "object" && config !== null && "vars" in config ? config.vars : void 0;
+	const url = typeof vars === "object" && vars !== null && "HOLLWARE_PUBLIC_URL" in vars ? vars.HOLLWARE_PUBLIC_URL : void 0;
+	return typeof url === "string" && URL.canParse(url) ? new URL(url).origin : void 0;
+}
+/** The link that lets a person set up a passkey with an invitation. */
+function setupLink(url, secret) {
+	return `${url ?? "<your Hollware URL>"}/setup?invitation=${secret}`;
+}
+//#endregion
+export { setupLink as n, publicUrlOf as t };

package/dist/token-B9r6vkEy.mjs

@@ -0,0 +1,2 @@
+import { c as token } from "./token-BjTgNwWV.mjs";
+export { token };

package/dist/{token-BLkrPLio.mjs → token-BjTgNwWV.mjs}

@@ -1,7 +1,7 @@
 import { i as UsageError, n as table, r as CliError, t as printable } from "./format-BpRYEsGB.mjs";
 import { t as parseFlags } from "./args-CljWh-kZ.mjs";
-import { _ as sitesAndOwnerQuery, c as listTokens, d as parseLabel, g as revokeToken, h as parseTokenId, i as resolveDatabase, m as parseSiteKey, p as parseScopes, r as query, s as insertToken, t as chooseTarget, u as parseExpiresInDays, v as sitesQuery } from "./d1-Bd-sdoDd.mjs";
-import { n as newId, r as newPersonalToken, t as inDays } from "./entropy-CIYbTHkj.mjs";
+import { _ as parseTokenId, b as sitesQuery, c as insertToken, f as parseExpiresInDays, g as parseSiteKey, h as parseScopes, i as resolveDatabase, l as listTokens, p as parseLabel, r as query, t as chooseTarget, v as revokeToken, y as sitesAndOwnerQuery } from "./d1-Dobi7CSp.mjs";
+import { i as newPersonalToken, n as newId, t as inDays } from "./entropy-CuRnfwXT.mjs";
 import { PERSONAL_TOKEN_TTL_DAYS, hashPersonalToken } from "@hollware/core";
 //#region src/commands/token.ts
 const WHERE_FLAGS = [
@@ -225,4 +225,4 @@ function scopesOf(value) {
 	return printable(value);
 }
 //#endregion
-export { token };
+export { TOKEN_USAGE as a, token as c, TOKEN_REVOKE_USAGE as i, TOKEN_CREATE_USAGE as n, WHERE_OPTIONS as o, TOKEN_LIST_USAGE as r, chooseSite as s, DEFAULT_SCOPES as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hollware",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "The Hollware CLI: init, migrate, token, import and export.",
   "homepage": "https://hollware.com",
   "bugs": {
@@ -31,7 +31,7 @@
     "provenance": true
   },
   "dependencies": {
-    "@hollware/core": "0.2.0",
+    "@hollware/core": "0.3.0",
     "@modelcontextprotocol/client": "2.3.1",
     "zod": "4.6.5"
   },