From 2ec541ad7cfdcb24cb3daf4614613dfcaae63fe8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=BF=85=E8=86=80?= Date: Fri, 23 Oct 2026 23:23:37 +0800 Subject: [PATCH] fix(admin): guard revisions and tenant targets Read-time authorization alone cannot protect concurrent edits. Guard revisions, current roles and destination ownership in the write transaction, and use per-group endpoints for isolated changes. --- server/lib/fragments.ts | 128 ++- server/lib/web/admin.ts | 1457 ++++++++++++++++++++++---- server/lib/web/auth.ts | 17 +- server/lib/web/tenants.ts | 99 +- server/lib/webhook.ts | 5 +- server/routes/admin/api/[...slug].ts | 8 + tests/admin-api.test.ts | 11 +- tests/admin.test.ts | 30 +- tests/data-integrity.test.ts | 931 ++++++++++++++++ tests/identity-and-claims.test.ts | 229 ++++ 10 files changed, 2615 insertions(+), 300 deletions(-) create mode 100644 tests/data-integrity.test.ts create mode 100644 tests/identity-and-claims.test.ts diff --git a/server/lib/fragments.ts b/server/lib/fragments.ts index 7808d80..48f9ce8 100644 --- a/server/lib/fragments.ts +++ b/server/lib/fragments.ts @@ -1,5 +1,13 @@ import type { FilterNode } from "./types"; import { log } from "./lib/log"; +import { canUseD1 } from "./storage/d1"; +import { + ConfigConflictError, + groupVersion, + groupVersionBump, + groupVersionGuard, + runGuarded, +} from "./storage/config-store"; export interface NamedFragment { id: string; @@ -15,59 +23,83 @@ interface D1FragmentRow { node: string; } -export async function loadFragments(db: D1Database): Promise { - try { - const stmt = db.prepare("SELECT id, group_id, name, node FROM d1_fragments ORDER BY id"); - if (typeof stmt.all !== "function") return []; - const { results } = await stmt.all(); - if (!results || results.length === 0) return []; - return results.map((r) => ({ - id: r.id, - groupId: r.group_id || undefined, - name: r.name, - node: JSON.parse(r.node) as FilterNode, - })); - } catch (err) { - log.warn({ err }, "Failed to load fragments from D1"); - return []; - } +/** + * Named filter fragments, optionally of one group. Without a usable D1 + * binding there are none; a D1 error propagates, because callers replace a + * group's whole list and must never build that list from a failed read. An + * unreadable row is skipped (logged) — or, with `strict`, an error: a write + * replacing the group's list must never silently delete a row nobody saw. + */ +export async function loadFragments( + db: D1Database, + groupId?: string, + strict = false, +): Promise { + if (!canUseD1(db)) return []; + const stmt = + groupId === undefined + ? db.prepare("SELECT id, group_id, name, node FROM d1_fragments ORDER BY id") + : db + .prepare( + "SELECT id, group_id, name, node FROM d1_fragments WHERE group_id = ? ORDER BY id", + ) + .bind(groupId); + const { results } = await stmt.all(); + return (results ?? []).flatMap((r) => { + try { + return [ + { + id: r.id, + groupId: r.group_id || undefined, + name: r.name, + node: JSON.parse(r.node) as FilterNode, + }, + ]; + } catch (err) { + if (strict) { + throw new Error(`filter fragment "${r.id}" is unreadable; repair the row before saving`); + } + log.warn({ err, id: r.id }, "Ignoring malformed filter fragment"); + return []; + } + }); } -export async function saveFragments(db: D1Database, fragments: NamedFragment[]): Promise { +/** + * Replace one group's fragments in a single transaction; other groups are + * untouched. `expect` sees the stored fragments first and may throw; the write + * then commits only if nothing changed the group in between (version guard). + */ +export async function saveGroupFragments( + db: D1Database, + groupId: string, + fragments: NamedFragment[], + opts?: { + expect?: (current: NamedFragment[]) => void | Promise; + /** Guard statements committed first in the write (see `GuardedWrite.guards`). */ + guards?: (db: D1Database) => D1PreparedStatement[]; + }, +): Promise { + if (!canUseD1(db)) throw new Error("Filter fragments require the D1 binding"); + const version = await groupVersion(db, groupId); + if (version == null) throw new ConfigConflictError(`group "${groupId}" does not exist`); + // Loaded strictly even without `expect`: an unreadable row aborts here. + const stored = await loadFragments(db, groupId, true); + await opts?.expect?.(stored); const now = Date.now(); - - // Load existing fragments to determine what to delete - const existing = await loadFragments(db); - const existingKeys = new Set(existing.map((f) => `${f.id}:${f.groupId ?? ""}`)); - const newKeys = new Set(fragments.map((f) => `${f.id}:${f.groupId ?? ""}`)); - - const statements: D1PreparedStatement[] = []; - - // Delete fragments that are no longer present - for (const key of existingKeys) { - if (!newKeys.has(key)) { - const [id, groupId] = key.split(":"); - statements.push( - db.prepare("DELETE FROM d1_fragments WHERE id = ? AND group_id = ?").bind(id, groupId), - ); - } - } - - // Upsert all fragments - for (const f of fragments) { - statements.push( + await runGuarded(db, [ + groupVersionGuard(db, groupId, version), + ...(opts?.guards?.(db) ?? []), + groupVersionBump(db, groupId), + db.prepare("DELETE FROM d1_fragments WHERE group_id = ?").bind(groupId), + ...fragments.map((f) => db .prepare( `INSERT INTO d1_fragments (id, group_id, name, node, version, created_at, updated_at) - VALUES (?, ?, ?, ?, 1, ?, ?) - ON CONFLICT(id, group_id) DO UPDATE SET - name = excluded.name, - node = excluded.node, - updated_at = excluded.updated_at`, + VALUES (?, ?, ?, ?, 1, ?, ?)`, ) - .bind(f.id, f.groupId ?? "", f.name, JSON.stringify(f.node), now, now), - ); - } - - await db.batch(statements); + .bind(f.id, groupId, f.name, JSON.stringify(f.node), now, now), + ), + ]); + return loadFragments(db, groupId); } diff --git a/server/lib/web/admin.ts b/server/lib/web/admin.ts index 0f6ad7d..2433c7e 100644 --- a/server/lib/web/admin.ts +++ b/server/lib/web/admin.ts @@ -7,18 +7,70 @@ import { setResponseHeader, setResponseStatus, } from "h3"; -import type { Route, Group, GroupMember, GroupRole, ForgeSource, FilterNode } from "../types"; -import { loadRoutes, saveRoutes } from "../config"; -import { loadFragments, saveFragments, type NamedFragment } from "../fragments"; -import { evaluateFilterNode, explainFilterNode } from "../events/filter-ast"; -import { getAdminSession, destroyAdminSession, clearAdminCookie, isDebugMode } from "./session"; -import { saveGroups, loadGroups, identityMatches, normalizeGroupMembers } from "./groups"; +import type { + Config, + Env, + Route, + RouteTarget, + Group, + GroupMember, + GroupRole, + ForgeSource, + Filter, + FilterNode, +} from "../types"; +import { loadConfigSnapshot, loadRoutes, saveGroupRoutes } from "../config"; +import { + ConfigConflictError, + groupVersion, + type LifecycleStatements, +} from "../storage/config-store"; +import { canUseD1 } from "../storage/d1"; +import { getToken } from "../github/store"; +import { resolveGitHubUserId } from "../github/oauth"; +import { loadFragments, saveGroupFragments, type NamedFragment } from "../fragments"; +import { + evaluateFilterNode, + explainFilterNode, + filterNodeWellFormed, + filterPatternsUsable, + regexSafetyIssue, +} from "../events/filter-ast"; +import { + authLogin, + getAdminSession, + destroyAdminSession, + clearAdminCookie, + isDebugMode, +} from "./session"; +import { + loadGroups, + createGroup, + updateGroup, + deleteGroup, + renameGroup, + carryMemberIds, + memberMatches, + memberRole, + memberRoleStatement, + roleAtLeast, + isIsolated, + normalizeGroupMembers, +} from "./groups"; +import { + deleteLifecycle, + isGroupIdRetired, + recordGroupRename, + renameLifecycle, + retireGroupId, +} from "./group-lifecycle"; import { requireAnyAccess, currentAuth, requireGroup, requireGroupRole, roleAt, + canEditRoutes, clientIp, type GroupAccess, } from "./auth"; @@ -32,10 +84,19 @@ import { getInvite, acceptInvite, migrateInvites, + deleteGroupInvites, + INVITE_LIFETIME_MS, } from "./invites"; -import { getTenantSecret, setTenantSecret, deleteTenantSecret } from "./tenants"; +import { + getTenantSecret, + rotateTenantSecret, + removeTenantSecret, + deleteTenantSecret, +} from "./tenants"; import { cfEnv } from "../cf"; import { log } from "../lib/log"; +import { MAX_ROLE_MENTIONS } from "../drivers/discord/render"; +import { destinationOf } from "../drivers"; const VALID_FILTER_TYPES = new Set([ "event", @@ -61,9 +122,16 @@ const VALID_OPS = new Set([ "exists", ]); const ID_RE = /^[a-z0-9][a-z0-9-]*$/; +/** Discord snowflake: anything else could inject text or mentions into `content`. */ +const SNOWFLAKE_RE = /^\d{15,25}$/; const HOST_RE = /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*$/; +/** Key of a route within the whole configuration: ids are unique per group. */ +function routeKey(groupId: string | undefined, id: string): string { + return `${groupId ?? ""}\u0000${id}`; +} + function isValidMatch(match: unknown): match is string | string[] { if (typeof match === "string") return match.trim().length > 0; if (Array.isArray(match)) @@ -93,6 +161,8 @@ function validateFilterNode(node: unknown, label: string): string | null { if (!node || typeof node !== "object" || Array.isArray(node)) { return `${label} must be an object`; } + // One kind per node (a leaf, or a single all/any/not), all the way down. + if (!filterNodeWellFormed(node)) return `${label} mixes condition kinds or is malformed`; const n = node as Record; if (Array.isArray(n.all)) { if (n.all.length === 0) return `${label}.all must not be empty`; @@ -123,9 +193,41 @@ function validateFilterNode(node: unknown, label: string): string | null { if (n.op !== undefined && !VALID_OPS.has(n.op as string)) { return `${label}.op is invalid`; } + // A keyword condition always searches the payload (`eq`, the default): + // any other operator would be saved and silently ignored. + if (n.type === "keyword" && n.op !== undefined && n.op !== "eq") { + return `${label}.op is not supported for keyword filters`; + } if ((n.op as string) !== "exists" && !isValidMatch(n.match)) { return `${label} needs a match value`; } + // `exists` reads no value; one given anyway must still be one the stored + // schema accepts, or the saved route could not be read back. + if ((n.op as string) === "exists" && n.match !== undefined && !isValidMatch(n.match)) { + return `${label}.match must be omitted (or a value) for exists`; + } + if ((n.op as string) !== "exists") { + const patterns = Array.isArray(n.match) ? (n.match as string[]) : [n.match as string]; + for (const p of patterns) { + // Only where the matcher reads a regex: `regex`, or a `/…/` value of an + // equality / keyword condition (`contains` & co. compare literally). + const op = n.type === "keyword" ? "keyword" : ((n.op as string | undefined) ?? "eq"); + const wrapped = p.length >= 2 && p.startsWith("/") && p.endsWith("/"); + const source = + op === "regex" + ? p + : wrapped && ["eq", "in", "ne", "keyword"].includes(op) + ? p.slice(1, -1) + : null; + const issue = source !== null ? regexSafetyIssue(source) : null; + if (issue) return `${label} has an unsafe regex ${JSON.stringify(p)}: ${issue}`; + } + // Read back, the route must run exactly as saved (e.g. no glob over the + // length the matcher compiles). + if (!filterPatternsUsable(n as unknown as Filter)) { + return `${label} has a pattern that cannot be used (too long or invalid)`; + } + } if (n.exclude !== undefined && typeof n.exclude !== "boolean") { return `${label}.exclude must be a boolean`; } @@ -138,7 +240,7 @@ function validateFilterNode(node: unknown, label: string): string | null { * incomplete route can never block edits to a different route. Only new or modified * routes are fully validated. Structural checks (id shape, uniqueness) still run for all. */ -function validateRoutes( +export function validateRoutes( routes: unknown, unchanged?: Map, ): { ok: true; routes: Route[] } | { ok: false; error: string } { @@ -163,7 +265,7 @@ function validateRoutes( } groupSeen.add(r.id); // Skip full validation for routes that are unchanged from what is stored. - const prev = unchanged?.get(r.id); + const prev = unchanged?.get(routeKey(r.groupId as string | undefined, r.id)); if (prev && deepEqual(r, prev)) continue; if (typeof r.name !== "string" || r.name.trim().length === 0) { return { ok: false, error: `route "${r.id}" needs a name` }; @@ -182,9 +284,20 @@ function validateRoutes( if ( r.discordRoleIds !== undefined && (!Array.isArray(r.discordRoleIds) || - !r.discordRoleIds.every((d) => typeof d === "string" && d.trim().length > 0)) + !r.discordRoleIds.every((d) => typeof d === "string" && SNOWFLAKE_RE.test(d))) ) { - return { ok: false, error: `route "${r.id}".discordRoleIds must be a list of strings` }; + return { + ok: false, + error: `route "${r.id}".discordRoleIds must be a list of Discord role ids`, + }; + } + // Saved, more could never be sent: the message would exceed Discord's + // content and allowed-mention limits. + if (r.discordRoleIds && new Set(r.discordRoleIds).size > MAX_ROLE_MENTIONS) { + return { + ok: false, + error: `route "${r.id}" mentions more than ${MAX_ROLE_MENTIONS} Discord roles`, + }; } if (!Array.isArray(r.filters)) { return { ok: false, error: `route "${r.id}".filters must be an array` }; @@ -193,6 +306,12 @@ function validateRoutes( return { ok: false, error: `route "${r.id}" needs at least one filter` }; } for (let j = 0; j < r.filters.length; j++) { + const f = r.filters[j] as Record | null; + // The flat list holds plain conditions only (all/any/not belong in + // `ast`): stored otherwise, the route could not be read back. + if (f && typeof f === "object" && ("all" in f || "any" in f || "not" in f)) { + return { ok: false, error: `route "${r.id}" filter[${j}] must be a plain condition` }; + } const err = validateFilterNode(r.filters[j], `route "${r.id}" filter[${j}]`); if (err) return { ok: false, error: err }; } @@ -212,6 +331,8 @@ function validateRoutes( return { ok: false, error: `route "${r.id}" needs at least one target` }; } const normalized: Route["targets"] = []; + // The same destination twice would get every message twice. + const destinations = new Set(); for (let j = 0; j < rawTargets.length; j++) { const t = rawTargets[j] as Record; if (!t || typeof t !== "object") { @@ -219,6 +340,11 @@ function validateRoutes( } const result = validateTarget(`route "${r.id}".targets[${j}]`, t); if (!result.ok) return result; + const destination = destinationOf(result.target); + if (destinations.has(destination)) { + return { ok: false, error: `route "${r.id}".targets[${j}] repeats another target` }; + } + destinations.add(destination); normalized.push(result.target); } (r as Record).targets = normalized; @@ -229,6 +355,19 @@ function validateRoutes( return { ok: true, routes: routes as Route[] }; } +/** + * Discord ids are snowflakes (digits); the check rules out everything that + * could change the meaning of a URL path (`/`, `.`, `%`, ...). + */ +const DISCORD_ID_RE = /^[A-Za-z0-9_-]{1,64}$/; + +/** + * Canonical only (no leading zeros, no "-0": Telegram reads `-0100` as + * `-100`) and within the range chat ids actually use — a longer number wraps + * around in Telegram's 64-bit parsing and could land on any chat. + */ +const TELEGRAM_CHAT_ID_RE = /^(?:0|-?[1-9]\d{0,14})$/; + function validateTarget( label: string, target: Record, @@ -243,22 +382,60 @@ function validateTarget( if (target.topicId !== undefined && typeof target.topicId !== "string") { return { ok: false, error: `${label}.topicId must be a string` }; } + // A topic is a message thread id: a positive 32-bit integer, written one + // way only (`01` or `1e0` would name topic 1 again, `abc` none at all). + const topic = typeof target.topicId === "string" ? target.topicId.trim() : ""; + if ( + platform === "telegram" && + topic && + !(/^[1-9]\d{0,9}$/.test(topic) && Number(topic) <= 2_147_483_647) + ) { + return { ok: false, error: `${label}.topicId must be a topic id (a positive integer)` }; + } + // Telegram also takes a public chat's `@username`, a second name for the + // same chat: only the numeric id is accepted, so the cross-group channel + // check compares one spelling per chat. + if (platform === "telegram" && !TELEGRAM_CHAT_ID_RE.test(target.chatId.trim())) { + return { ok: false, error: `${label}.chatId must be a numeric Telegram chat id` }; + } } else { if (typeof target.channelId !== "string" || target.channelId.trim().length === 0) return { ok: false, error: `${label}.channelId is required` }; if (target.threadId !== undefined && typeof target.threadId !== "string") { return { ok: false, error: `${label}.threadId must be a string` }; } + // One canonical spelling per channel (Discord ids are snowflakes): the + // cross-group channel check and the delivery ledger compare these + // strings, so no alias (`x/../123`, `%31...`) may stand for a channel. + for (const field of ["channelId", "threadId"] as const) { + const id = target[field]; + // A snowflake has no leading zeros either: `0123` would be read as `123`. + if ( + typeof id === "string" && + id.trim() && + (!DISCORD_ID_RE.test(id.trim()) || /^0\d/.test(id.trim())) + ) { + return { ok: false, error: `${label}.${field} must be a Discord id` }; + } + } } return { ok: true, target: { platform, - channelId: platform === "discord" ? (target.channelId as string) : undefined, - threadId: platform === "discord" ? ((target.threadId as string) ?? undefined) : undefined, + channelId: platform === "discord" ? (target.channelId as string).trim() : undefined, + threadId: + platform === "discord" + ? (target.threadId as string | undefined)?.trim() || undefined + : undefined, chatId: - platform === "telegram" || platform === "feishu" ? (target.chatId as string) : undefined, - topicId: platform === "telegram" ? ((target.topicId as string) ?? undefined) : undefined, + platform === "telegram" || platform === "feishu" + ? (target.chatId as string).trim() + : undefined, + topicId: + platform === "telegram" + ? (target.topicId as string | undefined)?.trim() || undefined + : undefined, }, }; } @@ -349,11 +526,13 @@ export function validateGroups( if ( g.providers !== undefined && (!Array.isArray(g.providers) || - !g.providers.every((p) => typeof p === "string" && ["github", "gitea"].includes(p))) + !g.providers.every( + (p) => typeof p === "string" && ["github", "gitea", "custom"].includes(p), + )) ) { return { ok: false, - error: `group "${g.id}".providers must be a list of "github" | "gitea"`, + error: `group "${g.id}".providers must be a list of "github" | "gitea" | "custom"`, }; } if (g.installationId !== undefined && g.installationId !== null) { @@ -363,6 +542,9 @@ export function validateGroups( } else { delete g.installationId; } + if (g.isolated !== undefined && typeof g.isolated !== "boolean") { + return { ok: false, error: `group "${g.id}".isolated must be a boolean` }; + } if (g.emoji !== undefined && typeof g.emoji !== "boolean") { return { ok: false, error: `group "${g.id}".emoji must be a boolean` }; } @@ -430,13 +612,347 @@ export function validateGroups( delete g.logTarget; } } - return { ok: true, groups: groups as Group[] }; + return { ok: true, groups: (groups as Record[]).map(sanitizeGroup) }; +} + +/** Keep only the known group fields (in a stable order); drops `revision` and junk. */ +function sanitizeGroup(g: Record): Group { + const out: Record = {}; + for (const key of GROUP_FIELDS) { + if (g[key] !== undefined) out[key] = g[key]; + } + return out as unknown as Group; +} + +const GROUP_FIELDS = [ + "id", + "name", + "adminIds", + "members", + "owners", + "providers", + "installationId", + "isolated", + "emoji", + "forgeSources", + "lang", + "logTarget", +] as const; + +/** Fields only super admins may change: they bound where a group's events come from. */ +function keepSuperOnlyFields(next: Group, prev: Group | undefined): Group { + const out: Group = { ...next }; + delete out.owners; + delete out.installationId; + delete out.isolated; + if (prev?.owners !== undefined) out.owners = prev.owners; + if (prev?.installationId !== undefined) out.installationId = prev.installationId; + if (prev?.isolated !== undefined) out.isolated = prev.isolated; + return sanitizeGroup(out as unknown as Record); +} + +/** Opaque content revision: equal revisions mean equal stored data. */ +/** JSON with object keys sorted: equal data hashes equal whatever the key order. */ +function stableJson(value: unknown): string { + return JSON.stringify(value, (_key, v: unknown) => + v && typeof v === "object" && !Array.isArray(v) + ? Object.fromEntries( + Object.entries(v as Record).sort(([a], [b]) => (a < b ? -1 : 1)), + ) + : v, + ); +} + +async function revisionOf(value: unknown): Promise { + const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(stableJson(value))); + return Array.from(new Uint8Array(digest).slice(0, 12)) + .map((b) => b.toString(16).padStart(2, "0")) + .join(""); +} + +/** Revision of a route list over the stored fields only, independent of key order or absent optionals. */ +function routesRevision(routes: Route[]): Promise { + return revisionOf( + routes.map((r) => ({ + id: r.id, + groupId: r.groupId ?? "", + name: r.name, + enabled: !!r.enabled, + filters: r.filters ?? [], + targets: r.targets ?? [], + stop: !!r.stop, + fallback: !!r.fallback, + discordRoleIds: r.discordRoleIds ?? null, + ast: r.ast ?? null, + })), + ); +} + +/** + * Groups as clients see them: the editable fields plus a revision. Server-owned + * identity (`instance`, `legacyId`, ...) never leaves the server, and so can + * never come back in a submission either. + */ +async function withRevisions(groups: Group[]): Promise { + return Promise.all( + groups.map(async (g) => { + const shown = sanitizeGroup({ ...g }); + return { ...shown, revision: await groupRevision(g) }; + }), + ); +} + +/** + * A group's revision: the fields clients see, plus its instance hashed in + * (never shown) — a view of a deleted group never confirms a write to a later + * group that reused its id, however alike the two look. + */ +function groupRevision(g: Group, instance = g.instance): Promise { + return revisionOf({ group: sanitizeGroup({ ...g }), instance: instance ?? null }); +} + +function submittedRevision(value: unknown): string | undefined { + return typeof value === "string" && value.length > 0 ? value : undefined; } function ownerCount(members: GroupMember[]): number { return members.filter((m) => m.role === "owner").length; } +/** The platform channels a target posts into (a Discord thread is a channel too). */ +function targetChannels(t: RouteTarget): string[] { + const platform = t.platform ?? "discord"; + const ids = platform === "discord" ? [t.channelId, t.threadId] : [t.chatId]; + return ids.filter((id): id is string => !!id).map((id) => `${platform}:${id}`); +} + +/** + * A statement that aborts its transaction while a group outside `allowed` + * delivers to `channel` (`platform:id`) through a route or its log target. + * Run inside the write itself, it makes "the channel is free" hold at commit: + * D1 transactions are serialized, so of two groups claiming one new channel + * at once, the second sees the first's committed rows and fails. + */ +export function channelFreeGuard( + db: D1Database, + channel: string, + allowed: string[], +): D1PreparedStatement { + const sep = channel.indexOf(":"); + const platform = channel.slice(0, sep); + const id = channel.slice(sep + 1); + // One JSON parameter, however many groups: D1 binds at most 100 per statement. + const notAllowed = "SELECT value FROM json_each(?)"; + return db + .prepare( + `SELECT CASE WHEN EXISTS ( + SELECT 1 FROM (SELECT group_id, CASE WHEN json_valid(targets) THEN targets ELSE '[]' END AS targets FROM d1_routes) r, json_each(r.targets) t + WHERE r.group_id NOT IN (${notAllowed}) + AND coalesce(json_extract(t.value, '$.platform'), 'discord') = ? + AND ? IN (json_extract(t.value, '$.channelId'), json_extract(t.value, '$.threadId'), + json_extract(t.value, '$.chatId')) + ) OR EXISTS ( + SELECT 1 FROM (SELECT id, CASE WHEN json_valid(data) THEN data ELSE '{}' END AS data FROM d1_groups) g + WHERE g.id NOT IN (${notAllowed}) + AND json_extract(g.data, '$.logTarget') IS NOT NULL + AND coalesce(json_extract(g.data, '$.logTarget.platform'), 'discord') = ? + AND ? IN (json_extract(g.data, '$.logTarget.channelId'), + json_extract(g.data, '$.logTarget.threadId'), + json_extract(g.data, '$.logTarget.chatId')) + ) THEN json('channel taken') ELSE 1 END AS ok`, + ) + .bind(JSON.stringify(allowed), platform, id, JSON.stringify(allowed), platform, id); +} + +/** + * A guard statement that aborts the write unless the signed-in user still + * holds at least `min` in group `gid` at commit time (super admins need none): + * a request authorized before an owner removed the user must not land after. + * Member entries match the way `memberMatches` does: a bound entry by user id, + * an all-digit one by user id, any other by (trusted) login; groups still on + * legacy `adminIds` count those as owners. + */ +export function roleGuard( + event: H3Event, + gid: string, + min: "admin" | "owner", +): LifecycleStatements | undefined { + const auth = currentAuth(event); + if (auth.scope.isSuper) return undefined; + const roles: GroupRole[] = min === "owner" ? ["owner"] : ["owner", "admin"]; + return (db) => [ + memberRoleStatement(db, gid, auth.session.userId, authLogin(auth.session), roles), + ]; +} + +/** Both guard lists, in order (either may be absent). */ +function bothGuards( + a: LifecycleStatements | undefined, + b: LifecycleStatements | undefined, +): LifecycleStatements | undefined { + if (!a) return b; + if (!b) return a; + return (db) => [...a(db), ...b(db)]; +} + +/** Whether the signed-in user still holds `min` in this (current) group. */ +function stillHolds(event: H3Event, group: Group, min: GroupRole): boolean { + const auth = currentAuth(event); + if (auth.scope.isSuper) return true; + return roleAtLeast(memberRole(group, auth.session.userId, authLogin(auth.session)), min); +} + +/** A route target (by route id) or the group's log target (`@log`) being written. */ +interface TargetRef { + ref: string; + target: RouteTarget; +} + +/** The targets a group's route list refers to, each tagged with its route. */ +function routeTargetRefs(routes: Route[]): TargetRef[] { + return routes.flatMap((r) => (r.targets ?? []).map((target) => ({ ref: r.id, target }))); +} + +/** + * Numeric ids of the Telegram `@username` targets still stored from before + * only numeric ids were accepted (a username and the chat's id name the same + * chat). Looked up with the bot; null when the lookup fails. + */ +async function telegramAliases( + env: Env, + routes: Route[], + groups: Group[], +): Promise> { + const names = new Set(); + const note = (t: RouteTarget | undefined): void => { + if (t?.platform === "telegram" && t.chatId?.startsWith("@")) names.add(t.chatId); + }; + for (const r of routes) for (const t of r.targets ?? []) note(t); + for (const g of groups) note(g.logTarget); + const out = new Map(); + for (const name of names) { + let id: string | null = null; + if (env.TELEGRAM_TOKEN) { + try { + const res = await fetch( + `https://api.telegram.org/bot${env.TELEGRAM_TOKEN}/getChat?chat_id=${encodeURIComponent(name)}`, + { signal: AbortSignal.timeout(5000) }, + ); + const data = (await res.json().catch(() => null)) as { result?: { id?: number } } | null; + if (res.ok && typeof data?.result?.id === "number") id = String(data.result.id); + } catch { + id = null; + } + } + out.set(name, id); + } + return out; +} + +/** + * Whether a non-super writer may point group `gid` at these targets. The bot + * posts with the operator's credentials, so a tenant must not aim it at a + * channel another group already delivers to — that channel belongs to someone + * else — unless the writer may edit that group's routes as well. A channel + * already shared before this write (older data) stays allowed only where it + * already was — the same route, or the log target — so an unchanged save never + * fails but the sharing never grows. `issue` explains a refusal now; `guards` + * re-check, inside the write, that unshared channels are still unshared. + */ +async function foreignTargetIssue( + event: H3Event, + gid: string, + refs: TargetRef[], + snapshot?: { config: Config; groups: Group[] }, +): Promise<{ issue: string | null; guards?: LifecycleStatements; keepsShared?: boolean }> { + const auth = currentAuth(event); + if (auth.scope.isSuper) return { issue: null }; + const env = cfEnv(event); + // The caller's own fresh read when it has one (one snapshot per request). + const { config, groups } = snapshot ?? (await loadConfigSnapshot(env, { fresh: true })); + const routes = config.routes; + // One spelling per chat: stored usernames are compared by their chat id — + // only needed when this write delivers to Telegram (a lookup per stored + // username is a request to the Bot API; other platforms' channels never + // compare with Telegram ones). + const aliases = refs.some(({ target }) => target.platform === "telegram") + ? await telegramAliases(env, routes, groups) + : new Map(); + const unresolved = [...aliases.values()].some((id) => id === null); + // Stored ids from before the stricter check are read the way Telegram + // reads them (leading zeros dropped, wrapped to 64 bits). + const channelsOf = (t: RouteTarget): string[] => + targetChannels(t).map((c) => { + const name = c.startsWith("telegram:@") ? c.slice("telegram:".length) : null; + const id = name ? aliases.get(name) : null; + if (id) return `telegram:${id}`; + const numeric = /^telegram:(-?\d+)$/.exec(c); + return numeric ? `telegram:${BigInt.asIntN(64, BigInt(numeric[1]!)).toString()}` : c; + }); + // A destination within a channel (a Telegram topic, a Discord thread). + const placeOf = (t: RouteTarget): string => t.topicId ?? t.threadId ?? ""; + const channelsOfGroup = (g: Group): Set => { + const out = new Set(); + for (const r of routes) { + if (r.groupId === g.id) + for (const t of r.targets ?? []) channelsOf(t).forEach((c) => out.add(c)); + } + if (g.logTarget) channelsOf(g.logTarget).forEach((c) => out.add(c)); + return out; + }; + // Where this group already delivers: `{route id | @log}|{channel}|{place}`. + const ownRefs = new Set(); + const addOwn = (ref: string, t: RouteTarget): void => + channelsOf(t).forEach((c) => ownRefs.add(`${ref}|${c}|${placeOf(t)}`)); + for (const r of routes) { + if (r.groupId !== gid) continue; + for (const t of r.targets ?? []) addOwn(r.id, t); + } + const self = groups.find((g) => g.id === gid); + if (self?.logTarget) addOwn("@log", self.logTarget); + + // Channels this write delivers to. + const written = new Set(refs.flatMap(({ target }) => channelsOf(target))); + // Other groups let through because the writer may edit them too — exactly + // those whose channels this write touches, and each re-checked at commit + // (the same set the commit-time channel check exempts, nothing more). + const vouching = groups.filter( + (g) => + g.id !== gid && + canEditRoutes(auth.scope, g.id) && + [...channelsOfGroup(g)].some((c) => written.has(c)), + ); + const allowed = [gid, ...vouching.map((g) => g.id)]; + const others = groups.filter((g) => !allowed.includes(g.id)).map(channelsOfGroup); + const guarded = new Set(); + let keepsShared = false; + for (const { ref, target } of refs) { + for (const channel of channelsOf(target)) { + const kept = ownRefs.has(`${ref}|${channel}|${placeOf(target)}`); + // A legacy username that cannot be resolved might be this very chat. + if (unresolved && channel.startsWith("telegram:") && !kept) { + return { issue: "Telegram targets cannot be verified right now; try again later" }; + } + if (!others.some((set) => set.has(channel))) guarded.add(channel); + else if (!kept) { + return { issue: `target ${channel} is already used by another group` }; + } else keepsShared = true; + } + } + // A kept shared channel is allowed only because the reference is still + // there: the caller must commit against the version this check saw + // (`keepsShared`), so a reference removed meanwhile is not restored. + if (guarded.size === 0 && vouching.length === 0) return { issue: null, keepsShared }; + return { + issue: null, + keepsShared, + guards: (db) => [ + ...[...guarded].map((c) => channelFreeGuard(db, c, allowed)), + ...vouching.flatMap((g) => roleGuard(event, g.id, "admin")?.(db) ?? []), + ], + }; +} + function respondError(event: H3Event, status: number, error: string): Record { setResponseStatus(event, status); return { error }; @@ -502,7 +1018,7 @@ export async function adminLogin(event: H3Event): Promise { /** GET /admin/logout */ export async function adminLogout(event: H3Event): Promise { const env = cfEnv(event); - const session = await getAdminSession(env.KV, getHeader(event, "cookie")); + const session = await getAdminSession(env.KV, getHeader(event, "cookie"), env.DB); if (session) { await recordAudit(env.DB, { ts: Date.now(), @@ -512,7 +1028,7 @@ export async function adminLogout(event: H3Event): Promise { ip: clientIp(event), }); } - await destroyAdminSession(env.KV, getHeader(event, "cookie")); + await destroyAdminSession(env.KV, getHeader(event, "cookie"), env.DB); setResponseHeader(event, "Set-Cookie", clearAdminCookie()); await sendRedirect(event, "/admin"); } @@ -525,7 +1041,7 @@ export async function adminInvite(event: H3Event): Promise { await sendRedirect(event, "/admin"); return; } - const session = await getAdminSession(env.KV, getHeader(event, "cookie")); + const session = await getAdminSession(env.KV, getHeader(event, "cookie"), env.DB); if (!session) { await sendRedirect( event, @@ -533,7 +1049,7 @@ export async function adminInvite(event: H3Event): Promise { ); return; } - const result = await acceptInvite(env, token, session.userId, session.login); + const result = await acceptInvite(env, token, session.userId, session.login, authLogin(session)); if (result.ok) { await recordAudit(env.DB, { ts: Date.now(), @@ -543,6 +1059,7 @@ export async function adminInvite(event: H3Event): Promise { targetType: "group", targetId: result.groupId, groupId: result.groupId, + groupInstance: result.groupInstance, detail: { role: result.role }, ip: clientIp(event), }); @@ -562,11 +1079,17 @@ export async function adminApiMe(event: H3Event): Promise { + const withRev = await withRevisions(groups); + return revisionOf(withRev.map((g) => [g.id, g.revision]).sort()); +} + /** GET /admin/api/groups */ export async function adminApiGroupsGet(event: H3Event): Promise> { const auth = await requireAnyAccess(event); @@ -575,176 +1098,562 @@ export async function adminApiGroupsGet(event: H3Event): Promise { + const env = cfEnv(event); + const auth = currentAuth(event); + const base = { + ts: Date.now(), + actorId: auth.session.userId, + actorLogin: auth.session.login, + targetType: "group", + targetId: next.id, + groupId: next.id, + groupInstance: next.instance, + ip: clientIp(event), + }; + if (!prev) { + await recordAudit(env.DB, { ...base, action: "group.create" }); + return; + } + const fields: string[] = []; + if (prev.name !== next.name) fields.push("name"); + if (prev.emoji !== next.emoji) fields.push("emoji"); + if (prev.lang !== next.lang) fields.push("lang"); + if (!deepEqual(prev.logTarget, next.logTarget)) fields.push("logTarget"); + if (!deepEqual(prev.providers ?? [], next.providers ?? [])) fields.push("providers"); + if (!deepEqual(prev.forgeSources ?? [], next.forgeSources ?? [])) fields.push("forgeSources"); + if (prev.installationId !== next.installationId) fields.push("installationId"); + if (prev.isolated !== next.isolated) fields.push("isolated"); + if (!deepEqual(prev.owners ?? [], next.owners ?? [])) fields.push("owners"); + if (!deepEqual(normalizeGroupMembers(prev), normalizeGroupMembers(next))) fields.push("members"); + if (fields.length > 0) { + await recordAudit(env.DB, { ...base, action: "group.update", detail: { fields } }); + } +} + +/** + * Bind members added by login to the account that holds the login right now + * (looked up with the editor's own GitHub token): a login can later be + * renamed away and claimed by someone else, a user id never changes. Members + * already in `current` keep their binding (carried over by login); without a + * token, or when GitHub does not answer, a member stays unbound and is bound + * on its own first sign-in instead. + */ +async function bindNewMembers(event: H3Event, next: Group, current?: Group): Promise { + if (!Array.isArray(next.members)) return next; + const known = new Set(normalizeGroupMembers(current ?? next).map((m) => m.login.toLowerCase())); + const fresh = next.members.filter( + (m) => + !m.userId && !/^\d+$/.test(m.login) && (!current || !known.has(m.login.trim().toLowerCase())), + ); + if (fresh.length === 0) return next; + const env = cfEnv(event); + const token = await getToken(env, currentAuth(event).session.userId).catch(() => null); + if (!token) return next; + const ids = new Map(); + for (const m of fresh) { + const id = await resolveGitHubUserId(token, m.login.trim()); + if (id) ids.set(m.login.trim().toLowerCase(), id); + } + if (ids.size === 0) return next; + return { + ...next, + members: next.members.map((m) => { + const id = m.userId ? undefined : ids.get(m.login.trim().toLowerCase()); + return id ? { ...m, userId: id } : m; + }), + }; +} + +/** A non-super owner may not leave a group without an owner. */ +function ownershipError(event: H3Event, g: Group): string | null { + const auth = currentAuth(event); + if (auth.scope.isSuper) return null; + const members = normalizeGroupMembers(g); + const stillMine = members.some( + (m) => m.role === "owner" && memberMatches(m, auth.session.userId, authLogin(auth.session)), + ); + if (!stillMine && ownerCount(members) < 1) { + return `group "${g.id}" would be left without an owner by you`; + } + return null; +} + +class OwnershipError extends Error {} + +/** + * Delete a group. Its configuration rows, history ownership and a retired-id + * marker commit in one D1 transaction. The KV side (webhook secret, invites) + * follows best-effort: both are bound to the group's immutable instance, so + * anything left behind can never be used by a later group with the same id. + */ +async function removeGroup( + env: Env, + id: string, + expect?: (current: Group) => void | Promise, + version?: number, +): Promise { + let removed: Group | undefined; + await deleteGroup(env.KV, id, { + version, + // Runs after `expect`, so the checked group's instance is known. + extra: (db) => deleteLifecycle(id, removed?.instance, removed?.legacyId)(db), + expect: async (current) => { + await expect?.(current); + removed = current; + }, + }); + await retireGroupId(env, id); + if (removed) { + await deleteTenantSecret(env.KV, removed).catch((err) => + log.warn({ err, id }, "Failed to delete the webhook secret of a deleted group"), + ); + } + await deleteGroupInvites(env.KV, id, removed); +} + +/** Group ids the system assigns (installation and personal groups); only super admins may claim them. */ +function reservedGroupId(id: string): boolean { + return /^(inst|u)-/.test(id); +} + +/** + * Create a group; false when the id is taken. A new group gets a new + * instance, so nothing a former group with this id left behind applies to it. + */ +async function createFreshGroup(env: Env, group: Group): Promise { + return createGroup(env.KV, group); +} + +/** Map a storage failure to a response (409 for a lost concurrent update). */ +function writeError(event: H3Event, err: unknown, what: string): Record { + if (err instanceof OwnershipError) return respondError(event, 403, err.message); + if (err instanceof ConfigConflictError) { + return respondError(event, 409, `The ${what} changed meanwhile; reload and try again`); + } + log.error({ err }, `Failed to save ${what}`); + return respondError(event, 500, `Failed to save ${what}`); +} + +/** + * PUT /admin/api/groups — bulk write (legacy API). Super admins replace the + * whole set; owners may change and delete only groups they own (other groups + * may be echoed back unchanged). Only groups that differ from the stored ones + * are written, one row each. Concurrency guards for clients that send the + * revisions they loaded: a group echoed back unedited is never written (so a + * stale copy cannot revert someone else's change), an edited group must still + * be at its loaded revision, and the list `revision` (when sent) must match, + * so groups created or changed meanwhile are never dropped or overwritten. + */ export async function adminApiGroupsPut(event: H3Event): Promise> { const auth = await requireAnyAccess(event); const env = cfEnv(event); const body = await readJsonBody(event); if (!body) return respondError(event, 400, "Invalid JSON body"); + const loadedRevisions = new Map(); + if (Array.isArray(body["groups"])) { + for (const raw of body["groups"] as Array | null>) { + const rev = submittedRevision(raw?.["revision"]); + if (rev && typeof raw?.["id"] === "string") loadedRevisions.set(raw["id"], rev); + } + } const result = validateGroups(body["groups"]); if (!result.ok) return respondError(event, 400, result.error); - const existing = await loadGroups(env.KV); + const existing = await loadGroups(env.KV, { fresh: true }); + const listRev = submittedRevision(body["revision"]); + if (listRev) { + const visible = auth.scope.isSuper + ? existing + : existing.filter((g) => auth.scope.groupIds.has(g.id)); + if ((await listRevision(visible)) !== listRev) { + return respondError(event, 409, "The groups changed meanwhile; reload and try again"); + } + } const prevById = new Map(existing.map((g) => [g.id, g])); - let nextAll: Group[]; - + const submittedIds = new Set(result.groups.map((g) => g.id)); + const writable = new Set(); if (auth.scope.isSuper) { - // Super admins see and submit every group: full replace. - nextAll = result.groups; + for (const g of [...existing, ...result.groups]) writable.add(g.id); } else { - // Owners may only write groups they own. Preserve every other group and - // never let a submission drop the last owner of a group. - const mine = new Set(); - for (const [gid, role] of auth.scope.roles) { - if (role === "owner") mine.add(gid); - } - for (const g of result.groups) { - if (!mine.has(g.id)) { - return respondError(event, 403, `group "${g.id}" is outside your ownership`); - } - const members = g.members ?? normalizeGroupMembers(g); - const stillMine = members.some( - (m) => - m.role === "owner" && identityMatches([m.login], auth.session.userId, auth.session.login), - ); - const otherOwner = ownerCount(members) > 1; - if (!stillMine && !otherOwner) { - return respondError(event, 403, `group "${g.id}" would be left without an owner by you`); - } - } - nextAll = [ - ...existing.filter((g) => !mine.has(g.id)), - ...result.groups.map((g) => { - const prev = prevById.get(g.id); - if (prev && prev.owners !== undefined && g.owners === undefined) { - // Owners cannot edit the `owners` scope; keep the stored value. - return { ...g, owners: prev.owners }; - } - return g; - }), - ]; + for (const [gid, role] of auth.scope.roles) if (role === "owner") writable.add(gid); } - // Audit every create / update / delete. - const prevGroups = existing; - const nextById = new Map(nextAll.map((g) => [g.id, g])); - const actor = { actorId: auth.session.userId, actorLogin: auth.session.login }; - for (const g of nextAll) { - const prev = prevById.get(g.id); - if (!prev) { - await recordAudit(env.DB, { - ts: Date.now(), - ...actor, - action: "group.create", - targetType: "group", - targetId: g.id, - groupId: g.id, - ip: clientIp(event), - }); - continue; + const upserts: Group[] = []; + const logTargetGuards = new Map(); + for (const submitted of result.groups) { + const prev = prevById.get(submitted.id); + // Member id bindings are server-owned: kept for members still listed, + // looked up for members added now. + const g = await bindNewMembers(event, carryMemberIds(submitted, prev), prev); + if (!writable.has(g.id)) { + // A visible group the user cannot write is fine as long as it is unchanged. + if (prev && deepEqual(sanitizeGroup({ ...prev }), g)) continue; + return respondError(event, 403, `group "${g.id}" is outside your ownership`); } - const fields: string[] = []; - if (prev.name !== g.name) fields.push("name"); - if (prev.emoji !== g.emoji) fields.push("emoji"); - if (prev.lang !== g.lang) fields.push("lang"); - if (!deepEqual(prev.logTarget, g.logTarget)) fields.push("logTarget"); - if (!deepEqual(prev.providers ?? [], g.providers ?? [])) fields.push("providers"); - if (prev.installationId !== g.installationId) fields.push("installationId"); - if (!deepEqual(prev.owners ?? [], g.owners ?? [])) fields.push("owners"); - if (!deepEqual(prev.members ?? normalizeGroupMembers(prev), g.members)) fields.push("members"); - if (fields.length > 0) { - await recordAudit(env.DB, { - ts: Date.now(), - ...actor, - action: "group.update", - targetType: "group", - targetId: g.id, - groupId: g.id, - detail: { fields }, - ip: clientIp(event), - }); - } - } - for (const g of prevGroups) { - if (!nextById.has(g.id)) { - await recordAudit(env.DB, { - ts: Date.now(), - ...actor, - action: "group.delete", - targetType: "group", - targetId: g.id, - groupId: g.id, - ip: clientIp(event), - }); - await deleteTenantSecret(env.KV, g.id).catch(() => undefined); + const loaded = loadedRevisions.get(g.id); + if (loaded && prev) { + // Unedited since it was loaded: not a change, whatever is stored now. + if ((await groupRevision(g, prev.instance)) === loaded) continue; + if ((await groupRevision(prev)) !== loaded) { + return respondError(event, 409, `group "${g.id}" changed meanwhile; reload and try again`); + } } + const next = auth.scope.isSuper ? g : keepSuperOnlyFields(g, prev); + const ownerIssue = ownershipError(event, next); + if (ownerIssue) return respondError(event, 403, ownerIssue); + if (next.logTarget) { + const check = await foreignTargetIssue(event, next.id, [ + { ref: "@log", target: next.logTarget }, + ]); + if (check.issue) return respondError(event, 403, check.issue); + if (check.guards) logTargetGuards.set(next.id, check.guards); + } + if (!prev && (await isGroupIdRetired(env, g.id))) { + return respondError(event, 409, `group id "${g.id}" was used recently; pick another id`); + } + if (!prev || !deepEqual(sanitizeGroup({ ...prev }), next)) upserts.push(next); } + const deletions = existing.filter((g) => writable.has(g.id) && !submittedIds.has(g.id)); + const audited = async (g: Group): Promise => { + await recordAudit(env.DB, { + ts: Date.now(), + actorId: auth.session.userId, + actorLogin: auth.session.login, + action: "group.delete", + targetType: "group", + targetId: g.id, + ip: clientIp(event), + }); + }; try { - await saveGroups(env.KV, nextAll); + for (const g of deletions) { + // Deletes only the group as it was when the decision was made — and + // only an empty one: this request carries no view of the group's routes, + // so it can never vouch for deleting them. + await removeGroup(env, g.id, async (current) => { + if (!stillHolds(event, current, "owner")) throw new OwnershipError("Forbidden"); + if (!deepEqual(sanitizeGroup({ ...current }), sanitizeGroup({ ...g }))) { + throw new ConfigConflictError(); + } + // Unreadable route rows count too: they would be deleted unseen. + const { config } = await loadConfigSnapshot(env, { fresh: true }); + if ( + config.routes.some((r) => r.groupId === g.id) || + config.unreadableGroups?.includes(g.id) || + // Strictly read: a fragment that cannot be parsed (or a failed + // read) still counts — it was never shown for confirmation. + (await loadFragments(env.DB, g.id, true).then( + (fragments) => fragments.length > 0, + () => true, + )) + ) { + throw new ConfigConflictError(); + } + }); + await audited(g); + } + for (const g of upserts) { + const prev = prevById.get(g.id); + let saved: Group | null = g; + if (!prev) { + if (!(await createFreshGroup(env, g))) throw new ConfigConflictError(); + // As stored (with its server-assigned instance), for its audit. + saved = (await loadGroups(env.KV, { fresh: true })).find((s) => s.id === g.id) ?? g; + } else { + // Each write still requires the group as it was decided on above. + saved = await updateGroup( + env.KV, + g.id, + (current) => { + if (!stillHolds(event, current, "owner")) throw new OwnershipError("Forbidden"); + if (!deepEqual(sanitizeGroup({ ...current }), sanitizeGroup({ ...prev }))) { + throw new ConfigConflictError(); + } + return g; + }, + { guards: logTargetGuards.get(g.id) }, + ); + // Deleted meanwhile: the change was not written. + if (!saved) throw new ConfigConflictError(); + } + // Audited as stored (with its real instance), never as submitted. + await auditGroupChange(event, prev, saved ?? g); + } } catch (err) { - log.error({ err }, "Failed to save groups"); - return respondError(event, 500, "Failed to save groups"); + return writeError(event, err, "groups"); } - log.info({ count: nextAll.length }, "Groups updated via admin UI"); - return { ok: true, count: nextAll.length }; + log.info({ updated: upserts.length, deleted: deletions.length }, "Groups updated via admin UI"); + return { ok: true, count: result.groups.length }; } -/** GET /admin/api/routes */ +/** POST /admin/api/groups — create one group (super admins). */ +export async function adminGroupCreate(event: H3Event): Promise> { + const auth = await requireAnyAccess(event); + const env = cfEnv(event); + if (!auth.scope.isSuper) return respondError(event, 403, "Forbidden"); + const body = await readJsonBody(event); + if (!body) return respondError(event, 400, "Invalid JSON body"); + const result = validateGroups([body["group"]]); + if (!result.ok) return respondError(event, 400, result.error); + // Members added by login are bound to their accounts, as on every update. + const group = await bindNewMembers(event, result.groups[0]!); + if (await isGroupIdRetired(env, group.id)) { + return respondError(event, 409, `group id "${group.id}" was used recently; pick another id`); + } + let created: boolean; + try { + created = await createFreshGroup(env, group); + } catch (err) { + return writeError(event, err, "group"); + } + if (!created) return respondError(event, 409, `group id "${group.id}" already exists`); + // What was stored (with its server-assigned instance): audited under that + // instance, and returned so its revision matches the next update. + const stored = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === group.id); + await auditGroupChange(event, undefined, stored ?? group); + const [withRev] = await withRevisions([stored ?? group]); + return { ok: true, group: withRev }; +} + +/** + * PUT /admin/api/groups/:groupId — update one group (owners). A submitted + * `revision` must match the stored group, so an edit made from a stale copy is + * refused (409) instead of silently reverting someone else's change. + */ +export async function adminGroupUpdate( + event: H3Event, + groupId: string, +): Promise> { + const auth = await requireAnyAccess(event); + const env = cfEnv(event); + const access = requireGroupRole(event, groupId, "owner"); + if (!access.ok) return accessError(event, access); + const body = await readJsonBody(event); + if (!body) return respondError(event, 400, "Invalid JSON body"); + const raw = body["group"]; + if (!raw || typeof raw !== "object" || Array.isArray(raw)) { + return respondError(event, 400, "Missing group object"); + } + const revision = submittedRevision((raw as Record)["revision"]); + const result = validateGroups([{ ...(raw as Record), id: groupId }]); + if (!result.ok) return respondError(event, 400, result.error); + const submitted = await bindNewMembers(event, result.groups[0]!, access.group); + const logTargetCheck = submitted.logTarget + ? await foreignTargetIssue(event, groupId, [{ ref: "@log", target: submitted.logTarget }]) + : { issue: null }; + if (logTargetCheck.issue) return respondError(event, 403, logTargetCheck.issue); + // Keeping a shared log channel was allowed for the group as authorized: + // the write must still find it so, even without a client revision. + const baseRevision = + revision ?? + ("keepsShared" in logTargetCheck && logTargetCheck.keepsShared + ? await groupRevision(access.group) + : undefined); + + let prev: Group | undefined; + let saved: Group | null; + try { + saved = await updateGroup( + env.KV, + groupId, + async (current) => { + if (baseRevision && (await groupRevision(current)) !== baseRevision) { + throw new ConfigConflictError(); + } + // Still an owner of the group as it is now (the write is a CAS on it). + if (!stillHolds(event, current, "owner")) throw new OwnershipError("Forbidden"); + prev = current; + const own = carryMemberIds(submitted, current); + const next = auth.scope.isSuper ? own : keepSuperOnlyFields(own, current); + const ownerIssue = ownershipError(event, next); + if (ownerIssue) throw new OwnershipError(ownerIssue); + return deepEqual(sanitizeGroup({ ...current }), next) ? null : next; + }, + { guards: logTargetCheck.guards }, + ); + } catch (err) { + if (err instanceof OwnershipError) return respondError(event, 403, err.message); + return writeError(event, err, "group"); + } + if (!saved) return respondError(event, 404, "Group not found"); + if (prev) await auditGroupChange(event, prev, saved); + const [withRev] = await withRevisions([saved]); + return { ok: true, group: withRev }; +} + +/** DELETE /admin/api/groups/:groupId — delete one group with its routes (owners). */ +export async function adminGroupDelete( + event: H3Event, + groupId: string, +): Promise> { + const auth = await requireAnyAccess(event); + const env = cfEnv(event); + const access = requireGroupRole(event, groupId, "owner"); + if (!access.ok) return accessError(event, access); + // What the deletion was confirmed on. Checked inside the delete: the group + // row's version is guarded, and every route write bumps it. + const query = getQuery(event); + const revision = submittedRevision(query["revision"]); + const routesRev = submittedRevision(query["routesRevision"]); + if (!revision || !routesRev) { + return respondError(event, 400, "revision and routesRevision are required"); + } + const versionParam = Number(query["version"]); + const version = Number.isInteger(versionParam) && versionParam > 0 ? versionParam : undefined; + if (canUseD1(env.DB) && version === undefined) { + return respondError(event, 400, "version is required"); + } + try { + await removeGroup( + env, + groupId, + async (current) => { + if (!stillHolds(event, current, "owner")) throw new OwnershipError("Forbidden"); + if ((await groupRevision(current)) !== revision) { + throw new ConfigConflictError(); + } + const { config } = await loadConfigSnapshot(env, { fresh: true }); + // A route nobody could see was never confirmed for deletion. + if (config.unreadableGroups?.includes(groupId)) throw new ConfigConflictError(); + const routes = config.routes.filter((r) => r.groupId === groupId); + if ((await routesRevision(routes)) !== routesRev) throw new ConfigConflictError(); + }, + version, + ); + } catch (err) { + return writeError(event, err, "group"); + } + // Not filed under the group: a later group reusing the id must not see it. + await recordAudit(env.DB, { + ts: Date.now(), + actorId: auth.session.userId, + actorLogin: auth.session.login, + action: "group.delete", + targetType: "group", + targetId: groupId, + ip: clientIp(event), + }); + log.info({ groupId }, "Group deleted via admin UI"); + return { ok: true }; +} + +/** GET /admin/api/routes — every visible route, plus each group's list `revisions`. */ export async function adminApiRoutesGet(event: H3Event): Promise> { const auth = await requireAnyAccess(event); const env = cfEnv(event); - const all = await loadRoutes(env.KV); + const all = await loadRoutes(env.KV, { fresh: true }); const routes = auth.scope.isSuper ? all : all.filter((r) => r.groupId != null && auth.scope.groupIds.has(r.groupId)); - return { routes }; + const revisions: Record = {}; + for (const g of auth.scope.groups) { + revisions[g.id] = await routesRevision(routes.filter((r) => r.groupId === g.id)); + } + return { routes, revisions }; } -/** PUT /admin/api/routes */ +/** + * PUT /admin/api/routes — bulk write (legacy API). Each affected group's + * routes are replaced in their own guarded transaction, and only for groups + * the caller may edit. With `revisions` (as returned by GET), a group whose + * list comes back unedited is left alone, a group the client never loaded is + * not touched, and an edited group must still be at its loaded revision. + * Without them, a group is only rewritten if nobody changed it while this + * request ran. + */ export async function adminApiRoutesPut(event: H3Event): Promise> { const auth = await requireAnyAccess(event); const env = cfEnv(event); const body = await readJsonBody(event); if (!body) return respondError(event, 400, "Invalid JSON body"); - const existing = await loadRoutes(env.KV); - const unchanged = new Map(existing.map((r) => [r.id, r])); + const rawRevisions = body["revisions"]; + const revisions = + rawRevisions && typeof rawRevisions === "object" && !Array.isArray(rawRevisions) + ? (rawRevisions as Record) + : undefined; + // One fresh read for the whole request: the target checks below use it too. + const snapshot = await loadConfigSnapshot(env, { fresh: true }); + const existing = snapshot.config.routes; + const unchanged = new Map(existing.map((r) => [routeKey(r.groupId, r.id), r])); const result = validateRoutes(body["routes"], unchanged); if (!result.ok) return respondError(event, 400, result.error); - let nextAll: Route[]; + const groupIds = new Set(auth.groups.map((g) => g.id)); + const writable = new Set(); + for (const gid of groupIds) { + const role = roleAt(auth.scope, gid); + if (role === "owner" || role === "admin") writable.add(gid); + } + const byGroup = (list: Route[]): Map => { + const out = new Map(); + for (const r of list) { + const gid = r.groupId ?? ""; + out.set(gid, [...(out.get(gid) ?? []), r]); + } + return out; + }; + const next = byGroup(result.routes); + const current = byGroup(existing); + for (const [gid, list] of next) { + if (!writable.has(gid)) { + if (!groupIds.has(gid)) return respondError(event, 400, `group "${gid}" does not exist`); + return respondError(event, 403, `route "${list[0]!.id}" is outside your groups`); + } + } - if (auth.scope.isSuper) { - // Super admins see and submit every route: full replace. - nextAll = result.routes; - } else { - // Owners and admins may only write routes inside groups they manage. - // Reject any submitted route that targets a group they cannot edit, - // then splice their groups' routes in place while preserving all others. - const writable = new Set(); - for (const [gid, role] of auth.scope.roles) { - if (role === "owner" || role === "admin") writable.add(gid); + const plan: Array<{ + gid: string; + routes: Route[]; + base: string; + guards?: LifecycleStatements; + }> = []; + for (const gid of writable) { + const submitted = next.get(gid) ?? []; + const loaded = revisions ? submittedRevision(revisions[gid]) : undefined; + if (revisions) { + if (!loaded && !next.has(gid)) continue; // never loaded, nothing sent + if (loaded && (await routesRevision(submitted)) === loaded) continue; // unedited } - for (const r of result.routes) { - if (!r.groupId || !writable.has(r.groupId)) { - return respondError(event, 403, `route "${r.id}" is outside your groups`); - } - } - nextAll = [ - ...existing.filter((r) => !(r.groupId != null && writable.has(r.groupId))), - ...result.routes, - ]; + const stored = current.get(gid) ?? []; + if ((await routesRevision(submitted)) === (await routesRevision(stored))) continue; + const targets = await foreignTargetIssue(event, gid, routeTargetRefs(submitted), snapshot); + if (targets.issue) return respondError(event, 403, targets.issue); + plan.push({ + gid, + routes: submitted, + base: loaded ?? (await routesRevision(stored)), + guards: targets.guards, + }); } try { - await saveRoutes(env.KV, nextAll); + for (const { gid, routes, base, guards } of plan) { + await saveGroupRoutes(env.KV, gid, routes, { + guards: bothGuards(roleGuard(event, gid, "admin"), guards), + expect: async (stored) => { + if ((await routesRevision(stored)) !== base) throw new ConfigConflictError(); + }, + }); + } } catch (err) { - log.error({ err }, "Failed to save routes"); - return respondError(event, 500, "Failed to save routes"); + return writeError(event, err, "routes"); } + const count = plan.reduce((n, p) => n + p.routes.length, 0); await recordAudit(env.DB, { ts: Date.now(), actorId: auth.session.userId, @@ -752,11 +1661,11 @@ export async function adminApiRoutesPut(event: H3Event): Promise p.gid), count }, ip: clientIp(event), }); - log.info({ count: nextAll.length }, "Routes updated via admin UI"); - return { ok: true, count: nextAll.length }; + log.info({ groups: plan.length }, "Routes updated via admin UI"); + return { ok: true, count: result.routes.length }; } /** The groups whose history a reader may see: one group, theirs, or all (super). */ @@ -807,11 +1716,29 @@ export async function adminGroupRoutesGet( const env = cfEnv(event); const access = requireGroup(event, groupId); if (!access.ok) return accessError(event, access); - const all = await loadRoutes(env.KV); - return { group: access.group, routes: all.filter((r) => r.groupId === groupId) }; + // Read before the routes: a write landing in between makes the version + // newer than what is shown, so a deletion confirmed on this view fails. + const version = canUseD1(env.DB) ? await groupVersion(env.DB, groupId) : null; + const { config } = await loadConfigSnapshot(env, { fresh: true }); + const routes = config.routes.filter((r) => r.groupId === groupId); + return { + group: sanitizeGroup({ ...access.group }), + routes, + revision: await routesRevision(routes), + // The group's version (routes, fragments, settings): a deletion is + // confirmed on it. + version, + // Stored routes not listed (unreadable): a save must repair them explicitly. + unreadable: config.unreadableGroups?.includes(groupId) === true, + }; } -/** PUT /admin/api/groups/:groupId/routes */ +/** + * PUT /admin/api/groups/:groupId/routes — replace one group's routes. A + * submitted `revision` (from the last load or save) must still match the + * stored list; otherwise someone changed the routes meanwhile and the write is + * refused (409) instead of reverting their change. + */ export async function adminGroupRoutesPut( event: H3Event, groupId: string, @@ -830,20 +1757,40 @@ export async function adminGroupRoutesPut( const scoped = Array.isArray(submitted) ? submitted.map((r) => ({ ...(r as Record), groupId })) : submitted; - const existing = await loadRoutes(env.KV); - const unchanged = new Map(existing.map((r) => [r.id, r])); + // One fresh read for the whole request: the target check below uses it too. + const snapshot = await loadConfigSnapshot(env, { fresh: true }); + const current = snapshot.config.routes.filter((r) => r.groupId === groupId); + const revision = submittedRevision(body["revision"]); + const unchanged = new Map(current.map((r) => [routeKey(r.groupId, r.id), r])); const result = validateRoutes(scoped, unchanged); if (!result.ok) return respondError(event, 400, result.error); + const targets = await foreignTargetIssue( + event, + groupId, + routeTargetRefs(result.routes), + snapshot, + ); + if (targets.issue) return respondError(event, 403, targets.issue); + // Keeping a shared channel was allowed for the routes as just read: the + // write must still find them so, even when the client sent no revision. + const base = revision ?? (targets.keepsShared ? await routesRevision(current) : undefined); - // Replace only this group's routes; every other group is preserved untouched. - const others = existing.filter((r) => r.groupId !== groupId); - const nextAll = [...others, ...result.routes]; - + let saved: Route[]; try { - await saveRoutes(env.KV, nextAll); + // The revision is checked against the stored routes inside the guarded + // write, so two saves from the same revision cannot both succeed. + saved = await saveGroupRoutes(env.KV, groupId, result.routes, { + guards: bothGuards(roleGuard(event, groupId, "admin"), targets.guards), + // An explicit repair: replace routes that can no longer be read. + discardUnreadable: body["discardUnreadable"] === true, + expect: async (stored) => { + if (base && (await routesRevision(stored)) !== base) { + throw new ConfigConflictError(); + } + }, + }); } catch (err) { - log.error({ err }, "Failed to save routes"); - return respondError(event, 500, "Failed to save routes"); + return writeError(event, err, "routes"); } const auth = currentAuth(event); await recordAudit(env.DB, { @@ -854,11 +1801,17 @@ export async function adminGroupRoutesPut( targetType: "group", targetId: groupId, groupId, + groupInstance: access.group.instance, detail: { count: result.routes.length }, ip: clientIp(event), }); log.info({ groupId, count: result.routes.length }, "Group routes updated via admin UI"); - return { ok: true, count: result.routes.length }; + return { + ok: true, + count: result.routes.length, + routes: saved, + revision: await routesRevision(saved), + }; } /** POST /admin/api/groups/:groupId/invites */ @@ -879,12 +1832,18 @@ export async function adminGroupInvitesPost( } const note = body["note"]; const auth = currentAuth(event); + const expiresAt = Date.now() + INVITE_LIFETIME_MS; const token = await createInvite(env.KV, { groupId, role, - expiresAt: Date.now() + 7 * 86400_000, + expiresAt, createdBy: auth.session.login, note: typeof note === "string" && note.trim() ? note.trim() : undefined, + groupInstance: access.group.instance, + // Who vouches for it: checked again when it is used. + issuer: auth.scope.isSuper + ? { super: true } + : { userId: auth.session.userId, login: authLogin(auth.session) }, }); await recordAudit(env.DB, { ts: Date.now(), @@ -894,6 +1853,7 @@ export async function adminGroupInvitesPost( targetType: "group", targetId: groupId, groupId, + groupInstance: access.group.instance, detail: { role }, ip: clientIp(event), }); @@ -901,7 +1861,7 @@ export async function adminGroupInvitesPost( ok: true, token, url: `/admin/invite?token=${token}`, - expiresAt: Date.now() + 7 * 86400_000, + expiresAt, }; } @@ -914,7 +1874,7 @@ export async function adminGroupInvitesGet( const env = cfEnv(event); const access = requireGroupRole(event, groupId, "owner"); if (!access.ok) return accessError(event, access); - const invites = await listInvites(env.KV, groupId); + const invites = await listInvites(env.KV, groupId, access.group); return { invites }; } @@ -927,9 +1887,24 @@ export async function adminInviteDelete( const env = cfEnv(event); const invite = await getInvite(env.KV, token); if (!invite) return respondError(event, 404, "Invite not found"); - const access = requireGroupRole(event, invite.groupId, "owner"); + // The group that issued it, under whatever id it has now (the invite may + // still name a former id); never another group that took over that id. + const groups = currentAuth(event).groups; + const issuer = invite.groupInstance + ? groups.find((g) => g.instance === invite.groupInstance)?.id + : groups.find((g) => g.legacyId === invite.groupId)?.id; + if (!issuer) return respondError(event, 403, "Forbidden"); + const access = requireGroupRole(event, issuer, "owner"); if (!access.ok) return respondError(event, 403, "Forbidden"); - await revokeInvite(env.KV, token); + try { + // Still an owner when the revocation commits (checked in its transaction). + await revokeInvite(env.KV, token, env.DB, roleGuard(event, issuer, "owner")); + } catch (err) { + // A guard aborts its transaction with a JSON error ("malformed JSON"). + if (/role revoked|malformed JSON/i.test(String(err))) + return respondError(event, 403, "Forbidden"); + throw err; + } const auth = currentAuth(event); await recordAudit(env.DB, { ts: Date.now(), @@ -937,14 +1912,20 @@ export async function adminInviteDelete( actorLogin: auth.session.login, action: "invite.revoke", targetType: "group", - targetId: invite.groupId, - groupId: invite.groupId, + targetId: issuer, + groupId: issuer, + groupInstance: invite.groupInstance, ip: clientIp(event), }); return { ok: true }; } -/** PUT /admin/api/groups/:groupId/rename */ +/** + * PUT /admin/api/groups/:groupId/rename — move a group to a new id. The group, + * its routes and its fragments move in one transaction; its history, webhook + * secret and invites follow, deliveries queued under the old id are redirected, + * and the old id stays retired for a while so no other group inherits them. + */ export async function adminGroupRename( event: H3Event, groupId: string, @@ -961,47 +1942,51 @@ export async function adminGroupRename( if (newId === groupId) { return respondError(event, 400, "newId must differ from the current id"); } + const revision = submittedRevision(body["revision"]); const auth = currentAuth(event); - const existing = await loadGroups(env.KV); + if (reservedGroupId(newId) && !auth.scope.isSuper) { + return respondError(event, 400, "ids starting with inst- or u- are reserved"); + } + const existing = await loadGroups(env.KV, { fresh: true }); if (existing.some((g) => g.id === newId)) { return respondError(event, 400, `group id "${newId}" already exists`); } - - // Re-point routes before saving the renamed group. The D1 group writer removes - // routes belonging to group ids that disappear; doing this in the opposite - // order would delete the old group's routes before they can be moved. - const routes = await loadRoutes(env.KV); - const touched = routes.filter((r) => r.groupId === groupId); - if (touched.length > 0) { - await saveRoutes( - env.KV, - routes.map((r) => (r.groupId === groupId ? { ...r, groupId: newId } : r)), - ); + if (await isGroupIdRetired(env, newId)) { + return respondError(event, 409, `group id "${newId}" was used recently; pick another id`); } + const routeCount = (await loadRoutes(env.KV, { fresh: true })).filter( + (r) => r.groupId === groupId, + ).length; - const next = existing.map((g) => (g.id === groupId ? { ...g, id: newId } : g)); + let renamed: Group; try { - await saveGroups(env.KV, next); + renamed = await renameGroup(env.KV, groupId, newId, { + // Checked against the row the copy is taken from, inside the guarded + // transaction: a concurrent change makes the rename fail, not revert it. + expect: async (current) => { + // Still an owner of the group as it is now (checked inside the guarded write). + if (!stillHolds(event, current, "owner")) throw new OwnershipError("Forbidden"); + if (revision && (await groupRevision(current)) !== revision) { + throw new ConfigConflictError(); + } + }, + extra: renameLifecycle(groupId, newId), + // The id no longer marks a personal group: keep its isolation explicit. + transform: (g) => ({ ...g, isolated: g.isolated ?? (isIsolated(g) || undefined) }), + }); } catch (err) { - log.error({ err }, "Failed to save groups on rename"); - return respondError(event, 500, "Failed to save groups"); + if (err instanceof ConfigConflictError) return writeError(event, err, "group"); + log.error({ err }, "Failed to rename group"); + return respondError(event, 500, "Failed to rename group"); } - // Re-point fragments, the tenant webhook secret and pending invites. - const fragments = await loadFragments(env.DB); - const touchedFragments = fragments.filter((f) => f.groupId === groupId); - if (touchedFragments.length > 0) { - await saveFragments( - env.DB, - fragments.map((f) => (f.groupId === groupId ? { ...f, groupId: newId } : f)), - ); - } - const secret = await getTenantSecret(env.KV, groupId); - if (secret) { - await env.KV.put(`tenant:${newId}`, secret); - await env.KV.delete(`tenant:${groupId}`); - } - await migrateInvites(env.KV, groupId, newId); + await recordGroupRename(env, groupId, newId).catch((err) => + log.warn({ err, from: groupId, to: newId }, "Failed to record group rename"), + ); + await retireGroupId(env, groupId); + // The secret is keyed by instance and follows the group by itself; invites + // are accepted by instance too — moving the index only keeps them listed. + await migrateInvites(env.KV, groupId, newId, renamed); await recordAudit(env.DB, { ts: Date.now(), @@ -1011,11 +1996,13 @@ export async function adminGroupRename( targetType: "group", targetId: newId, groupId: newId, - detail: { from: groupId, to: newId, routes: touched.length }, + groupInstance: renamed?.instance, + detail: { from: groupId, to: newId, routes: routeCount }, ip: clientIp(event), }); log.info({ from: groupId, to: newId }, "Group renamed via admin UI"); - return { ok: true, id: newId }; + const [withRev] = await withRevisions([renamed]); + return { ok: true, id: newId, group: withRev, revision: withRev!.revision }; } /** GET /admin/api/groups/:groupId/webhook */ @@ -1029,7 +2016,7 @@ export async function adminGroupWebhookGet( if (!access.ok) return accessError(event, access); return { url: webhookUrl(event, groupId), - hasSecret: (await getTenantSecret(env.KV, groupId)) != null, + hasSecret: (await getTenantSecret(env.KV, access.group)) != null, }; } @@ -1042,7 +2029,16 @@ export async function adminGroupWebhookRegenerate( const env = cfEnv(event); const access = requireGroupRole(event, groupId, "owner"); if (!access.ok) return accessError(event, access); - const secret = await setTenantSecret(env.KV, groupId); + let secret: string | null; + try { + // Only by someone who is an owner when the new secret is committed. + secret = await rotateTenantSecret(env.KV, groupId, (current) => { + if (!stillHolds(event, current, "owner")) throw new OwnershipError("Forbidden"); + }); + } catch (err) { + return writeError(event, err, "webhook secret"); + } + if (!secret) return respondError(event, 404, "Group not found"); const auth = currentAuth(event); await recordAudit(env.DB, { ts: Date.now(), @@ -1052,9 +2048,10 @@ export async function adminGroupWebhookRegenerate( targetType: "group", targetId: groupId, groupId, + groupInstance: access.group.instance, ip: clientIp(event), }); - return { ok: true, url: webhookUrl(event, groupId), secret }; + return { ok: true, url: webhookUrl(event, groupId), secret, hasSecret: true }; } /** DELETE /admin/api/groups/:groupId/webhook */ @@ -1066,7 +2063,14 @@ export async function adminGroupWebhookDelete( const env = cfEnv(event); const access = requireGroupRole(event, groupId, "owner"); if (!access.ok) return accessError(event, access); - await deleteTenantSecret(env.KV, groupId); + try { + const removed = await removeTenantSecret(env.KV, groupId, (current) => { + if (!stillHolds(event, current, "owner")) throw new OwnershipError("Forbidden"); + }); + if (!removed) return respondError(event, 404, "Group not found"); + } catch (err) { + return writeError(event, err, "webhook secret"); + } const auth = currentAuth(event); await recordAudit(env.DB, { ts: Date.now(), @@ -1076,6 +2080,7 @@ export async function adminGroupWebhookDelete( targetType: "group", targetId: groupId, groupId, + groupInstance: access.group.instance, ip: clientIp(event), }); return { ok: true }; @@ -1166,8 +2171,18 @@ export async function adminGroupFragmentsGet( const env = cfEnv(event); const access = requireGroup(event, groupId); if (!access.ok) return accessError(event, access); - const all = await loadFragments(env.DB); - return { group: access.group, fragments: all.filter((f) => f.groupId === groupId) }; + let fragments: NamedFragment[]; + try { + fragments = await loadFragments(env.DB, groupId); + } catch (err) { + log.error({ err, groupId }, "Failed to load fragments"); + return respondError(event, 500, "Failed to load fragments"); + } + return { + group: sanitizeGroup({ ...access.group }), + fragments, + revision: await revisionOf(fragments), + }; } /** PUT /admin/api/groups/:groupId/fragments */ @@ -1187,15 +2202,17 @@ export async function adminGroupFragmentsPut( const result = validateFragments(submitted, groupId); if (!result.ok) return respondError(event, 400, result.error); - const existing = await loadFragments(env.DB); - const others = existing.filter((f) => f.groupId !== groupId); - const nextAll = [...others, ...result.fragments]; - + let saved: NamedFragment[]; try { - await saveFragments(env.DB, nextAll); + const revision = submittedRevision(body["revision"]); + saved = await saveGroupFragments(env.DB, groupId, result.fragments, { + guards: roleGuard(event, groupId, "admin"), + expect: async (stored) => { + if (revision && (await revisionOf(stored)) !== revision) throw new ConfigConflictError(); + }, + }); } catch (err) { - log.error({ err }, "Failed to save fragments"); - return respondError(event, 500, "Failed to save fragments"); + return writeError(event, err, "fragments"); } const auth = currentAuth(event); await recordAudit(env.DB, { @@ -1206,10 +2223,16 @@ export async function adminGroupFragmentsPut( targetType: "group", targetId: groupId, groupId, + groupInstance: access.group.instance, detail: { count: result.fragments.length }, ip: clientIp(event), }); - return { ok: true, count: result.fragments.length }; + return { + ok: true, + count: result.fragments.length, + fragments: saved, + revision: await revisionOf(saved), + }; } /** POST /admin/api/test-match */ diff --git a/server/lib/web/auth.ts b/server/lib/web/auth.ts index 328fdc4..b0d6d1c 100644 --- a/server/lib/web/auth.ts +++ b/server/lib/web/auth.ts @@ -1,7 +1,7 @@ import type { H3Event } from "h3"; import { createError, getHeader } from "h3"; import type { Group, GroupRole } from "../types"; -import { getAdminSession, isDebugMode, type AdminSession } from "./session"; +import { authLogin, getAdminSession, isDebugMode, type AdminSession } from "./session"; import { loadGroups, resolveScope, @@ -28,14 +28,15 @@ const AUTH_KEY = "auth"; export async function loadAuth(event: H3Event): Promise { const env = cfEnv(event); initConfigStore(env); - const groups = await loadGroups(env.KV); - if (isDebugMode(env)) { - const session: AdminSession = { userId: "debug", login: "debug" }; - return { session, scope: resolveScope(env, groups, session.userId, session.login), groups }; - } - const session = await getAdminSession(env.KV, getHeader(event, "cookie")); + // The session first: a request without one reads no configuration. + const session: AdminSession | null = isDebugMode(env) + ? { userId: "debug", login: "debug" } + : await getAdminSession(env.KV, getHeader(event, "cookie"), env.DB); if (!session) return null; - const scope = resolveScope(env, groups, session.userId, session.login); + // Access checks read the authoritative store: a membership revoked in + // another isolate must not linger in this one's cache. + const groups = await loadGroups(env.KV, { fresh: true }); + const scope = resolveScope(env, groups, session.userId, authLogin(session)); return { session, scope, groups }; } diff --git a/server/lib/web/tenants.ts b/server/lib/web/tenants.ts index a627758..01e4a86 100644 --- a/server/lib/web/tenants.ts +++ b/server/lib/web/tenants.ts @@ -1,12 +1,28 @@ -import { log } from "../lib/log"; +import type { Group } from "../types"; +import { updateGroup } from "./groups"; /** * Per-group webhook tenant secrets. A group can opt into its own webhook * ingress (`POST /webhook/{groupId}`) with an independent secret, so SaaS * users can configure their own GitHub/Gitea/custom webhooks without sharing * (or even knowing) the operator's global secrets. + * + * Secrets are keyed by the group's immutable `instance`: a rename keeps the + * secret without moving anything, and a group re-created under a former id + * never inherits the old group's secret. A secret stored before instances + * existed (`tenant:{groupId}`) is still read — only by the group that had that + * id back then (`legacyId`) — until the secret is regenerated or removed. It is + * never copied over: a lazy copy could race a rotation and resurrect the old + * secret. */ -const TENANT_KEY = (groupId: string): string => `tenant:${groupId}`; +type TenantGroup = Pick; + +const LEGACY_KEY = (groupId: string): string => `tenant:${groupId}`; +const INSTANCE_KEY = (instance: string): string => `tenant:i:${instance}`; + +function keyOf(group: TenantGroup): string { + return group.instance ? INSTANCE_KEY(group.instance) : LEGACY_KEY(group.id); +} /** 32 random bytes → 64 hex chars. */ export function generateTenantSecret(): string { @@ -17,22 +33,79 @@ export function generateTenantSecret(): string { .join(""); } -export async function getTenantSecret(kv: KVNamespace, groupId: string): Promise { - try { - return await kv.get(TENANT_KEY(groupId), "text"); - } catch (err) { - log.warn({ err, groupId }, "Failed to read tenant webhook secret"); - return null; - } +/** + * The group's webhook secret, or null when it has none. Read errors propagate: + * a failed read must never pass for "no secret". + */ +export async function getTenantSecret(kv: KVNamespace, group: TenantGroup): Promise { + // Stored with the group (how secrets are written now); KV keys are read for + // secrets set before that. + // "" is an explicit "none" (removed): no older KV copy counts then. + if (group.webhookSecret != null) return group.webhookSecret || null; + const secret = await kv.get(keyOf(group), "text"); + // Only the group that had the id before instances may use a pre-instance + // secret — not a group created since, nor one renamed to that id. + if (secret || !group.instance || !group.legacyId) return secret; + return kv.get(LEGACY_KEY(group.legacyId), "text"); +} + +/** + * The pre-instance key the group's secret may still be found under. Keys + * under its current id are left alone: they may belong to the group that had + * that id before instances (now under another id). + */ +function legacyKeys(group: TenantGroup): string[] { + return group.legacyId ? [LEGACY_KEY(group.legacyId)] : []; } /** Generate (or regenerate) the group's webhook secret. */ -export async function setTenantSecret(kv: KVNamespace, groupId: string): Promise { +export async function setTenantSecret(kv: KVNamespace, group: TenantGroup): Promise { const secret = generateTenantSecret(); - await kv.put(TENANT_KEY(groupId), secret); + await kv.put(keyOf(group), secret); + // The new secret replaces the group's pre-instance one. + if (group.instance) for (const key of legacyKeys(group)) await kv.delete(key); return secret; } -export async function deleteTenantSecret(kv: KVNamespace, groupId: string): Promise { - await kv.delete(TENANT_KEY(groupId)); +/** + * Generate (or regenerate) the group's webhook secret, stored with the group + * in a compare-and-swap: `check` sees the group as it is at that moment and + * may throw (e.g. the writer is no longer an owner), so a request authorized + * earlier can never overwrite a later rotation. Older KV copies are dropped. + * Null when the group does not exist. + */ +export async function rotateTenantSecret( + kv: KVNamespace, + groupId: string, + check: (current: Group) => void, +): Promise { + const secret = generateTenantSecret(); + const saved = await updateGroup(kv, groupId, (g) => { + check(g); + return { ...g, webhookSecret: secret }; + }); + if (!saved) return null; + await deleteTenantSecret(kv, saved).catch(() => undefined); + return secret; +} + +/** Remove the group's webhook secret (the same compare-and-swap as rotation). */ +export async function removeTenantSecret( + kv: KVNamespace, + groupId: string, + check: (current: Group) => void, +): Promise { + const saved = await updateGroup(kv, groupId, (g) => { + check(g); + return { ...g, webhookSecret: null }; + }); + if (!saved) return false; + await deleteTenantSecret(kv, saved); + return true; +} + +/** Drop the KV copies of a group's secret (from before secrets lived with the group). */ +export async function deleteTenantSecret(kv: KVNamespace, group: TenantGroup): Promise { + await kv.delete(keyOf(group)); + for (const key of legacyKeys(group)) await kv.delete(key); } diff --git a/server/lib/webhook.ts b/server/lib/webhook.ts index c09610e..47f87d1 100644 --- a/server/lib/webhook.ts +++ b/server/lib/webhook.ts @@ -43,7 +43,10 @@ export async function processWebhook( if (!groups.some((g) => g.id === tenantId)) { return { status: 404, body: { error: "Group not found" } }; } - const secret = await getTenantSecret(env.KV, tenantId); + const secret = await getTenantSecret( + env.KV, + groups.find((g) => g.id === tenantId)!, + ); if (!secret) { return { status: 404, body: { error: "Webhook disabled for this group" } }; } diff --git a/server/routes/admin/api/[...slug].ts b/server/routes/admin/api/[...slug].ts index 2f7f84f..93aa314 100644 --- a/server/routes/admin/api/[...slug].ts +++ b/server/routes/admin/api/[...slug].ts @@ -9,6 +9,9 @@ import { adminApiMe, adminApiGroupsGet, adminApiGroupsPut, + adminGroupCreate, + adminGroupUpdate, + adminGroupDelete, adminApiRoutesGet, adminApiRoutesPut, adminApiLogs, @@ -40,6 +43,11 @@ export default defineEventHandler((event) => { if (seg[0] === "groups" && seg.length === 1) { if (method === "GET") return adminApiGroupsGet(event); if (method === "PUT") return adminApiGroupsPut(event); + if (method === "POST") return adminGroupCreate(event); + } + if (seg[0] === "groups" && seg.length === 2) { + if (method === "PUT") return adminGroupUpdate(event, seg[1]!); + if (method === "DELETE") return adminGroupDelete(event, seg[1]!); } if (seg[0] === "routes" && seg.length === 1) { if (method === "GET") return adminApiRoutesGet(event); diff --git a/tests/admin-api.test.ts b/tests/admin-api.test.ts index acfacfb..d56f902 100644 --- a/tests/admin-api.test.ts +++ b/tests/admin-api.test.ts @@ -9,7 +9,7 @@ import { createAdminSession, adminCookie } from "../server/lib/web/session"; import { loadGroups, invalidateGroupsCache } from "../server/lib/web/groups"; import { loadRoutes } from "../server/lib/config"; import { createInvite, listInvites } from "../server/lib/web/invites"; -import { getTenantSecret, setTenantSecret } from "../server/lib/web/tenants"; +import { getTenantSecret } from "../server/lib/web/tenants"; import { makeEvent, responseStatus } from "./helpers"; import type { Env, Route } from "../server/lib/types"; @@ -85,8 +85,9 @@ describe("admin handlers (h3)", () => { }, ] as Route[]), ); - await setTenantSecret(kv, "old-team"); - const originalSecret = (await getTenantSecret(kv, "old-team"))!; + // A secret stored before group instances existed (keyed by group id). + const originalSecret = "legacy-secret"; + await kv.put("tenant:old-team", originalSecret); await createInvite(kv, { groupId: "old-team", role: "viewer", @@ -114,8 +115,8 @@ describe("admin handlers (h3)", () => { const routes = await loadRoutes(kv); expect(routes[0]!.groupId).toBe("new-team"); - expect(await getTenantSecret(kv, "new-team")).toBe(originalSecret); - expect(await getTenantSecret(kv, "old-team")).toBeNull(); + // The secret follows the group (it is keyed by the group's instance). + expect(await getTenantSecret(kv, groups[0]!)).toBe(originalSecret); const invites = await listInvites(kv, "new-team"); expect(invites).toHaveLength(1); diff --git a/tests/admin.test.ts b/tests/admin.test.ts index a578f0e..bdb3f36 100644 --- a/tests/admin.test.ts +++ b/tests/admin.test.ts @@ -296,6 +296,20 @@ describe("ensureInstallationGroup", () => { }); describe("tenant webhook secrets", () => { + const G1 = { id: "g1", instance: "inst-g1" }; + + it("never lets a group created later adopt a secret left under its id", async () => { + const kv = createMockKV(); + await kv.put("tenant:g1", "old-secret"); + expect(await getTenantSecret(kv, G1)).toBeNull(); + // The group that had the id before instances still uses its old secret, + // under whatever id it has now — and without copying it anywhere. + expect(await getTenantSecret(kv, { ...G1, id: "moved", legacyId: "g1" })).toBe("old-secret"); + // A pre-instance group renamed to the id later never adopts it. + expect(await getTenantSecret(kv, { ...G1, legacyId: "other" })).toBeNull(); + expect(await kv.get("tenant:i:" + G1.instance)).toBeNull(); + }); + it("generates 64-char hex secrets", () => { const s = generateTenantSecret(); expect(s).toMatch(/^[0-9a-f]{64}$/); @@ -303,19 +317,19 @@ describe("tenant webhook secrets", () => { it("creates, reads, and deletes a tenant secret", async () => { const kv = createMockKV(); - expect(await getTenantSecret(kv, "g1")).toBeNull(); - const secret = await setTenantSecret(kv, "g1"); - expect(await getTenantSecret(kv, "g1")).toBe(secret); - await deleteTenantSecret(kv, "g1"); - expect(await getTenantSecret(kv, "g1")).toBeNull(); + expect(await getTenantSecret(kv, G1)).toBeNull(); + const secret = await setTenantSecret(kv, G1); + expect(await getTenantSecret(kv, G1)).toBe(secret); + await deleteTenantSecret(kv, G1); + expect(await getTenantSecret(kv, G1)).toBeNull(); }); it("regenerating replaces the previous secret", async () => { const kv = createMockKV(); - const a = await setTenantSecret(kv, "g1"); - const b = await setTenantSecret(kv, "g1"); + const a = await setTenantSecret(kv, G1); + const b = await setTenantSecret(kv, G1); expect(a).not.toBe(b); - expect(await getTenantSecret(kv, "g1")).toBe(b); + expect(await getTenantSecret(kv, G1)).toBe(b); }); }); diff --git a/tests/data-integrity.test.ts b/tests/data-integrity.test.ts new file mode 100644 index 0000000..84e7434 --- /dev/null +++ b/tests/data-integrity.test.ts @@ -0,0 +1,931 @@ +import { describe, it, expect, beforeEach } from "bun:test"; +import type { H3Event } from "h3"; +import { + adminApiGroupsGet, + adminApiGroupsPut, + adminGroupCreate, + adminGroupDelete, + adminGroupFragmentsGet, + adminGroupFragmentsPut, + adminGroupInvitesPost, + adminInviteDelete, + adminGroupRename, + adminGroupRoutesGet, + adminGroupRoutesPut, + adminGroupUpdate, + adminGroupWebhookRegenerate, + channelFreeGuard, + roleGuard, +} from "../server/lib/web/admin"; +import { ConfigConflictError } from "../server/lib/storage/config-store"; +import { createAdminSession, adminCookie } from "../server/lib/web/session"; +import { + createGroup, + ensureInstallationGroup, + loadGroups, + updateGroup, +} from "../server/lib/web/groups"; +import { + initConfigStore, + loadRoutes, + resetConfigStore, + saveGroupRoutes, +} from "../server/lib/config"; +import { saveToken, findUserIdByToken } from "../server/lib/github/store"; +import { makeEvent, responseStatus } from "./helpers"; +import { resolveGroupAlias } from "../server/lib/web/group-lifecycle"; +import { acceptInvite, getInvite } from "../server/lib/web/invites"; +import { createMemoryKV, createSqliteD1 } from "./d1-sqlite"; +import type { Env, Group, Route } from "../server/lib/types"; +import type { Database } from "bun:sqlite"; + +let env: Env; +let sqlite: Database; + +function group(id: string, owner: string, extra: Partial = {}): Group { + return { id, name: id, adminIds: [owner], members: [{ login: owner, role: "owner" }], ...extra }; +} + +function route(id: string, extra: Partial = {}): Route { + return { + id, + name: id, + enabled: true, + filters: [{ type: "event", match: "push" }], + targets: [{ platform: "discord", channelId: "1" }], + ...extra, + }; +} + +async function cookieFor(userId: string, login: string): Promise { + return adminCookie(await createAdminSession(env.KV, userId, login)); +} + +/** Delete a group the way the console does: confirmed on its shown revisions. */ +async function deleteAs(cookie: string, id: string): Promise { + const routes = (await adminGroupRoutesGet( + call(`/admin/api/groups/${id}/routes`, cookie), + id, + )) as { + revision: string; + version: number; + }; + const listed = (await adminApiGroupsGet(call("/admin/api/groups", cookie))) as { + groups: Array<{ id: string; revision: string }>; + }; + const rev = listed.groups.find((g) => g.id === id)!.revision; + const del = call( + `/admin/api/groups/${id}?revision=${rev}&routesRevision=${routes.revision}&version=${routes.version}`, + cookie, + "DELETE", + ); + await adminGroupDelete(del, id); + expect(responseStatus(del)).toBe(200); +} + +function call(path: string, cookie: string, method = "GET", body?: unknown): H3Event { + return makeEvent(path, { + method, + headers: { cookie, "content-type": "application/json" }, + body: body === undefined ? undefined : JSON.stringify(body), + env, + }); +} + +beforeEach(async () => { + const d1 = createSqliteD1(); + sqlite = d1.sqlite; + const { kv } = createMemoryKV(); + env = { GITHUB_WEBHOOK_SECRET: "s", KV: kv, DB: d1.db, ADMIN_USER_IDS: "1" }; + resetConfigStore(kv); + initConfigStore(env); + await createGroup(kv, group("alpha", "alice")); + await createGroup( + kv, + group("beta", "bob", { + members: [ + { login: "bob", role: "owner" }, + { login: "alice", role: "viewer" }, + ], + }), + ); +}); + +describe("delivery targets", () => { + it("never lets a tenant aim its routes at a channel another group delivers to", async () => { + await saveGroupRoutes(env.KV, "beta", [ + route("b1", { groupId: "beta", targets: [{ platform: "discord", channelId: "beta-ch" }] }), + ]); + const alice = await cookieFor("2", "alice"); + const hijack = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1", { targets: [{ platform: "discord", channelId: "beta-ch" }] })], + }); + await adminGroupRoutesPut(hijack, "alpha"); + expect(responseStatus(hijack)).toBe(403); + // Nor through another spelling of the same channel (a URL path alias). + const alias = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1", { targets: [{ platform: "discord", channelId: "x/../beta-ch" }] })], + }); + await adminGroupRoutesPut(alias, "alpha"); + expect(responseStatus(alias)).toBe(400); + for (const target of [ + { platform: "telegram", chatId: "-0100" }, + // Wraps around to an existing chat in Telegram's 64-bit parsing. + { platform: "telegram", chatId: "-18446744073709652393" }, + { platform: "discord", channelId: "0123" }, + ]) { + const padded = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1", { targets: [target as never] })], + }); + await adminGroupRoutesPut(padded, "alpha"); + expect(responseStatus(padded)).toBe(400); + } + const username = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1", { targets: [{ platform: "telegram", chatId: "@beta_channel" }] })], + }); + await adminGroupRoutesPut(username, "alpha"); + expect(responseStatus(username)).toBe(400); + // A channel nobody else uses is fine; so is one the writer also manages. + const own = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1", { targets: [{ platform: "discord", channelId: "alpha-ch" }] })], + }); + await adminGroupRoutesPut(own, "alpha"); + expect(responseStatus(own)).toBe(200); + const root = await cookieFor("1", "root"); + const shared = call("/admin/api/groups/alpha/routes", root, "PUT", { + routes: [route("a1", { targets: [{ platform: "discord", channelId: "beta-ch" }] })], + }); + await adminGroupRoutesPut(shared, "alpha"); + expect(responseStatus(shared)).toBe(200); + }); +}); + +describe("shared and aliased targets", () => { + it("compares a stored Telegram @username by the chat id it names", async () => { + env.TELEGRAM_TOKEN = "bot"; + // Stored before only numeric ids were accepted. + await saveGroupRoutes(env.KV, "beta", [ + route("b1", { groupId: "beta", targets: [{ platform: "telegram", chatId: "@beta_chat" }] }), + ]); + const realFetch = globalThis.fetch; + globalThis.fetch = (async (input: unknown) => { + expect(String(input)).toContain("getChat?chat_id=%40beta_chat"); + return new Response(JSON.stringify({ ok: true, result: { id: -100777 } }), { status: 200 }); + }) as unknown as typeof fetch; + try { + const alice = await cookieFor("2", "alice"); + const same = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1", { targets: [{ platform: "telegram", chatId: "-100777" }] })], + }); + await adminGroupRoutesPut(same, "alpha"); + expect(responseStatus(same)).toBe(403); + } finally { + globalThis.fetch = realFetch; + } + }); + + it("looks up no Telegram usernames for a save without Telegram targets", async () => { + env.TELEGRAM_TOKEN = "bot"; + await saveGroupRoutes(env.KV, "beta", [ + route("b1", { groupId: "beta", targets: [{ platform: "telegram", chatId: "@beta_chat" }] }), + ]); + let lookups = 0; + const realFetch = globalThis.fetch; + globalThis.fetch = (async () => { + lookups++; + return new Response(JSON.stringify({ ok: true, result: { id: -100777 } }), { status: 200 }); + }) as unknown as typeof fetch; + try { + const alice = await cookieFor("2", "alice"); + const discord = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1", { targets: [{ platform: "discord", channelId: "alpha-ch" }] })], + }); + await adminGroupRoutesPut(discord, "alpha"); + expect(responseStatus(discord)).toBe(200); + } finally { + globalThis.fetch = realFetch; + } + expect(lookups).toBe(0); + }); + + it("keeps a channel shared from older data only where it already was", async () => { + const shared = [{ platform: "discord" as const, channelId: "shared-ch" }]; + await saveGroupRoutes(env.KV, "alpha", [route("a1", { groupId: "alpha", targets: shared })]); + await saveGroupRoutes(env.KV, "beta", [route("b1", { groupId: "beta", targets: shared })]); + const alice = await cookieFor("2", "alice"); + // Unchanged: fine. + const same = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1", { targets: shared })], + }); + await adminGroupRoutesPut(same, "alpha"); + expect(responseStatus(same)).toBe(200); + // Another topic/thread of the shared channel on the same route: refused. + const thread = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [ + route("a1", { + targets: [...shared, { platform: "discord", channelId: "shared-ch", threadId: "t2" }], + }), + ], + }); + await adminGroupRoutesPut(thread, "alpha"); + expect(responseStatus(thread)).toBe(403); + // A new route sending more into the shared channel: refused. + const more = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1", { targets: shared }), route("a2", { targets: shared })], + }); + await adminGroupRoutesPut(more, "alpha"); + expect(responseStatus(more)).toBe(403); + }); +}); + +describe("webhook secrets", () => { + it("keeps the secret with the group, re-checked at commit and never sent to clients", async () => { + const { rotateTenantSecret, getTenantSecret } = await import("../server/lib/web/tenants"); + const alice = await cookieFor("2", "alice"); + const rotate = call("/admin/api/groups/alpha/webhook/regenerate", alice, "POST"); + const { secret } = (await adminGroupWebhookRegenerate(rotate, "alpha")) as { secret: string }; + expect(secret).toMatch(/^[0-9a-f]{64}$/); + const stored = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "alpha")!; + expect(await getTenantSecret(env.KV, stored)).toBe(secret); + // Never in what clients read. + const listed = await adminApiGroupsGet(call("/admin/api/groups", alice)); + expect(JSON.stringify(listed)).not.toContain(secret); + // A rotation whose writer lost the right meanwhile changes nothing. + await expect( + rotateTenantSecret(env.KV, "alpha", () => { + throw new Error("no longer an owner"); + }), + ).rejects.toThrow(); + const after = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "alpha")!; + expect(after.webhookSecret).toBe(secret); + // A plain group edit keeps it. + await updateGroup(env.KV, "alpha", (g) => ({ + ...g, + name: "Renamed", + webhookSecret: undefined, + })); + const edited = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "alpha")!; + expect(edited.webhookSecret).toBe(secret); + }); + + it("creates groups with their members bound to their accounts", async () => { + await saveToken(env.KV, "1", "root-token", 3600); + const realFetch = globalThis.fetch; + globalThis.fetch = (async () => + new Response(JSON.stringify({ id: 77, login: "bob" }), { + status: 200, + })) as unknown as typeof fetch; + try { + const root = await cookieFor("1", "root"); + const create = call("/admin/api/groups", root, "POST", { group: group("delta", "bob") }); + await adminGroupCreate(create); + expect(responseStatus(create)).toBe(200); + } finally { + globalThis.fetch = realFetch; + } + const delta = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "delta")!; + expect(delta.members).toEqual([{ login: "bob", role: "owner", userId: "77" }]); + }); +}); + +describe("sources and links", () => { + it("accepts and keeps the custom source restriction", async () => { + const alice = await cookieFor("2", "alice"); + const listed = (await adminApiGroupsGet(call("/admin/api/groups", alice))) as { + groups: Group[]; + }; + const alpha = listed.groups.find((g) => g.id === "alpha")!; + const save = call("/admin/api/groups/alpha", alice, "PUT", { + group: { ...alpha, providers: ["github", "custom"] }, + }); + await adminGroupUpdate(save, "alpha"); + expect(responseStatus(save)).toBe(200); + const stored = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "alpha")!; + expect(stored.providers).toEqual(["github", "custom"]); + }); + + it("uses an account-link confirmation once", async () => { + const { handleLinkConfirm } = await import("../server/lib/web/oauth"); + const nonce = "0123456789abcdef0123456789abcdef"; + const link = JSON.stringify({ + platform: "discord", + userId: "d1", + githubUserId: "42", + login: "alice", + }); + await env.KV.put(`link:${nonce}`, link); + const confirm = (): H3Event => + makeEvent("/auth/github/link", { + method: "POST", + headers: { "content-type": "application/json" }, + body: JSON.stringify({ nonce }), + env, + }); + await handleLinkConfirm(confirm()); + // Replayed later (a stale KV copy elsewhere still has the confirmation). + await env.KV.put(`link:${nonce}`, link); + const again = confirm(); + await handleLinkConfirm(again); + expect(responseStatus(again)).toBe(400); + }); +}); + +describe("repairing unreadable routes", () => { + it("lets an admin explicitly replace a group whose stored route cannot be read", async () => { + await saveGroupRoutes(env.KV, "alpha", [route("broken", { groupId: "alpha" })]); + sqlite.exec("UPDATE d1_routes SET targets = '{oops' WHERE id = 'broken'"); + const alice = await cookieFor("2", "alice"); + const shown = (await adminGroupRoutesGet( + call("/admin/api/groups/alpha/routes", alice), + "alpha", + )) as { unreadable: boolean }; + expect(shown.unreadable).toBe(true); + // A plain save is refused (the unseen row would be lost)... + const plain = call("/admin/api/groups/alpha/routes", alice, "PUT", { routes: [route("a1")] }); + await adminGroupRoutesPut(plain, "alpha"); + expect(responseStatus(plain)).not.toBe(200); + // ...an explicit repair goes through. + const repair = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1")], + discardUnreadable: true, + }); + await adminGroupRoutesPut(repair, "alpha"); + expect(responseStatus(repair)).toBe(200); + expect(sqlite.query("SELECT id FROM d1_routes WHERE group_id = 'alpha'").all()).toEqual([ + { id: "a1" }, + ]); + }); +}); + +describe("authorization at commit time", () => { + it("refuses a route write by someone removed from the group meanwhile", async () => { + const alice = await cookieFor("2", "alice"); + const write = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1", { targets: [{ platform: "discord", channelId: "fresh" }] })], + }); + // Authorized now (the request's access check runs and is kept)... + const { requireAnyAccess } = await import("../server/lib/web/auth"); + await requireAnyAccess(write); + // ...but an owner removes alice before the write lands. + await updateGroup(env.KV, "alpha", (g) => ({ + ...g, + members: [{ login: "carol", role: "owner" }], + adminIds: ["carol"], + })); + // The write itself re-checks the role at commit. + await expect( + saveGroupRoutes(env.KV, "alpha", [route("a1", { groupId: "alpha" })], { + guards: roleGuard(write, "alpha", "admin"), + }), + ).rejects.toBeInstanceOf(ConfigConflictError); + expect((await loadRoutes(env.KV, { fresh: true })).some((r) => r.id === "a1")).toBe(false); + }); + + it("voids an invite whose issuing owner was removed before it was used", async () => { + const owner = await cookieFor("2", "alice"); + const created = (await adminGroupInvitesPost( + call("/admin/api/groups/alpha/invites", owner, "POST", { role: "admin" }), + "alpha", + )) as { token: string }; + await updateGroup(env.KV, "alpha", (g) => ({ + ...g, + members: [{ login: "carol", role: "owner" }], + adminIds: ["carol"], + })); + expect(await acceptInvite(env, created.token, "9", "mallory")).toEqual({ + ok: false, + reason: "invalid", + }); + }); + + it("refuses a filter node that mixes condition kinds", async () => { + const alice = await cookieFor("2", "alice"); + const mixed = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [route("a1", { ast: { all: 0, any: [{ type: "event", match: "push" }] } as never })], + }); + await adminGroupRoutesPut(mixed, "alpha"); + expect(responseStatus(mixed)).toBe(400); + }); + + it("refuses a glob longer than the matcher can run", async () => { + const alice = await cookieFor("2", "alice"); + const long = call("/admin/api/groups/alpha/routes", alice, "PUT", { + routes: [ + route("a1", { filters: [{ type: "branch", match: `${"a".repeat(201)}*`, exclude: true }] }), + ], + }); + await adminGroupRoutesPut(long, "alpha"); + expect(responseStatus(long)).toBe(400); + }); + + it("never accepts an invite revoked after it was read", async () => { + const owner = await cookieFor("2", "alice"); + const created = (await adminGroupInvitesPost( + call("/admin/api/groups/alpha/invites", owner, "POST", { role: "admin" }), + "alpha", + )) as { token: string }; + const { revokeInvite } = await import("../server/lib/web/invites"); + // Revoked with its D1 record; the KV copy another isolate may still read + // is put back to stand for that stale read. + const raw = await env.KV.get(`invite:${created.token}`); + await revokeInvite(env.KV, created.token, env.DB); + await env.KV.put(`invite:${created.token}`, raw!); + expect(await acceptInvite(env, created.token, "9", "mallory")).toEqual({ + ok: false, + reason: "invalid", + }); + }); +}); + +describe("delivery target claims at commit time", () => { + it("aborts a write whose new channel another group took meanwhile", async () => { + // The pre-check passed; then beta committed a route and a log target. + await saveGroupRoutes(env.KV, "beta", [ + route("b1", { groupId: "beta", targets: [{ platform: "telegram", chatId: "-100" }] }), + ]); + await updateGroup(env.KV, "beta", (g) => ({ + ...g, + logTarget: { platform: "discord", channelId: "log-ch" }, + })); + for (const channel of ["telegram:-100", "discord:log-ch"]) { + await expect( + saveGroupRoutes(env.KV, "alpha", [route("a1", { groupId: "alpha" })], { + guards: (db) => [channelFreeGuard(db, channel, ["alpha"])], + }), + ).rejects.toBeInstanceOf(ConfigConflictError); + } + // Same platform id on another platform, or a group the writer may edit: free. + await saveGroupRoutes(env.KV, "alpha", [route("a1", { groupId: "alpha" })], { + guards: (db) => [ + channelFreeGuard(db, "discord:-100", ["alpha"]), + channelFreeGuard(db, "telegram:-100", ["alpha", "beta"]), + ], + }); + expect((await loadRoutes(env.KV, { fresh: true })).some((r) => r.id === "a1")).toBe(true); + }); +}); + +describe("member binding", () => { + it("binds a member added by login to the account holding it now", async () => { + await saveToken(env.KV, "2", "alice-token", 3600); + const realFetch = globalThis.fetch; + globalThis.fetch = (async (input: unknown) => { + expect(String(input)).toBe("https://api.github.com/users/bob"); + return new Response(JSON.stringify({ id: 99, login: "bob" }), { status: 200 }); + }) as unknown as typeof fetch; + try { + const cookie = await cookieFor("2", "alice"); + const listed = (await adminApiGroupsGet(call("/admin/api/groups", cookie))) as { + groups: Group[]; + }; + const alpha = listed.groups.find((g) => g.id === "alpha")!; + const event = call("/admin/api/groups/alpha", cookie, "PUT", { + group: { ...alpha, members: [...alpha.members!, { login: "bob", role: "viewer" }] }, + }); + await adminGroupUpdate(event, "alpha"); + expect(responseStatus(event)).toBe(200); + } finally { + globalThis.fetch = realFetch; + } + const stored = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "alpha")!; + expect(stored.members).toContainEqual({ login: "bob", role: "viewer", userId: "99" }); + }); +}); + +describe("group writes", () => { + it("an owner of one group can update it while viewing another", async () => { + const cookie = await cookieFor("2", "alice"); + const listed = (await adminApiGroupsGet(call("/admin/api/groups", cookie))) as { + groups: Group[]; + }; + const alpha = listed.groups.find((g) => g.id === "alpha")!; + const event = call("/admin/api/groups/alpha", cookie, "PUT", { + group: { ...alpha, name: "Alpha!" }, + }); + await adminGroupUpdate(event, "alpha"); + expect(responseStatus(event)).toBe(200); + expect((await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "alpha")!.name).toBe( + "Alpha!", + ); + + // The legacy bulk API accepts the visible-but-not-owned group unchanged. + const again = (await adminApiGroupsGet(call("/admin/api/groups", cookie))) as { + groups: Group[]; + }; + const bulk = call("/admin/api/groups", cookie, "PUT", { groups: again.groups }); + await adminApiGroupsPut(bulk); + expect(responseStatus(bulk)).toBe(200); + }); + + it("refuses an update built on a stale copy", async () => { + const cookie = await cookieFor("2", "alice"); + const listed = (await adminApiGroupsGet(call("/admin/api/groups", cookie))) as { + groups: Group[]; + }; + const alpha = listed.groups.find((g) => g.id === "alpha")!; + const first = call("/admin/api/groups/alpha", cookie, "PUT", { + group: { ...alpha, name: "first" }, + }); + await adminGroupUpdate(first, "alpha"); + const second = call("/admin/api/groups/alpha", cookie, "PUT", { + group: { ...alpha, lang: "zh" }, + }); + await adminGroupUpdate(second, "alpha"); + expect(responseStatus(second)).toBe(409); + const stored = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "alpha")!; + expect(stored.name).toBe("first"); + expect(stored.lang).toBeUndefined(); + }); + + it("owners cannot change the source-isolation fields", async () => { + await createGroup(env.KV, group("u-2", "alice", { isolated: true, installationId: 5 })); + const cookie = await cookieFor("2", "alice"); + const event = call("/admin/api/groups/u-2", cookie, "PUT", { + group: { ...group("u-2", "alice"), owners: [], isolated: false, installationId: 99 }, + }); + await adminGroupUpdate(event, "u-2"); + const stored = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "u-2")!; + expect(stored.isolated).toBe(true); + expect(stored.installationId).toBe(5); + }); + + it("a stale bulk save no longer reverts or drops another group", async () => { + const admin = await cookieFor("1", "root"); + const snapshot = (await adminApiGroupsGet(call("/admin/api/groups", admin))) as { + groups: Group[]; + }; + // Someone else edits beta and creates gamma afterwards. + const bob = await cookieFor("3", "bob"); + const beta = snapshot.groups.find((g) => g.id === "beta")!; + await adminGroupUpdate( + call("/admin/api/groups/beta", bob, "PUT", { group: { ...beta, name: "Beta v2" } }), + "beta", + ); + // The super admin saves an alpha change from the old snapshot (old beta). + const edited = snapshot.groups.map((g) => (g.id === "alpha" ? { ...g, lang: "zh" } : g)); + const bulk = call("/admin/api/groups", admin, "PUT", { groups: edited }); + await adminApiGroupsPut(bulk); + expect(responseStatus(bulk)).toBe(200); + const stored = await loadGroups(env.KV, { fresh: true }); + expect(stored.find((g) => g.id === "alpha")!.lang).toBe("zh"); + // beta came back unedited from the old snapshot: bob's change survives. + expect(stored.find((g) => g.id === "beta")!.name).toBe("Beta v2"); + }); + + it("a bulk save based on an outdated list is refused", async () => { + const admin = await cookieFor("1", "root"); + const snapshot = (await adminApiGroupsGet(call("/admin/api/groups", admin))) as { + groups: Group[]; + revision: string; + }; + await adminGroupCreate( + call("/admin/api/groups", admin, "POST", { group: group("gamma", "carol") }), + ); + const bulk = call("/admin/api/groups", admin, "PUT", { + groups: snapshot.groups, + revision: snapshot.revision, + }); + await adminApiGroupsPut(bulk); + expect(responseStatus(bulk)).toBe(409); + expect((await loadGroups(env.KV, { fresh: true })).map((g) => g.id)).toContain("gamma"); + }); + + it("never deletes what was added to a group after its deletion was confirmed", async () => { + const cookie = await cookieFor("2", "alice"); + const shown = (await adminGroupRoutesGet( + call("/admin/api/groups/alpha/routes", cookie), + "alpha", + )) as { revision: string; version: number }; + const groups = (await adminApiGroupsGet(call("/admin/api/groups", cookie))) as { + groups: Array<{ id: string; revision: string }>; + }; + const rev = groups.groups.find((g) => g.id === "alpha")!.revision; + // A filter fragment saved meanwhile (the routes are unchanged). + const frag = call("/admin/api/groups/alpha/fragments", cookie, "PUT", { + fragments: [{ id: "f1", name: "F", node: { type: "event", match: "push" } }], + }); + await adminGroupFragmentsPut(frag, "alpha"); + expect(responseStatus(frag)).toBe(200); + const del = call( + `/admin/api/groups/alpha?revision=${rev}&routesRevision=${shown.revision}&version=${shown.version}`, + cookie, + "DELETE", + ); + await adminGroupDelete(del, "alpha"); + expect(responseStatus(del)).toBe(409); + }); + + it("deleting a group detaches its history and retires its id", async () => { + sqlite.exec( + "INSERT INTO send_logs (ts, route_id, group_id, event, target, ok) VALUES (1, 'r', 'alpha', 'push', 't', 1)", + ); + const cookie = await cookieFor("2", "alice"); + // Confirmed on the group and its routes as shown. + const shown = (await adminGroupRoutesGet( + call("/admin/api/groups/alpha/routes", cookie), + "alpha", + )) as { revision: string; version: number }; + const groups = (await adminApiGroupsGet(call("/admin/api/groups", cookie))) as { + groups: Array<{ id: string; revision: string }>; + }; + const rev = groups.groups.find((g) => g.id === "alpha")!.revision; + const del = call( + `/admin/api/groups/alpha?revision=${rev}&routesRevision=${shown.revision}&version=${shown.version}`, + cookie, + "DELETE", + ); + await adminGroupDelete(del, "alpha"); + expect(responseStatus(del)).toBe(200); + expect(sqlite.query("SELECT group_id FROM send_logs").get()).toEqual({ group_id: null }); + + const admin = await cookieFor("1", "root"); + const recreate = call("/admin/api/groups", admin, "POST", { group: group("alpha", "eve") }); + await adminGroupCreate(recreate); + expect(responseStatus(recreate)).toBe(409); + }); + + it("renaming moves routes and history in one go", async () => { + sqlite.exec( + "INSERT INTO send_logs (ts, route_id, group_id, event, target, ok) VALUES (1, 'r', 'alpha', 'push', 't', 1)", + ); + const cookie = await cookieFor("2", "alice"); + await adminGroupRoutesPut( + call("/admin/api/groups/alpha/routes", cookie, "PUT", { routes: [route("r1")] }), + "alpha", + ); + const event = call("/admin/api/groups/alpha/rename", cookie, "PUT", { newId: "omega" }); + await adminGroupRename(event, "alpha"); + expect(responseStatus(event)).toBe(200); + expect((await loadRoutes(env.KV, { fresh: true })).map((r) => r.groupId)).toEqual(["omega"]); + expect(sqlite.query("SELECT group_id FROM send_logs").get()).toEqual({ group_id: "omega" }); + expect(await resolveGroupAlias(env, "alpha")).toBe("omega"); + }); +}); + +describe("route writes", () => { + it("refuses a save built on routes changed meanwhile", async () => { + const cookie = await cookieFor("2", "alice"); + const loaded = (await adminGroupRoutesGet( + call("/admin/api/groups/alpha/routes", cookie), + "alpha", + )) as { revision: string }; + const first = call("/admin/api/groups/alpha/routes", cookie, "PUT", { + routes: [route("a")], + revision: loaded.revision, + }); + const saved = (await adminGroupRoutesPut(first, "alpha")) as { revision: string }; + expect(responseStatus(first)).toBe(200); + const stale = call("/admin/api/groups/alpha/routes", cookie, "PUT", { + routes: [route("b")], + revision: loaded.revision, + }); + await adminGroupRoutesPut(stale, "alpha"); + expect(responseStatus(stale)).toBe(409); + const fresh = call("/admin/api/groups/alpha/routes", cookie, "PUT", { + routes: [route("a"), route("b")], + revision: saved.revision, + }); + await adminGroupRoutesPut(fresh, "alpha"); + expect(responseStatus(fresh)).toBe(200); + }); + + it("rejects regexes RE2 cannot run and non-snowflake role ids", async () => { + const cookie = await cookieFor("2", "alice"); + const backref = call("/admin/api/groups/alpha/routes", cookie, "PUT", { + routes: [route("x", { filters: [{ type: "keyword", match: "/(a)\\1/" }] })], + }); + await adminGroupRoutesPut(backref, "alpha"); + expect(responseStatus(backref)).toBe(400); + const mention = call("/admin/api/groups/alpha/routes", cookie, "PUT", { + routes: [route("x", { discordRoleIds: ["1> @everyone <@&2"] })], + }); + await adminGroupRoutesPut(mention, "alpha"); + expect(responseStatus(mention)).toBe(400); + }); +}); + +describe("fragment writes", () => { + it("replaces only the group's own fragments and detects stale saves", async () => { + sqlite.exec( + "INSERT INTO d1_fragments (id, group_id, name, node, created_at, updated_at) VALUES ('keep', 'beta', 'K', '{\"type\":\"event\",\"match\":\"push\"}', 1, 1)", + ); + const cookie = await cookieFor("2", "alice"); + const loaded = (await adminGroupFragmentsGet( + call("/admin/api/groups/alpha/fragments", cookie), + "alpha", + )) as { revision: string }; + const node = { type: "event", match: "push" }; + const save = call("/admin/api/groups/alpha/fragments", cookie, "PUT", { + fragments: [{ id: "f1", name: "F1", node }], + revision: loaded.revision, + }); + await adminGroupFragmentsPut(save, "alpha"); + expect(responseStatus(save)).toBe(200); + const stale = call("/admin/api/groups/alpha/fragments", cookie, "PUT", { + fragments: [], + revision: loaded.revision, + }); + await adminGroupFragmentsPut(stale, "alpha"); + expect(responseStatus(stale)).toBe(409); + expect(sqlite.query("SELECT group_id, id FROM d1_fragments ORDER BY group_id").all()).toEqual([ + { group_id: "alpha", id: "f1" }, + { group_id: "beta", id: "keep" }, + ]); + }); +}); + +describe("token rotation", () => { + it("stops an old token from authenticating after re-authorization", async () => { + await saveToken(env.KV, "42", "old-token", 3600); + expect(await findUserIdByToken(env.KV, "old-token")).toBe("42"); + await saveToken(env.KV, "42", "new-token", 3600); + expect(await findUserIdByToken(env.KV, "old-token")).toBeNull(); + expect(await findUserIdByToken(env.KV, "new-token")).toBe("42"); + }); + + it("rejects a token whose reverse key outlived its replacement", async () => { + await saveToken(env.KV, "42", "old-token", 3600); + const reverse = [...(await env.KV.list({ prefix: "token-reverse:" })).keys][0]!.name; + const value = await env.KV.get(reverse); + await saveToken(env.KV, "42", "new-token", 3600); + await env.KV.put(reverse, value!); + expect(await findUserIdByToken(env.KV, "old-token")).toBeNull(); + }); +}); + +describe("reserved and squatted installation ids", () => { + it("does not let owners rename into the system id space", async () => { + const cookie = await cookieFor("2", "alice"); + const event = call("/admin/api/groups/alpha/rename", cookie, "PUT", { newId: "inst-555" }); + await adminGroupRename(event, "alpha"); + expect(responseStatus(event)).toBe(400); + }); + + it("never binds an installation to an unbound group that merely has its name", async () => { + await createGroup(env.KV, group("inst-777", "mallory")); + const bound = await ensureInstallationGroup(env.KV, 777, "victim-org"); + expect(bound).toBeNull(); + const stored = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "inst-777")!; + expect(stored.installationId).toBeUndefined(); + }); +}); + +describe("round-2 regressions", () => { + it("keeps a legacy personal group isolated when it is renamed", async () => { + sqlite.exec( + `INSERT INTO d1_groups (id, name, data, version, created_at, updated_at) VALUES ('u-42', 'me', '{"id":"u-42","name":"me","adminIds":["alice"],"members":[{"login":"alice","role":"owner"}]}', 1, 0, 0)`, + ); + const cookie = await cookieFor("2", "alice"); + const event = call("/admin/api/groups/u-42/rename", cookie, "PUT", { newId: "team" }); + await adminGroupRename(event, "u-42"); + expect(responseStatus(event)).toBe(200); + const team = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "team")!; + expect(team.isolated).toBe(true); + }); + + it("never lets an old invite join a group re-created under the same id", async () => { + const owner = await cookieFor("2", "alice"); + const created = (await adminGroupInvitesPost( + call("/admin/api/groups/alpha/invites", owner, "POST", { role: "admin" }), + "alpha", + )) as { token: string }; + await deleteAs(owner, "alpha"); + // The invite's KV record survived (as if its cleanup had failed). + await env.KV.put( + `invite:${created.token}`, + JSON.stringify({ + groupId: "alpha", + role: "admin", + expiresAt: Date.now() + 86400_000, + createdBy: "alice", + groupInstance: "gone", + }), + ); + sqlite.exec("DELETE FROM dedup_keys"); + await createGroup(env.KV, group("alpha", "eve")); + const result = await acceptInvite(env, created.token, "9", "mallory"); + expect(result).toEqual({ ok: false, reason: "invalid" }); + }); + + it("never lets a second person in on an invite whose first use committed unseen", async () => { + const owner = await cookieFor("2", "alice"); + const created = (await adminGroupInvitesPost( + call("/admin/api/groups/alpha/invites", owner, "POST", { role: "admin" }), + "alpha", + )) as { token: string }; + // The first acceptance committed, but its answer was lost: its claim was + // given back while the "used" record stayed. + sqlite.exec( + `INSERT INTO dedup_keys (key, claimed_at, expires_at) VALUES ('accepted:invite-used:${created.token}', 0, ${Date.now() + 86400_000})`, + ); + expect(await acceptInvite(env, created.token, "9", "mallory")).toEqual({ + ok: false, + reason: "invalid", + }); + const alpha = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "alpha")!; + expect(alpha.members!.some((m) => m.login === "mallory")).toBe(false); + }); + + it("never records an invite as used by a member write that changed nothing", async () => { + // What the "used" record is conditioned on: the write right before it. + await env.DB.batch([ + env.DB.prepare( + "UPDATE d1_groups SET version = version + 1 WHERE id = ? AND version = ?", + ).bind("alpha", -1), + env.DB.prepare( + "INSERT INTO dedup_keys (key, claimed_at, expires_at) SELECT 'probe', 0, 1 WHERE changes() > 0", + ), + ]); + expect(sqlite.query("SELECT COUNT(*) AS n FROM dedup_keys WHERE key = 'probe'").get()).toEqual({ + n: 0, + }); + }); + + it("confirms the invite as used in the transaction that adds the member", async () => { + const owner = await cookieFor("2", "alice"); + const created = (await adminGroupInvitesPost( + call("/admin/api/groups/alpha/invites", owner, "POST", { role: "viewer" }), + "alpha", + )) as { token: string }; + const result = await acceptInvite(env, created.token, "9", "mallory"); + expect(result).toMatchObject({ ok: true, groupId: "alpha" }); + expect( + sqlite + .query("SELECT COUNT(*) AS n FROM dedup_keys WHERE key = ?") + .get(`accepted:invite-used:${created.token}`), + ).toEqual({ n: 1 }); + }); +}); + +describe("deletion confirmed on a former group", () => { + it("never deletes a later group that reused the id, however alike", async () => { + const owner = await cookieFor("2", "alice"); + const routes = (await adminGroupRoutesGet( + call("/admin/api/groups/alpha/routes", owner), + "alpha", + )) as { revision: string; version: number }; + const listed = (await adminApiGroupsGet(call("/admin/api/groups", owner))) as { + groups: Array<{ id: string; revision: string }>; + }; + const rev = listed.groups.find((g) => g.id === "alpha")!.revision; + await deleteAs(owner, "alpha"); + // Past the retirement: the id is taken again, by a group alike in every + // field the console shows (and at the same version). + sqlite.exec("DELETE FROM dedup_keys"); + await createGroup(env.KV, group("alpha", "alice")); + const del = call( + `/admin/api/groups/alpha?revision=${rev}&routesRevision=${routes.revision}&version=${routes.version}`, + owner, + "DELETE", + ); + await adminGroupDelete(del, "alpha"); + expect(responseStatus(del)).toBe(409); + expect((await loadGroups(env.KV, { fresh: true })).some((g) => g.id === "alpha")).toBe(true); + }); +}); + +describe("bulk deletion and unreadable fragments", () => { + it("never deletes a group whose fragments cannot be read", async () => { + sqlite.exec( + `INSERT INTO d1_fragments (id, group_id, name, node, created_at, updated_at) VALUES ('f', 'alpha', 'f', '{', 0, 0)`, + ); + const owner = await cookieFor("2", "alice"); + const listed = (await adminApiGroupsGet(call("/admin/api/groups", owner))) as { + groups: Array; + revision: string; + }; + const event = call("/admin/api/groups", owner, "PUT", { + groups: listed.groups.filter((g) => g.id !== "alpha"), + revision: listed.revision, + }); + await adminApiGroupsPut(event); + expect(responseStatus(event)).toBe(409); + expect((await loadGroups(env.KV, { fresh: true })).some((g) => g.id === "alpha")).toBe(true); + }); +}); + +describe("invite revocation at commit time", () => { + it("refuses a revocation whose owner was removed before it committed", async () => { + const owner = await cookieFor("2", "alice"); + const created = (await adminGroupInvitesPost( + call("/admin/api/groups/alpha/invites", owner, "POST", { role: "admin" }), + "alpha", + )) as { token: string }; + // Alice is removed while her request is under way (after its checks). + const kvGet = env.KV.get.bind(env.KV); + let reads = 0; + env.KV.get = (async (key: string, ...rest: unknown[]) => { + if (key === `invite:${created.token}` && ++reads === 2) { + sqlite.exec( + `UPDATE d1_groups SET data = json_set(data, '$.members', json('[{"login":"bob","role":"owner"}]'), '$.adminIds', json('["bob"]')) WHERE id = 'alpha'`, + ); + } + return (kvGet as (...a: unknown[]) => Promise)(key, ...rest); + }) as KVNamespace["get"]; + const del = call(`/admin/api/invites/${created.token}`, owner, "DELETE"); + await adminInviteDelete(del, created.token); + env.KV.get = kvGet; + expect(responseStatus(del)).toBe(403); + expect(await getInvite(env.KV, created.token)).not.toBeNull(); + }); +}); diff --git a/tests/identity-and-claims.test.ts b/tests/identity-and-claims.test.ts new file mode 100644 index 0000000..7e29bc9 --- /dev/null +++ b/tests/identity-and-claims.test.ts @@ -0,0 +1,229 @@ +import { describe, it, expect } from "bun:test"; +import { isAdminUser } from "../server/lib/web/session"; +import { createAdminSession, adminCookie } from "../server/lib/web/session"; +import { + bindMemberIds, + carryMemberIds, + loadGroups, + memberRole, + saveGroups, +} from "../server/lib/web/groups"; +import { adminApiGroupsGet, adminGroupDelete, adminGroupRoutesGet } from "../server/lib/web/admin"; +import { saveGroupRoutes, resetConfigStore } from "../server/lib/config"; +import { createInvite, listInvites } from "../server/lib/web/invites"; +import { + claimOnce, + confirmClaim, + deliveryKey, + idempotencyStore, +} from "../server/lib/lib/idempotency"; +import { handleTelegramUpdate } from "../server/lib/drivers/telegram/commands"; +import { kvFallbackActive, noteKvFallback } from "../server/lib/storage/d1"; +import { d1ConfigStore } from "../server/lib/storage/config-store"; +import { makeEvent, responseStatus } from "./helpers"; +import { createMemoryKV, createSqliteD1 } from "./d1-sqlite"; +import type { Env, Group, Route } from "../server/lib/types"; + +const route = (id: string, groupId: string): Route => ({ + id, + name: id, + enabled: true, + filters: [{ type: "event", match: "push" }], + targets: [{ platform: "discord", channelId: "c1" }], + groupId, +}); + +describe("member identity", () => { + it("never matches one configured string both as a user id and as a login", () => { + const env = { ADMIN_USER_IDS: "123, alice" } as Env; + // User id 123 is the admin; a different account whose login is "123" is not. + expect(isAdminUser(env, "123", "someone")).toBe(true); + expect(isAdminUser(env, "999", "123")).toBe(false); + expect(isAdminUser(env, "5", "ALICE")).toBe(true); + }); + + it("matches a bound member by user id only, so a reclaimed login inherits nothing", () => { + const group: Group = { + id: "g", + name: "G", + adminIds: [], + members: [{ login: "alice", role: "owner", userId: "42" }], + }; + expect(memberRole(group, "42", "alice-renamed")).toBe("owner"); + // Someone who took over the old login after a rename. + expect(memberRole(group, "77", "alice")).toBeUndefined(); + }); + + it("binds a member's user id on sign-in and keeps it across member edits", async () => { + const { kv } = createMemoryKV(); + resetConfigStore(kv); + await saveGroups(kv, [ + { + id: "g", + name: "G", + adminIds: [], + members: [ + { login: "alice", role: "owner" }, + { login: "bob", role: "viewer" }, + ], + }, + ]); + await bindMemberIds(kv, await loadGroups(kv, { fresh: true }), "42", "Alice"); + const stored = (await loadGroups(kv, { fresh: true }))[0]!; + expect(stored.members).toEqual([ + { login: "alice", role: "owner", userId: "42" }, + { login: "bob", role: "viewer" }, + ]); + // A client edit (which never carries ids) keeps the binding. + const edited = carryMemberIds( + { + ...stored, + members: [ + { login: "alice", role: "owner" }, + { login: "bob", role: "admin" }, + ], + }, + stored, + ); + expect(edited.members![0]).toEqual({ login: "alice", role: "owner", userId: "42" }); + }); +}); + +describe("group deletion", () => { + it("refuses to delete a group whose routes changed after the deletion was confirmed", async () => { + const { kv } = createMemoryKV(); + resetConfigStore(kv); + await saveGroups(kv, [ + { id: "g", name: "G", adminIds: [], members: [{ login: "alice", role: "owner" }] }, + ]); + const env = { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: {} as D1Database } as Env; + const sessionId = await createAdminSession(kv, "42", "alice"); + const headers = { cookie: adminCookie(sessionId) }; + const view = makeEvent("/admin/api/groups/g/routes", { headers, env }); + const { revision } = (await adminGroupRoutesGet(view, "g")) as { revision: string }; + const listed = (await adminApiGroupsGet(makeEvent("/admin/api/groups", { headers, env }))) as { + groups: Array<{ revision: string }>; + }; + const groupRev = listed.groups[0]!.revision; + // Someone adds a route after the owner saw an empty group. + await saveGroupRoutes(kv, "g", [route("r1", "g")]); + const del = makeEvent(`/admin/api/groups/g?revision=${groupRev}&routesRevision=${revision}`, { + method: "DELETE", + headers, + env, + }); + await adminGroupDelete(del, "g"); + expect(responseStatus(del)).toBe(409); + expect((await loadGroups(kv, { fresh: true })).map((g) => g.id)).toEqual(["g"]); + }); +}); + +describe("one-time claims", () => { + it("tells a confirmed run from one left unconfirmed", async () => { + const { kv } = createMemoryKV(); + const store = idempotencyStore({} as D1Database, kv); + expect(await claimOnce(store, "k", 60)).toBe("claimed"); + expect(await claimOnce(store, "k", 60)).toBe("pending"); + await confirmClaim(store, "k", 600); + expect(await claimOnce(store, "k", 60)).toBe("done"); + // A delivery id crafted to look like a confirmation never passes for one. + await confirmClaim(store, deliveryKey("custom", "g", "x#accepted"), 600); + await confirmClaim(store, deliveryKey("custom", "g", "accepted:x"), 600); + expect(await claimOnce(store, deliveryKey("custom", "g", "x"), 60)).toBe("claimed"); + }); + + it("makes Telegram redeliver an update whose earlier run is unconfirmed", async () => { + const { kv } = createMemoryKV(); + const env = { GITHUB_WEBHOOK_SECRET: "", KV: kv, DB: {} as D1Database } as Env; + // An earlier run took the update and could neither finish nor give it back. + await idempotencyStore(env.DB, kv).claim("bot:telegram::7", 300); + const update = { update_id: 7, message: { text: "/gh", chat: { id: 1 } } }; + expect(handleTelegramUpdate(env, update)).rejects.toThrow(); + }); +}); + +describe("invite listing", () => { + it("lists both of two invites whose index writes overwrote each other", async () => { + const { kv } = createMemoryKV(); + const invite = { + groupId: "team", + role: "viewer" as const, + expiresAt: Date.now() + 86400_000, + createdBy: "boss", + }; + const a = await createInvite(kv, invite); + const b = await createInvite(kv, invite); + // The second creation read the index before the first wrote it. + await kv.put("invite:group:team", JSON.stringify([b])); + expect((await listInvites(kv, "team")).map((i) => i.token).sort()).toEqual([a, b].sort()); + }); +}); + +describe("storage fallbacks", () => { + it("retries the KV fallback marker until it is actually stored", async () => { + const { kv, store } = createMemoryKV(); + const put = kv.put.bind(kv); + let failing = true; + kv.put = async (key: string, value: string, opts?: KVNamespacePutOptions): Promise => { + if (failing) throw new Error("KV down"); + return put(key, value, opts); + }; + await expect(noteKvFallback(kv)).rejects.toThrow(); + failing = false; + await noteKvFallback(kv); + expect(Number(store.get("storage:kv-fallback"))).toBeGreaterThan(Date.now()); + expect(await kvFallbackActive(kv)).toBe(true); + }); + + it("remembers KV-only state, so a D1 binding added later still honors it", async () => { + const { kv, store } = createMemoryKV(); + const kvOnly = idempotencyStore({} as D1Database, kv); + expect(await kvOnly.claim("delivery:github:@global:d9", 600)).toBe(true); + expect(store.has("storage:kv-fallback")).toBe(true); + // The deployment gets D1 (tables migrated) in a fresh isolate. + const { db } = createSqliteD1(); + const { kv: sameKv } = { kv: { ...kv } as KVNamespace }; + expect(await idempotencyStore(db, sameKv).claim("delivery:github:@global:d9", 600)).toBe(false); + }); + + it("never re-seeds a configuration another isolate seeded and an admin emptied", async () => { + const { db } = createSqliteD1(); + const { kv, store } = createMemoryKV(); + store.set("config:groups", JSON.stringify([{ id: "legacy", name: "L", adminIds: [] }])); + store.set("config:routes", JSON.stringify([route("r1", "legacy")])); + const first = d1ConfigStore(db, kv); + expect((await first.loadGroups({ fresh: true })).map((g) => g.id)).toEqual(["legacy"]); + await first.deleteGroup("legacy"); + // A second isolate that had already passed the KV marker check. + store.delete("config:d1-seeded"); + const late = d1ConfigStore(db, kv); + expect(await late.loadGroups({ fresh: true })).toEqual([]); + }); + + it("keeps listing invites when the index cannot be read, instead of dropping them", async () => { + const { kv } = createMemoryKV(); + await createInvite(kv, { + groupId: "team", + role: "viewer", + expiresAt: Date.now() + 86400_000, + createdBy: "boss", + }); + const get = kv.get.bind(kv); + kv.get = (async (key: string, type?: never) => { + if (key === "invite:group:team") throw new Error("KV down"); + return get(key, type); + }) as typeof kv.get; + await expect( + createInvite(kv, { + groupId: "team", + role: "viewer", + expiresAt: Date.now() + 86400_000, + createdBy: "boss", + }), + ).rejects.toThrow(); + kv.get = get; + // Neither invite is lost from the list: the half-created one is listed + // through its own marker, so it can still be found and revoked. + expect(await listInvites(kv, "team")).toHaveLength(2); + }); +});