happy2 0.0.5 → 0.0.11

package/packages/happy2-server/dist/modules/integrations/repository.js

@@ -1,1229 +0,0 @@
-import { createHash, createHmac } from "node:crypto";
-import { createId } from "@paralleldrive/cuid2";
-import { createClient } from "@libsql/client";
-import { and, asc, desc, eq, gt, isNull, lte, or, sql } from "drizzle-orm";
-import { createDatabase, retrySqliteBusy, } from "../drizzle.js";
-import { accounts, apiCredentials, auditLogEntries, botIdentities, chatMembers, chats, files, integrations, serverSyncState, slashCommands, syncEvents, users, webhookDeliveries, webhookSubscriptions, } from "../schema.js";
-import { generateApiToken, generateIncomingWebhookToken, generateSigningSecret, hashesEqual, secretHash, tokenPrefix, } from "./secrets.js";
-import { StrictWebhookUrlPolicy } from "./ssrf.js";
-import { IntegrationError, integrationKinds, integrationScopes, } from "./types.js";
-const MAX_DELIVERY_RESPONSE = 16_000;
-const MAX_EVENT_PAYLOAD = 1_000_000;
-const MAX_DELIVERY_ATTEMPTS = 8;
-export class IntegrationRepository {
-    client;
-    db;
-    ownsClient;
-    protector;
-    urlPolicy;
-    now;
-    constructor(source, options) {
-        this.ownsClient = typeof source === "string";
-        this.client =
-            typeof source === "string"
-                ? createClient({ url: source, authToken: options.authToken })
-                : source;
-        this.protector = options.secretProtector;
-        this.urlPolicy = options.urlPolicy ?? new StrictWebhookUrlPolicy();
-        this.now = options.now ?? (() => new Date());
-        this.db = createDatabase(this.client);
-    }
-    close() {
-        if (this.ownsClient)
-            this.client.close();
-    }
-    async listBots(actorUserId) {
-        await this.requireAdminDb(this.db, actorUserId);
-        const rows = await this.db
-            .select({
-            id: botIdentities.id,
-            name: botIdentities.name,
-            username: botIdentities.username,
-            description: botIdentities.description,
-            photo_file_id: botIdentities.photoFileId,
-            owner_user_id: botIdentities.ownerUserId,
-            active: botIdentities.active,
-            created_at: botIdentities.createdAt,
-            updated_at: botIdentities.updatedAt,
-        })
-            .from(botIdentities)
-            .orderBy(desc(botIdentities.createdAt), desc(botIdentities.id));
-        return rows.map(asBot);
-    }
-    async createBot(input) {
-        const name = requiredTrimmed(input.name, "Bot name", 200);
-        const username = normalizedUsername(input.username);
-        const description = optionalTrimmed(input.description, "Bot description", 2_000);
-        return this.writeDb(async (tx) => {
-            await this.requireAdminDb(tx, input.actorUserId);
-            if (input.ownerUserId)
-                await this.requireActiveUserDb(tx, input.ownerUserId);
-            if (input.photoFileId)
-                await this.requireFileDb(tx, input.photoFileId);
-            const id = createId();
-            try {
-                await tx.insert(botIdentities).values({
-                    id,
-                    name,
-                    username,
-                    description: description ?? null,
-                    photoFileId: input.photoFileId ?? null,
-                    ownerUserId: input.ownerUserId ?? null,
-                    createdByUserId: input.actorUserId,
-                });
-            }
-            catch (error) {
-                throw constraintConflict(error, "Bot username is already in use");
-            }
-            const change = await this.recordChangeDb(tx, input.actorUserId, "bot.created", id);
-            await this.appendAuditDb(tx, input.actorUserId, "bot.created", "bot", id);
-            await tx
-                .update(botIdentities)
-                .set({ syncSequence: Number(change.sequence) })
-                .where(eq(botIdentities.id, id));
-            return { value: await this.getBotDb(tx, id), change };
-        });
-    }
-    async updateBot(input) {
-        if (input.name === undefined &&
-            input.username === undefined &&
-            input.description === undefined &&
-            input.photoFileId === undefined &&
-            input.ownerUserId === undefined)
-            throw new IntegrationError("invalid", "At least one bot field is required");
-        const name = input.name === undefined ? undefined : requiredTrimmed(input.name, "Bot name", 200);
-        const username = input.username === undefined ? undefined : normalizedUsername(input.username);
-        const description = input.description === undefined || input.description === null
-            ? input.description
-            : optionalTrimmed(input.description, "Bot description", 2_000);
-        return this.writeDb(async (tx) => {
-            await this.requireAdminDb(tx, input.actorUserId);
-            await this.getBotDb(tx, input.botId, true);
-            if (input.ownerUserId)
-                await this.requireActiveUserDb(tx, input.ownerUserId);
-            if (input.photoFileId)
-                await this.requireFileDb(tx, input.photoFileId);
-            try {
-                await tx
-                    .update(botIdentities)
-                    .set({
-                    ...(name === undefined ? {} : { name }),
-                    ...(username === undefined ? {} : { username }),
-                    ...(input.description === undefined
-                        ? {}
-                        : { description: description ?? null }),
-                    ...(input.photoFileId === undefined
-                        ? {}
-                        : { photoFileId: input.photoFileId }),
-                    ...(input.ownerUserId === undefined
-                        ? {}
-                        : { ownerUserId: input.ownerUserId }),
-                    updatedAt: sql `CURRENT_TIMESTAMP`,
-                })
-                    .where(and(eq(botIdentities.id, input.botId), isNull(botIdentities.deletedAt)));
-            }
-            catch (error) {
-                throw constraintConflict(error, "Bot username is already in use");
-            }
-            const change = await this.recordChangeDb(tx, input.actorUserId, "bot.updated", input.botId);
-            await this.appendAuditDb(tx, input.actorUserId, "bot.updated", "bot", input.botId);
-            await tx
-                .update(botIdentities)
-                .set({ syncSequence: Number(change.sequence) })
-                .where(eq(botIdentities.id, input.botId));
-            return { value: await this.getBotDb(tx, input.botId), change };
-        });
-    }
-    async revokeBot(actorUserId, botId) {
-        return this.writeDb(async (tx) => {
-            await this.requireAdminDb(tx, actorUserId);
-            const changed = await tx
-                .update(botIdentities)
-                .set({
-                active: 0,
-                deletedAt: sql `CURRENT_TIMESTAMP`,
-                updatedAt: sql `CURRENT_TIMESTAMP`,
-            })
-                .where(and(eq(botIdentities.id, botId), isNull(botIdentities.deletedAt)))
-                .returning({ id: botIdentities.id });
-            if (changed.length === 0)
-                throw new IntegrationError("not_found", "Bot was not found");
-            const integrationIds = tx
-                .select({ id: integrations.id })
-                .from(integrations)
-                .where(eq(integrations.botId, botId));
-            await tx
-                .update(apiCredentials)
-                .set({ revokedAt: sql `coalesce(${apiCredentials.revokedAt}, CURRENT_TIMESTAMP)` })
-                .where(or(eq(apiCredentials.botId, botId), sql `${apiCredentials.integrationId} in (${integrationIds})`));
-            await tx
-                .update(integrations)
-                .set({
-                active: 0,
-                deletedAt: sql `coalesce(${integrations.deletedAt}, CURRENT_TIMESTAMP)`,
-                updatedAt: sql `CURRENT_TIMESTAMP`,
-            })
-                .where(eq(integrations.botId, botId));
-            const change = await this.recordChangeDb(tx, actorUserId, "bot.revoked", botId);
-            await this.appendAuditDb(tx, actorUserId, "bot.revoked", "bot", botId);
-            return change;
-        });
-    }
-    async listIntegrations(actorUserId) {
-        await this.requireAdminDb(this.db, actorUserId);
-        const rows = await this.db
-            .select(integrationSelection)
-            .from(integrations)
-            .orderBy(desc(integrations.createdAt), desc(integrations.id));
-        return rows.map(asIntegration);
-    }
-    async createIntegration(input) {
-        return this.createIntegrationRecord(input);
-    }
-    async revokeIntegration(actorUserId, integrationId) {
-        return this.writeDb(async (tx) => {
-            await this.requireAdminDb(tx, actorUserId);
-            const changed = await tx
-                .update(integrations)
-                .set({
-                active: 0,
-                deletedAt: sql `CURRENT_TIMESTAMP`,
-                updatedAt: sql `CURRENT_TIMESTAMP`,
-            })
-                .where(and(eq(integrations.id, integrationId), isNull(integrations.deletedAt)))
-                .returning({ id: integrations.id });
-            if (changed.length === 0)
-                throw new IntegrationError("not_found", "Integration was not found");
-            await tx
-                .update(apiCredentials)
-                .set({ revokedAt: sql `coalesce(${apiCredentials.revokedAt}, CURRENT_TIMESTAMP)` })
-                .where(eq(apiCredentials.integrationId, integrationId));
-            await tx
-                .update(webhookSubscriptions)
-                .set({ active: 0, updatedAt: sql `CURRENT_TIMESTAMP` })
-                .where(eq(webhookSubscriptions.integrationId, integrationId));
-            await tx
-                .update(slashCommands)
-                .set({ active: 0, updatedAt: sql `CURRENT_TIMESTAMP` })
-                .where(eq(slashCommands.integrationId, integrationId));
-            const change = await this.recordChangeDb(tx, actorUserId, "integration.revoked", integrationId);
-            await this.appendAuditDb(tx, actorUserId, "integration.revoked", "integration", integrationId);
-            return change;
-        });
-    }
-    async listApiCredentials(actorUserId, integrationId) {
-        await this.requireAdminDb(this.db, actorUserId);
-        await this.requireIntegrationDb(this.db, integrationId, false);
-        const rows = await this.db
-            .select(credentialSelection)
-            .from(apiCredentials)
-            .where(eq(apiCredentials.integrationId, integrationId))
-            .orderBy(desc(apiCredentials.createdAt), desc(apiCredentials.id));
-        return rows.map(asCredential);
-    }
-    async createApiCredential(input) {
-        const name = requiredTrimmed(input.name, "Credential name", 200);
-        const expiresAt = input.expiresAt ? futureDate(input.expiresAt, this.now()) : undefined;
-        const token = generateApiToken();
-        return this.writeDb(async (tx) => {
-            await this.requireAdminDb(tx, input.actorUserId);
-            const integration = await this.requireIntegrationDb(tx, input.integrationId, true);
-            const scopes = input.scopes ? normalizeScopes(input.scopes) : integration.scopes;
-            requireScopeSubset(scopes, integration.scopes);
-            const id = createId();
-            await tx.insert(apiCredentials).values({
-                id,
-                integrationId: input.integrationId,
-                name,
-                tokenPrefix: tokenPrefix(token),
-                tokenHash: secretHash(token),
-                scopesJson: JSON.stringify(scopes),
-                createdByUserId: input.actorUserId,
-                expiresAt: expiresAt ?? null,
-            });
-            await this.appendAuditDb(tx, input.actorUserId, "integration.credential_created", "api_credential", id, { integrationId: input.integrationId, scopes });
-            const [row] = await tx
-                .select(credentialSelection)
-                .from(apiCredentials)
-                .where(eq(apiCredentials.id, id));
-            if (!row)
-                throw new Error("API credential was not created");
-            return { credential: asCredential(row), token };
-        });
-    }
-    async revokeApiCredential(actorUserId, credentialId) {
-        await this.writeDb(async (tx) => {
-            await this.requireAdminDb(tx, actorUserId);
-            const changed = await tx
-                .update(apiCredentials)
-                .set({ revokedAt: sql `CURRENT_TIMESTAMP` })
-                .where(and(eq(apiCredentials.id, credentialId), isNull(apiCredentials.revokedAt)))
-                .returning({ id: apiCredentials.id });
-            if (changed.length === 0)
-                throw new IntegrationError("not_found", "API credential was not found");
-            await this.appendAuditDb(tx, actorUserId, "integration.credential_revoked", "api_credential", credentialId);
-        });
-    }
-    async authenticateApiCredential(token, requiredScopes = []) {
-        if (!token.startsWith("happy2_api_") || token.length > 256)
-            return undefined;
-        const requested = normalizeScopes(requiredScopes);
-        const candidates = await this.db
-            .select({
-            id: apiCredentials.id,
-            integrationId: apiCredentials.integrationId,
-            tokenHash: apiCredentials.tokenHash,
-            credentialScopesJson: apiCredentials.scopesJson,
-            integrationScopesJson: integrations.scopesJson,
-            botId: integrations.botId,
-            createdByUserId: integrations.createdByUserId,
-        })
-            .from(apiCredentials)
-            .innerJoin(integrations, eq(integrations.id, apiCredentials.integrationId))
-            .innerJoin(users, eq(users.id, integrations.createdByUserId))
-            .innerJoin(accounts, eq(accounts.id, users.accountId))
-            .where(and(eq(apiCredentials.tokenPrefix, tokenPrefix(token)), isNull(apiCredentials.revokedAt), or(isNull(apiCredentials.expiresAt), gt(sql `datetime(${apiCredentials.expiresAt})`, sql `CURRENT_TIMESTAMP`)), eq(integrations.active, 1), isNull(integrations.deletedAt), eq(users.role, "admin"), isNull(users.deletedAt), eq(accounts.active, 1), isNull(accounts.bannedAt), isNull(accounts.deletedAt)));
-        const digest = secretHash(token);
-        const row = candidates.find((candidate) => hashesEqual(candidate.tokenHash, digest));
-        if (!row)
-            return undefined;
-        const credentialScopes = parseScopes(row.credentialScopesJson);
-        const integrationScopeValues = parseScopes(row.integrationScopesJson);
-        const effective = credentialScopes.filter((scope) => integrationScopeValues.includes(scope));
-        if (requested.some((scope) => !effective.includes(scope)))
-            return undefined;
-        await this.db
-            .update(apiCredentials)
-            .set({ lastUsedAt: sql `CURRENT_TIMESTAMP` })
-            .where(and(eq(apiCredentials.id, row.id), isNull(apiCredentials.revokedAt)));
-        return {
-            credentialId: row.id,
-            integrationId: row.integrationId,
-            actorUserId: row.createdByUserId,
-            botId: row.botId ?? undefined,
-            scopes: effective,
-        };
-    }
-    async createIncomingWebhook(input) {
-        const token = generateIncomingWebhookToken();
-        return this.writeDb(async (tx) => {
-            await this.requireAdminDb(tx, input.actorUserId);
-            await this.requireBotDb(tx, input.botId);
-            await this.requireChatDb(tx, input.chatId);
-            const integration = await this.insertIntegrationDb(tx, {
-                actorUserId: input.actorUserId,
-                kind: "incoming_webhook",
-                name: input.name,
-                description: input.description,
-                botId: input.botId,
-                scopes: ["messages:write"],
-            });
-            const subscriptionId = createId();
-            await tx.insert(webhookSubscriptions).values({
-                id: subscriptionId,
-                integrationId: integration.id,
-                direction: "incoming",
-                chatId: input.chatId,
-                tokenHash: secretHash(token),
-                eventTypesJson: "[]",
-            });
-            const change = await this.finishIntegrationChangeDb(tx, input.actorUserId, "integration.created", integration.id);
-            return {
-                value: {
-                    integration: await this.getIntegrationDb(tx, integration.id),
-                    subscription: await this.getSubscriptionDb(tx, subscriptionId),
-                    token,
-                },
-                change,
-            };
-        });
-    }
-    async invokeIncomingWebhook(token, textValue, sink, idempotencyKey) {
-        if (!token.startsWith("happy2_hook_") || token.length > 256)
-            throw new IntegrationError("unauthorized", "Incoming webhook token is invalid");
-        const textBody = requiredText(textValue, "Webhook message", 40_000);
-        if (idempotencyKey !== undefined &&
-            (idempotencyKey.length === 0 ||
-                idempotencyKey.length > 200 ||
-                !/^[\x21-\x7e]+$/.test(idempotencyKey)))
-            throw new IntegrationError("invalid", "Idempotency key is invalid");
-        const [row] = await this.db
-            .select({
-            id: webhookSubscriptions.id,
-            chatId: webhookSubscriptions.chatId,
-            integrationId: integrations.id,
-            botId: integrations.botId,
-            scopesJson: integrations.scopesJson,
-            createdByUserId: integrations.createdByUserId,
-        })
-            .from(webhookSubscriptions)
-            .innerJoin(integrations, eq(integrations.id, webhookSubscriptions.integrationId))
-            .innerJoin(users, eq(users.id, integrations.createdByUserId))
-            .innerJoin(accounts, eq(accounts.id, users.accountId))
-            .where(and(eq(webhookSubscriptions.direction, "incoming"), eq(webhookSubscriptions.tokenHash, secretHash(token)), eq(webhookSubscriptions.active, 1), eq(integrations.kind, "incoming_webhook"), eq(integrations.active, 1), isNull(integrations.deletedAt), eq(users.role, "admin"), isNull(users.deletedAt), eq(accounts.active, 1), isNull(accounts.bannedAt), isNull(accounts.deletedAt)));
-        if (!row || !parseScopes(row.scopesJson).includes("messages:write"))
-            throw new IntegrationError("unauthorized", "Incoming webhook token is invalid");
-        const chatId = row.chatId ?? undefined;
-        const botId = row.botId ?? undefined;
-        const actorUserId = row.createdByUserId ?? undefined;
-        if (!chatId || !botId || !actorUserId)
-            throw new IntegrationError("forbidden", "Incoming webhook is no longer configured");
-        return sink.sendMessage({
-            actorUserId,
-            integrationId: row.integrationId,
-            subscriptionId: row.id,
-            botId,
-            chatId,
-            text: textBody,
-            ...(idempotencyKey ? { idempotencyKey } : {}),
-        });
-    }
-    async createOutgoingWebhook(input) {
-        const url = this.urlPolicy.validateForStorage(input.url);
-        const eventTypes = normalizeEventTypes(input.eventTypes);
-        const signingSecret = generateSigningSecret();
-        const ciphertext = await this.protector.protect(signingSecret);
-        return this.writeDb(async (tx) => {
-            await this.requireAdminDb(tx, input.actorUserId);
-            if (input.chatId)
-                await this.requireChatDb(tx, input.chatId);
-            const integration = await this.insertIntegrationDb(tx, {
-                actorUserId: input.actorUserId,
-                kind: "outgoing_webhook",
-                name: input.name,
-                description: input.description,
-                scopes: ["events:read"],
-            });
-            const subscriptionId = createId();
-            await tx.insert(webhookSubscriptions).values({
-                id: subscriptionId,
-                integrationId: integration.id,
-                direction: "outgoing",
-                chatId: input.chatId ?? null,
-                url,
-                signingSecretCiphertext: ciphertext,
-                eventTypesJson: JSON.stringify(eventTypes),
-            });
-            const change = await this.finishIntegrationChangeDb(tx, input.actorUserId, "integration.created", integration.id);
-            return {
-                value: {
-                    integration: await this.getIntegrationDb(tx, integration.id),
-                    subscription: await this.getSubscriptionDb(tx, subscriptionId),
-                    signingSecret,
-                },
-                change,
-            };
-        });
-    }
-    async listWebhookSubscriptions(actorUserId, integrationId) {
-        await this.requireAdminDb(this.db, actorUserId);
-        await this.requireIntegrationDb(this.db, integrationId, false);
-        const rows = await this.db
-            .select(subscriptionSelection)
-            .from(webhookSubscriptions)
-            .where(eq(webhookSubscriptions.integrationId, integrationId))
-            .orderBy(desc(webhookSubscriptions.createdAt), desc(webhookSubscriptions.id));
-        return rows.map(asSubscription);
-    }
-    async enqueueOutgoingEvent(input) {
-        boundedIdentifier(input.eventId, "Event id");
-        const eventType = normalizedEventType(input.eventType);
-        const payloadJson = serializedPayload({
-            eventId: input.eventId,
-            eventType,
-            occurredAt: this.now().toISOString(),
-            payload: input.payload,
-        });
-        if ((await outgoingSubscriptionIds(this.db, eventType, input.chatId)).length === 0)
-            return [];
-        return this.writeDb(async (tx) => {
-            const subscriptions = await outgoingSubscriptionIds(tx, eventType, input.chatId);
-            const deliveries = [];
-            for (const row of subscriptions) {
-                const subscriptionId = row.id;
-                const id = createId();
-                await tx
-                    .insert(webhookDeliveries)
-                    .values({
-                    id,
-                    subscriptionId,
-                    eventId: input.eventId,
-                    eventType,
-                    payloadJson,
-                    nextAttemptAt: this.now().toISOString(),
-                })
-                    .onConflictDoNothing();
-                const [delivery] = await tx
-                    .select(deliverySelection)
-                    .from(webhookDeliveries)
-                    .where(and(eq(webhookDeliveries.subscriptionId, subscriptionId), eq(webhookDeliveries.eventId, input.eventId)));
-                if (delivery)
-                    deliveries.push(asDelivery(delivery));
-            }
-            return deliveries;
-        });
-    }
-    /**
-     * Converts durable sync rows into idempotently queued outgoing events. Calling
-     * this again after a crash is safe because each delivery uses the sync row id.
-     */
-    async enqueueSyncSequence(sequence) {
-        if (!/^\d+$/.test(sequence))
-            throw new IntegrationError("invalid", "Sync sequence is invalid");
-        const events = await this.db
-            .select()
-            .from(syncEvents)
-            .where(eq(syncEvents.sequence, Number(sequence)))
-            .orderBy(asc(syncEvents.id));
-        const deliveries = [];
-        for (const event of events) {
-            deliveries.push(...(await this.enqueueOutgoingEvent({
-                eventId: `sync:${event.id}`,
-                eventType: event.kind,
-                chatId: event.chatId ?? undefined,
-                payload: {
-                    syncEventId: String(event.id),
-                    sequence: String(event.sequence),
-                    chatId: event.chatId ?? undefined,
-                    chatPts: event.chatPts === null ? undefined : String(event.chatPts),
-                    entityId: event.entityId ?? undefined,
-                    actorUserId: event.actorUserId ?? undefined,
-                    targetUserId: event.targetUserId ?? undefined,
-                    createdAt: event.createdAt,
-                },
-            })));
-        }
-        return deliveries;
-    }
-    /** Recovers sync rows missed by ephemeral pubsub delivery, without a local cursor. */
-    async enqueuePendingSyncEvents(limit = 100) {
-        positiveLimit(limit, 1_000);
-        const alreadyQueued = this.db
-            .select({ id: webhookDeliveries.id })
-            .from(webhookDeliveries)
-            .where(and(eq(webhookDeliveries.subscriptionId, webhookSubscriptions.id), eq(webhookDeliveries.eventId, sql `'sync:' || ${syncEvents.id}`)));
-        const eligibleSubscription = this.db
-            .select({ id: webhookSubscriptions.id })
-            .from(webhookSubscriptions)
-            .innerJoin(integrations, eq(integrations.id, webhookSubscriptions.integrationId))
-            .where(and(eq(webhookSubscriptions.direction, "outgoing"), eq(webhookSubscriptions.active, 1), eq(integrations.active, 1), isNull(integrations.deletedAt), sql `julianday(${syncEvents.createdAt}) >= julianday(${webhookSubscriptions.createdAt})`, or(isNull(webhookSubscriptions.chatId), eq(webhookSubscriptions.chatId, syncEvents.chatId)), sql `exists (select 1 from json_each(${webhookSubscriptions.eventTypesJson}) where value = ${syncEvents.kind})`, sql `exists (select 1 from json_each(${integrations.scopesJson}) where value = 'events:read')`, sql `not exists ${alreadyQueued}`));
-        const firstEventId = sql `min(${syncEvents.id})`;
-        const sequences = await this.db
-            .select({ sequence: syncEvents.sequence, firstEventId })
-            .from(syncEvents)
-            .where(sql `exists ${eligibleSubscription}`)
-            .groupBy(syncEvents.sequence)
-            .orderBy(firstEventId)
-            .limit(limit);
-        const deliveries = [];
-        for (const row of sequences)
-            deliveries.push(...(await this.enqueueSyncSequence(String(row.sequence))));
-        return deliveries;
-    }
-    async listWebhookDeliveries(actorUserId, integrationId, limit = 100) {
-        await this.requireAdminDb(this.db, actorUserId);
-        positiveLimit(limit, 200);
-        await this.requireIntegrationDb(this.db, integrationId, false);
-        const rows = await this.db
-            .select(deliverySelection)
-            .from(webhookDeliveries)
-            .innerJoin(webhookSubscriptions, eq(webhookSubscriptions.id, webhookDeliveries.subscriptionId))
-            .where(eq(webhookSubscriptions.integrationId, integrationId))
-            .orderBy(desc(webhookDeliveries.createdAt), desc(webhookDeliveries.id))
-            .limit(limit);
-        return rows.map(asDelivery);
-    }
-    async createSlashCommand(input) {
-        const command = normalizedCommand(input.command);
-        const handlerUrl = this.urlPolicy.validateForStorage(input.handlerUrl);
-        const signingSecret = generateSigningSecret();
-        const ciphertext = await this.protector.protect(signingSecret);
-        return this.writeDb(async (tx) => {
-            await this.requireAdminDb(tx, input.actorUserId);
-            if (input.botId)
-                await this.requireBotDb(tx, input.botId);
-            const integration = await this.insertIntegrationDb(tx, {
-                actorUserId: input.actorUserId,
-                kind: "slash_command",
-                name: input.name,
-                description: input.description,
-                botId: input.botId,
-                scopes: ["commands:receive"],
-            });
-            const commandId = createId();
-            try {
-                await tx.insert(slashCommands).values({
-                    id: commandId,
-                    integrationId: integration.id,
-                    command,
-                    description: optionalTrimmed(input.description, "Command description", 500) ?? null,
-                    usageHint: optionalTrimmed(input.usageHint, "Usage hint", 500) ?? null,
-                    handlerUrl,
-                });
-            }
-            catch (error) {
-                throw constraintConflict(error, "Slash command is already registered");
-            }
-            await tx.insert(webhookSubscriptions).values({
-                id: createId(),
-                integrationId: integration.id,
-                direction: "outgoing",
-                url: handlerUrl,
-                signingSecretCiphertext: ciphertext,
-                eventTypesJson: JSON.stringify([slashEventType(commandId)]),
-            });
-            const change = await this.finishIntegrationChangeDb(tx, input.actorUserId, "integration.created", integration.id);
-            return {
-                value: {
-                    integration: await this.getIntegrationDb(tx, integration.id),
-                    command: await this.getSlashCommandDb(tx, commandId),
-                    signingSecret,
-                },
-                change,
-            };
-        });
-    }
-    async listSlashCommands(actorUserId) {
-        await this.requireActiveUserDb(this.db, actorUserId);
-        const rows = await this.db
-            .select(slashCommandSelection)
-            .from(slashCommands)
-            .innerJoin(integrations, eq(integrations.id, slashCommands.integrationId))
-            .where(and(eq(slashCommands.active, 1), eq(integrations.active, 1), isNull(integrations.deletedAt)))
-            .orderBy(asc(slashCommands.command));
-        return rows.map(asSlashCommand);
-    }
-    async invokeSlashCommand(input) {
-        const command = normalizedCommand(input.command);
-        const commandText = optionalTextBody(input.text, "Command text", 20_000) ?? "";
-        return this.writeDb(async (tx) => {
-            await this.requireChatMemberDb(tx, input.actorUserId, input.chatId);
-            const commandRow = await this.findSlashSubscriptionDb(tx, command);
-            if (!commandRow)
-                throw new IntegrationError("not_found", "Slash command was not found");
-            const eventId = `slash:${createId()}`;
-            const eventType = slashEventType(commandRow.id);
-            const payload = serializedPayload({
-                eventId,
-                eventType,
-                occurredAt: this.now().toISOString(),
-                payload: {
-                    command,
-                    text: commandText,
-                    chatId: input.chatId,
-                    actorUserId: input.actorUserId,
-                    integrationId: commandRow.integrationId,
-                },
-            });
-            const deliveryId = createId();
-            await tx.insert(webhookDeliveries).values({
-                id: deliveryId,
-                subscriptionId: commandRow.subscriptionId,
-                eventId,
-                eventType,
-                payloadJson: payload,
-                nextAttemptAt: this.now().toISOString(),
-            });
-            const [delivery] = await tx
-                .select(deliverySelection)
-                .from(webhookDeliveries)
-                .where(eq(webhookDeliveries.id, deliveryId));
-            if (!delivery)
-                throw new Error("Slash command invocation was not queued");
-            return asDelivery(delivery);
-        });
-    }
-    async dispatchDueWebhooks(transport, options = {}) {
-        const limit = positiveLimit(options.limit ?? 25, 100);
-        const leaseMs = positiveLimit(options.leaseMs ?? 30_000, 300_000);
-        const maxAttempts = positiveLimit(options.maxAttempts ?? MAX_DELIVERY_ATTEMPTS, 20);
-        const claimed = await this.claimDueDeliveries(limit, leaseMs, maxAttempts);
-        let delivered = 0;
-        let failed = 0;
-        for (const delivery of claimed) {
-            try {
-                const target = await this.urlPolicy.resolveForDelivery(delivery.url);
-                const secret = await this.protector.reveal(delivery.signingSecretCiphertext);
-                const timestamp = Math.floor(this.now().getTime() / 1_000).toString();
-                const signature = `v1=${createHmac("sha256", secret)
-                    .update(`${timestamp}.${delivery.payloadJson}`, "utf8")
-                    .digest("hex")}`;
-                const response = await transport.deliver({
-                    deliveryId: delivery.id,
-                    eventId: delivery.eventId,
-                    eventType: delivery.eventType,
-                    url: target.url,
-                    allowedAddresses: target.addresses,
-                    body: delivery.payloadJson,
-                    headers: {
-                        "content-type": "application/json",
-                        "x-happy2-event-id": delivery.eventId,
-                        "x-happy2-signature": signature,
-                        "x-happy2-timestamp": timestamp,
-                    },
-                });
-                if (response.statusCode < 200 || response.statusCode >= 300)
-                    throw new DeliveryHttpError(response.statusCode, response.body);
-                await this.completeDelivery(delivery, response.statusCode, response.body);
-                delivered += 1;
-            }
-            catch (error) {
-                await this.failDelivery(delivery, error, maxAttempts);
-                failed += 1;
-            }
-        }
-        return { delivered, failed };
-    }
-    async createIntegrationRecord(input) {
-        return this.writeDb(async (tx) => {
-            await this.requireAdminDb(tx, input.actorUserId);
-            if (input.botId)
-                await this.requireBotDb(tx, input.botId);
-            const integration = await this.insertIntegrationDb(tx, input);
-            const change = await this.finishIntegrationChangeDb(tx, input.actorUserId, "integration.created", integration.id);
-            return { value: await this.getIntegrationDb(tx, integration.id), change };
-        });
-    }
-    async claimDueDeliveries(limit, leaseMs, maxAttempts) {
-        const now = this.now();
-        const nowIso = now.toISOString();
-        const leaseUntil = new Date(now.getTime() + leaseMs).toISOString();
-        const dueCondition = and(sql `${webhookDeliveries.attempts} < ${maxAttempts}`, or(sql `${webhookDeliveries.status} in ('pending', 'failed')`, and(eq(webhookDeliveries.status, "delivering"), lte(sql `julianday(${webhookDeliveries.nextAttemptAt})`, sql `julianday(${nowIso})`))), lte(sql `julianday(${webhookDeliveries.nextAttemptAt})`, sql `julianday(${nowIso})`), eq(webhookSubscriptions.active, 1), eq(webhookSubscriptions.direction, "outgoing"), eq(integrations.active, 1), isNull(integrations.deletedAt));
-        const [candidate] = await this.db
-            .select({ id: webhookDeliveries.id })
-            .from(webhookDeliveries)
-            .innerJoin(webhookSubscriptions, eq(webhookSubscriptions.id, webhookDeliveries.subscriptionId))
-            .innerJoin(integrations, eq(integrations.id, webhookSubscriptions.integrationId))
-            .where(dueCondition)
-            .limit(1);
-        if (!candidate)
-            return [];
-        return this.writeDb(async (tx) => {
-            const due = await tx
-                .select({ id: webhookDeliveries.id })
-                .from(webhookDeliveries)
-                .innerJoin(webhookSubscriptions, eq(webhookSubscriptions.id, webhookDeliveries.subscriptionId))
-                .innerJoin(integrations, eq(integrations.id, webhookSubscriptions.integrationId))
-                .where(dueCondition)
-                .orderBy(asc(webhookDeliveries.nextAttemptAt), asc(webhookDeliveries.id))
-                .limit(limit);
-            const claimed = [];
-            for (const candidate of due) {
-                const id = candidate.id;
-                const changed = await tx
-                    .update(webhookDeliveries)
-                    .set({
-                    status: "delivering",
-                    attempts: sql `${webhookDeliveries.attempts} + 1`,
-                    nextAttemptAt: leaseUntil,
-                })
-                    .where(and(eq(webhookDeliveries.id, id), sql `${webhookDeliveries.attempts} < ${maxAttempts}`, or(sql `${webhookDeliveries.status} in ('pending', 'failed')`, and(eq(webhookDeliveries.status, "delivering"), lte(sql `julianday(${webhookDeliveries.nextAttemptAt})`, sql `julianday(${now.toISOString()})`)))))
-                    .returning({ id: webhookDeliveries.id });
-                if (changed.length === 0)
-                    continue;
-                const [row] = await tx
-                    .select({
-                    ...deliverySelection,
-                    payload_json: webhookDeliveries.payloadJson,
-                    url: webhookSubscriptions.url,
-                    signing_secret_ciphertext: webhookSubscriptions.signingSecretCiphertext,
-                })
-                    .from(webhookDeliveries)
-                    .innerJoin(webhookSubscriptions, eq(webhookSubscriptions.id, webhookDeliveries.subscriptionId))
-                    .where(eq(webhookDeliveries.id, id));
-                if (row)
-                    claimed.push(asClaimedDelivery(row));
-            }
-            return claimed;
-        });
-    }
-    async completeDelivery(delivery, responseStatus, responseBody) {
-        await this.db
-            .update(webhookDeliveries)
-            .set({
-            status: "delivered",
-            responseStatus,
-            responseBody: truncate(responseBody, MAX_DELIVERY_RESPONSE) ?? null,
-            lastError: null,
-            deliveredAt: sql `CURRENT_TIMESTAMP`,
-        })
-            .where(and(eq(webhookDeliveries.id, delivery.id), eq(webhookDeliveries.status, "delivering"), eq(webhookDeliveries.nextAttemptAt, delivery.nextAttemptAt)));
-    }
-    async failDelivery(delivery, error, maxAttempts) {
-        const response = error instanceof DeliveryHttpError ? error : undefined;
-        const exhausted = delivery.attempts >= maxAttempts;
-        const nextAttemptAt = exhausted
-            ? this.now().toISOString()
-            : new Date(this.now().getTime() + retryDelay(delivery.id, delivery.attempts)).toISOString();
-        await this.db
-            .update(webhookDeliveries)
-            .set({
-            status: "failed",
-            nextAttemptAt,
-            responseStatus: response?.statusCode ?? null,
-            responseBody: truncate(response?.responseBody, MAX_DELIVERY_RESPONSE) ?? null,
-            lastError: truncate(errorMessage(error), 2_000),
-        })
-            .where(and(eq(webhookDeliveries.id, delivery.id), eq(webhookDeliveries.status, "delivering"), eq(webhookDeliveries.nextAttemptAt, delivery.nextAttemptAt)));
-    }
-    async requireAdminDb(executor, userId) {
-        const [row] = await executor
-            .select({ id: users.id })
-            .from(users)
-            .innerJoin(accounts, eq(accounts.id, users.accountId))
-            .where(and(eq(users.id, userId), eq(users.role, "admin"), isNull(users.deletedAt), eq(accounts.active, 1), isNull(accounts.bannedAt), isNull(accounts.deletedAt)));
-        if (!row)
-            throw new IntegrationError("forbidden", "Server admin permission is required");
-    }
-    async requireActiveUserDb(executor, userId) {
-        const [row] = await executor
-            .select({ id: users.id })
-            .from(users)
-            .innerJoin(accounts, eq(accounts.id, users.accountId))
-            .where(and(eq(users.id, userId), isNull(users.deletedAt), eq(accounts.active, 1), isNull(accounts.bannedAt), isNull(accounts.deletedAt)));
-        if (!row)
-            throw new IntegrationError("not_found", "User was not found");
-    }
-    async requireChatMemberDb(executor, userId, chatId) {
-        const [row] = await executor
-            .select({ id: chatMembers.chatId })
-            .from(chatMembers)
-            .innerJoin(chats, eq(chats.id, chatMembers.chatId))
-            .innerJoin(users, eq(users.id, chatMembers.userId))
-            .innerJoin(accounts, eq(accounts.id, users.accountId))
-            .where(and(eq(chatMembers.chatId, chatId), eq(chatMembers.userId, userId), isNull(chatMembers.leftAt), isNull(chats.deletedAt), isNull(chats.archivedAt), isNull(users.deletedAt), eq(accounts.active, 1), isNull(accounts.bannedAt), isNull(accounts.deletedAt)));
-        if (!row)
-            throw new IntegrationError("not_found", "Chat was not found");
-    }
-    async requireChatDb(executor, chatId) {
-        const [row] = await executor
-            .select({ id: chats.id })
-            .from(chats)
-            .where(and(eq(chats.id, chatId), isNull(chats.deletedAt)));
-        if (!row)
-            throw new IntegrationError("not_found", "Chat was not found");
-    }
-    async requireFileDb(executor, fileId) {
-        const [row] = await executor
-            .select({ id: files.id })
-            .from(files)
-            .where(and(eq(files.id, fileId), isNull(files.deletedAt), eq(files.uploadStatus, "complete"), sql `${files.scanStatus} != 'infected'`));
-        if (!row)
-            throw new IntegrationError("not_found", "File was not found");
-    }
-    async requireBotDb(executor, botId) {
-        await this.getBotDb(executor, botId, true);
-    }
-    async requireIntegrationDb(executor, integrationId, active) {
-        const row = await this.getIntegrationDb(executor, integrationId);
-        if (active && !row.active)
-            throw new IntegrationError("not_found", "Integration was not found");
-        return row;
-    }
-    async getBotDb(executor, botId, active = false) {
-        const [row] = await executor
-            .select(botSelection)
-            .from(botIdentities)
-            .where(eq(botIdentities.id, botId));
-        if (!row || (active && (row.active !== 1 || row.deleted_at !== null)))
-            throw new IntegrationError("not_found", "Bot was not found");
-        return asBot(row);
-    }
-    async getIntegrationDb(executor, integrationId) {
-        const [row] = await executor
-            .select(integrationSelection)
-            .from(integrations)
-            .where(eq(integrations.id, integrationId));
-        if (!row)
-            throw new IntegrationError("not_found", "Integration was not found");
-        return asIntegration(row);
-    }
-    async getSubscriptionDb(executor, subscriptionId) {
-        const [row] = await executor
-            .select(subscriptionSelection)
-            .from(webhookSubscriptions)
-            .where(eq(webhookSubscriptions.id, subscriptionId));
-        if (!row)
-            throw new Error("Webhook subscription was not created");
-        return asSubscription(row);
-    }
-    async getSlashCommandDb(executor, commandId) {
-        const [row] = await executor
-            .select(slashCommandSelection)
-            .from(slashCommands)
-            .where(eq(slashCommands.id, commandId));
-        if (!row)
-            throw new Error("Slash command was not created");
-        return asSlashCommand(row);
-    }
-    async findSlashSubscriptionDb(executor, command) {
-        const [row] = await executor
-            .select({
-            id: slashCommands.id,
-            integrationId: slashCommands.integrationId,
-            subscriptionId: webhookSubscriptions.id,
-        })
-            .from(slashCommands)
-            .innerJoin(integrations, eq(integrations.id, slashCommands.integrationId))
-            .innerJoin(webhookSubscriptions, eq(webhookSubscriptions.integrationId, integrations.id))
-            .where(and(sql `${slashCommands.command} = ${command} collate nocase`, eq(slashCommands.active, 1), eq(integrations.active, 1), isNull(integrations.deletedAt), sql `exists (select 1 from json_each(${integrations.scopesJson}) where value = 'commands:receive')`, eq(webhookSubscriptions.direction, "outgoing"), eq(webhookSubscriptions.active, 1), sql `exists (select 1 from json_each(${webhookSubscriptions.eventTypesJson}) where value = 'slash_command:' || ${slashCommands.id})`))
-            .limit(1);
-        return row;
-    }
-    async insertIntegrationDb(tx, input) {
-        if (!integrationKinds.includes(input.kind))
-            throw new IntegrationError("invalid", "Integration kind is invalid");
-        const id = createId();
-        await tx.insert(integrations).values({
-            id,
-            kind: input.kind,
-            name: requiredTrimmed(input.name, "Integration name", 200),
-            description: optionalTrimmed(input.description, "Integration description", 2_000) ?? null,
-            botId: input.botId ?? null,
-            createdByUserId: input.actorUserId,
-            scopesJson: JSON.stringify(normalizeScopes(input.scopes)),
-        });
-        return { id };
-    }
-    async finishIntegrationChangeDb(tx, actorUserId, kind, integrationId) {
-        const change = await this.recordChangeDb(tx, actorUserId, kind, integrationId);
-        await this.appendAuditDb(tx, actorUserId, kind, "integration", integrationId);
-        await tx
-            .update(integrations)
-            .set({ syncSequence: Number(change.sequence) })
-            .where(eq(integrations.id, integrationId));
-        return change;
-    }
-    async recordChangeDb(tx, actorUserId, kind, entityId) {
-        const [state] = await tx
-            .update(serverSyncState)
-            .set({ sequence: sql `${serverSyncState.sequence} + 1` })
-            .where(eq(serverSyncState.id, 1))
-            .returning({ sequence: serverSyncState.sequence });
-        if (!state)
-            throw new Error("Server sync state is not initialized");
-        await tx.insert(syncEvents).values({
-            sequence: state.sequence,
-            kind,
-            entityId,
-            actorUserId,
-        });
-        return { sequence: String(state.sequence), kind, entityId };
-    }
-    async appendAuditDb(tx, actorUserId, action, targetType, targetId, metadata) {
-        await tx.insert(auditLogEntries).values({
-            id: createId(),
-            actorUserId,
-            action,
-            targetType,
-            targetId,
-            metadataJson: metadata ? JSON.stringify(metadata) : null,
-        });
-    }
-    writeDb(operation) {
-        return retrySqliteBusy(() => this.db.transaction(operation));
-    }
-}
-function outgoingSubscriptionIds(executor, eventType, chatId) {
-    return executor
-        .select({ id: webhookSubscriptions.id })
-        .from(webhookSubscriptions)
-        .innerJoin(integrations, eq(integrations.id, webhookSubscriptions.integrationId))
-        .where(and(eq(webhookSubscriptions.direction, "outgoing"), eq(webhookSubscriptions.active, 1), eq(integrations.active, 1), isNull(integrations.deletedAt), or(isNull(webhookSubscriptions.chatId), eq(webhookSubscriptions.chatId, chatId ?? "")), sql `exists (select 1 from json_each(${webhookSubscriptions.eventTypesJson}) where value = ${eventType})`, sql `exists (select 1 from json_each(${integrations.scopesJson}) where value = 'events:read')`))
-        .orderBy(asc(webhookSubscriptions.id));
-}
-const botSelection = {
-    id: botIdentities.id,
-    name: botIdentities.name,
-    username: botIdentities.username,
-    description: botIdentities.description,
-    photo_file_id: botIdentities.photoFileId,
-    owner_user_id: botIdentities.ownerUserId,
-    active: botIdentities.active,
-    created_at: botIdentities.createdAt,
-    updated_at: botIdentities.updatedAt,
-    deleted_at: botIdentities.deletedAt,
-};
-const integrationSelection = {
-    id: integrations.id,
-    kind: integrations.kind,
-    name: integrations.name,
-    description: integrations.description,
-    bot_id: integrations.botId,
-    scopes_json: integrations.scopesJson,
-    active: integrations.active,
-    created_at: integrations.createdAt,
-    updated_at: integrations.updatedAt,
-};
-const credentialSelection = {
-    id: apiCredentials.id,
-    integration_id: apiCredentials.integrationId,
-    name: apiCredentials.name,
-    token_prefix: apiCredentials.tokenPrefix,
-    scopes_json: apiCredentials.scopesJson,
-    expires_at: apiCredentials.expiresAt,
-    last_used_at: apiCredentials.lastUsedAt,
-    revoked_at: apiCredentials.revokedAt,
-    created_at: apiCredentials.createdAt,
-};
-const subscriptionSelection = {
-    id: webhookSubscriptions.id,
-    integration_id: webhookSubscriptions.integrationId,
-    direction: webhookSubscriptions.direction,
-    chat_id: webhookSubscriptions.chatId,
-    url: webhookSubscriptions.url,
-    event_types_json: webhookSubscriptions.eventTypesJson,
-    active: webhookSubscriptions.active,
-    created_at: webhookSubscriptions.createdAt,
-    updated_at: webhookSubscriptions.updatedAt,
-};
-const slashCommandSelection = {
-    id: slashCommands.id,
-    integration_id: slashCommands.integrationId,
-    command: slashCommands.command,
-    description: slashCommands.description,
-    usage_hint: slashCommands.usageHint,
-    active: slashCommands.active,
-    created_at: slashCommands.createdAt,
-    updated_at: slashCommands.updatedAt,
-};
-const deliverySelection = {
-    id: webhookDeliveries.id,
-    subscription_id: webhookDeliveries.subscriptionId,
-    event_id: webhookDeliveries.eventId,
-    event_type: webhookDeliveries.eventType,
-    status: webhookDeliveries.status,
-    attempts: webhookDeliveries.attempts,
-    next_attempt_at: webhookDeliveries.nextAttemptAt,
-    created_at: webhookDeliveries.createdAt,
-};
-function asBot(row) {
-    return {
-        id: text(row.id),
-        name: text(row.name),
-        username: text(row.username),
-        description: optionalText(row.description),
-        photoFileId: optionalText(row.photo_file_id),
-        ownerUserId: optionalText(row.owner_user_id),
-        active: number(row.active) === 1,
-        createdAt: text(row.created_at),
-        updatedAt: text(row.updated_at),
-    };
-}
-function asIntegration(row) {
-    return {
-        id: text(row.id),
-        kind: text(row.kind),
-        name: text(row.name),
-        description: optionalText(row.description),
-        botId: optionalText(row.bot_id),
-        scopes: parseScopes(row.scopes_json),
-        active: number(row.active) === 1,
-        createdAt: text(row.created_at),
-        updatedAt: text(row.updated_at),
-    };
-}
-function asCredential(row) {
-    return {
-        id: text(row.id),
-        integrationId: text(row.integration_id),
-        name: text(row.name),
-        tokenPrefix: text(row.token_prefix),
-        scopes: parseScopes(row.scopes_json),
-        expiresAt: optionalText(row.expires_at),
-        lastUsedAt: optionalText(row.last_used_at),
-        revokedAt: optionalText(row.revoked_at),
-        createdAt: text(row.created_at),
-    };
-}
-function asSubscription(row) {
-    return {
-        id: text(row.id),
-        integrationId: text(row.integration_id),
-        direction: text(row.direction),
-        chatId: optionalText(row.chat_id),
-        url: optionalText(row.url),
-        eventTypes: stringArray(row.event_types_json),
-        active: number(row.active) === 1,
-        createdAt: text(row.created_at),
-        updatedAt: text(row.updated_at),
-    };
-}
-function asSlashCommand(row) {
-    return {
-        id: text(row.id),
-        integrationId: text(row.integration_id),
-        command: text(row.command),
-        description: optionalText(row.description),
-        usageHint: optionalText(row.usage_hint),
-        active: number(row.active) === 1,
-        createdAt: text(row.created_at),
-        updatedAt: text(row.updated_at),
-    };
-}
-function asDelivery(row) {
-    return {
-        id: text(row.id),
-        subscriptionId: text(row.subscription_id),
-        eventId: text(row.event_id),
-        eventType: text(row.event_type),
-        status: text(row.status),
-        attempts: number(row.attempts),
-        nextAttemptAt: text(row.next_attempt_at),
-        createdAt: text(row.created_at),
-    };
-}
-function asClaimedDelivery(row) {
-    return {
-        ...asDelivery(row),
-        url: text(row.url),
-        signingSecretCiphertext: text(row.signing_secret_ciphertext),
-        payloadJson: text(row.payload_json),
-    };
-}
-function normalizeScopes(values) {
-    const unique = [...new Set(values)];
-    if (unique.some((scope) => !integrationScopes.includes(scope)))
-        throw new IntegrationError("invalid", "Integration scope is invalid");
-    return unique.sort();
-}
-function parseScopes(value) {
-    const parsed = stringArray(value);
-    if (parsed.some((scope) => !integrationScopes.includes(scope)))
-        throw new Error("Database contains an invalid integration scope");
-    return parsed;
-}
-function requireScopeSubset(requested, allowed) {
-    if (requested.some((scope) => !allowed.includes(scope)))
-        throw new IntegrationError("forbidden", "Credential scope exceeds its integration");
-}
-function normalizeEventTypes(values) {
-    if (values.length === 0 || values.length > 50)
-        throw new IntegrationError("invalid", "Outgoing webhook requires 1-50 event types");
-    return [...new Set(values.map(normalizedEventType))].sort();
-}
-function normalizedEventType(value) {
-    const normalized = value.trim();
-    if (!/^[A-Za-z][A-Za-z0-9_.:-]{0,127}$/.test(normalized))
-        throw new IntegrationError("invalid", "Webhook event type is invalid");
-    return normalized;
-}
-function normalizedCommand(value) {
-    const normalized = value.trim().toLowerCase();
-    if (!/^\/[a-z0-9][a-z0-9_-]{0,63}$/.test(normalized))
-        throw new IntegrationError("invalid", "Slash command is invalid");
-    return normalized;
-}
-function slashEventType(commandId) {
-    return `slash_command:${commandId}`;
-}
-function normalizedUsername(value) {
-    const normalized = value.trim().toLowerCase();
-    if (!/^[a-z0-9][a-z0-9_.-]{1,31}$/.test(normalized))
-        throw new IntegrationError("invalid", "Bot username must contain 2-32 safe characters");
-    return normalized;
-}
-function requiredTrimmed(value, name, maximum) {
-    const normalized = value.trim();
-    if (!normalized || normalized.length > maximum)
-        throw new IntegrationError("invalid", `${name} must contain 1-${maximum} characters`);
-    return normalized;
-}
-function optionalTrimmed(value, name, maximum) {
-    if (value === undefined)
-        return undefined;
-    const normalized = value.trim();
-    if (!normalized || normalized.length > maximum)
-        throw new IntegrationError("invalid", `${name} must contain 1-${maximum} characters`);
-    return normalized;
-}
-function requiredText(value, name, maximum) {
-    if (!value.trim() || value.length > maximum)
-        throw new IntegrationError("invalid", `${name} must contain 1-${maximum} characters`);
-    return value;
-}
-function optionalTextBody(value, name, maximum) {
-    if (value === undefined)
-        return undefined;
-    if (value.length > maximum)
-        throw new IntegrationError("invalid", `${name} must contain at most ${maximum} characters`);
-    return value;
-}
-function futureDate(value, now) {
-    const timestamp = Date.parse(value);
-    if (!Number.isFinite(timestamp) || timestamp <= now.getTime())
-        throw new IntegrationError("invalid", "Credential expiry must be in the future");
-    return new Date(timestamp).toISOString();
-}
-function serializedPayload(value) {
-    let serialized;
-    try {
-        serialized = JSON.stringify(value);
-    }
-    catch {
-        throw new IntegrationError("invalid", "Webhook payload must be JSON serializable");
-    }
-    if (Buffer.byteLength(serialized, "utf8") > MAX_EVENT_PAYLOAD)
-        throw new IntegrationError("invalid", "Webhook payload is too large");
-    return serialized;
-}
-function boundedIdentifier(value, name) {
-    if (!value || value.length > 256 || value.trim() !== value)
-        throw new IntegrationError("invalid", `${name} is invalid`);
-}
-function positiveLimit(value, maximum) {
-    if (!Number.isSafeInteger(value) || value <= 0 || value > maximum)
-        throw new IntegrationError("invalid", `Value must be between 1 and ${maximum}`);
-    return value;
-}
-function retryDelay(deliveryId, attempts) {
-    const base = Math.min(60 * 60_000, 1_000 * 2 ** Math.max(0, attempts - 1));
-    const digest = createHash("sha256").update(`${deliveryId}:${attempts}`).digest();
-    const jitter = 0.8 + (digest.readUInt16BE(0) / 65_535) * 0.4;
-    return Math.round(base * jitter);
-}
-function constraintConflict(error, message) {
-    const code = error.code;
-    return code?.includes("CONSTRAINT") ? new IntegrationError("conflict", message) : error;
-}
-function truncate(value, maximum) {
-    return value === undefined ? undefined : value.slice(0, maximum);
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function stringArray(value) {
-    const parsed = JSON.parse(text(value));
-    if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string"))
-        throw new Error("Expected JSON string array");
-    return parsed;
-}
-function text(value) {
-    if (typeof value === "string")
-        return value;
-    if (typeof value === "number" || typeof value === "bigint")
-        return String(value);
-    throw new Error("Expected database text value");
-}
-function optionalText(value) {
-    return value === null || value === undefined ? undefined : text(value);
-}
-function number(value) {
-    if (typeof value === "number")
-        return value;
-    if (typeof value === "bigint")
-        return Number(value);
-    if (typeof value === "string" && /^-?\d+$/.test(value))
-        return Number(value);
-    throw new Error("Expected database integer value");
-}
-class DeliveryHttpError extends Error {
-    statusCode;
-    responseBody;
-    constructor(statusCode, responseBody) {
-        super(`Webhook returned HTTP ${statusCode}`);
-        this.statusCode = statusCode;
-        this.responseBody = responseBody;
-    }
-}
-//# sourceMappingURL=repository.js.map