@oomol-lab/open-connector 1.9.1 → 1.9.2

package/src/triggers/sources/operation.js

@@ -0,0 +1,146 @@
+import { z } from "zod";
+import { IntegrationConnectionError, PermanentIntegrationError } from "../common/integration.js";
+import { createEventSourceSchema, updateEventSourceSchema, sourceCreateSchema } from "./configuration-schema.js";
+const jsonObject = z.record(z.string(), z.json());
+const configuration = z.object({
+    identity: z.string().min(1),
+    eventTypes: z.array(z.string()),
+    config: jsonObject,
+    secrets: jsonObject,
+    state: jsonObject,
+});
+export const sourceOperationSchema = z.discriminatedUnion("action", [
+    z.strictObject({ action: z.literal("initialize"), input: jsonObject }),
+    z.strictObject({ action: z.literal("update"), source: configuration, input: jsonObject }),
+    z.strictObject({ action: z.literal("inspect"), source: configuration }),
+    z.strictObject({
+        action: z.literal("prepare"),
+        source: configuration,
+        config: jsonObject,
+        endpointUrl: z.string().optional(),
+    }),
+    z.strictObject({
+        action: z.literal("receive"),
+        source: configuration,
+        headers: z
+            .record(z.string(), z.string().max(8192))
+            .refine((headers) => new Set(Object.keys(headers).map((name) => name.toLowerCase())).size === Object.keys(headers).length, "Duplicate webhook header."),
+        rawBody: z
+            .string()
+            .max(90000)
+            .regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/),
+        consumers: z.array(z.object({ id: z.string(), config: jsonObject })).max(10000),
+    }),
+]);
+export function sourceMetadata(definition) {
+    const source = definition.source;
+    if (source == null)
+        return undefined;
+    return {
+        createSchema: z.toJSONSchema(sourceCreateSchema(source.kind)),
+        updateSchema: z.toJSONSchema(updateEventSourceSchema),
+        kind: source.kind,
+        provider: source.provider,
+        triggerId: source.resources.triggerId,
+        maximumBodyBytes: source.maximumBodyBytes,
+        applicationIngress: source.applicationIngress === true,
+        managed: source.resources.managed === true,
+    };
+}
+export async function executeSourceOperation(definition, request, connector, signal, now = Date.now()) {
+    const source = definition.source;
+    if (source == null)
+        throw new PermanentIntegrationError("This Trigger has no shared event source protocol.");
+    const execute = async (operation) => {
+        const context = { config: operation.config, connector, now: new Date(now), signal };
+        if (operation.operation === "sourceIdentity") {
+            if (definition.sourceIdentity == null)
+                throw new PermanentIntegrationError("Source identity verification is unavailable.");
+            return definition.sourceIdentity(context);
+        }
+        if (definition.sourceReceive == null)
+            throw new PermanentIntegrationError("Source callback verification is unavailable.");
+        return definition.sourceReceive({ ...context, headers: operation.headers, rawBody: operation.rawBody });
+    };
+    const project = (configuration) => ({
+        ...configuration,
+        state: {
+            ...configuration.state,
+            projection: JSON.parse(JSON.stringify({
+                view: source.view(configuration, now),
+                ready: source.ready(configuration, now),
+                expiresAt: source.expiresAt?.(configuration),
+            })),
+        },
+    });
+    switch (request.action) {
+        case "initialize": {
+            const parsed = createEventSourceSchema.safeParse(request.input);
+            if (!parsed.success)
+                throw new PermanentIntegrationError("Invalid event source configuration.");
+            const input = parsed.data;
+            let configuration = source.initialize(input, connector.providerAccountId);
+            if (source.verifyIdentity != null)
+                configuration = await source.verifyIdentity(configuration, (config) => execute({ operation: "sourceIdentity", config }));
+            return { source: project(configuration) };
+        }
+        case "update": {
+            const parsed = updateEventSourceSchema.safeParse(request.input);
+            if (!parsed.success)
+                throw new PermanentIntegrationError("Invalid event source update.");
+            return { source: project(source.update(request.source, parsed.data)) };
+        }
+        case "inspect":
+            return { source: project(request.source) };
+        case "prepare": {
+            if (connector.providerAccountId !== (request.source.config.accountId ?? request.source.identity))
+                throw new IntegrationConnectionError("The source Connection requires reauthorization.");
+            if (source.verifyIdentity != null)
+                await source.verifyIdentity(request.source, (config) => execute({ operation: "sourceIdentity", config }));
+            if (!source.resources.managed && !source.ready(request.source, now))
+                throw new PermanentIntegrationError("Verify the event source before publishing.");
+            if (!Array.isArray(request.config.eventTypes) ||
+                !request.config.eventTypes.every((type) => typeof type === "string" && request.source.eventTypes.includes(type)))
+                throw new PermanentIntegrationError("Configure the requested events on the event source first.");
+            return {
+                source: project(request.source),
+                subscriptions: source.resources.requests(request.source, source.provider, request.config, request.endpointUrl),
+            };
+        }
+        case "receive": {
+            const bytes = Uint8Array.from(atob(request.rawBody), (value) => value.charCodeAt(0));
+            if (bytes.byteLength > source.maximumBodyBytes)
+                return { response: { status: 413, body: "", headers: {} } };
+            let result;
+            try {
+                result = await source.receive(request.source, bytes, new Headers(request.headers), now, execute);
+            }
+            catch (error) {
+                signal.throwIfAborted();
+                if (!(error instanceof TypeError || error instanceof SyntaxError || error instanceof DOMException))
+                    throw error;
+                return { response: { status: 401, body: "", headers: {} } };
+            }
+            signal.throwIfAborted();
+            const configuration = project({ ...request.source, state: result.state ?? request.source.state });
+            if ("response" in result)
+                return {
+                    source: configuration,
+                    response: {
+                        status: result.response.status,
+                        body: await result.response.text(),
+                        headers: Object.fromEntries(result.response.headers),
+                    },
+                };
+            return {
+                source: configuration,
+                event: {
+                    ...result.event,
+                    matches: request.consumers
+                        .filter((consumer) => source.matches(consumer.config, result.event))
+                        .map((consumer) => consumer.id),
+                },
+            };
+        }
+    }
+}

package/src/triggers/sources/sentry.d.ts

@@ -0,0 +1,3 @@
+import type { CreateEventSource, EventSource, UpdateEventSource } from "./configuration.ts";
+import type { EventSourceDefinition } from "./definition.ts";
+export declare const sentryApplication: EventSourceDefinition<CreateEventSource, UpdateEventSource, Pick<EventSource, "appId" | "installationId" | "organizationId" | "manageSubscriptions" | "verificationTokenConfigured" | "encryptKeyConfigured" | "signingSecretConfigured" | "verifiedAt">>;

package/src/triggers/sources/sentry.js

@@ -0,0 +1,125 @@
+import { isJsonObject } from "../common/json.js";
+import { SourceIdentityError } from "./definition.js";
+import { verifySourceHmac } from "./signature.js";
+export const sentryApplication = {
+    kind: "sentry",
+    provider: "sentry",
+    applicationIngress: true,
+    maximumBodyBytes: 64 * 1024,
+    initialize(input, accountId) {
+        if (input.kind !== "sentry" || !accountId)
+            throw new SourceIdentityError("Connector must provide the verified Sentry organization identity.");
+        if (input.eventTypes.length !== 1 || input.eventTypes[0] !== "issue.alert")
+            throw new SourceIdentityError("Only Sentry Issue Alert Rule notifications are supported.");
+        return {
+            identity: JSON.stringify([input.teamId, input.connectionId, input.appId, input.installationId, accountId]),
+            eventTypes: input.eventTypes,
+            config: {
+                appId: input.appId,
+                installationId: input.installationId,
+                organizationId: input.organizationId,
+                accountId,
+            },
+            secrets: { signingSecret: input.signingSecret },
+            state: {},
+        };
+    },
+    async verifyIdentity(source, read) {
+        const identity = await read(source.config);
+        if (!isJsonObject(identity) ||
+            identity.accountId !== source.config.accountId ||
+            identity.appId !== source.config.appId ||
+            identity.installationId !== source.config.installationId ||
+            typeof identity.organizationSlug !== "string" ||
+            typeof identity.organizationId !== "string")
+            throw new SourceIdentityError("The Sentry installation does not belong to the connected organization and application.");
+        return {
+            ...source,
+            config: {
+                ...source.config,
+                organizationSlug: identity.organizationSlug,
+                organizationId: identity.organizationId,
+            },
+        };
+    },
+    update(source, input) {
+        if (input.verificationToken != null || input.encryptKey != null)
+            throw new SourceIdentityError("Sentry uses the integration Client Secret.");
+        if (input.eventTypes.length !== 1 || input.eventTypes[0] !== "issue.alert")
+            throw new SourceIdentityError("Only Sentry Issue Alert Rule notifications are supported.");
+        const signingSecret = input.signingSecret ?? source.secrets.signingSecret;
+        return {
+            ...source,
+            eventTypes: input.eventTypes,
+            secrets: { signingSecret },
+            state: signingSecret === source.secrets.signingSecret ? source.state : {},
+        };
+    },
+    view(source) {
+        return {
+            appId: String(source.config.appId),
+            installationId: String(source.config.installationId),
+            organizationId: String(source.config.organizationId),
+            manageSubscriptions: false,
+            verificationTokenConfigured: false,
+            encryptKeyConfigured: false,
+            signingSecretConfigured: true,
+            verifiedAt: typeof source.state.verifiedAt === "number" ? new Date(source.state.verifiedAt).toISOString() : null,
+        };
+    },
+    ready: (source) => typeof source.state.verifiedAt === "number",
+    async receive(source, bytes, headers, now) {
+        const signature = headers.get("sentry-hook-signature") ?? "";
+        if (!/^[0-9a-f]{64}$/.test(signature))
+            throw new TypeError("Invalid Sentry signature.");
+        if (!(await verifySourceHmac(bytes, signature, String(source.secrets.signingSecret))))
+            throw new TypeError("Invalid Sentry signature.");
+        const payload = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        if (!isJsonObject(payload) || !isJsonObject(payload.installation))
+            throw new TypeError("Invalid Sentry envelope.");
+        if (payload.installation.uuid !== source.config.installationId ||
+            headers.get("sentry-hook-resource") !== "event_alert" ||
+            payload.action !== "triggered")
+            return { response: Response.json({}), state: source.state };
+        if (!isJsonObject(payload.data) || !isJsonObject(payload.data.event))
+            throw new TypeError("Invalid Sentry issue alert.");
+        const event = payload.data.event;
+        if (typeof event.event_id !== "string" ||
+            !event.event_id ||
+            typeof event.issue_id !== "string" ||
+            !event.issue_id ||
+            typeof payload.data.triggered_rule !== "string" ||
+            !payload.data.triggered_rule)
+            throw new TypeError("Incomplete Sentry issue alert.");
+        const deliveryId = JSON.stringify([source.config.installationId, event.event_id, payload.data.triggered_rule]);
+        return {
+            state: { ...source.state, verifiedAt: now },
+            event: {
+                id: deliveryId,
+                type: "issue.alert",
+                payload: {
+                    event: "issue.alert",
+                    deliveryId,
+                    organizationId: source.config.organizationId,
+                    issueId: event.issue_id,
+                    body: payload.data,
+                },
+            },
+        };
+    },
+    matches(config, event) {
+        if (!Array.isArray(config.eventTypes) || !config.eventTypes.includes(event.type))
+            return false;
+        const body = event.payload.body;
+        if (!isJsonObject(body) || !isJsonObject(body.event))
+            return false;
+        if (Array.isArray(config.projectIds) &&
+            config.projectIds.length > 0 &&
+            !config.projectIds.includes(String(body.event.project)))
+            return false;
+        return (!Array.isArray(config.ruleNames) ||
+            config.ruleNames.length === 0 ||
+            config.ruleNames.includes(body.triggered_rule));
+    },
+    resources: { triggerId: "sentry.on_issue_alert", requests: () => [] },
+};

package/src/triggers/sources/signature.d.ts

@@ -0,0 +1 @@
+export declare function verifySourceHmac(bytes: Uint8Array, signature: string, secret: string, hash?: "SHA-1" | "SHA-256"): Promise<boolean>;

package/src/triggers/sources/signature.js

@@ -0,0 +1,10 @@
+export async function verifySourceHmac(bytes, signature, secret, hash = "SHA-256") {
+    const length = hash === "SHA-1" ? 40 : 64;
+    if (signature.length !== length || !/^[0-9a-f]+$/.test(signature))
+        return false;
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash }, false, [
+        "verify",
+    ]);
+    const supplied = Uint8Array.from(signature.match(/../g), (value) => Number.parseInt(value, 16));
+    return crypto.subtle.verify("HMAC", key, supplied, bytes.slice());
+}

package/src/triggers/sources/slack.d.ts

@@ -0,0 +1,3 @@
+import type { CreateEventSource, EventSource, UpdateEventSource } from "./configuration.ts";
+import type { EventSourceDefinition } from "./definition.ts";
+export declare const slackApplication: EventSourceDefinition<CreateEventSource, UpdateEventSource, Pick<EventSource, "appId" | "workspaceId" | "manageSubscriptions" | "verificationTokenConfigured" | "encryptKeyConfigured" | "signingSecretConfigured" | "verifiedAt">>;

package/src/triggers/sources/slack.js

@@ -0,0 +1,127 @@
+import { isJsonObject } from "../common/json.js";
+import { SourceIdentityError } from "./definition.js";
+import { verifySourceHmac } from "./signature.js";
+const events = new Set(["app_mention", "message.im"]);
+const encoder = new TextEncoder();
+export const slackApplication = {
+    kind: "slack",
+    applicationIngress: true,
+    provider: "slackbot",
+    maximumBodyBytes: 64 * 1024,
+    initialize(input, accountId) {
+        if (input.kind !== "slack" || accountId == null || !/^U[A-Z0-9]+$/.test(accountId))
+            throw new SourceIdentityError("Connector must provide the verified Slack bot user identity.");
+        if (input.eventTypes.some((event) => !events.has(event)))
+            throw new SourceIdentityError("Unsupported Slack event type.");
+        return {
+            identity: JSON.stringify([input.teamId, input.connectionId, input.appId, input.workspaceId, accountId]),
+            eventTypes: input.eventTypes,
+            config: { appId: input.appId, workspaceId: input.workspaceId, accountId },
+            secrets: { signingSecret: input.signingSecret },
+            state: {},
+        };
+    },
+    update(source, input) {
+        if (input.eventTypes.some((event) => !events.has(event)))
+            throw new SourceIdentityError("Unsupported Slack event type.");
+        const signingSecret = input.signingSecret ?? source.secrets.signingSecret;
+        return {
+            ...source,
+            eventTypes: input.eventTypes,
+            secrets: { signingSecret },
+            state: signingSecret === source.secrets.signingSecret ? source.state : {},
+        };
+    },
+    view(source) {
+        return {
+            appId: String(source.config.appId),
+            workspaceId: String(source.config.workspaceId),
+            manageSubscriptions: false,
+            verificationTokenConfigured: false,
+            encryptKeyConfigured: false,
+            signingSecretConfigured: true,
+            verifiedAt: typeof source.state.verifiedAt === "number" ? new Date(source.state.verifiedAt).toISOString() : null,
+        };
+    },
+    ready: (source) => typeof source.state.verifiedAt === "number",
+    async receive(source, bytes, headers, now) {
+        const timestamp = headers.get("x-slack-request-timestamp") ?? "";
+        const signature = headers.get("x-slack-signature") ?? "";
+        if (!/^\d{10}$/.test(timestamp) ||
+            Math.abs(now - Number(timestamp) * 1000) > 300_000 ||
+            !/^v0=[0-9a-f]{64}$/.test(signature))
+            throw new TypeError("Invalid Slack signature or timestamp.");
+        const prefix = encoder.encode(`v0:${timestamp}:`);
+        const body = new Uint8Array(prefix.length + bytes.length);
+        body.set(prefix);
+        body.set(bytes, prefix.length);
+        if (!(await verifySourceHmac(body, signature.slice(3), String(source.secrets.signingSecret))))
+            throw new TypeError("Invalid Slack signature.");
+        const payload = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        if (!isJsonObject(payload))
+            throw new TypeError("Invalid Slack envelope.");
+        if (payload.type === "url_verification") {
+            if (typeof payload.challenge !== "string" || !payload.challenge || payload.challenge.length > 1024)
+                throw new TypeError("Invalid Slack challenge.");
+            return { response: Response.json({ challenge: payload.challenge }), state: { ...source.state, verifiedAt: now } };
+        }
+        const ignored = () => ({ response: Response.json({}), state: source.state });
+        if (payload.type !== "event_callback" ||
+            payload.api_app_id !== source.config.appId ||
+            payload.team_id !== source.config.workspaceId)
+            return ignored();
+        if (!Array.isArray(payload.authorizations) ||
+            !payload.authorizations.some((authorization) => isJsonObject(authorization) &&
+                authorization.is_bot === true &&
+                authorization.user_id === source.config.accountId &&
+                authorization.team_id === source.config.workspaceId))
+            return ignored();
+        const event = payload.event;
+        if (!isJsonObject(event) ||
+            event.bot_id != null ||
+            event.subtype != null ||
+            event.user === source.config.accountId ||
+            payload.is_ext_shared_channel === true)
+            return ignored();
+        const type = event.type === "app_mention"
+            ? "app_mention"
+            : event.type === "message" && event.channel_type === "im"
+                ? "message.im"
+                : undefined;
+        if (type == null)
+            return ignored();
+        if (typeof payload.event_id !== "string" ||
+            !payload.event_id ||
+            typeof event.channel !== "string" ||
+            typeof event.user !== "string" ||
+            typeof event.text !== "string" ||
+            typeof event.ts !== "string")
+            throw new TypeError("Incomplete Slack event.");
+        return {
+            event: {
+                id: payload.event_id,
+                type,
+                payload: {
+                    event: type,
+                    deliveryId: payload.event_id,
+                    appId: payload.api_app_id,
+                    teamId: payload.team_id,
+                    channel: event.channel,
+                    user: event.user,
+                    text: event.text,
+                    ts: event.ts,
+                    threadTs: typeof event.thread_ts === "string" ? event.thread_ts : null,
+                    body: event,
+                },
+            },
+        };
+    },
+    matches(config, event) {
+        return (Array.isArray(config.eventTypes) &&
+            config.eventTypes.includes(event.type) &&
+            (!Array.isArray(config.channelIds) ||
+                config.channelIds.length === 0 ||
+                config.channelIds.includes(event.payload.channel)));
+    },
+    resources: { triggerId: "slackbot.on_event", requests: () => [] },
+};

package/src/triggers/sources/zoom.d.ts

@@ -0,0 +1,3 @@
+import type { CreateEventSource, EventSource, UpdateEventSource } from "./configuration.ts";
+import type { EventSourceDefinition } from "./definition.ts";
+export declare const zoomApplication: EventSourceDefinition<CreateEventSource, UpdateEventSource, Pick<EventSource, "appId" | "manageSubscriptions" | "verificationTokenConfigured" | "encryptKeyConfigured" | "signingSecretConfigured" | "verifiedAt">>;

package/src/triggers/sources/zoom.js

@@ -0,0 +1,113 @@
+import { isJsonObject } from "../common/json.js";
+import { SourceIdentityError } from "./definition.js";
+import { verifySourceHmac } from "./signature.js";
+const encoder = new TextEncoder();
+export const zoomApplication = {
+    kind: "zoom",
+    provider: "zoom",
+    applicationIngress: true,
+    maximumBodyBytes: 64 * 1024,
+    initialize(input, accountId) {
+        if (input.kind !== "zoom" || !accountId)
+            throw new SourceIdentityError("Connector must provide the verified Zoom connection identity.");
+        if (input.eventTypes.length !== 1 || input.eventTypes[0] !== "recording.completed")
+            throw new SourceIdentityError("Only completed Zoom cloud recordings are supported.");
+        return {
+            identity: JSON.stringify([input.teamId, input.connectionId, input.appId, accountId]),
+            eventTypes: input.eventTypes,
+            config: { appId: input.appId, accountId },
+            secrets: { signingSecret: input.signingSecret },
+            state: {},
+        };
+    },
+    async verifyIdentity(source, read) {
+        const identity = await read(source.config);
+        if (!isJsonObject(identity) ||
+            identity.accountId !== source.config.accountId ||
+            typeof identity.userId !== "string" ||
+            !identity.userId ||
+            typeof identity.zoomAccountId !== "string" ||
+            !identity.zoomAccountId)
+            throw new SourceIdentityError("Zoom did not return the connected user and account identity.");
+        if (source.config.userId != null &&
+            (source.config.userId !== identity.userId || source.config.zoomAccountId !== identity.zoomAccountId))
+            throw new SourceIdentityError("The Zoom user or account changed. Recreate the event source.");
+        return { ...source, config: { ...source.config, userId: identity.userId, zoomAccountId: identity.zoomAccountId } };
+    },
+    update(source, input) {
+        if (input.verificationToken != null || input.encryptKey != null)
+            throw new SourceIdentityError("Zoom uses the Webhook Secret Token.");
+        if (input.eventTypes.length !== 1 || input.eventTypes[0] !== "recording.completed")
+            throw new SourceIdentityError("Only completed Zoom cloud recordings are supported.");
+        const signingSecret = input.signingSecret ?? source.secrets.signingSecret;
+        return {
+            ...source,
+            eventTypes: input.eventTypes,
+            secrets: { signingSecret },
+            state: signingSecret === source.secrets.signingSecret ? source.state : {},
+        };
+    },
+    view(source) {
+        return {
+            appId: String(source.config.appId),
+            manageSubscriptions: false,
+            verificationTokenConfigured: false,
+            encryptKeyConfigured: false,
+            signingSecretConfigured: true,
+            verifiedAt: typeof source.state.verifiedAt === "number" ? new Date(source.state.verifiedAt).toISOString() : null,
+        };
+    },
+    ready: (source) => typeof source.state.verifiedAt === "number",
+    async receive(source, bytes, headers, now) {
+        const timestamp = headers.get("x-zm-request-timestamp") ?? "";
+        const signature = headers.get("x-zm-signature") ?? "";
+        if (!/^\d{10}$/.test(timestamp) ||
+            Math.abs(now - Number(timestamp) * 1000) > 300000 ||
+            !signature.startsWith("v0="))
+            throw new TypeError("Invalid Zoom signature or timestamp.");
+        const prefix = encoder.encode(`v0:${timestamp}:`);
+        const signed = new Uint8Array(prefix.length + bytes.length);
+        signed.set(prefix);
+        signed.set(bytes, prefix.length);
+        if (!(await verifySourceHmac(signed, signature.slice(3), String(source.secrets.signingSecret))))
+            throw new TypeError("Invalid Zoom signature.");
+        const payload = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        if (!isJsonObject(payload) || !isJsonObject(payload.payload))
+            throw new TypeError("Invalid Zoom envelope.");
+        if (payload.event === "endpoint.url_validation") {
+            const plainToken = payload.payload.plainToken;
+            if (typeof plainToken !== "string" || !plainToken || plainToken.length > 1024)
+                throw new TypeError("Invalid Zoom challenge.");
+            const key = await crypto.subtle.importKey("raw", encoder.encode(String(source.secrets.signingSecret)), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+            const digest = await crypto.subtle.sign("HMAC", key, encoder.encode(plainToken));
+            const encryptedToken = Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join("");
+            return { response: Response.json({ plainToken, encryptedToken }), state: { ...source.state, verifiedAt: now } };
+        }
+        const object = payload.payload.object;
+        if (payload.event !== "recording.completed" ||
+            payload.payload.account_id !== source.config.zoomAccountId ||
+            !isJsonObject(object) ||
+            object.host_id !== source.config.userId)
+            return { response: Response.json({}), state: source.state };
+        if (typeof object.uuid !== "string" || !object.uuid || !Array.isArray(object.recording_files))
+            throw new TypeError("Incomplete Zoom recording.");
+        const files = object.recording_files.filter((file) => isJsonObject(file) && file.status === "completed");
+        if (!files.length)
+            return { response: Response.json({}), state: source.state };
+        return {
+            event: {
+                id: object.uuid,
+                type: "recording.completed",
+                payload: {
+                    event: "recording.completed",
+                    deliveryId: object.uuid,
+                    accountId: payload.payload.account_id,
+                    meetingUuid: object.uuid,
+                    body: { ...object, recording_files: files },
+                },
+            },
+        };
+    },
+    matches: (config, event) => Array.isArray(config.eventTypes) && config.eventTypes.includes(event.type),
+    resources: { triggerId: "zoom.on_recording_ready", requests: () => [] },
+};

package/src/triggers/trigger-runner.d.ts

@@ -2,11 +2,13 @@ import type { CatalogStore } from "../catalog-store.ts";
 import type { ConnectionService } from "../connection-service.ts";
 import type { ActionPolicySnapshot } from "../core/action-policy.ts";
 import type { ProviderHttpDispatchOptions } from "../core/provider-http-dispatch.ts";
+import type { OAuthClientConfigService } from "../oauth/oauth-client-config-service.ts";
 import type { IProviderLoader } from "../providers/provider-loader.ts";
 import type { RuntimeGrant } from "../server/storage/runtime-token-service.ts";
 import type { TriggerRequest } from "./request.ts";
 import type { TriggerSubscription, TriggerStore } from "./store.ts";
 interface TriggerRunnerOptions {
+    oauthClientConfigs?: Pick<OAuthClientConfigService, "getConfig">;
     providerHttpDispatch?: ProviderHttpDispatchOptions;
     catalog: CatalogStore;
     providerLoader: IProviderLoader;