@vercel/board 0.15.0 → 0.17.0

package/dist/access.d.mts

@@ -1,7 +1,7 @@
 import { a as Grant, i as ChannelPattern, n as AccessSummary, o as Permission, r as Can, t as Access } from "./access-CV96SYgr.mjs";
-import { _ as oidc, a as CallerRequest, c as HostPrincipal, d as OidcTokensOptions, f as Principal, g as githubActions, h as compileRules, i as AuthenticateContext, l as IssuerConfig, m as RuleFunction, n as AccessRule, o as Claims, p as PrincipalKind, r as Authenticate, t as AccessFunction, u as Known, v as vercelProject } from "./auth-wHFcAte3.mjs";
+import { _ as oidc, a as CallerRequest, c as HostPrincipal, d as OidcTokensOptions, f as Principal, g as githubActions, h as compileRules, i as AuthenticateContext, l as IssuerConfig, m as RuleFunction, n as AccessRule, o as Claims, p as PrincipalKind, r as Authenticate, t as AccessFunction, u as Known, v as vercelProject } from "./auth-CU56Q2Xh.mjs";
 import { o as Author } from "./schemas-CWxs3ECJ.mjs";
-import { t as Actor } from "./reducers-B_vUGQRp.mjs";
+import { t as Actor } from "./folds-CRYY14kc.mjs";
 //#region src/server/tokens.d.ts
 /**
  * The OIDC tokens made out to this board: a request's bearer token, from Vercel (people and
@@ -21,8 +21,9 @@ type ResolvedActor = {
 };
 /**
  * The actor a caller writes as: its principal, plus the profile it claims (`vercel:user:u_123+claude`).
- * A person's handle and name are what they claim; anyone else's are their principal's. `audience`
- * is the board's URL, which serves the known agents' avatars.
+ * A person's name is what they claim, and so is their handle unless a host's verifier named them;
+ * anyone else's are their principal's. `audience` is the board's URL, which serves the known
+ * agents' avatars.
  */
 export declare function resolveActor(principal: Principal, claims: Claims, audience: string): ResolvedActor;
 //#endregion

package/dist/access.mjs

@@ -1,4 +1,4 @@
-import { i as resolveActor } from "./actors-rdN4dDTU.mjs";
-import { a as compileRules, c as githubActions, h as vercelProject, p as oidc } from "./auth-COzc09sn.mjs";
-import { t as oidcTokens } from "./tokens-DKLn5P9B.mjs";
+import { a as compileRules, c as githubActions, h as vercelProject, p as oidc } from "./auth-Drg9FiC2.mjs";
+import { i as resolveActor } from "./actors-BOamkEuz.mjs";
+import { t as oidcTokens } from "./tokens-DhuzKzAl.mjs";
 export { compileRules, githubActions, oidc, oidcTokens, resolveActor, vercelProject };

package/dist/{actors-rdN4dDTU.mjs → actors-BOamkEuz.mjs}

@@ -1,78 +1,8 @@
 import { C as toStorable } from "./schemas-Be08nyfW.mjs";
 import { r as badRequest } from "./errors-DX3hpwWt.mjs";
 import { t as own } from "./own-OwgPWdmh.mjs";
-import { i as parseScope } from "./access-CJU2-vaa.mjs";
-//#region src/contract/mentions.ts
-const FENCED_CODE = /```[\s\S]*?```/g;
-const INLINE_CODE = /`[^`\n]*`/g;
-const NAME = "[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?";
-const MENTION = new RegExp(`(?<![\\w@.-])@(${NAME}(?:/${NAME})?)(?!:|[a-z0-9_/-]|\\.(?=[a-z0-9]))`, "gi");
-const EXACT = /(?<![\w@.-])@\[([^\]\s]+)\]/g;
-/** Blanks out code so mentions inside it never count. */
-const proseOnly = (text) => text.replace(FENCED_CODE, (match) => " ".repeat(match.length)).replace(INLINE_CODE, (match) => " ".repeat(match.length));
-/** Mentions in prose order, deduplicated. Handles are lowercased. */
-function extractMentions(text) {
-	const prose = proseOnly(text);
-	const found = [];
-	for (const match of prose.matchAll(EXACT)) {
-		const actor = match[1];
-		if (actor !== void 0) found.push({
-			index: match.index,
-			token: {
-				kind: "actor",
-				actor
-			},
-			key: `actor:${actor}`
-		});
-	}
-	for (const match of prose.replace(EXACT, (m) => " ".repeat(m.length)).matchAll(MENTION)) {
-		const handle = match[1]?.toLowerCase();
-		if (handle !== void 0) found.push({
-			index: match.index,
-			token: {
-				kind: "handle",
-				handle
-			},
-			key: `handle:${handle}`
-		});
-	}
-	const seen = /* @__PURE__ */ new Set();
-	return found.sort((a, b) => a.index - b.index).filter(({ key }) => !seen.has(key) && seen.add(key)).map(({ token }) => token);
-}
-/**
-* Rewrites each mention in prose with `replace`, which also gets the mention as
-* written; one it returns null for stays as written.
-* Code is left alone, as in `extractMentions`.
-*/
-function replaceMentions(text, replace) {
-	const prose = proseOnly(text);
-	const found = [];
-	for (const match of prose.matchAll(EXACT)) found.push({
-		index: match.index,
-		length: match[0].length,
-		token: {
-			kind: "actor",
-			actor: match[1]
-		}
-	});
-	for (const match of prose.replace(EXACT, (m) => " ".repeat(m.length)).matchAll(MENTION)) found.push({
-		index: match.index,
-		length: match[0].length,
-		token: {
-			kind: "handle",
-			handle: match[1].toLowerCase()
-		}
-	});
-	let out = "";
-	let at = 0;
-	for (const { index, length, token } of found.sort((a, b) => a.index - b.index)) {
-		const written = text.slice(index, index + length);
-		out += text.slice(at, index) + (replace(token, written) ?? written);
-		at = index + length;
-	}
-	return out + text.slice(at);
-}
-//#endregion
+import { t as extractMentions } from "./mentions-CB6ShY4R.mjs";
+import { y as parseScope } from "./auth-Drg9FiC2.mjs";
 //#region src/server/actors.ts
 /** Agents whose avatars the board serves itself. */
 const KNOWN_AGENTS = [
@@ -122,11 +52,12 @@ function claimsOf(headers) {
 }
 /**
 * The actor a caller writes as: its principal, plus the profile it claims (`vercel:user:u_123+claude`).
-* A person's handle and name are what they claim; anyone else's are their principal's. `audience`
-* is the board's URL, which serves the known agents' avatars.
+* A person's name is what they claim, and so is their handle unless a host's verifier named them;
+* anyone else's are their principal's. `audience` is the board's URL, which serves the known
+* agents' avatars.
 */
 function resolveActor(principal, claims, audience) {
-	const baseHandle = principal.kind === "person" && claims.handle ? claims.handle : principal.handle;
+	const baseHandle = principal.kind === "person" && principal.facts?.issuer !== "host" && claims.handle ? claims.handle : principal.handle;
 	const personName = principal.kind === "person" ? claims.name : null;
 	const profile = claims.profile?.toLowerCase() ?? null;
 	const id = profile === null ? principal.id : `${principal.id}+${profile}`;
@@ -220,4 +151,4 @@ function resolveMentions(text, known, pending, lenient = false, candidates = tru
 	};
 }
 //#endregion
-export { resolveMentions as a, resolveActor as i, actorSeen as n, extractMentions as o, claimsOf as r, replaceMentions as s, KNOWN_AGENTS as t };
+export { resolveMentions as a, resolveActor as i, actorSeen as n, claimsOf as r, KNOWN_AGENTS as t };

package/dist/attempts-CLG840Oj.mjs

@@ -0,0 +1,20 @@
+//#region src/server/wait-until.ts
+/**
+* Keeps `task` running after the response, where the platform offers it: Vercel's request context, as A2
+* reads it too. Elsewhere it runs on in the process.
+*/
+function waitUntil(task) {
+	try {
+		Reflect.get(globalThis, Symbol.for("@vercel/request-context"))?.get?.()?.waitUntil?.(task);
+	} catch {}
+}
+/**
+* Whether a run comes after a retry from a dead letter. A2 keeps counting
+* `ctx.attempt` across one, and no earlier run sees an attempt past A2_TRIES:
+* the event is dead by then. board gives up early, and records why, only in an
+* event's first tries; a retried one gets A2's fresh tries, and dead-letters
+* again if they all fail.
+*/
+const afterRetry = (attempt) => attempt > 10;
+//#endregion
+export { waitUntil as n, afterRetry as t };

package/dist/{auth-wHFcAte3.d.mts → auth-CU56Q2Xh.d.mts}

@@ -39,7 +39,7 @@ type Principal = {
   /** `vercel:user:<id>`, `vercel:project:<id>:<env>`, `github:repo:<id>`, `oidc:<issuer>:<sub>`. */
   id: string;
   kind: PrincipalKind;
-  /** The default handle; a person's is replaced by the handle their CLI sends. */
+  /** The default handle; a person's is replaced by the handle their CLI sends, unless a host's verifier named them. */
   handle: string;
   expiresAt: Date | null;
   /** The verified token's claims, so its access can be worked out again later, as a schedule's sends do. Absent for people and the board's own code. */
@@ -196,6 +196,7 @@ type HostPrincipal = {
   /** `vercel:user:<id>`, `vercel:project:<id>:<env>`, …: records keep their shape. */
   id: string;
   kind: PrincipalKind;
+  /** Kept as it is: `x-board-handle` doesn't replace it. Return `request.claims.handle` to take the caller's. */
   handle: string;
   expiresAt?: Date | null;
 };

package/dist/{auth-COzc09sn.mjs → auth-Drg9FiC2.mjs}

@@ -1,5 +1,228 @@
+import { c as ChannelPath, v as SCOPE_MAX } from "./schemas-Be08nyfW.mjs";
 import { a as forbidden, l as unauthorized } from "./errors-DX3hpwWt.mjs";
-import { i as parseScope, r as compileAccess, t as FULL_ACCESS } from "./access-CJU2-vaa.mjs";
+//#region src/server/access.ts
+/**
+* What a principal may do in a channel. `read` covers messages, threads,
+* `/events`, and schedules; `post` starts threads and edits your own messages;
+* `manage` is the board's own bookkeeping (inbox, sources).
+*/
+const PERMISSIONS = [
+	"read",
+	"post",
+	"react",
+	"label",
+	"sync",
+	"manage"
+];
+/**
+* One hop of implication, kept as data like Vercel's git broker
+* (`ACTION_IMPLICATIONS`). Each verb that addresses a message by ID implies
+* `read`, so none of them is a blind existence oracle. `post` implies nothing:
+* write-only is `['post']`.
+*/
+const IMPLIES = {
+	read: [],
+	post: [],
+	react: ["read"],
+	label: ["read"],
+	sync: ["read"],
+	manage: [
+		"read",
+		"post",
+		"react",
+		"label",
+		"sync"
+	]
+};
+const ORDER = new Map(PERMISSIONS.map((permission, index) => [permission, index]));
+const SHAPE = "write *, a channel, or a channel and its subtree (feedback/)";
+/** A pattern's parts; any other `*` throws, and says what to type instead. */
+function parsePattern(pattern) {
+	if (pattern === "*") return { kind: "all" };
+	if (pattern.includes("*")) {
+		const before = pattern.slice(0, pattern.indexOf("*")).replace(/\/+$/, "");
+		const hint = before === "" ? "write * for every channel" : ChannelPath.safeParse(before).success ? `write ${before}/ for ${before} and its subtree` : SHAPE;
+		throw new Error(`invalid channel pattern ${pattern}: ${hint}`);
+	}
+	const subtree = pattern.endsWith("/");
+	const path = subtree ? pattern.slice(0, -1) : pattern;
+	if (!ChannelPath.safeParse(path).success) throw new Error(`invalid channel pattern ${pattern || "(empty)"}: ${SHAPE}`);
+	return subtree ? {
+		kind: "subtree",
+		path
+	} : {
+		kind: "exact",
+		path
+	};
+}
+const key = (pattern) => pattern.kind === "all" ? "*" : pattern.kind === "subtree" ? `${pattern.path}/` : pattern.path;
+/** A grant with its implications, closed: `['label']` is `read` and `label`. */
+function expand(grant) {
+	const out = /* @__PURE__ */ new Set();
+	const add = (permission) => {
+		if (!ORDER.has(permission)) throw new Error(`unknown permission ${String(permission)}: use ${PERMISSIONS.join(", ")}`);
+		if (out.has(permission)) return;
+		out.add(permission);
+		for (const implied of IMPLIES[permission]) add(implied);
+	};
+	for (const permission of grant === "all" ? PERMISSIONS : grant) add(permission);
+	return out;
+}
+const NOTHING = /* @__PURE__ */ new Set();
+function compile(entries) {
+	let all = null;
+	const exact = /* @__PURE__ */ new Map();
+	const subtrees = [];
+	for (const [pattern, permissions] of entries) if (pattern.kind === "all") all = permissions;
+	else if (pattern.kind === "exact") exact.set(pattern.path, permissions);
+	else subtrees.push([pattern.path, permissions]);
+	subtrees.sort((a, b) => b[0].length - a[0].length);
+	return {
+		all,
+		exact,
+		subtrees
+	};
+}
+const under = (channel, path) => channel === path || channel.startsWith(`${path}/`);
+/** What the most specific pattern covering `channel` gives; with `subtreeOnly`, ignoring an exact rule for it. */
+function resolve(rules, channel, subtreeOnly = false) {
+	if (!subtreeOnly) {
+		const exact = rules.exact.get(channel);
+		if (exact) return exact;
+	}
+	for (const [path, permissions] of rules.subtrees) if (under(channel, path)) return permissions;
+	return rules.all ?? NOTHING;
+}
+/**
+* What `rules` gives every channel `pattern` governs where nothing more
+* specific does. The patterns matching one channel form a chain, so that's one
+* answer: an exact channel resolves as itself, a subtree as whatever covers the
+* subtree's root, ignoring an exact rule for the root.
+*/
+const at = (rules, pattern) => pattern.kind === "all" ? rules.all ?? NOTHING : resolve(rules, pattern.path, pattern.kind === "subtree");
+const equal = (a, b) => a.size === b.size && [...a].every((permission) => b.has(permission));
+/** The answer of the pattern next less specific than `pattern` in `rules`. */
+function parent(rules, pattern) {
+	if (pattern.kind === "exact") return resolve(rules, pattern.path, true);
+	if (pattern.kind === "subtree") {
+		for (const [path, permissions] of rules.subtrees) if (path !== pattern.path && under(pattern.path, path)) return permissions;
+	}
+	return rules.all ?? NOTHING;
+}
+/** Drops rules that say what their parent says, and an empty `*`, so equal access has one summary. */
+function canonical(entries) {
+	const rules = compile(entries);
+	return compile(entries.filter(([pattern, permissions]) => pattern.kind === "all" ? permissions.size > 0 : !equal(permissions, parent(rules, pattern))));
+}
+function entriesOf(can) {
+	if (can === "all" || Array.isArray(can)) return [[{ kind: "all" }, expand(can)]];
+	return Object.entries(can).map(([pattern, grant]) => [parsePattern(pattern), expand(grant)]);
+}
+const entriesIn = (rules) => [
+	...rules.all ? [[{ kind: "all" }, rules.all]] : [],
+	...rules.subtrees.map(([path, permissions]) => [{
+		kind: "subtree",
+		path
+	}, permissions]),
+	...[...rules.exact].map(([path, permissions]) => [{
+		kind: "exact",
+		path
+	}, permissions])
+];
+const RULES = Symbol("board.access");
+const isAccess = (value) => typeof value === "object" && RULES in value;
+function fromRules(rules) {
+	const entries = entriesIn(rules);
+	const everywhere = (permission) => (rules.all?.has(permission) ?? false) && entries.every(([, permissions]) => permissions.has(permission));
+	const readable = /* @__PURE__ */ new Map();
+	return {
+		[RULES]: rules,
+		can: (permission, channel) => resolve(rules, channel).has(permission),
+		readable(channel) {
+			let found = readable.get(channel);
+			if (found === void 0) readable.set(channel, found = resolve(rules, channel).has("read"));
+			return found;
+		},
+		readsAll: everywhere("read"),
+		everywhere,
+		anywhere: (permission) => entries.some(([, permissions]) => permissions.has(permission)),
+		narrow(scope) {
+			const other = isAccess(scope) ? scope[RULES] : canonical(entriesOf(scope));
+			const patterns = /* @__PURE__ */ new Map([["*", { kind: "all" }]]);
+			for (const [pattern] of [...entries, ...entriesIn(other)]) patterns.set(key(pattern), pattern);
+			return fromRules(canonical([...patterns.values()].map((pattern) => {
+				const theirs = at(other, pattern);
+				return [pattern, new Set([...at(rules, pattern)].filter((permission) => theirs.has(permission)))];
+			})));
+		},
+		summary() {
+			const named = entries.map(([pattern, permissions]) => [key(pattern), permissions]);
+			named.sort(([a], [b]) => a === "*" ? -1 : b === "*" ? 1 : a.localeCompare(b));
+			const out = {};
+			for (const [name, permissions] of named) out[name] = [...permissions].sort((a, b) => ORDER.get(a) - ORDER.get(b));
+			return out;
+		}
+	};
+}
+/** Access from config: `'all'`, a list for every channel, or a map from pattern to grant. Throws on a bad pattern or permission. */
+function compileAccess(can) {
+	return fromRules(canonical(entriesOf(can)));
+}
+const FULL_ACCESS = compileAccess("all");
+/**
+* `x-board-scope`: `dev/=read,post,react,label;ci/=read`. Each entry is a
+* pattern and its permissions (or `all`). It's meant for a proxy that holds the
+* credential, like Pi's sandbox: the board intersects it with the principal's
+* access, so it can only narrow, and a caller holding its own token gains
+* nothing by sending it.
+*/
+function parseScope(header) {
+	if (header.length > 4e3) throw new Error(`x-board-scope is longer than ${SCOPE_MAX} characters`);
+	const out = {};
+	const entries = header.split(";").map((entry) => entry.trim());
+	if (entries.every((entry) => entry === "")) throw new Error("x-board-scope is empty: write pattern=permissions, like dev/=read,post");
+	for (const entry of entries) {
+		if (entry === "") continue;
+		const split = entry.indexOf("=");
+		if (split < 0) throw new Error(`x-board-scope entry ${entry} needs =: write pattern=permissions, like dev/=read,post`);
+		const pattern = entry.slice(0, split).trim();
+		const list = entry.slice(split + 1).trim();
+		if (Object.hasOwn(out, pattern)) throw new Error(`x-board-scope lists ${pattern} twice`);
+		parsePattern(pattern);
+		const permissions = list === "" ? [] : list.split(",").map((permission) => permission.trim());
+		if (permissions.length === 1 && permissions[0] === "all") {
+			out[pattern] = "all";
+			continue;
+		}
+		for (const permission of permissions) if (!ORDER.has(permission)) throw new Error(`x-board-scope: unknown permission ${permission || "(empty)"}: use ${PERMISSIONS.join(", ")}, or all`);
+		out[pattern] = permissions;
+	}
+	return out;
+}
+const PHRASE = {
+	read: (channel) => `read ${channel}`,
+	post: (channel) => `post in ${channel}`,
+	react: (channel) => `react in ${channel}`,
+	label: (channel) => `label in ${channel}`,
+	sync: (channel) => `sync in ${channel}`,
+	manage: (channel) => `manage ${channel}`
+};
+/**
+* A proof that `access` allows `permission` in `channel`, or a 403 naming what's
+* missing: `this token can't label in dev`. Pass the channel the board looked
+* up, never one the request named. What the caller can't read should answer as
+* if it didn't exist: pass that error as `hidden`, and it's thrown instead
+* whenever `channel` isn't readable.
+*/
+function authorize(access, permission, channel, hidden) {
+	if (hidden && !access.readable(channel)) throw hidden();
+	if (!access.can(permission, channel)) throw forbidden(`this token can't ${PHRASE[permission](channel)}`);
+	return Object.freeze({
+		permission,
+		channel
+	});
+}
+//#endregion
 //#region src/server/auth.ts
 /**
 * Principal IDs a board authenticates: its people, deployments, workflows, and its own code. No
@@ -273,4 +496,4 @@ function hostPrincipal(value) {
 	};
 }
 //#endregion
-export { compileRules as a, githubActions as c, issuersOf as d, markVerified as f, verifiesTokens as g, vercelProject as h, authenticates as i, hostPrincipal as l, trustedIssuers as m, TOKENS as n, createAuthority as o, oidc as p, VERCEL_ISSUER as r, fromTokens as s, GITHUB_ISSUER as t, issuerName as u };
+export { FULL_ACCESS as _, compileRules as a, githubActions as c, issuersOf as d, markVerified as f, verifiesTokens as g, vercelProject as h, authenticates as i, hostPrincipal as l, trustedIssuers as m, TOKENS as n, createAuthority as o, oidc as p, VERCEL_ISSUER as r, fromTokens as s, GITHUB_ISSUER as t, issuerName as u, authorize as v, parseScope as y };