mirror of
https://github.com/Elysola/WebHooker.git
synced 2026-11-20 17:13:49 +00:00
* fix(log): preserve structured error details Error objects lose their useful details when serialized as plain JSON. Keep the message, stack and cause in structured log output. * fix(runtime): bound shared in-flight waits A canceled request can leave its shared promise pending forever. Bound joins and coordinate a single replacement so later requests make progress without multiplying upstream work. * fix(bot): reject oversized callback bodies Reject declared oversized bot callbacks before reading their bodies. This keeps unauthenticated requests from wasting worker resources. * test(d1): exercise real sqlite transactions Exercise real foreign keys, transactions and conditional statements instead of mocks that cannot reproduce lost updates or cascades. * fix(storage): preserve claims across kv fallback Only missing tables justify KV fallback; other failures must surface. Remember fallback writes so migration to D1 cannot forget claims and replay completed work. Share marker checks without extra writes. * fix(filter): use isolated linear-time patterns Backtracking patterns can exhaust worker CPU on untrusted payloads. Use linear-time matching and separate bounded cache namespaces so glob and regex entries cannot corrupt each other. * fix(filter): read each event branch correctly Deployment and check branches live in event-specific nested fields. Read those fields and remove only the actual leading ref prefix. * fix(filter): read only own payload properties Inherited object properties are not webhook payload data. Read own properties only so JSONPath cannot traverse prototypes. * fix(filter): validate executable condition trees Malformed trees and unsupported patterns must not silently turn an exclude rule into a pass. Validate the shape and only the patterns the evaluator actually executes. * fix(i18n): bound and cache translation loads Repeated misses and simultaneous override loads spend KV reads for the same language. Cache confirmed misses and share bounded loads without caching read failures as missing translations. * i18n(bot): explain command and account failures Explain account linking, command failures and skipped delivery outcomes consistently in both supported languages. * fix(github): bound and reuse app token fetches Repeated token exchanges waste requests and JWT work for every event. Reuse valid installation tokens, share refreshes and back off briefly after failures while keeping every shared wait bounded. * fix(github): restrict enrichment request urls Webhook-provided URLs must never receive an installation token on another host. Restrict enrichment to GitHub repository API paths, reject redirects and bound optional requests. * fix(formatter): preserve invalid code points Out-of-range numeric entities can throw while formatting a delivery. Keep invalid code points verbatim instead of aborting the message. * fix(formatter): preserve bounded markdown text Code spans, fences, indentation and autolinks are Markdown content, not HTML tags to strip. Preserve them while bounding cleanup input and reusing results across routes for the same event. * fix(formatter): strip only leading ref prefixes A short branch or tag may itself contain refs/heads or refs/tags. Strip one leading full-ref prefix at the caller and keep short names unchanged when generating labels and links. * fix(gitea): link push authors to their forge A Gitea author is not the same-named GitHub account. Build author profile links from the originating forge. * fix(formatter): render deployment state values The deployment status object stringifies as [object Object]. Render its actual state in the status field. * fix(formatter): read security severity levels The scanner severity is not the security severity of an alert. Prefer the security level so critical and high alerts get the right label and color. * fix(formatter): hide actions on other forges Action buttons call the GitHub API as the linked user. Hide them for other forges to avoid operating on a same-named GitHub repository. * fix(check): isolate updates by check suite Same-named checks from different suites must not edit one message. Include the suite or app identity and retain the former key for controlled adoption of existing tracked messages. * fix(logs): scope queries before limiting results Filter authorized groups in SQL before LIMIT and aggregate only visible rows. Preserve current group attribution for late writes, surface read failures and combine related totals in one scan. * perf(d1): index pruning and failed send queries Pruning and failure views should not scan all historical rows. Index the high-value access paths without adding a write-heavy index for infrequent delivery-detail lookups. * fix(discord): bound individual api requests An unbounded API request can outlive an update-chain lock. Bound each request so another holder cannot race a late edit. * fix(discord): defer long rate-limit waits Long rate-limit sleeps block delivery progress inside a worker. Return a retryable 429 for the queue when the wait exceeds the bound. * fix(discord): encode channel path segments Stored channel and message ids are path segments, not URL paths. Encode them so aliases cannot address another Discord resource. * fix(discord): reuse nonces after lost responses A successful create may lose its response. Reuse a stable nonce with enforce_nonce so retries recover that message instead of posting duplicates or accepting an unreadable success. * fix(discord): constrain embeds and role mentions Respect combined embed and component limits as well as field caps. Restrict allowed mentions to validated route roles so payload text cannot notify everyone. * fix(discord): resume bounded command syncs Application changes, command rollbacks and large guild lists can leave commands stale indefinitely. Track the current hash per app and resume bounded paginated work without needless KV writes. * fix(github): verify installation management An installation id is user-controlled, and repository access is not installation management. Verify the owning account or an active organization admin using the user token and read:org scope. * fix(github): resolve immutable member ids A login can be renamed and reclaimed before its first sign-in. Resolve the current immutable user id when membership is granted so a future holder of the login cannot inherit access. * fix(auth): revoke stale sessions and tokens Revoked or rotated credentials must stop working despite stale KV replicas. Track the live token and revocations in D1 and preserve immutable identity bindings rather than trusting a recycled login. * fix(auth): bind sessions and tokens to identity Automatic retries can repeat non-idempotent user actions. Disable those retries and expose a write hook so bot handlers can record completion immediately before the GitHub write. * fix(discord): defer and deduplicate interactions Acknowledge slow actions before Discord times out and deduplicate interaction writes. Preserve comment text and reject edits whose source changed after the modal opened. * fix(telegram): always verify webhook secrets Webhook verification must not silently disable itself when the optional secret is absent. Derive a stable secret from the bot token and reject callbacks when verification is unavailable. * fix(telegram): bound individual api requests Bound individual platform calls so they cannot outlive the lock protecting a message update or stall a whole delivery invocation. * fix(telegram): honor nested rate-limit delays Telegram places retry_after inside parameters, not at the top level. Read that value and defer long waits to the delivery queue. * fix(telegram): report unreadable send results An unreadable successful response may already have sent the message. Report an explicit uncertain result instead of retrying a create without an idempotency key or pretending it succeeded. * fix(telegram): keep editable messages as text Guessing photo versus text from message content makes later edits use the wrong API and a smaller caption budget. Always send text and use the avatar as a link preview. * fix(telegram): render hard breaks as newlines Telegram HTML does not support br tags. Render Markdown hard breaks as plain newlines so otherwise valid messages are accepted. * fix(telegram): clamp visible html characters Telegram counts visible characters, not HTML source bytes. Truncate without splitting tags, entities or surrogate pairs. * fix(telegram): honor the author emoji toggle The author marker must obey the group emoji preference just like formatter-added decoration. * fix(telegram): keep completed commands claimed Redelivery after a completed write must never post another comment. Keep completion claims despite reply failures, scope updates per bot and only issue account-login links in private chats. * fix(feishu): bound individual api requests Bound individual platform calls so they cannot outlive the lock protecting a message update or stall a whole delivery invocation. * fix(feishu): classify retryable api failures Business error codes can be transient even in HTTP 200 responses. Classify token and rate-limit errors for retry and defer long waits. * fix(feishu): retry sends with stable uuids An unreadable response does not prove a send failed. Reuse the same uuid for retries so recovering the result cannot create a second Feishu message. * fix(feishu): refresh and evict tokens safely Separate app token caches, stop reusing refused tokens and share refreshes. Cache failures briefly and keep valid tokens in memory when a best-effort KV cache write fails. * fix(feishu): use the card update endpoint Delayed card updates use the card update endpoint; the config endpoint cannot update an interaction response. * fix(feishu): neutralize untrusted mentions Forge text is untrusted and can contain at-all tags. Neutralize mentions in card bodies and footers before rendering. * fix(feishu): authenticate and dedupe callbacks Authenticate signed or token-verified callbacks before dispatching commands. Decode encrypted envelopes and handle card actions using the correct fields without claiming irrelevant chat events. * fix(target): normalize actual destinations Different target spellings can name the same actual destination. Normalize channel, thread and topic identities for ownership checks and per-route duplicate suppression. * fix(config): transact per-group configuration Whole-table writes and cached snapshots can overwrite other groups or resurrect removed configuration. Use per-group guarded writes, one-time identity migration and explicit unreadable-row failures. * fix(group): preserve identity through lifecycle Group names are mutable and reusable, so they cannot own durable state. Preserve immutable identities across lifecycle operations and commit invite use with membership under transaction-time guards. * fix(oauth): confirm account links and installs A login link or installation id is not proof of account ownership. Verify installation management, bind browser state and require an explicit account-link confirmation before granting chat access. * fix(queue): fence leases and record target outcomes Retries must remember completed targets and distinguish active lease holders. Fence state updates, preserve permanent outcomes and reject missing parked payloads instead of dispatching empty data. * fix(dispatch): isolate and resume tenant sends Check tenant sources before filters and never dispatch orphan routes. Record each target outcome, isolate update chains by forge and group identity, and keep stale events from overwriting newer messages. * fix(queue): bound batches and resume deliveries A queue invocation has shared query and subrequest limits. Use a small batch and shared send budget, renew fenced leases and resume only unfinished work without exhausting unstarted messages. * 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. * fix(webhook): confirm only accepted deliveries Acknowledging before queue acceptance permanently loses deliveries. Confirm only accepted work, release failed claims, scope replay identities and strip tenant-supplied installation authority. * fix(storage): prune abandoned parked payloads Oversized payloads can remain after interrupted enqueue attempts. Prune objects beyond their retry lifetime without deleting payloads that a current delivery may still need. * fix(console): expose api conflict statuses Callers need the HTTP status to distinguish stale edits from other failures and reload current data after a conflict. * refactor(console): model group revisions Carry server revisions explicitly so console writes can reject changes based on an outdated group snapshot. * fix(console): send loaded route revisions Send the revision actually loaded with the route list and adopt the server response after a save. Reload on conflict instead of silently overwriting another editor. * fix(console): guard fragment saves by revision Fragments share a group version with other configuration writes. Submit the loaded revision and reload on conflict to preserve concurrent edits. * fix(console): save groups with guarded writes Whole-list saves can overwrite unrelated groups. Use per-group revision-aware writes, retain rename results and confirm deletion on the exact group, routes and version shown to the user. * fix(console): reject edits of stale routes A conflict reload can leave an older route editor open. Compare its original value before saving so it cannot overwrite the newly loaded route. * fix(console): show overview loading failures Failed overview requests must not look like an empty dashboard or a successful refresh. Show the reason while retaining prior data. * fix(console): explain rejected install bindings Explain why an installation binding was refused instead of silently returning to the console with no visible outcome. * fix(console): allow selecting a group named all The all sentinel collides with a valid group id. Use a value that cannot be a group id so that group stays selectable. * fix(console): discard stale log detail responses An older detail request can finish after a newer selection or close. Discard it so the dialog never shows the previously clicked record. * fix(console): retain legacy group owners Groups predating member roles store owners in adminIds. Load those as owners so adding a member never drops all old owners. * fix(console): lock member edits during saves Edits made during a save are overwritten by its result. Disable member controls and guard handlers until the write settles. * fix(console): show invite loading failures Failed invite loads must not look like no pending invites. Show the error and discard responses from a previously shown group. * fix(console): retain legacy discord log targets A stored log target without platform means Discord. Keep that meaning in the editor instead of clearing the target. * fix(console): retain undisplayed forge sources An editor that only displays some providers must preserve the others. Keep stored custom sources when saving unrelated group settings. * fix(console): lock the group editor while saving Prevent edits while a group save is in flight and make super-only installation settings readonly instead of silently ignoring edits. * fix(console): lock route edits and show failures Lock the route editor while saving and show fragment load failures with a retry action rather than presenting a false empty list. * fix(config): expose the legal contact override Declare the public runtime key so the documented environment override reaches legal pages in deployed Nuxt builds. * build(deploy): migrate d1 before deployment Apply pending D1 migrations before deploying code that requires them. Stop deployment when migration fails instead of running against an incomplete schema. * docs(worker): align guides with runtime behavior Synchronize both language guides, API references and examples with the implemented authorization, storage and delivery behavior. Document migration requirements and accepted operational limits. * fix(storage): repair orphaned KV routes Repair orphaned KV routes before serving KV-only configuration. * fix(security): fully escape forge HTML --------- Co-authored-by: RhenCloud <i@rhen.cloud>
2265 lines
86 KiB
TypeScript
2265 lines
86 KiB
TypeScript
import type { H3Event } from "h3";
|
|
import {
|
|
getHeader,
|
|
getQuery,
|
|
readBody,
|
|
sendRedirect,
|
|
setResponseHeader,
|
|
setResponseStatus,
|
|
} from "h3";
|
|
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";
|
|
import { getSendLog, getSendLogById, getSendLogByDelivery, type GroupScope } from "../lib/send-log";
|
|
import { getDeliveryMetrics } from "../observability/metrics";
|
|
import { getAuditLog, recordAudit } from "../lib/audit";
|
|
import {
|
|
createInvite,
|
|
listInvites,
|
|
revokeInvite,
|
|
getInvite,
|
|
acceptInvite,
|
|
migrateInvites,
|
|
deleteGroupInvites,
|
|
INVITE_LIFETIME_MS,
|
|
} from "./invites";
|
|
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",
|
|
"repo",
|
|
"actor",
|
|
"action",
|
|
"branch",
|
|
"keyword",
|
|
"field",
|
|
]);
|
|
const VALID_OPS = new Set([
|
|
"eq",
|
|
"ne",
|
|
"contains",
|
|
"startsWith",
|
|
"endsWith",
|
|
"regex",
|
|
"gt",
|
|
"gte",
|
|
"lt",
|
|
"lte",
|
|
"in",
|
|
"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))
|
|
return match.length > 0 && match.every((m) => typeof m === "string" && m.trim().length > 0);
|
|
return false;
|
|
}
|
|
|
|
function deepEqual(a: unknown, b: unknown): boolean {
|
|
if (a === b) return true;
|
|
if (typeof a !== typeof b || a === null || b === null) return false;
|
|
if (Array.isArray(a) || Array.isArray(b)) {
|
|
if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
|
|
return a.every((x, i) => deepEqual(x, b[i]));
|
|
}
|
|
if (typeof a === "object" && typeof b === "object") {
|
|
const ao = a as Record<string, unknown>;
|
|
const bo = b as Record<string, unknown>;
|
|
const ak = Object.keys(ao);
|
|
const bk = Object.keys(bo);
|
|
if (ak.length !== bk.length) return false;
|
|
return ak.every((k) => Object.prototype.hasOwnProperty.call(bo, k) && deepEqual(ao[k], bo[k]));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
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<string, unknown>;
|
|
if (Array.isArray(n.all)) {
|
|
if (n.all.length === 0) return `${label}.all must not be empty`;
|
|
for (let i = 0; i < n.all.length; i++) {
|
|
const err = validateFilterNode(n.all[i], `${label}.all[${i}]`);
|
|
if (err) return err;
|
|
}
|
|
return null;
|
|
}
|
|
if (Array.isArray(n.any)) {
|
|
if (n.any.length === 0) return `${label}.any must not be empty`;
|
|
for (let i = 0; i < n.any.length; i++) {
|
|
const err = validateFilterNode(n.any[i], `${label}.any[${i}]`);
|
|
if (err) return err;
|
|
}
|
|
return null;
|
|
}
|
|
if (n.not !== undefined) return validateFilterNode(n.not, `${label}.not`);
|
|
if (!VALID_FILTER_TYPES.has(n.type as string)) {
|
|
return `${label} has unknown type`;
|
|
}
|
|
if (n.type === "field" && (typeof n.path !== "string" || n.path.trim().length === 0)) {
|
|
return `${label}.path is required for field filters`;
|
|
}
|
|
if (n.path !== undefined && typeof n.path !== "string") {
|
|
return `${label}.path must be a string`;
|
|
}
|
|
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`;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Validates the submitted routes. Routes that are byte-for-byte identical to an
|
|
* entry in `unchanged` (keyed by id) skip the full content check, so a pre-existing
|
|
* 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.
|
|
*/
|
|
export function validateRoutes(
|
|
routes: unknown,
|
|
unchanged?: Map<string, Route>,
|
|
): { ok: true; routes: Route[] } | { ok: false; error: string } {
|
|
if (!Array.isArray(routes)) return { ok: false, error: "routes must be an array" };
|
|
if (routes.length > 200) return { ok: false, error: "too many routes" };
|
|
|
|
const seenByGroup = new Map<string, Set<string>>();
|
|
for (let i = 0; i < routes.length; i++) {
|
|
const r = routes[i] as Record<string, unknown>;
|
|
if (!r || typeof r !== "object") return { ok: false, error: `route[${i}] is not an object` };
|
|
if (typeof r.id !== "string" || !ID_RE.test(r.id)) {
|
|
return { ok: false, error: `route[${i}].id is invalid` };
|
|
}
|
|
const gid = (r.groupId as string) ?? "__nogroup__";
|
|
let groupSeen = seenByGroup.get(gid);
|
|
if (!groupSeen) {
|
|
groupSeen = new Set();
|
|
seenByGroup.set(gid, groupSeen);
|
|
}
|
|
if (groupSeen.has(r.id)) {
|
|
return { ok: false, error: `duplicate route id "${r.id}" in group "${gid}"` };
|
|
}
|
|
groupSeen.add(r.id);
|
|
// Skip full validation for routes that are unchanged from what is stored.
|
|
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` };
|
|
}
|
|
if (typeof r.groupId !== "string" || r.groupId.trim().length === 0) {
|
|
return { ok: false, error: `route "${r.id}" needs a group` };
|
|
}
|
|
if (typeof r.enabled !== "boolean")
|
|
return { ok: false, error: `route "${r.id}".enabled must be boolean` };
|
|
if (r.fallback !== undefined && typeof r.fallback !== "boolean") {
|
|
return { ok: false, error: `route "${r.id}".fallback must be a boolean` };
|
|
}
|
|
if (r.stop !== undefined && typeof r.stop !== "boolean") {
|
|
return { ok: false, error: `route "${r.id}".stop must be a boolean` };
|
|
}
|
|
if (
|
|
r.discordRoleIds !== undefined &&
|
|
(!Array.isArray(r.discordRoleIds) ||
|
|
!r.discordRoleIds.every((d) => typeof d === "string" && SNOWFLAKE_RE.test(d)))
|
|
) {
|
|
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` };
|
|
}
|
|
if (r.fallback !== true && r.filters.length === 0 && r.ast === undefined) {
|
|
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<string, unknown> | 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 };
|
|
}
|
|
if (r.ast !== undefined) {
|
|
const err = validateFilterNode(r.ast, `route "${r.id}".ast`);
|
|
if (err) return { ok: false, error: err };
|
|
}
|
|
const rawTarget = r.target as Record<string, unknown> | undefined;
|
|
const rawTargets = r.targets as unknown;
|
|
if (rawTargets === undefined && rawTarget && typeof rawTarget === "object") {
|
|
const legacy = validateTarget(`route "${r.id}"`, rawTarget);
|
|
if (!legacy.ok) return legacy;
|
|
(r as Record<string, unknown>).targets = [legacy.target];
|
|
delete (r as Record<string, unknown>).target;
|
|
} else if (Array.isArray(rawTargets)) {
|
|
if (rawTargets.length === 0) {
|
|
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<string>();
|
|
for (let j = 0; j < rawTargets.length; j++) {
|
|
const t = rawTargets[j] as Record<string, unknown>;
|
|
if (!t || typeof t !== "object") {
|
|
return { ok: false, error: `route "${r.id}".targets[${j}] is not an object` };
|
|
}
|
|
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<string, unknown>).targets = normalized;
|
|
} else {
|
|
return { ok: false, error: `route "${r.id}" needs a targets array` };
|
|
}
|
|
}
|
|
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<string, unknown>,
|
|
): { ok: true; target: Route["targets"][number] } | { ok: false; error: string } {
|
|
const platform = target.platform === undefined ? "discord" : target.platform;
|
|
if (platform !== "discord" && platform !== "telegram" && platform !== "feishu") {
|
|
return { ok: false, error: `${label}.platform must be "discord", "telegram" or "feishu"` };
|
|
}
|
|
if (platform === "telegram" || platform === "feishu") {
|
|
if (typeof target.chatId !== "string" || target.chatId.trim().length === 0)
|
|
return { ok: false, error: `${label}.chatId is required` };
|
|
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).trim() : undefined,
|
|
threadId:
|
|
platform === "discord"
|
|
? (target.threadId as string | undefined)?.trim() || undefined
|
|
: undefined,
|
|
chatId:
|
|
platform === "telegram" || platform === "feishu"
|
|
? (target.chatId as string).trim()
|
|
: undefined,
|
|
topicId:
|
|
platform === "telegram"
|
|
? (target.topicId as string | undefined)?.trim() || undefined
|
|
: undefined,
|
|
},
|
|
};
|
|
}
|
|
|
|
function validateMembers(
|
|
g: Record<string, unknown>,
|
|
gid: string,
|
|
): { ok: true; members: GroupMember[] } | { ok: false; error: string } {
|
|
const raw = g.members;
|
|
if (raw === undefined || raw === null) {
|
|
// Legacy payload without members: derive owners from adminIds.
|
|
const adminIds = g.adminIds;
|
|
if (!Array.isArray(adminIds)) {
|
|
return { ok: false, error: `group "${gid}" needs a members list` };
|
|
}
|
|
if (!adminIds.every((a) => typeof a === "string" && a.trim().length > 0)) {
|
|
return { ok: false, error: `group "${gid}".adminIds must be a list of strings` };
|
|
}
|
|
const members: GroupMember[] = [];
|
|
const seen = new Set<string>();
|
|
for (const a of adminIds as string[]) {
|
|
const login = a.trim();
|
|
if (!login || seen.has(login.toLowerCase())) continue;
|
|
seen.add(login.toLowerCase());
|
|
members.push({ login, role: "owner" });
|
|
}
|
|
return { ok: true, members };
|
|
}
|
|
if (!Array.isArray(raw)) return { ok: false, error: `group "${gid}".members must be an array` };
|
|
const seen = new Set<string>();
|
|
const members: GroupMember[] = [];
|
|
for (let i = 0; i < raw.length; i++) {
|
|
const m = raw[i] as Record<string, unknown>;
|
|
if (!m || typeof m !== "object")
|
|
return { ok: false, error: `group "${gid}".members[${i}] is not an object` };
|
|
const login = typeof m.login === "string" ? m.login.trim() : "";
|
|
if (!login) return { ok: false, error: `group "${gid}".members[${i}].login is required` };
|
|
const role = m.role;
|
|
if (role !== "owner" && role !== "admin" && role !== "viewer") {
|
|
return {
|
|
ok: false,
|
|
error: `group "${gid}".members[${i}].role must be "owner" | "admin" | "viewer"`,
|
|
};
|
|
}
|
|
if (seen.has(login.toLowerCase())) {
|
|
return { ok: false, error: `group "${gid}" has duplicate member "${login}"` };
|
|
}
|
|
seen.add(login.toLowerCase());
|
|
members.push({ login, role });
|
|
}
|
|
if (members.length > 0 && !members.some((m) => m.role === "owner")) {
|
|
return { ok: false, error: `group "${gid}" needs at least one owner` };
|
|
}
|
|
return { ok: true, members };
|
|
}
|
|
|
|
export function validateGroups(
|
|
groups: unknown,
|
|
): { ok: true; groups: Group[] } | { ok: false; error: string } {
|
|
if (!Array.isArray(groups)) return { ok: false, error: "groups must be an array" };
|
|
if (groups.length > 100) return { ok: false, error: "too many groups" };
|
|
|
|
const seen = new Set<string>();
|
|
for (let i = 0; i < groups.length; i++) {
|
|
const g = groups[i] as Record<string, unknown>;
|
|
if (!g || typeof g !== "object") return { ok: false, error: `group[${i}] is not an object` };
|
|
if (typeof g.id !== "string" || !ID_RE.test(g.id)) {
|
|
return { ok: false, error: `group[${i}].id is invalid` };
|
|
}
|
|
if (seen.has(g.id)) return { ok: false, error: `duplicate group id "${g.id}"` };
|
|
seen.add(g.id);
|
|
if (typeof g.name !== "string" || g.name.trim().length === 0) {
|
|
return { ok: false, error: `group "${g.id}" needs a name` };
|
|
}
|
|
const mres = validateMembers(g, g.id);
|
|
if (!mres.ok) return mres;
|
|
// `members` is the single source of truth; adminIds stays in sync so
|
|
// legacy consumers (isGroupAdmin, older UI) keep working.
|
|
g.members = mres.members;
|
|
g.adminIds = mres.members.filter((m) => m.role === "owner").map((m) => m.login);
|
|
if (
|
|
g.owners !== undefined &&
|
|
(!Array.isArray(g.owners) ||
|
|
!g.owners.every((o) => typeof o === "string" && o.trim().length > 0))
|
|
) {
|
|
return { ok: false, error: `group "${g.id}".owners must be a list of strings` };
|
|
}
|
|
if (
|
|
g.providers !== undefined &&
|
|
(!Array.isArray(g.providers) ||
|
|
!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" | "custom"`,
|
|
};
|
|
}
|
|
if (g.installationId !== undefined && g.installationId !== null) {
|
|
if (typeof g.installationId !== "number" || !Number.isInteger(g.installationId)) {
|
|
return { ok: false, error: `group "${g.id}".installationId must be an integer` };
|
|
}
|
|
} 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` };
|
|
}
|
|
if (g.forgeSources !== undefined && g.forgeSources !== null) {
|
|
if (!Array.isArray(g.forgeSources)) {
|
|
return { ok: false, error: `group "${g.id}".forgeSources must be an array` };
|
|
}
|
|
if (g.forgeSources.length > 20) {
|
|
return { ok: false, error: `group "${g.id}".forgeSources: too many sources` };
|
|
}
|
|
const seen = new Set<string>();
|
|
const normalized: ForgeSource[] = [];
|
|
for (let i = 0; i < g.forgeSources.length; i++) {
|
|
const s = g.forgeSources[i] as Record<string, unknown>;
|
|
if (!s || typeof s !== "object") {
|
|
return { ok: false, error: `group "${g.id}".forgeSources[${i}] is not an object` };
|
|
}
|
|
if (typeof s.host !== "string" || !HOST_RE.test(s.host)) {
|
|
return {
|
|
ok: false,
|
|
error: `group "${g.id}".forgeSources[${i}].host must be a valid hostname`,
|
|
};
|
|
}
|
|
if (s.type !== "github" && s.type !== "gitea") {
|
|
return {
|
|
ok: false,
|
|
error: `group "${g.id}".forgeSources[${i}].type must be "github" | "gitea"`,
|
|
};
|
|
}
|
|
if (s.name !== undefined && (typeof s.name !== "string" || s.name.length > 50)) {
|
|
return {
|
|
ok: false,
|
|
error: `group "${g.id}".forgeSources[${i}].name must be a string`,
|
|
};
|
|
}
|
|
const key = `${s.type}:${s.host.toLowerCase()}`;
|
|
if (seen.has(key)) {
|
|
return { ok: false, error: `group "${g.id}".forgeSources has a duplicate source` };
|
|
}
|
|
seen.add(key);
|
|
normalized.push({
|
|
host: s.host.trim(),
|
|
type: s.type,
|
|
...(s.name !== undefined && s.name.trim() ? { name: s.name.trim() } : {}),
|
|
});
|
|
}
|
|
g.forgeSources = normalized;
|
|
} else {
|
|
delete g.forgeSources;
|
|
}
|
|
if (g.lang !== undefined && typeof g.lang !== "string") {
|
|
return { ok: false, error: `group "${g.id}".lang must be a string` };
|
|
}
|
|
if (g.logTarget !== undefined && g.logTarget !== null) {
|
|
if (typeof g.logTarget !== "object" || Array.isArray(g.logTarget)) {
|
|
return { ok: false, error: `group "${g.id}".logTarget must be an object` };
|
|
}
|
|
const tgt = validateTarget(
|
|
`group "${g.id}".logTarget`,
|
|
g.logTarget as Record<string, unknown>,
|
|
);
|
|
if (!tgt.ok) return tgt;
|
|
g.logTarget = tgt.target;
|
|
} else {
|
|
delete g.logTarget;
|
|
}
|
|
}
|
|
return { ok: true, groups: (groups as Record<string, unknown>[]).map(sanitizeGroup) };
|
|
}
|
|
|
|
/** Keep only the known group fields (in a stable order); drops `revision` and junk. */
|
|
function sanitizeGroup(g: Record<string, unknown>): Group {
|
|
const out: Record<string, unknown> = {};
|
|
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<string, unknown>);
|
|
}
|
|
|
|
/** 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<string, unknown>).sort(([a], [b]) => (a < b ? -1 : 1)),
|
|
)
|
|
: v,
|
|
);
|
|
}
|
|
|
|
async function revisionOf(value: unknown): Promise<string> {
|
|
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<string> {
|
|
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<Group[]> {
|
|
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<string> {
|
|
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<Map<string, string | null>> {
|
|
const names = new Set<string>();
|
|
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<string, string | null>();
|
|
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<string, string | null>();
|
|
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<string> => {
|
|
const out = new Set<string>();
|
|
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<string>();
|
|
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<string>();
|
|
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<string, unknown> {
|
|
setResponseStatus(event, status);
|
|
return { error };
|
|
}
|
|
|
|
function accessError(
|
|
event: H3Event,
|
|
access: Extract<GroupAccess, { ok: false }>,
|
|
): Record<string, unknown> {
|
|
return respondError(
|
|
event,
|
|
access.status,
|
|
access.status === 404 ? "Group not found" : "Forbidden",
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Read a JSON body, returning null when it is not valid JSON. h3's readBody
|
|
* only parses `application/json` bodies; tolerate clients that omit the
|
|
* Content-Type header (curl, older UI) by JSON-parsing the raw string.
|
|
*/
|
|
async function readJsonBody(event: H3Event): Promise<Record<string, unknown> | null> {
|
|
try {
|
|
const body = await readBody(event);
|
|
if (typeof body === "string") {
|
|
try {
|
|
return JSON.parse(body) as Record<string, unknown>;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
return (body ?? {}) as Record<string, unknown>;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function webhookUrl(event: H3Event, groupId: string): string {
|
|
const env = cfEnv(event);
|
|
const origin = env.BASE_URL ?? getRequestOrigin(event);
|
|
return `${origin.replace(/\/$/, "")}/webhook/${groupId}`;
|
|
}
|
|
|
|
function getRequestOrigin(event: H3Event): string {
|
|
const proto = getHeader(event, "x-forwarded-proto") ?? "https";
|
|
const host = getHeader(event, "host") ?? "localhost";
|
|
return `${proto}://${host}`;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Handlers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/** GET /admin/login */
|
|
export async function adminLogin(event: H3Event): Promise<void> {
|
|
if (isDebugMode(cfEnv(event))) {
|
|
await sendRedirect(event, "/admin");
|
|
return;
|
|
}
|
|
await sendRedirect(event, "/auth/github?redirect=/admin");
|
|
}
|
|
|
|
/** GET /admin/logout */
|
|
export async function adminLogout(event: H3Event): Promise<void> {
|
|
const env = cfEnv(event);
|
|
const session = await getAdminSession(env.KV, getHeader(event, "cookie"), env.DB);
|
|
if (session) {
|
|
await recordAudit(env.DB, {
|
|
ts: Date.now(),
|
|
actorId: session.userId,
|
|
actorLogin: session.login,
|
|
action: "session.logout",
|
|
ip: clientIp(event),
|
|
});
|
|
}
|
|
await destroyAdminSession(env.KV, getHeader(event, "cookie"), env.DB);
|
|
setResponseHeader(event, "Set-Cookie", clearAdminCookie());
|
|
await sendRedirect(event, "/admin");
|
|
}
|
|
|
|
/** GET /admin/invite?token=… */
|
|
export async function adminInvite(event: H3Event): Promise<void> {
|
|
const env = cfEnv(event);
|
|
const token = String(getQuery(event)["token"] ?? "");
|
|
if (!token) {
|
|
await sendRedirect(event, "/admin");
|
|
return;
|
|
}
|
|
const session = await getAdminSession(env.KV, getHeader(event, "cookie"), env.DB);
|
|
if (!session) {
|
|
await sendRedirect(
|
|
event,
|
|
`/auth/github?redirect=${encodeURIComponent(`/admin/invite?token=${token}`)}`,
|
|
);
|
|
return;
|
|
}
|
|
const result = await acceptInvite(env, token, session.userId, session.login, authLogin(session));
|
|
if (result.ok) {
|
|
await recordAudit(env.DB, {
|
|
ts: Date.now(),
|
|
actorId: session.userId,
|
|
actorLogin: session.login,
|
|
action: "invite.accept",
|
|
targetType: "group",
|
|
targetId: result.groupId,
|
|
groupId: result.groupId,
|
|
groupInstance: result.groupInstance,
|
|
detail: { role: result.role },
|
|
ip: clientIp(event),
|
|
});
|
|
}
|
|
await sendRedirect(event, `/admin?invite=${result.ok ? "ok" : result.reason}`);
|
|
}
|
|
|
|
/** GET /admin/api/me */
|
|
export async function adminApiMe(event: H3Event): Promise<Record<string, unknown>> {
|
|
const auth = await requireAnyAccess(event);
|
|
const roles: Record<string, GroupRole> = {};
|
|
for (const g of auth.scope.groups) {
|
|
const role = roleAt(auth.scope, g.id);
|
|
if (role) roles[g.id] = role;
|
|
}
|
|
return {
|
|
login: auth.session.login,
|
|
userId: auth.session.userId,
|
|
isSuper: auth.scope.isSuper,
|
|
groups: await withRevisions(auth.scope.groups),
|
|
roles,
|
|
};
|
|
}
|
|
|
|
/** Revision of a whole group list (ids and contents), for the bulk write. */
|
|
async function listRevision(groups: Group[]): Promise<string> {
|
|
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<Record<string, unknown>> {
|
|
const auth = await requireAnyAccess(event);
|
|
const roles: Record<string, GroupRole> = {};
|
|
for (const g of auth.scope.groups) {
|
|
const role = roleAt(auth.scope, g.id);
|
|
if (role) roles[g.id] = role;
|
|
}
|
|
return {
|
|
groups: await withRevisions(auth.scope.groups),
|
|
revision: await listRevision(auth.scope.groups),
|
|
isSuper: auth.scope.isSuper,
|
|
roles,
|
|
};
|
|
}
|
|
|
|
/** Audit a group create / update by comparing it with its previous version. */
|
|
async function auditGroupChange(
|
|
event: H3Event,
|
|
prev: Group | undefined,
|
|
next: Group,
|
|
): Promise<void> {
|
|
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<Group> {
|
|
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<string, string>();
|
|
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<void>,
|
|
version?: number,
|
|
): Promise<void> {
|
|
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<boolean> {
|
|
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<string, unknown> {
|
|
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<Record<string, unknown>> {
|
|
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<string, string>();
|
|
if (Array.isArray(body["groups"])) {
|
|
for (const raw of body["groups"] as Array<Record<string, unknown> | 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, { 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]));
|
|
const submittedIds = new Set(result.groups.map((g) => g.id));
|
|
const writable = new Set<string>();
|
|
if (auth.scope.isSuper) {
|
|
for (const g of [...existing, ...result.groups]) writable.add(g.id);
|
|
} else {
|
|
for (const [gid, role] of auth.scope.roles) if (role === "owner") writable.add(gid);
|
|
}
|
|
|
|
const upserts: Group[] = [];
|
|
const logTargetGuards = new Map<string, LifecycleStatements>();
|
|
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 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<void> => {
|
|
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 {
|
|
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) {
|
|
return writeError(event, err, "groups");
|
|
}
|
|
log.info({ updated: upserts.length, deleted: deletions.length }, "Groups updated via admin UI");
|
|
return { ok: true, count: result.groups.length };
|
|
}
|
|
|
|
/** POST /admin/api/groups — create one group (super admins). */
|
|
export async function adminGroupCreate(event: H3Event): Promise<Record<string, unknown>> {
|
|
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<Record<string, unknown>> {
|
|
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<string, unknown>)["revision"]);
|
|
const result = validateGroups([{ ...(raw as Record<string, unknown>), 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<Record<string, unknown>> {
|
|
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<Record<string, unknown>> {
|
|
const auth = await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
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));
|
|
const revisions: Record<string, string> = {};
|
|
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 — 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<Record<string, unknown>> {
|
|
const auth = await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const body = await readJsonBody(event);
|
|
if (!body) return respondError(event, 400, "Invalid JSON body");
|
|
const rawRevisions = body["revisions"];
|
|
const revisions =
|
|
rawRevisions && typeof rawRevisions === "object" && !Array.isArray(rawRevisions)
|
|
? (rawRevisions as Record<string, unknown>)
|
|
: 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);
|
|
|
|
const groupIds = new Set(auth.groups.map((g) => g.id));
|
|
const writable = new Set<string>();
|
|
for (const gid of groupIds) {
|
|
const role = roleAt(auth.scope, gid);
|
|
if (role === "owner" || role === "admin") writable.add(gid);
|
|
}
|
|
const byGroup = (list: Route[]): Map<string, Route[]> => {
|
|
const out = new Map<string, Route[]>();
|
|
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`);
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
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 {
|
|
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) {
|
|
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,
|
|
actorLogin: auth.session.login,
|
|
action: "routes.update",
|
|
targetType: "routes",
|
|
targetId: "all",
|
|
detail: { groups: plan.map((p) => p.gid), count },
|
|
ip: clientIp(event),
|
|
});
|
|
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). */
|
|
function visibleScope(event: H3Event, groupId: string | undefined): GroupScope {
|
|
const auth = currentAuth(event);
|
|
if (groupId) return groupId;
|
|
return auth.scope.isSuper ? undefined : [...auth.scope.groupIds];
|
|
}
|
|
|
|
/** GET /admin/api/logs */
|
|
export async function adminApiLogs(event: H3Event): Promise<Record<string, unknown>> {
|
|
const auth = await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const query = getQuery(event);
|
|
const limit = Math.min(Math.max(Number(String(query["limit"] ?? "50")) || 50, 1), 100);
|
|
const filterGroupId = String(query["groupId"] ?? "") || undefined;
|
|
if (filterGroupId && !auth.scope.isSuper && !auth.scope.groupIds.has(filterGroupId)) {
|
|
return respondError(event, 403, "Forbidden");
|
|
}
|
|
const logs = await getSendLog(env.DB, limit, visibleScope(event, filterGroupId));
|
|
return { logs };
|
|
}
|
|
|
|
/** GET /admin/api/logs/:id */
|
|
export async function adminApiLogsById(
|
|
event: H3Event,
|
|
id: number,
|
|
): Promise<Record<string, unknown>> {
|
|
const auth = await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
if (!Number.isInteger(id) || id <= 0) return respondError(event, 400, "Invalid log id");
|
|
const entry = await getSendLogById(env.DB, id);
|
|
if (!entry) return respondError(event, 404, "Log entry not found");
|
|
if (!auth.scope.isSuper) {
|
|
if (!entry.groupId || !auth.scope.groupIds.has(entry.groupId)) {
|
|
return respondError(event, 403, "Forbidden");
|
|
}
|
|
}
|
|
return { log: entry };
|
|
}
|
|
|
|
/** GET /admin/api/groups/:groupId/routes */
|
|
export async function adminGroupRoutesGet(
|
|
event: H3Event,
|
|
groupId: string,
|
|
): Promise<Record<string, unknown>> {
|
|
await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const access = requireGroup(event, groupId);
|
|
if (!access.ok) return accessError(event, access);
|
|
// 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 — 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,
|
|
): Promise<Record<string, unknown>> {
|
|
await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const access = requireGroupRole(event, groupId, "admin");
|
|
if (!access.ok) return accessError(event, access);
|
|
|
|
const body = await readJsonBody(event);
|
|
if (!body) return respondError(event, 400, "Invalid JSON body");
|
|
|
|
// Force every submitted route into this group so the client never has to
|
|
// carry a groupId; the path parameter is the single source of truth.
|
|
const submitted = body["routes"];
|
|
const scoped = Array.isArray(submitted)
|
|
? submitted.map((r) => ({ ...(r as Record<string, unknown>), groupId }))
|
|
: submitted;
|
|
// 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);
|
|
|
|
let saved: Route[];
|
|
try {
|
|
// 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) {
|
|
return writeError(event, err, "routes");
|
|
}
|
|
const auth = currentAuth(event);
|
|
await recordAudit(env.DB, {
|
|
ts: Date.now(),
|
|
actorId: auth.session.userId,
|
|
actorLogin: auth.session.login,
|
|
action: "group.routes.update",
|
|
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,
|
|
routes: saved,
|
|
revision: await routesRevision(saved),
|
|
};
|
|
}
|
|
|
|
/** POST /admin/api/groups/:groupId/invites */
|
|
export async function adminGroupInvitesPost(
|
|
event: H3Event,
|
|
groupId: string,
|
|
): Promise<Record<string, unknown>> {
|
|
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 role = body["role"];
|
|
if (role !== "admin" && role !== "viewer") {
|
|
return respondError(event, 400, 'role must be "admin" or "viewer"');
|
|
}
|
|
const note = body["note"];
|
|
const auth = currentAuth(event);
|
|
const expiresAt = Date.now() + INVITE_LIFETIME_MS;
|
|
const token = await createInvite(env.KV, {
|
|
groupId,
|
|
role,
|
|
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(),
|
|
actorId: auth.session.userId,
|
|
actorLogin: auth.session.login,
|
|
action: "invite.create",
|
|
targetType: "group",
|
|
targetId: groupId,
|
|
groupId,
|
|
groupInstance: access.group.instance,
|
|
detail: { role },
|
|
ip: clientIp(event),
|
|
});
|
|
return {
|
|
ok: true,
|
|
token,
|
|
url: `/admin/invite?token=${token}`,
|
|
expiresAt,
|
|
};
|
|
}
|
|
|
|
/** GET /admin/api/groups/:groupId/invites */
|
|
export async function adminGroupInvitesGet(
|
|
event: H3Event,
|
|
groupId: string,
|
|
): Promise<Record<string, unknown>> {
|
|
await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const access = requireGroupRole(event, groupId, "owner");
|
|
if (!access.ok) return accessError(event, access);
|
|
const invites = await listInvites(env.KV, groupId, access.group);
|
|
return { invites };
|
|
}
|
|
|
|
/** DELETE /admin/api/invites/:token */
|
|
export async function adminInviteDelete(
|
|
event: H3Event,
|
|
token: string,
|
|
): Promise<Record<string, unknown>> {
|
|
await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const invite = await getInvite(env.KV, token);
|
|
if (!invite) return respondError(event, 404, "Invite not found");
|
|
// 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");
|
|
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(),
|
|
actorId: auth.session.userId,
|
|
actorLogin: auth.session.login,
|
|
action: "invite.revoke",
|
|
targetType: "group",
|
|
targetId: issuer,
|
|
groupId: issuer,
|
|
groupInstance: invite.groupInstance,
|
|
ip: clientIp(event),
|
|
});
|
|
return { ok: true };
|
|
}
|
|
|
|
/**
|
|
* 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,
|
|
): Promise<Record<string, unknown>> {
|
|
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 newId = String(body["newId"] ?? "").trim();
|
|
if (!ID_RE.test(newId)) return respondError(event, 400, "newId is invalid");
|
|
if (newId === groupId) {
|
|
return respondError(event, 400, "newId must differ from the current id");
|
|
}
|
|
const revision = submittedRevision(body["revision"]);
|
|
const auth = currentAuth(event);
|
|
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`);
|
|
}
|
|
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;
|
|
|
|
let renamed: Group;
|
|
try {
|
|
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) {
|
|
if (err instanceof ConfigConflictError) return writeError(event, err, "group");
|
|
log.error({ err }, "Failed to rename group");
|
|
return respondError(event, 500, "Failed to rename group");
|
|
}
|
|
|
|
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(),
|
|
actorId: auth.session.userId,
|
|
actorLogin: auth.session.login,
|
|
action: "group.rename",
|
|
targetType: "group",
|
|
targetId: newId,
|
|
groupId: newId,
|
|
groupInstance: renamed?.instance,
|
|
detail: { from: groupId, to: newId, routes: routeCount },
|
|
ip: clientIp(event),
|
|
});
|
|
log.info({ from: groupId, to: newId }, "Group renamed via admin UI");
|
|
const [withRev] = await withRevisions([renamed]);
|
|
return { ok: true, id: newId, group: withRev, revision: withRev!.revision };
|
|
}
|
|
|
|
/** GET /admin/api/groups/:groupId/webhook */
|
|
export async function adminGroupWebhookGet(
|
|
event: H3Event,
|
|
groupId: string,
|
|
): Promise<Record<string, unknown>> {
|
|
await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const access = requireGroupRole(event, groupId, "owner");
|
|
if (!access.ok) return accessError(event, access);
|
|
return {
|
|
url: webhookUrl(event, groupId),
|
|
hasSecret: (await getTenantSecret(env.KV, access.group)) != null,
|
|
};
|
|
}
|
|
|
|
/** POST /admin/api/groups/:groupId/webhook/regenerate */
|
|
export async function adminGroupWebhookRegenerate(
|
|
event: H3Event,
|
|
groupId: string,
|
|
): Promise<Record<string, unknown>> {
|
|
await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const access = requireGroupRole(event, groupId, "owner");
|
|
if (!access.ok) return accessError(event, access);
|
|
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(),
|
|
actorId: auth.session.userId,
|
|
actorLogin: auth.session.login,
|
|
action: "webhook.secret.regenerate",
|
|
targetType: "group",
|
|
targetId: groupId,
|
|
groupId,
|
|
groupInstance: access.group.instance,
|
|
ip: clientIp(event),
|
|
});
|
|
return { ok: true, url: webhookUrl(event, groupId), secret, hasSecret: true };
|
|
}
|
|
|
|
/** DELETE /admin/api/groups/:groupId/webhook */
|
|
export async function adminGroupWebhookDelete(
|
|
event: H3Event,
|
|
groupId: string,
|
|
): Promise<Record<string, unknown>> {
|
|
await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const access = requireGroupRole(event, groupId, "owner");
|
|
if (!access.ok) return accessError(event, access);
|
|
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(),
|
|
actorId: auth.session.userId,
|
|
actorLogin: auth.session.login,
|
|
action: "webhook.secret.delete",
|
|
targetType: "group",
|
|
targetId: groupId,
|
|
groupId,
|
|
groupInstance: access.group.instance,
|
|
ip: clientIp(event),
|
|
});
|
|
return { ok: true };
|
|
}
|
|
|
|
/** GET /admin/api/audit */
|
|
export async function adminAudit(event: H3Event): Promise<Record<string, unknown>> {
|
|
const auth = await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const query = getQuery(event);
|
|
const limit = Math.min(Math.max(Number(String(query["limit"] ?? "50")) || 50, 1), 200);
|
|
const groupId = String(query["groupId"] ?? "") || undefined;
|
|
if (groupId && !auth.scope.isSuper && !auth.scope.groupIds.has(groupId)) {
|
|
return respondError(event, 403, "Forbidden");
|
|
}
|
|
const audit = await getAuditLog(env.DB, { groupId: visibleScope(event, groupId), limit });
|
|
return { audit };
|
|
}
|
|
|
|
/** GET /admin/api/metrics */
|
|
export async function adminApiMetrics(event: H3Event): Promise<Record<string, unknown>> {
|
|
const auth = await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const query = getQuery(event);
|
|
const groupId = String(query["groupId"] ?? "") || undefined;
|
|
if (groupId && !auth.scope.isSuper && !auth.scope.groupIds.has(groupId)) {
|
|
return respondError(event, 403, "Forbidden");
|
|
}
|
|
// Every aggregate (not only the failure list) is computed over the groups
|
|
// the reader may see; nobody but a super admin gets global totals.
|
|
const metrics = await getDeliveryMetrics(env.DB, visibleScope(event, groupId));
|
|
return { metrics };
|
|
}
|
|
|
|
/** GET /admin/api/delivery/:deliveryId */
|
|
export async function adminApiDelivery(
|
|
event: H3Event,
|
|
deliveryId: string,
|
|
): Promise<Record<string, unknown>> {
|
|
const auth = await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const rows = await getSendLogByDelivery(env.DB, deliveryId);
|
|
// One delivery can fan out to several groups: show the reader their part.
|
|
// A delivery id is chosen by its sender, so two senders (two groups'
|
|
// endpoints) may use the same one: `?groupId=` narrows it to one group.
|
|
const only = getQuery(event)["groupId"];
|
|
const attempts = (
|
|
auth.scope.isSuper
|
|
? rows
|
|
: rows.filter((r) => r.groupId != null && auth.scope.groupIds.has(r.groupId))
|
|
).filter((r) => typeof only !== "string" || !only || r.groupId === only);
|
|
if (attempts.length === 0) return respondError(event, 404, "Delivery not found");
|
|
return { deliveryId, attempts };
|
|
}
|
|
|
|
function validateFragments(
|
|
fragments: unknown,
|
|
groupId: string,
|
|
): { ok: true; fragments: NamedFragment[] } | { ok: false; error: string } {
|
|
if (!Array.isArray(fragments)) return { ok: false, error: "fragments must be an array" };
|
|
if (fragments.length > 200) return { ok: false, error: "too many fragments" };
|
|
const seen = new Set<string>();
|
|
const out: NamedFragment[] = [];
|
|
for (let i = 0; i < fragments.length; i++) {
|
|
const f = fragments[i] as Record<string, unknown>;
|
|
if (!f || typeof f !== "object") return { ok: false, error: `fragment[${i}] is not an object` };
|
|
if (typeof f.id !== "string" || !ID_RE.test(f.id)) {
|
|
return { ok: false, error: `fragment[${i}].id is invalid` };
|
|
}
|
|
if (seen.has(f.id)) return { ok: false, error: `duplicate fragment id "${f.id}"` };
|
|
seen.add(f.id);
|
|
if (typeof f.name !== "string" || f.name.trim().length === 0) {
|
|
return { ok: false, error: `fragment "${f.id}" needs a name` };
|
|
}
|
|
const err = validateFilterNode(f.node, `fragment "${f.id}".node`);
|
|
if (err) return { ok: false, error: err };
|
|
out.push({ id: f.id, groupId, name: f.name, node: f.node as FilterNode });
|
|
}
|
|
return { ok: true, fragments: out };
|
|
}
|
|
|
|
/** GET /admin/api/groups/:groupId/fragments */
|
|
export async function adminGroupFragmentsGet(
|
|
event: H3Event,
|
|
groupId: string,
|
|
): Promise<Record<string, unknown>> {
|
|
await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const access = requireGroup(event, groupId);
|
|
if (!access.ok) return accessError(event, access);
|
|
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 */
|
|
export async function adminGroupFragmentsPut(
|
|
event: H3Event,
|
|
groupId: string,
|
|
): Promise<Record<string, unknown>> {
|
|
await requireAnyAccess(event);
|
|
const env = cfEnv(event);
|
|
const access = requireGroupRole(event, groupId, "admin");
|
|
if (!access.ok) return accessError(event, access);
|
|
|
|
const body = await readJsonBody(event);
|
|
if (!body) return respondError(event, 400, "Invalid JSON body");
|
|
|
|
const submitted = body["fragments"];
|
|
const result = validateFragments(submitted, groupId);
|
|
if (!result.ok) return respondError(event, 400, result.error);
|
|
|
|
let saved: NamedFragment[];
|
|
try {
|
|
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) {
|
|
return writeError(event, err, "fragments");
|
|
}
|
|
const auth = currentAuth(event);
|
|
await recordAudit(env.DB, {
|
|
ts: Date.now(),
|
|
actorId: auth.session.userId,
|
|
actorLogin: auth.session.login,
|
|
action: "group.fragments.update",
|
|
targetType: "group",
|
|
targetId: groupId,
|
|
groupId,
|
|
groupInstance: access.group.instance,
|
|
detail: { count: result.fragments.length },
|
|
ip: clientIp(event),
|
|
});
|
|
return {
|
|
ok: true,
|
|
count: result.fragments.length,
|
|
fragments: saved,
|
|
revision: await revisionOf(saved),
|
|
};
|
|
}
|
|
|
|
/** POST /admin/api/test-match */
|
|
export async function adminApiTestMatch(event: H3Event): Promise<Record<string, unknown>> {
|
|
await requireAnyAccess(event);
|
|
const body = await readJsonBody(event);
|
|
if (!body) return respondError(event, 400, "Invalid JSON body");
|
|
|
|
const rawNode =
|
|
body["node"] ?? (Array.isArray(body["filters"]) ? { all: body["filters"] } : undefined);
|
|
if (rawNode === undefined) return respondError(event, 400, "Missing filter node");
|
|
const err = validateFilterNode(rawNode, "node");
|
|
if (err) return respondError(event, 400, err);
|
|
|
|
const payload = body["payload"];
|
|
if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
|
|
return respondError(event, 400, "Missing payload object");
|
|
}
|
|
const eventName =
|
|
typeof body["event"] === "string" && body["event"].trim() ? body["event"].trim() : "custom";
|
|
const webhookEvent = { event: eventName, payload: payload as Record<string, unknown> };
|
|
let matched = false;
|
|
try {
|
|
matched = evaluateFilterNode(rawNode as FilterNode, webhookEvent);
|
|
} catch (e) {
|
|
return respondError(event, 400, `Failed to evaluate: ${String(e)}`);
|
|
}
|
|
return { matched, explanation: explainFilterNode(rawNode as FilterNode) };
|
|
}
|