mirror of
https://github.com/Elysola/WebHooker.git
synced 2026-11-20 17:13:49 +00:00
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.
This commit is contained in:
1 parent
2ec541ad7c
commit
88800611e5
5 files changed
+3985
-97
No files matched your search
@@ -2,9 +2,28 @@ import type { Env, WebhookEvent } from "../../types";
|
||||
import type { Provider } from "../types";
|
||||
import { hmacSha256Hex, timingSafeEqual } from "../hmac";
|
||||
import { verifySignature } from "../github/verify";
|
||||
import { claimOnce, idempotencyStore } from "../../lib/idempotency";
|
||||
|
||||
const REPLAY_WINDOW_SECONDS = 300;
|
||||
const NONCE_TTL_SECONDS = 600;
|
||||
/** How long an accepted nonce is remembered (longer than the signature window). */
|
||||
export const NONCE_TTL_SECONDS = 600;
|
||||
/**
|
||||
* How long a nonce stays held while its request is processed. Short, so a
|
||||
* request whose attempt failed (and could not give the nonce back) can be
|
||||
* retried well within the signature window.
|
||||
*/
|
||||
export const NONCE_CLAIM_SECONDS = 120;
|
||||
|
||||
/**
|
||||
* The request cannot be judged now: its nonce is held by an attempt not
|
||||
* confirmed as accepted (still running, or failed without giving the nonce
|
||||
* back), or the nonce store is unavailable. Not a proven replay: retry later.
|
||||
*/
|
||||
export class ReplayPendingError extends Error {
|
||||
constructor(message = "Replay nonce is held by an unconfirmed attempt") {
|
||||
super(message);
|
||||
}
|
||||
}
|
||||
|
||||
function parseTimestamp(value: string | undefined): number | null {
|
||||
if (!value) return null;
|
||||
@@ -17,14 +36,18 @@ function parseTimestamp(value: string | undefined): number | null {
|
||||
* (Unix seconds) and `X-WebHooker-Nonce` and signs
|
||||
* `timestamp + "." + nonce + "." + body` instead of the bare body. We reject
|
||||
* timestamps outside a ±5min window and reject any nonce already seen (nonces
|
||||
* live in KV for 10min). Senders without those headers keep the legacy
|
||||
* are kept for 10min). Senders without those headers keep the legacy
|
||||
* body-only signature so existing integrations continue to work.
|
||||
*
|
||||
* Nonces are scoped to the signing secret, so two tenants picking the same
|
||||
* nonce never block each other, and claimed atomically (D1 when available),
|
||||
* so two concurrent replays cannot both pass.
|
||||
*/
|
||||
async function verifyReplayProtected(
|
||||
body: string,
|
||||
headers: Record<string, string>,
|
||||
secret: string,
|
||||
kv: KVNamespace,
|
||||
env: Env,
|
||||
): Promise<boolean> {
|
||||
const timestamp = parseTimestamp(headers["x-webhooker-timestamp"]);
|
||||
const nonce = headers["x-webhooker-nonce"];
|
||||
@@ -37,11 +60,23 @@ async function verifyReplayProtected(
|
||||
const expected = `sha256=${await hmacSha256Hex(secret, `${timestamp}.${nonce}.${body}`)}`;
|
||||
if (!timingSafeEqual(signature ?? "", expected)) return false;
|
||||
|
||||
const nonceKey = `nonce:${nonce}`;
|
||||
const seen = await kv.get(nonceKey);
|
||||
if (seen !== null && seen !== undefined) return false;
|
||||
await kv.put(nonceKey, "1", { expirationTtl: NONCE_TTL_SECONDS });
|
||||
return true;
|
||||
const key = await replayNonceKey(secret, nonce);
|
||||
let state;
|
||||
try {
|
||||
state = await claimOnce(idempotencyStore(env.DB, env.KV), key, NONCE_CLAIM_SECONDS);
|
||||
} catch {
|
||||
// A storage failure says nothing about the signature.
|
||||
throw new ReplayPendingError("Replay protection is temporarily unavailable");
|
||||
}
|
||||
// Only a nonce whose request was accepted makes this a replay.
|
||||
if (state === "pending") throw new ReplayPendingError();
|
||||
return state === "claimed";
|
||||
}
|
||||
|
||||
/** Claim key of a replay-protection nonce, scoped to the signing secret. */
|
||||
export async function replayNonceKey(secret: string, nonce: string): Promise<string> {
|
||||
const scope = (await hmacSha256Hex(secret, "webhooker:nonce-scope")).slice(0, 16);
|
||||
return `nonce:${scope}:${nonce}`;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -72,7 +107,7 @@ export const customProvider: Provider = {
|
||||
headers["x-webhooker-timestamp"] !== undefined &&
|
||||
headers["x-webhooker-nonce"] !== undefined
|
||||
) {
|
||||
return verifyReplayProtected(body, headers, secret, env.KV);
|
||||
return verifyReplayProtected(body, headers, secret, env);
|
||||
}
|
||||
return verifySignature(body, headers["x-webhooker-signature"], secret);
|
||||
},
|
||||
@@ -80,7 +115,9 @@ export const customProvider: Provider = {
|
||||
parse(body, _headers): WebhookEvent | null {
|
||||
try {
|
||||
const payload = JSON.parse(body) as Record<string, unknown>;
|
||||
if (!payload || typeof payload !== "object") return null;
|
||||
// An object only: a top-level array (or scalar) could not be parked and
|
||||
// restored like every other payload, so it is refused up front.
|
||||
if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;
|
||||
// Optional id for sender-side dedup (retries from monitoring systems).
|
||||
const deliveryId =
|
||||
typeof payload.deliveryId === "string" && payload.deliveryId
|
||||
|
||||
+322
-86
@@ -1,22 +1,46 @@
|
||||
import type { H3Event } from "h3";
|
||||
import { getHeader, readRawBody, setResponseStatus } from "h3";
|
||||
import type { Env } from "./types";
|
||||
import type { Env, Group } from "./types";
|
||||
import { detectProvider } from "./providers";
|
||||
import { dispatchEvent } from "./core/dispatch";
|
||||
import { loadConfig, initConfigStore } from "./config";
|
||||
import { loadGroups, ensureInstallationGroup } from "./web/groups";
|
||||
import { loadConfigSnapshot, loadGroupFresh, initConfigStore } from "./config";
|
||||
import { ensureInstallationGroup } from "./web/groups";
|
||||
import { getTenantSecret } from "./web/tenants";
|
||||
import { NONCE_TTL_SECONDS, ReplayPendingError, replayNonceKey } from "./providers/custom";
|
||||
import { recordAudit } from "./lib/audit";
|
||||
import { cfEnv, cfWaitUntil, headersFrom } from "./cf";
|
||||
import { log } from "./lib/log";
|
||||
import { deliveryKey, idempotencyStore } from "./lib/idempotency";
|
||||
import { claimOnce, confirmClaim, deliveryKey, idempotencyStore } from "./lib/idempotency";
|
||||
import { newCorrelationId } from "./lib/correlation";
|
||||
import { enqueueWebhook, type DeliveryMessage } from "./queue/delivery";
|
||||
import {
|
||||
deliveryStateKey,
|
||||
enqueueWebhook,
|
||||
hadPermanentFailure,
|
||||
isRetryableFailure,
|
||||
markTargetsDone,
|
||||
targetDoneChecker,
|
||||
type DeliveryMessage,
|
||||
} from "./queue/delivery";
|
||||
|
||||
const MAX_BODY_SIZE = 1024 * 1024;
|
||||
/** How long a delivery's dedup claim lasts when it is queued. */
|
||||
const QUEUED_CLAIM_SECONDS = 120;
|
||||
/** How long it lasts for an inline dispatch, which may run for minutes. */
|
||||
const INLINE_CLAIM_SECONDS = 600;
|
||||
/** An installation's auto-provisioning is remembered as long as delivery state (7 days). */
|
||||
const PROVISIONED_TTL_SECONDS = 7 * 86400;
|
||||
/** Sending time of one inline dispatch: within its claim, with a margin. */
|
||||
const INLINE_SEND_BUDGET_MS = 8 * 60_000;
|
||||
|
||||
/** Result of an inline dispatch: whether the sender should retry. */
|
||||
interface InlineOutcome {
|
||||
retry: boolean;
|
||||
/** A target failed for good (in this or an earlier attempt). */
|
||||
failed: boolean;
|
||||
}
|
||||
|
||||
export interface WebhookResult {
|
||||
status: 200 | 400 | 401 | 404 | 413;
|
||||
status: 200 | 400 | 401 | 404 | 413 | 503;
|
||||
body: unknown;
|
||||
}
|
||||
|
||||
@@ -27,6 +51,10 @@ export interface WebhookResult {
|
||||
* `POST /webhook/{groupId}`) the group's own secret is used for verification
|
||||
* (GITHUB_WEBHOOK_SECRET/GITEA_WEBHOOK_SECRET are overridden per request) and
|
||||
* only that group's routes are eligible.
|
||||
*
|
||||
* A tenant-signed payload is only as trustworthy as the tenant: its claimed
|
||||
* GitHub App installation is dropped, so it can neither borrow the operator's
|
||||
* App credentials nor provision or rebind installation groups.
|
||||
*/
|
||||
export async function processWebhook(
|
||||
env: Env,
|
||||
@@ -38,30 +66,39 @@ export async function processWebhook(
|
||||
const requestId = newCorrelationId();
|
||||
let effectiveEnv = env;
|
||||
initConfigStore(env);
|
||||
const groups = await loadGroups(env.KV);
|
||||
// Until the request is verified, nothing but the receiving group's own row
|
||||
// is read (fresh): an unsigned flood must not read the whole configuration
|
||||
// each time. The full snapshot is read once the event is accepted.
|
||||
const provider = detectProvider(headers);
|
||||
if (!provider) {
|
||||
return { status: 400, body: { error: "Unknown webhook provider" } };
|
||||
}
|
||||
let tenant: Group | undefined;
|
||||
if (tenantId) {
|
||||
if (!groups.some((g) => g.id === tenantId)) {
|
||||
const found = await loadGroupFresh(env, tenantId);
|
||||
if (!found.group) {
|
||||
// Unreadable is not missing: the sender is asked to retry.
|
||||
if (found.unreadable) {
|
||||
return { status: 503, body: { error: "Group configuration unreadable; retry later" } };
|
||||
}
|
||||
return { status: 404, body: { error: "Group not found" } };
|
||||
}
|
||||
const secret = await getTenantSecret(
|
||||
env.KV,
|
||||
groups.find((g) => g.id === tenantId)!,
|
||||
);
|
||||
tenant = found.group;
|
||||
const secret = await getTenantSecret(env.KV, tenant);
|
||||
if (!secret) {
|
||||
return { status: 404, body: { error: "Webhook disabled for this group" } };
|
||||
}
|
||||
effectiveEnv = { ...env, GITHUB_WEBHOOK_SECRET: secret, GITEA_WEBHOOK_SECRET: secret };
|
||||
}
|
||||
|
||||
const provider = detectProvider(headers);
|
||||
if (!provider) {
|
||||
return { status: 400, body: { error: "Unknown webhook provider" } };
|
||||
}
|
||||
|
||||
let verified = false;
|
||||
try {
|
||||
verified = await provider.verify(body, headers, effectiveEnv);
|
||||
} catch (err) {
|
||||
if (err instanceof ReplayPendingError) {
|
||||
// The nonce is held by an attempt not (yet) accepted: not a replay.
|
||||
return { status: 503, body: { error: "Request is already being processed; retry later" } };
|
||||
}
|
||||
// A malformed secret or an unavailable crypto implementation must fail as
|
||||
// a clean 401, never an uncaught 500.
|
||||
log.warn(
|
||||
@@ -88,82 +125,281 @@ export async function processWebhook(
|
||||
return { status: 401, body: { error: "Invalid signature" } };
|
||||
}
|
||||
|
||||
const event = provider.parse(body, headers);
|
||||
if (!event) {
|
||||
return { status: 400, body: { error: "Invalid event" } };
|
||||
// From here on, one-time claims are held (the custom-webhook nonce taken
|
||||
// by `verify`, the delivery dedup key). Only once the event is accepted
|
||||
// (queued, or dispatched without a transient failure) are they confirmed;
|
||||
// otherwise they are given back, so the sender's retry is not refused. A
|
||||
// claim that could not be given back is never mistaken for an accepted
|
||||
// event: a retry finds it unconfirmed and is asked to come back later.
|
||||
const claims = idempotencyStore(env.DB, env.KV);
|
||||
const held: { key: string; ttl: number }[] = [];
|
||||
const nonce = headers["x-webhooker-nonce"];
|
||||
if (provider.id === "custom" && nonce && headers["x-webhooker-timestamp"]) {
|
||||
held.push({
|
||||
key: await replayNonceKey(effectiveEnv.GITHUB_WEBHOOK_SECRET, nonce),
|
||||
ttl: NONCE_TTL_SECONDS,
|
||||
});
|
||||
}
|
||||
|
||||
// Auto-provision GitHub App installations so tenant isolation is configured
|
||||
// without manual id entry: a group is created (or existing matching groups
|
||||
// are bound) before the event is dispatched.
|
||||
if (
|
||||
provider.id === "github" &&
|
||||
event.event === "installation" &&
|
||||
event.payload.action === "created" &&
|
||||
event.installationId != null
|
||||
) {
|
||||
const install = event.payload.installation as { account?: { login?: string } } | undefined;
|
||||
const account = install?.account?.login ?? "";
|
||||
try {
|
||||
const group = await ensureInstallationGroup(env.KV, event.installationId, account);
|
||||
if (group) {
|
||||
await recordAudit(env.DB, {
|
||||
ts: Date.now(),
|
||||
actorLogin: account || undefined,
|
||||
action: "installation.created",
|
||||
targetType: "group",
|
||||
targetId: group.id,
|
||||
groupId: group.id,
|
||||
});
|
||||
}
|
||||
} catch (err) {
|
||||
log.warn(
|
||||
{ err, installationId: event.installationId },
|
||||
"Failed to auto-provision installation group",
|
||||
);
|
||||
const releaseClaims = async (): Promise<void> => {
|
||||
for (const { key } of held.splice(0)) {
|
||||
await claims.release(key).catch((err: unknown) => {
|
||||
log.warn({ requestId, key, err }, "Failed to release a webhook claim");
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
const confirmClaims = async (): Promise<void> => {
|
||||
for (const { key, ttl } of held.splice(0)) {
|
||||
// Unconfirmed, a claim only delays a duplicate until it expires.
|
||||
await confirmClaim(claims, key, ttl).catch((err: unknown) => {
|
||||
log.warn({ requestId, key, err }, "Failed to confirm a webhook claim");
|
||||
});
|
||||
}
|
||||
};
|
||||
const retryLater = (error: string): WebhookResult => ({
|
||||
status: 503,
|
||||
body: { error, requestId },
|
||||
});
|
||||
|
||||
try {
|
||||
const event = provider.parse(body, headers);
|
||||
if (!event) {
|
||||
await releaseClaims();
|
||||
return { status: 400, body: { error: "Invalid event" } };
|
||||
}
|
||||
if (tenantId) event.installationId = undefined;
|
||||
|
||||
if (event.deliveryId) {
|
||||
// Dedup via the idempotency store: a provider/tenant-scoped key means
|
||||
// different accounts may reuse a delivery id without colliding, while
|
||||
// retries of the same delivery never dispatch twice.
|
||||
const store = idempotencyStore(env.DB, env.KV);
|
||||
const key = deliveryKey(provider.id, tenantId, event.deliveryId);
|
||||
if (!(await store.claim(key, 120))) {
|
||||
return { status: 200, body: { ok: true, duplicate: true, requestId } };
|
||||
// retries of the same delivery never dispatch twice. An inline dispatch
|
||||
// holds its claim for as long as it may run.
|
||||
// A custom sender's ids are namespaced (`d:`) as its delivery identity is
|
||||
// below: no id it picks can take the key of a nonce-identified request.
|
||||
const dedupKey = event.deliveryId
|
||||
? deliveryKey(
|
||||
provider.id,
|
||||
tenantId,
|
||||
provider.id === "custom" ? `d:${event.deliveryId}` : event.deliveryId,
|
||||
tenant?.instance,
|
||||
)
|
||||
: null;
|
||||
if (dedupKey) {
|
||||
const ttl = env.QUEUE ? QUEUED_CLAIM_SECONDS : INLINE_CLAIM_SECONDS;
|
||||
const state = await claimOnce(claims, dedupKey, ttl);
|
||||
if (state === "done") {
|
||||
// Already accepted: this request's own nonce is used up as well.
|
||||
await confirmClaims();
|
||||
return { status: 200, body: { ok: true, duplicate: true, requestId } };
|
||||
}
|
||||
if (state === "pending") {
|
||||
// Still in flight elsewhere, or left over from an attempt that was
|
||||
// not accepted: the event may not be on its way yet.
|
||||
await releaseClaims();
|
||||
return retryLater("Delivery is already being processed; retry later");
|
||||
}
|
||||
held.push({ key: dedupKey, ttl });
|
||||
}
|
||||
|
||||
// Provisioning runs only for an event not yet accepted (a duplicate
|
||||
// returned above): a redelivery must not redo a binding an admin undid.
|
||||
// Auto-provision GitHub App installations so tenant isolation is
|
||||
// configured without manual id entry: a group is created (or existing
|
||||
// matching groups are bound) before the event is dispatched. Only events
|
||||
// signed with the operator's own secret (the global endpoint) may do this.
|
||||
if (
|
||||
!tenantId &&
|
||||
provider.id === "github" &&
|
||||
event.event === "installation" &&
|
||||
event.payload.action === "created" &&
|
||||
event.installationId != null
|
||||
) {
|
||||
const install = event.payload.installation as { account?: { login?: string } } | undefined;
|
||||
const account = install?.account?.login ?? "";
|
||||
// Done once per installation, on record as long as delivery state is
|
||||
// kept: a redelivery after the dedup claim lapsed (minutes) must not
|
||||
// redo a binding an admin undid since. Recorded only once it succeeded,
|
||||
// so a provisioning that failed midway is completed by the retry.
|
||||
const doneKey = `installation-provisioned:${event.installationId}`;
|
||||
try {
|
||||
if (!(await claims.has(doneKey))) {
|
||||
const group = await ensureInstallationGroup(
|
||||
env.KV,
|
||||
event.installationId,
|
||||
account,
|
||||
env.DB,
|
||||
);
|
||||
await claims.claim(doneKey, PROVISIONED_TTL_SECONDS);
|
||||
if (group) {
|
||||
await recordAudit(env.DB, {
|
||||
ts: Date.now(),
|
||||
actorLogin: account || undefined,
|
||||
action: "installation.created",
|
||||
targetType: "group",
|
||||
targetId: group.id,
|
||||
groupId: group.id,
|
||||
groupInstance: group.instance,
|
||||
});
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
// Not accepted: the consumer never provisions, so a sender retry is
|
||||
// the only way the group gets created (provisioning is idempotent).
|
||||
log.warn(
|
||||
{ err, installationId: event.installationId },
|
||||
"Failed to auto-provision installation group",
|
||||
);
|
||||
await releaseClaims();
|
||||
return retryLater("Installation provisioning failed; retry later");
|
||||
}
|
||||
}
|
||||
|
||||
// A stable identity across the sender's retries: the delivery id, else the
|
||||
// replay-protection nonce of a signed request. Queued or inline, it keys
|
||||
// the delivery's state and target ledger, so a retry of a request whose
|
||||
// first attempt went through after all is recognized, not sent again.
|
||||
// A custom sender picks its delivery ids freely: they get a namespace of
|
||||
// their own, so none can coincide with a nonce-derived identity.
|
||||
const nonceKey = held.find((h) => h.key.startsWith("nonce:"))?.key;
|
||||
const identity =
|
||||
event.deliveryId != null
|
||||
? provider.id === "custom"
|
||||
? `d:${event.deliveryId}`
|
||||
: event.deliveryId
|
||||
: nonceKey
|
||||
? `n:${nonceKey}`
|
||||
: undefined;
|
||||
|
||||
// Inline, a request identified by its nonce alone is held for the whole
|
||||
// dispatch, as a delivery id is above: its nonce claim is short (shorter
|
||||
// than a long dispatch), and a copy arriving meanwhile must not send the
|
||||
// targets not yet on the ledger a second time.
|
||||
if (!env.QUEUE && event.deliveryId == null && identity) {
|
||||
const key = deliveryKey(provider.id, tenantId, identity, tenant?.instance);
|
||||
const state = await claimOnce(claims, key, INLINE_CLAIM_SECONDS);
|
||||
if (state === "done") {
|
||||
await confirmClaims();
|
||||
return { status: 200, body: { ok: true, duplicate: true, requestId } };
|
||||
}
|
||||
if (state === "pending") {
|
||||
await releaseClaims();
|
||||
return retryLater("Delivery is already being processed; retry later");
|
||||
}
|
||||
held.push({ key, ttl: INLINE_CLAIM_SECONDS });
|
||||
}
|
||||
|
||||
if (env.QUEUE) {
|
||||
const message: DeliveryMessage = {
|
||||
deliveryId: identity ?? requestId,
|
||||
groupId: tenantId,
|
||||
groupInstance: tenant?.instance,
|
||||
provider: provider.id,
|
||||
event: event.event,
|
||||
payload: event.payload,
|
||||
installationId: event.installationId,
|
||||
receivedAt: Date.now(),
|
||||
requestId,
|
||||
stateVersion: 2,
|
||||
};
|
||||
// Acknowledge only once the event is durably queued.
|
||||
await enqueueWebhook(env, message);
|
||||
await confirmClaims();
|
||||
return { status: 200, body: { ok: true, requestId } };
|
||||
}
|
||||
|
||||
// Inline dispatch (no queue): there is no durable retry, so the sender
|
||||
// is answered only after the dispatch, and asked to retry while a target
|
||||
// failed transiently. A delivery id gets a target ledger, so targets
|
||||
// already sent are skipped when the sender redelivers.
|
||||
// One consistent snapshot of routes and groups serves the dispatch — read
|
||||
// fresh: a route or target removed moments ago in another isolate must
|
||||
// not still be dispatched to from this isolate's cache.
|
||||
const snapshot = await loadConfigSnapshot(env, { fresh: true });
|
||||
if (tenantId) {
|
||||
const current = snapshot.groups.find((g) => g.id === tenantId);
|
||||
if (!current || current.instance !== tenant?.instance) {
|
||||
// Gone or replaced since its row was read: not this group's event now.
|
||||
await releaseClaims();
|
||||
if (snapshot.config.unreadableGroups?.includes(tenantId)) {
|
||||
return retryLater("Group configuration unreadable; retry later");
|
||||
}
|
||||
return { status: 404, body: { error: "Group not found" } };
|
||||
}
|
||||
}
|
||||
const scoped = tenantId
|
||||
? {
|
||||
...snapshot.config,
|
||||
routes: snapshot.config.routes.filter((r) => r.groupId === tenantId),
|
||||
}
|
||||
: snapshot.config;
|
||||
const ledgerKey = identity
|
||||
? deliveryStateKey(provider.id, tenantId, identity, tenant?.instance)
|
||||
: null;
|
||||
const run = (async (): Promise<InlineOutcome> => {
|
||||
const recorded = new Set<string>();
|
||||
// Dispatched under the delivery's identity (as a queued copy is), so the
|
||||
// platform idempotency keys stay the same when the sender retries.
|
||||
const delivered = identity ? { ...event, deliveryId: identity } : event;
|
||||
// Sending stops well before the claim held for this dispatch expires
|
||||
// (a target takes under a minute at worst): a copy arriving after that
|
||||
// could otherwise send the targets still in flight. What is left is a
|
||||
// transient failure, so the sender retries it (the ledger skips the rest).
|
||||
const sendUntil = Date.now() + INLINE_SEND_BUDGET_MS;
|
||||
const summary = await dispatchEvent(scoped, delivered, env, snapshot.groups, {
|
||||
tenantId,
|
||||
beforeTarget: async (): Promise<boolean> => Date.now() < sendUntil,
|
||||
skipTarget: ledgerKey ? targetDoneChecker(env, ledgerKey) : undefined,
|
||||
afterTarget: ledgerKey
|
||||
? async (targetKey): Promise<void> => {
|
||||
await markTargetsDone(env, ledgerKey, [targetKey]);
|
||||
recorded.add(targetKey);
|
||||
}
|
||||
: undefined,
|
||||
});
|
||||
const permanent = summary.failures.filter((f) => !isRetryableFailure(f));
|
||||
if (ledgerKey) {
|
||||
await markTargetsDone(
|
||||
env,
|
||||
ledgerKey,
|
||||
[...(summary.succeeded ?? []), ...permanent.flatMap((f) => f.key ?? [])].filter(
|
||||
(k) => !recorded.has(k),
|
||||
),
|
||||
{ permanentFailure: permanent.length > 0 },
|
||||
);
|
||||
}
|
||||
// A transient failure is always retried: without a ledger the retry
|
||||
// sends the other targets again too — duplicates rather than a loss.
|
||||
return {
|
||||
retry: summary.failures.some(isRetryableFailure),
|
||||
// Targets that failed for good in an earlier attempt still count.
|
||||
failed:
|
||||
permanent.length > 0 ||
|
||||
(ledgerKey != null && (await hadPermanentFailure(env, ledgerKey))),
|
||||
};
|
||||
})();
|
||||
// The dispatch keeps running should the sender hang up meanwhile.
|
||||
waitUntil(run.catch(() => undefined));
|
||||
let outcome: InlineOutcome;
|
||||
try {
|
||||
outcome = await run;
|
||||
} catch (err) {
|
||||
log.error({ requestId, err }, "Dispatch failed");
|
||||
await releaseClaims();
|
||||
return retryLater("Dispatch failed; retry later");
|
||||
}
|
||||
if (outcome.retry) {
|
||||
log.warn({ requestId }, "Inline dispatch failed transiently");
|
||||
await releaseClaims();
|
||||
return retryLater("Some targets failed temporarily; retry later");
|
||||
}
|
||||
await confirmClaims();
|
||||
// Accepted for good; a target that can never take the event is reported.
|
||||
return outcome.failed
|
||||
? { status: 200, body: { ok: true, requestId, failed: true } }
|
||||
: { status: 200, body: { ok: true, requestId } };
|
||||
} catch (err) {
|
||||
log.error({ requestId, err }, "Failed to accept webhook");
|
||||
await releaseClaims();
|
||||
return retryLater("Temporarily unable to accept webhook");
|
||||
}
|
||||
|
||||
const config = await loadConfig(env);
|
||||
if (tenantId) {
|
||||
config.routes = config.routes.filter((r) => r.groupId === tenantId);
|
||||
}
|
||||
|
||||
if (env.QUEUE) {
|
||||
const message: DeliveryMessage = {
|
||||
deliveryId: event.deliveryId ?? requestId,
|
||||
groupId: tenantId,
|
||||
provider: provider.id,
|
||||
event: event.event,
|
||||
payload: event.payload,
|
||||
installationId: event.installationId,
|
||||
receivedAt: Date.now(),
|
||||
requestId,
|
||||
};
|
||||
const enqueue = enqueueWebhook(env, message).catch((err) =>
|
||||
log.error({ requestId, err }, "Failed to enqueue webhook"),
|
||||
);
|
||||
waitUntil(enqueue);
|
||||
return { status: 200, body: { ok: true, requestId } };
|
||||
}
|
||||
|
||||
const dispatch = dispatchEvent(config, event, env, groups).catch((err) =>
|
||||
log.error({ requestId, err }, "Dispatch failed"),
|
||||
);
|
||||
waitUntil(dispatch);
|
||||
|
||||
return { status: 200, body: { ok: true, requestId } };
|
||||
}
|
||||
|
||||
/** h3 wrapper for `POST /webhook` / `POST /webhook/:groupId`. */
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
import { describe, it, expect } from "bun:test";
|
||||
import { createHmac } from "crypto";
|
||||
import { customProvider } from "../server/lib/providers/custom";
|
||||
import { customProvider, ReplayPendingError, replayNonceKey } from "../server/lib/providers/custom";
|
||||
import { acceptedKey, idempotencyStore } from "../server/lib/lib/idempotency";
|
||||
import type { Env } from "../server/lib/types";
|
||||
|
||||
function createMockKV(): KVNamespace {
|
||||
@@ -60,9 +61,29 @@ describe("custom provider replay protection", () => {
|
||||
"x-webhooker-nonce": nonce,
|
||||
};
|
||||
expect(await customProvider.verify(body, headers, env)).toBe(true);
|
||||
// While the first request is not confirmed as accepted, the nonce is
|
||||
// neither free nor a proven replay.
|
||||
expect(customProvider.verify(body, headers, env)).rejects.toBeInstanceOf(ReplayPendingError);
|
||||
const key = await replayNonceKey(secret, nonce);
|
||||
await idempotencyStore(env.DB, env.KV).claim(acceptedKey(key), 600);
|
||||
expect(await customProvider.verify(body, headers, env)).toBe(false);
|
||||
});
|
||||
|
||||
it("scopes nonces to the signing secret", async () => {
|
||||
const kv = createMockKV();
|
||||
const body = JSON.stringify({ hello: "world" });
|
||||
const nonce = "shared-nonce";
|
||||
for (const secret of ["tenant-a", "tenant-b"]) {
|
||||
const env = { ...createEnv(secret), KV: kv };
|
||||
const headers = {
|
||||
"x-webhooker-signature": replaySignature(secret, now, nonce, body),
|
||||
"x-webhooker-timestamp": String(now),
|
||||
"x-webhooker-nonce": nonce,
|
||||
};
|
||||
expect(await customProvider.verify(body, headers, env)).toBe(true);
|
||||
}
|
||||
});
|
||||
|
||||
it("rejects a timestamp outside the window", async () => {
|
||||
const secret = "s3cret";
|
||||
const env = createEnv(secret);
|
||||
|
||||
@@ -0,0 +1,560 @@
|
||||
import { describe, it, expect, afterEach } from "bun:test";
|
||||
import { createHmac } from "crypto";
|
||||
import { processWebhook } from "../server/lib/webhook";
|
||||
import { dispatchEvent } from "../server/lib/core/dispatch";
|
||||
import { resetConfigStore } from "../server/lib/config";
|
||||
import { githubApiUrl } from "../server/lib/github/app-token";
|
||||
import { htmlToText } from "../server/lib/formatters/helpers";
|
||||
import { formatEvent } from "../server/lib/formatters";
|
||||
import { renderNeutralMessage as renderTelegram } from "../server/lib/drivers/telegram/render";
|
||||
import { createMemoryKV, createSqliteD1 } from "./d1-sqlite";
|
||||
import type { Config, Env, Group, Route } from "../server/lib/types";
|
||||
import type { DeliveryMessage, DispatchSummary } from "../server/lib/queue/delivery";
|
||||
|
||||
const restoredFetch = globalThis.fetch;
|
||||
afterEach(() => {
|
||||
globalThis.fetch = restoredFetch;
|
||||
});
|
||||
|
||||
function sign(body: string, secret: string): string {
|
||||
return `sha256=${createHmac("sha256", secret).update(body).digest("hex")}`;
|
||||
}
|
||||
|
||||
function config(routes: Route[]): Config {
|
||||
return {
|
||||
baseUrl: "https://x",
|
||||
github: { webhookSecret: "", appId: 0, privateKey: "", clientId: "", clientSecret: "" },
|
||||
discord: { token: "t" },
|
||||
routes,
|
||||
};
|
||||
}
|
||||
|
||||
function route(id: string, groupId: string, extra: Partial<Route> = {}): Route {
|
||||
return {
|
||||
id,
|
||||
name: id,
|
||||
enabled: true,
|
||||
filters: [{ type: "event", match: ["push", "workflow_run", "issues"] }],
|
||||
targets: [{ platform: "discord", channelId: "c1" }],
|
||||
groupId,
|
||||
...extra,
|
||||
};
|
||||
}
|
||||
|
||||
const group = (id: string, extra: Partial<Group> = {}): Group => ({
|
||||
id,
|
||||
name: id,
|
||||
adminIds: [],
|
||||
...extra,
|
||||
});
|
||||
|
||||
describe("webhook ingress", () => {
|
||||
function tenantEnv(queue?: Queue, routes: Route[] = [route("r", "team")]): Env {
|
||||
const { kv, store } = createMemoryKV();
|
||||
store.set("config:groups", JSON.stringify([group("team")]));
|
||||
store.set("config:routes", JSON.stringify(routes));
|
||||
store.set("tenant:team", "tenant-secret");
|
||||
resetConfigStore(kv);
|
||||
return {
|
||||
GITHUB_WEBHOOK_SECRET: "global",
|
||||
DISCORD_TOKEN: "t",
|
||||
KV: kv,
|
||||
DB: {} as D1Database,
|
||||
QUEUE: queue,
|
||||
};
|
||||
}
|
||||
|
||||
it("never lets an accepted installation event provision again when redelivered", async () => {
|
||||
const sent: DeliveryMessage[] = [];
|
||||
const queue = { send: async (m: DeliveryMessage) => void sent.push(m) } as unknown as Queue;
|
||||
const env = tenantEnv(queue);
|
||||
const body = JSON.stringify({
|
||||
action: "created",
|
||||
installation: { id: 123, account: { login: "acme" } },
|
||||
});
|
||||
const headers = {
|
||||
"x-github-event": "installation",
|
||||
"x-github-delivery": "inst-dup",
|
||||
"x-hub-signature-256": sign(body, "global"),
|
||||
};
|
||||
expect((await processWebhook(env, body, headers, () => undefined)).status).toBe(200);
|
||||
const { loadGroups, updateGroup } = await import("../server/lib/web/groups");
|
||||
const created = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "inst-123");
|
||||
expect(created?.installationId).toBe(123);
|
||||
// A super admin unbinds it; the same delivery arrives again.
|
||||
await updateGroup(env.KV, "inst-123", (g) => ({ ...g, installationId: undefined }));
|
||||
const again = await processWebhook(env, body, headers, () => undefined);
|
||||
expect(again.body).toMatchObject({ duplicate: true });
|
||||
const after = (await loadGroups(env.KV, { fresh: true })).find((g) => g.id === "inst-123");
|
||||
expect(after?.installationId).toBeUndefined();
|
||||
});
|
||||
|
||||
it("asks for a retry when installation provisioning failed, queueing nothing", async () => {
|
||||
const sent: DeliveryMessage[] = [];
|
||||
const queue = { send: async (m: DeliveryMessage) => void sent.push(m) } as unknown as Queue;
|
||||
const env = tenantEnv(queue);
|
||||
const kvPut = env.KV.put.bind(env.KV);
|
||||
env.KV.put = (async (key: string, ...rest: unknown[]): Promise<void> =>
|
||||
key === "config:groups"
|
||||
? Promise.reject(new Error("KV down"))
|
||||
: (kvPut as (...a: unknown[]) => Promise<void>)(key, ...rest)) as KVNamespace["put"];
|
||||
const body = JSON.stringify({
|
||||
action: "created",
|
||||
installation: { id: 99, account: { login: "acme" } },
|
||||
});
|
||||
const res = await processWebhook(
|
||||
env,
|
||||
body,
|
||||
{
|
||||
"x-github-event": "installation",
|
||||
"x-github-delivery": "inst-1",
|
||||
"x-hub-signature-256": sign(body, "global"),
|
||||
},
|
||||
() => undefined,
|
||||
);
|
||||
expect(res.status).toBe(503);
|
||||
expect(sent).toHaveLength(0);
|
||||
});
|
||||
|
||||
it("never passes a claim it could not give back for an accepted duplicate", async () => {
|
||||
let fail = true;
|
||||
const sent: DeliveryMessage[] = [];
|
||||
const queue = {
|
||||
send: async (m: DeliveryMessage) => {
|
||||
if (fail) throw new Error("queue down");
|
||||
sent.push(m);
|
||||
},
|
||||
} as unknown as Queue;
|
||||
const env = tenantEnv(queue);
|
||||
// Giving the claim back fails too.
|
||||
const kvDelete = env.KV.delete.bind(env.KV);
|
||||
env.KV.delete = async (key: string): Promise<void> =>
|
||||
key.startsWith("delivery:") ? Promise.reject(new Error("KV down")) : kvDelete(key);
|
||||
const body = JSON.stringify({ ref: "refs/heads/main" });
|
||||
const headers = {
|
||||
"x-github-event": "push",
|
||||
"x-github-delivery": "d-3",
|
||||
"x-hub-signature-256": sign(body, "tenant-secret"),
|
||||
};
|
||||
expect((await processWebhook(env, body, headers, () => undefined, "team")).status).toBe(503);
|
||||
fail = false;
|
||||
// The leftover claim is not confirmed: the retry is told to come back,
|
||||
// never acknowledged as a duplicate of an event that was never queued.
|
||||
const retry = await processWebhook(env, body, headers, () => undefined, "team");
|
||||
expect(retry.status).toBe(503);
|
||||
expect(sent).toHaveLength(0);
|
||||
});
|
||||
|
||||
it("keeps one delivery identity for a nonce-signed request retried after an unclear enqueue", async () => {
|
||||
const sent: DeliveryMessage[] = [];
|
||||
let first = true;
|
||||
const queue = {
|
||||
send: async (m: DeliveryMessage) => {
|
||||
sent.push(m);
|
||||
// The queue took it, but the answer was lost.
|
||||
if (first) {
|
||||
first = false;
|
||||
throw new Error("connection reset");
|
||||
}
|
||||
},
|
||||
} as unknown as Queue;
|
||||
const env = tenantEnv(queue);
|
||||
const body = JSON.stringify({ alert: "disk full" });
|
||||
const ts = String(Math.floor(Date.now() / 1000));
|
||||
const headers = {
|
||||
"x-webhooker-signature": `sha256=${createHmac("sha256", "tenant-secret")
|
||||
.update(`${ts}.n-1.${body}`)
|
||||
.digest("hex")}`,
|
||||
"x-webhooker-timestamp": ts,
|
||||
"x-webhooker-nonce": "n-1",
|
||||
};
|
||||
expect((await processWebhook(env, body, headers, () => undefined, "team")).status).toBe(503);
|
||||
expect((await processWebhook(env, body, headers, () => undefined, "team")).status).toBe(200);
|
||||
expect(sent).toHaveLength(2);
|
||||
// Same delivery: the consumer recognizes the second copy.
|
||||
expect(sent[1]!.deliveryId).toBe(sent[0]!.deliveryId);
|
||||
});
|
||||
|
||||
it("asks for a retry on a transient failure even without a delivery id", async () => {
|
||||
const env = tenantEnv(undefined, [
|
||||
route("r", "team", {
|
||||
event: undefined,
|
||||
filters: [{ type: "event", match: "custom" }],
|
||||
targets: [
|
||||
{ platform: "discord", channelId: "ok" },
|
||||
{ platform: "discord", channelId: "flaky" },
|
||||
],
|
||||
}),
|
||||
]);
|
||||
globalThis.fetch = async (input): Promise<Response> =>
|
||||
String(input).includes("/channels/flaky/")
|
||||
? new Response(JSON.stringify({ retry_after: 999 }), { status: 429 })
|
||||
: new Response(JSON.stringify({ id: "m" }), { status: 200 });
|
||||
const body = JSON.stringify({ alert: "disk full" });
|
||||
const headers = { "x-webhooker-signature": sign(body, "tenant-secret") };
|
||||
// No identity to skip what was sent: a duplicate beats a lost target.
|
||||
const res = await processWebhook(env, body, headers, () => undefined, "team");
|
||||
expect(res.status).toBe(503);
|
||||
});
|
||||
|
||||
it("answers an inline dispatch after it ran and asks for a retry on a transient failure", async () => {
|
||||
const env = tenantEnv(undefined, [
|
||||
route("r", "team", {
|
||||
targets: [
|
||||
{ platform: "discord", channelId: "ok" },
|
||||
{ platform: "discord", channelId: "flaky" },
|
||||
],
|
||||
}),
|
||||
]);
|
||||
const calls: Record<string, number> = {};
|
||||
let limited = true;
|
||||
globalThis.fetch = async (input): Promise<Response> => {
|
||||
const channel = String(input).split("/channels/")[1]!.split("/")[0]!;
|
||||
calls[channel] = (calls[channel] ?? 0) + 1;
|
||||
if (channel === "flaky" && limited) {
|
||||
return new Response(JSON.stringify({ retry_after: 999 }), { status: 429 });
|
||||
}
|
||||
return new Response(JSON.stringify({ id: "m" }), { status: 200 });
|
||||
};
|
||||
const body = JSON.stringify({ ref: "refs/heads/main" });
|
||||
const headers = {
|
||||
"x-github-event": "push",
|
||||
"x-github-delivery": "d-4",
|
||||
"x-hub-signature-256": sign(body, "tenant-secret"),
|
||||
};
|
||||
const first = await processWebhook(env, body, headers, () => undefined, "team");
|
||||
expect(first.status).toBe(503);
|
||||
limited = false;
|
||||
const retry = await processWebhook(env, body, headers, () => undefined, "team");
|
||||
expect(retry.status).toBe(200);
|
||||
// The target sent the first time is not sent again.
|
||||
expect(calls).toEqual({ ok: 1, flaky: 2 });
|
||||
const again = await processWebhook(env, body, headers, () => undefined, "team");
|
||||
expect(again.body).toMatchObject({ duplicate: true });
|
||||
});
|
||||
|
||||
it("answers 503 and releases the dedup claim when the queue rejects the event", async () => {
|
||||
let fail = true;
|
||||
const sent: DeliveryMessage[] = [];
|
||||
const queue = {
|
||||
send: async (m: DeliveryMessage) => {
|
||||
if (fail) throw new Error("queue down");
|
||||
sent.push(m);
|
||||
},
|
||||
} as unknown as Queue;
|
||||
const env = tenantEnv(queue);
|
||||
const body = JSON.stringify({ ref: "refs/heads/main" });
|
||||
const headers = {
|
||||
"x-github-event": "push",
|
||||
"x-github-delivery": "d-1",
|
||||
"x-hub-signature-256": sign(body, "tenant-secret"),
|
||||
};
|
||||
const first = await processWebhook(env, body, headers, () => undefined, "team");
|
||||
expect(first.status).toBe(503);
|
||||
fail = false;
|
||||
// The sender's redelivery is accepted, not dropped as a duplicate.
|
||||
const retry = await processWebhook(env, body, headers, () => undefined, "team");
|
||||
expect(retry.status).toBe(200);
|
||||
expect((retry.body as { duplicate?: boolean }).duplicate).toBeUndefined();
|
||||
expect(sent).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("drops the installation claim of tenant-signed payloads", async () => {
|
||||
const sent: DeliveryMessage[] = [];
|
||||
const queue = { send: async (m: DeliveryMessage) => void sent.push(m) } as unknown as Queue;
|
||||
const env = tenantEnv(queue);
|
||||
const body = JSON.stringify({
|
||||
action: "created",
|
||||
installation: { id: 999, account: { login: "victim" } },
|
||||
});
|
||||
const headers = {
|
||||
"x-github-event": "installation",
|
||||
"x-github-delivery": "d-2",
|
||||
"x-hub-signature-256": sign(body, "tenant-secret"),
|
||||
};
|
||||
const res = await processWebhook(env, body, headers, () => undefined, "team");
|
||||
expect(res.status).toBe(200);
|
||||
expect(sent[0]!.installationId).toBeUndefined();
|
||||
// No group was provisioned for the claimed installation.
|
||||
const groups = JSON.parse((await env.KV.get("config:groups"))!) as Group[];
|
||||
expect(groups.map((g) => g.id)).toEqual(["team"]);
|
||||
});
|
||||
|
||||
it("never lets a custom delivery id take the key of a nonce-identified request", async () => {
|
||||
const env = tenantEnv(undefined, [
|
||||
route("r", "team", {
|
||||
event: undefined,
|
||||
filters: [{ type: "event", match: "custom" }],
|
||||
targets: [{ platform: "discord", channelId: "ok" }],
|
||||
}),
|
||||
]);
|
||||
let sends = 0;
|
||||
globalThis.fetch = async (): Promise<Response> => {
|
||||
sends++;
|
||||
return new Response(JSON.stringify({ id: "m" }), { status: 200 });
|
||||
};
|
||||
const { replayNonceKey } = await import("../server/lib/providers/custom");
|
||||
const nonce = "n-77";
|
||||
// Event A names, as its delivery id, exactly the identity event B's nonce gets.
|
||||
const a = JSON.stringify({ deliveryId: `n:${await replayNonceKey("tenant-secret", nonce)}` });
|
||||
expect(
|
||||
(
|
||||
await processWebhook(
|
||||
env,
|
||||
a,
|
||||
{ "x-webhooker-signature": sign(a, "tenant-secret") },
|
||||
() => undefined,
|
||||
"team",
|
||||
)
|
||||
).status,
|
||||
).toBe(200);
|
||||
const b = JSON.stringify({ alert: "other event" });
|
||||
const ts = String(Math.floor(Date.now() / 1000));
|
||||
const res = await processWebhook(
|
||||
env,
|
||||
b,
|
||||
{
|
||||
"x-webhooker-signature": `sha256=${createHmac("sha256", "tenant-secret")
|
||||
.update(`${ts}.${nonce}.${b}`)
|
||||
.digest("hex")}`,
|
||||
"x-webhooker-timestamp": ts,
|
||||
"x-webhooker-nonce": nonce,
|
||||
},
|
||||
() => undefined,
|
||||
"team",
|
||||
);
|
||||
expect(res.status).toBe(200);
|
||||
expect((res.body as { duplicate?: boolean }).duplicate).toBeUndefined();
|
||||
expect(sends).toBe(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe("dispatch", () => {
|
||||
function env(): Env {
|
||||
return { GITHUB_WEBHOOK_SECRET: "", KV: createMemoryKV().kv, DB: createSqliteD1().db };
|
||||
}
|
||||
|
||||
it("records a formatter crash as a permanent failure instead of dropping it", async () => {
|
||||
globalThis.fetch = async (): Promise<Response> => new Response("{}", { status: 200 });
|
||||
const e = env();
|
||||
const summary = await dispatchEvent(
|
||||
config([route("r", "g")]),
|
||||
// `issue: null` makes the issues formatter throw.
|
||||
{ event: "issues", payload: { issue: null } as never },
|
||||
e,
|
||||
[group("g")],
|
||||
);
|
||||
expect(summary.failures).toHaveLength(1);
|
||||
expect(summary.failures[0]!.errorCode).toBe("FORMAT");
|
||||
});
|
||||
|
||||
it("skips targets a previous attempt already finished", async () => {
|
||||
const urls: string[] = [];
|
||||
globalThis.fetch = async (input): Promise<Response> => {
|
||||
urls.push(String(input));
|
||||
return new Response(JSON.stringify({ id: "m" }), { status: 200 });
|
||||
};
|
||||
const r = route("r", "g", {
|
||||
targets: [
|
||||
{ platform: "discord", channelId: "done" },
|
||||
{ platform: "discord", channelId: "todo" },
|
||||
],
|
||||
});
|
||||
const summary = await dispatchEvent(
|
||||
config([r]),
|
||||
{ event: "push", payload: {} },
|
||||
env(),
|
||||
[group("g")],
|
||||
{ skipTarget: async (key) => key.endsWith(":done") },
|
||||
);
|
||||
expect(urls.some((u) => u.includes("/done/"))).toBe(false);
|
||||
expect(urls.some((u) => u.includes("/todo/"))).toBe(true);
|
||||
expect(summary.succeeded).toEqual(["g:r:discord:todo"]);
|
||||
});
|
||||
|
||||
it("never mints App tokens for tenant events and only calls the GitHub API", async () => {
|
||||
const urls: string[] = [];
|
||||
globalThis.fetch = async (input): Promise<Response> => {
|
||||
urls.push(String(input));
|
||||
return new Response(JSON.stringify({ id: "m" }), { status: 200 });
|
||||
};
|
||||
const e = { ...env(), GITHUB_APP_ID: "1", GITHUB_PRIVATE_KEY: "pem" };
|
||||
await dispatchEvent(
|
||||
config([route("r", "g")]),
|
||||
{
|
||||
event: "workflow_run",
|
||||
payload: { workflow_run: { id: 1, jobs_url: "https://evil.example/steal" } },
|
||||
installationId: 42,
|
||||
},
|
||||
e,
|
||||
[group("g")],
|
||||
{ tenantId: "g" },
|
||||
);
|
||||
expect(urls.some((u) => u.includes("evil.example"))).toBe(false);
|
||||
expect(urls.some((u) => u.includes("access_tokens"))).toBe(false);
|
||||
});
|
||||
|
||||
it("keeps editing the same message after a transient edit failure", async () => {
|
||||
const calls: Array<{ method: string; url: string }> = [];
|
||||
let editStatus = 200;
|
||||
globalThis.fetch = async (input, init): Promise<Response> => {
|
||||
const method = init?.method ?? "GET";
|
||||
calls.push({ method, url: String(input) });
|
||||
if (method === "PATCH") {
|
||||
return editStatus === 200
|
||||
? new Response(JSON.stringify({ id: "m1" }), { status: 200 })
|
||||
: new Response("bad request", { status: editStatus });
|
||||
}
|
||||
return new Response(JSON.stringify({ id: "m1" }), { status: 200 });
|
||||
};
|
||||
const e = env();
|
||||
const run = (status: string, updated: string): Promise<DispatchSummary> =>
|
||||
dispatchEvent(
|
||||
config([route("r", "g")]),
|
||||
{
|
||||
event: "workflow_run",
|
||||
provider: "github",
|
||||
payload: {
|
||||
action: "in_progress",
|
||||
repository: { full_name: "o/r", html_url: "https://github.com/o/r" },
|
||||
workflow_run: { id: 7, status, name: "CI", updated_at: updated, jobs: [{}] },
|
||||
},
|
||||
},
|
||||
e,
|
||||
[group("g")],
|
||||
);
|
||||
await run("queued", "2026-01-01T00:00:00Z");
|
||||
expect(calls.filter((c) => c.method === "POST")).toHaveLength(1);
|
||||
editStatus = 400;
|
||||
const failed = await run("in_progress", "2026-01-01T00:01:00Z");
|
||||
expect(failed.failures).toHaveLength(1);
|
||||
// No second message was posted for the same chain.
|
||||
expect(calls.filter((c) => c.method === "POST")).toHaveLength(1);
|
||||
editStatus = 200;
|
||||
// An older event arriving late does not overwrite the newer state.
|
||||
const before = calls.length;
|
||||
await run("queued", "2025-12-31T00:00:00Z");
|
||||
expect(calls.length).toBe(before);
|
||||
});
|
||||
|
||||
it("separates update chains of two forges with the same repository name", async () => {
|
||||
const posts: string[] = [];
|
||||
globalThis.fetch = async (input, init): Promise<Response> => {
|
||||
if ((init?.method ?? "GET") === "POST") posts.push(String(input));
|
||||
return new Response(JSON.stringify({ id: `m${posts.length}` }), { status: 200 });
|
||||
};
|
||||
const e = env();
|
||||
for (const host of ["git1.example.com", "git2.example.com"]) {
|
||||
await dispatchEvent(
|
||||
config([route("r", "g")]),
|
||||
{
|
||||
event: "workflow_run",
|
||||
provider: "gitea",
|
||||
payload: {
|
||||
repository: { full_name: "o/r", html_url: `https://${host}/o/r` },
|
||||
workflow_run: { id: 7, status: "queued", name: "CI", jobs: [{}] },
|
||||
},
|
||||
},
|
||||
e,
|
||||
[group("g")],
|
||||
);
|
||||
}
|
||||
expect(posts).toHaveLength(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe("formatting safety", () => {
|
||||
it("keeps out-of-range character references verbatim", () => {
|
||||
expect(htmlToText("a � b A")).toBe("a � b A");
|
||||
});
|
||||
|
||||
it("offers merge/close buttons only for github.com", () => {
|
||||
const payload = {
|
||||
action: "opened",
|
||||
repository: { full_name: "o/r", html_url: "https://gitea.example/o/r" },
|
||||
pull_request: { number: 1, state: "open", title: "t" },
|
||||
};
|
||||
const r = route("r", "g");
|
||||
expect(formatEvent(r, { event: "pull_request", provider: "gitea", payload }).actions).toBe(
|
||||
undefined,
|
||||
);
|
||||
const gh = {
|
||||
...payload,
|
||||
repository: { full_name: "o/r", html_url: "https://github.com/o/r" },
|
||||
};
|
||||
expect(
|
||||
formatEvent(r, { event: "pull_request", provider: "github", payload: gh }).actions,
|
||||
).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("shows the deployment state, not the status object", () => {
|
||||
const message = formatEvent(route("r", "g"), {
|
||||
event: "deployment_status",
|
||||
payload: {
|
||||
repository: { full_name: "o/r" },
|
||||
deployment_status: { state: "success", environment: "prod" },
|
||||
deployment: { id: 1 },
|
||||
},
|
||||
});
|
||||
const status = message.fields!.find((f) => /status/i.test(f.name))!;
|
||||
expect(status.value).toContain("success");
|
||||
expect(status.value).not.toContain("[object Object]");
|
||||
});
|
||||
|
||||
it("drops Telegram's author emoji when the group turned emoji off", () => {
|
||||
const html = renderTelegram({ title: "t", author: { name: "bob" }, emoji: false });
|
||||
expect(html).not.toContain("👤");
|
||||
});
|
||||
|
||||
it("accepts only GitHub REST repository URLs for enrichment", () => {
|
||||
expect(githubApiUrl("https://api.github.com/repos/o/r/actions/runs/1/jobs")).not.toBeNull();
|
||||
expect(githubApiUrl("https://evil.example/repos/o/r")).toBeNull();
|
||||
expect(githubApiUrl("http://api.github.com/repos/o/r")).toBeNull();
|
||||
expect(githubApiUrl("https://api.github.com/user")).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("round-trip safety", () => {
|
||||
it("records an unreadable delivery ledger as a retryable failure", async () => {
|
||||
globalThis.fetch = async (): Promise<Response> =>
|
||||
new Response(JSON.stringify({ id: "m" }), { status: 200 });
|
||||
const summary = await dispatchEvent(
|
||||
config([route("r", "g")]),
|
||||
{ event: "push", payload: {} },
|
||||
{ GITHUB_WEBHOOK_SECRET: "", KV: createMemoryKV().kv, DB: createSqliteD1().db },
|
||||
[group("g")],
|
||||
{
|
||||
skipTarget: async () => {
|
||||
throw new Error("D1 down");
|
||||
},
|
||||
},
|
||||
);
|
||||
expect(summary.failures).toHaveLength(1);
|
||||
expect(summary.failures[0]!.errorCode).toBeUndefined();
|
||||
});
|
||||
|
||||
it("gives the custom-webhook nonce back when the queue rejects the event", async () => {
|
||||
const { kv, store } = createMemoryKV();
|
||||
store.set("config:groups", JSON.stringify([group("team")]));
|
||||
store.set("tenant:team", "tenant-secret");
|
||||
resetConfigStore(kv);
|
||||
let fail = true;
|
||||
const queue = {
|
||||
send: async (): Promise<void> => {
|
||||
if (fail) throw new Error("queue down");
|
||||
},
|
||||
} as unknown as Queue;
|
||||
const env: Env = { GITHUB_WEBHOOK_SECRET: "g", KV: kv, DB: {} as D1Database, QUEUE: queue };
|
||||
const body = JSON.stringify({ title: "hi" });
|
||||
const ts = String(Math.floor(Date.now() / 1000));
|
||||
const nonce = "n-1";
|
||||
const headers = {
|
||||
"x-webhooker-signature": `sha256=${createHmac("sha256", "tenant-secret").update(`${ts}.${nonce}.${body}`).digest("hex")}`,
|
||||
"x-webhooker-timestamp": ts,
|
||||
"x-webhooker-nonce": nonce,
|
||||
};
|
||||
expect((await processWebhook(env, body, headers, () => undefined, "team")).status).toBe(503);
|
||||
fail = false;
|
||||
expect((await processWebhook(env, body, headers, () => undefined, "team")).status).toBe(200);
|
||||
});
|
||||
});
|
||||
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user