@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/triggers/common/integration.d.ts

@@ -1,3 +1,5 @@
+import type { CreateEventSource, UpdateEventSource, EventSource } from "../sources/configuration.ts";
+import type { EventSourceDefinition } from "../sources/definition.ts";
 import type { TriggerConfigOption, TriggerConfigOptionsContext } from "./configOptions.ts";
 import type { ConnectorProxyRequest, ConnectorProxyResult, ConnectorProxy } from "./proxy.ts";
 import type { IntegrationEndpointMethod, JsonValue, TriggerKeySnapshot } from "./types.ts";
@@ -85,13 +87,21 @@ export interface ResourceSubscription {
     readonly unsubscribe: ConnectorProxyRequest;
     readonly inspect?: ConnectorProxyRequest;
 }
-export interface ResourceDefinition {
+export type ResourceDefinition = {
     readonly subscriptions: (config: Readonly<Record<string, JsonValue>>) => readonly ResourceSubscription[];
     readonly response: (result: ConnectorProxyResult) => Readonly<Record<string, JsonValue>>;
-}
+} | {
+    readonly reconcile: (context: IntegrationReconcileContext) => Promise<IntegrationReconcileResult>;
+};
 export interface IntegrationDefinition {
+    readonly source?: EventSourceDefinition<CreateEventSource, UpdateEventSource, Partial<EventSource>>;
+    readonly sourceReceive?: (context: Omit<ListenerReadContext, "checkpoint"> & {
+        readonly headers: Readonly<Record<string, string>>;
+        readonly rawBody: string;
+    }) => Promise<Readonly<Record<string, JsonValue>>>;
+    readonly sourceIdentity?: (context: Omit<ListenerReadContext, "checkpoint">) => Promise<Readonly<Record<string, JsonValue>>>;
     readonly resources?: ResourceDefinition;
-    readonly eventSource?: "feishu";
+    readonly eventSource?: "feishu" | "slack" | "intercom" | "sentry" | "zoom" | "fireflies" | "jira";
     readonly configOptions?: (context: TriggerConfigOptionsContext) => Promise<readonly TriggerConfigOption[]>;
     readonly listener?: ListenerSource;
     readonly initialState?: {
@@ -109,6 +119,8 @@ export declare class IntegrationConnectionError extends Error {
 }
 export declare class PermanentIntegrationError extends Error {
     readonly name = "PermanentIntegrationError";
+    readonly reason: "trigger_quota_exceeded" | "trigger_subscription_uncertain" | undefined;
+    constructor(message: string, reason?: "trigger_quota_exceeded" | "trigger_subscription_uncertain");
 }
 export declare class TransientIntegrationError extends Error {
     readonly name = "TransientIntegrationError";

package/src/triggers/common/integration.js

@@ -25,6 +25,11 @@ export class IntegrationConnectionError extends Error {
 }
 export class PermanentIntegrationError extends Error {
     name = "PermanentIntegrationError";
+    reason;
+    constructor(message, reason) {
+        super(message);
+        this.reason = reason;
+    }
 }
 export class TransientIntegrationError extends Error {
     name = "TransientIntegrationError";

package/src/triggers/common/proxy.d.ts

@@ -6,9 +6,16 @@ export interface ConnectorProxyRequest {
     readonly query?: Readonly<Record<string, boolean | number | string | null>>;
 }
 export interface ConnectorProxyResult {
+    readonly headers?: Readonly<Record<string, string>>;
     readonly data: unknown;
     readonly status: number;
 }
 export interface ConnectorProxy {
+    readonly oauthClientConfig?: {
+        readonly clientId: string;
+        readonly clientSecret?: string;
+    };
+    readonly providerAccountId?: string;
+    readonly authType?: string;
     execute(request: ConnectorProxyRequest, signal?: AbortSignal): Promise<ConnectorProxyResult>;
 }

package/src/triggers/managed-webhook.d.ts

@@ -0,0 +1,13 @@
+import type { IntegrationReconcileContext, IntegrationReconcileResult } from "./common/integration.ts";
+import type { ConnectorProxyRequest, ConnectorProxyResult } from "./common/proxy.ts";
+export interface ManagedWebhook {
+    readonly id: string;
+    readonly secret: string;
+}
+export declare function webhookRequest(context: Pick<IntegrationReconcileContext, "connector" | "signal">, request: ConnectorProxyRequest): Promise<ConnectorProxyResult>;
+export declare function reconcileManagedWebhook(context: IntegrationReconcileContext, operations: {
+    readonly find: () => Promise<readonly ManagedWebhook[]>;
+    readonly create: () => Promise<ManagedWebhook>;
+    readonly remove: (id: string) => Promise<void>;
+    readonly align?: (id: string) => Promise<void>;
+}): Promise<IntegrationReconcileResult>;

package/src/triggers/managed-webhook.js

@@ -0,0 +1,48 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "./common/integration.js";
+export async function webhookRequest(context, request) {
+    context.signal?.throwIfAborted();
+    const result = await context.connector.execute(request, context.signal);
+    context.signal?.throwIfAborted();
+    if ((result.status >= 200 && result.status < 300) || (request.method == "DELETE" && result.status == 404))
+        return result;
+    const message = `Webhook ${request.method} request failed (HTTP ${result.status}). Check resource access and webhook permissions.`;
+    if (result.status >= 400 && result.status < 500 && result.status != 429)
+        throw new PermanentIntegrationError(message);
+    throw new TransientIntegrationError(message);
+}
+export async function reconcileManagedWebhook(context, operations) {
+    const state = context.state;
+    if (state == null)
+        throw new PermanentIntegrationError("Webhook subscription state is missing.");
+    const matches = await operations.find();
+    if (matches.length > 1)
+        throw new PermanentIntegrationError("Multiple webhooks match this subscription. Remove duplicates before retrying.");
+    let hook = matches[0];
+    if (!context.active) {
+        if (hook != null)
+            await operations.remove(hook.id);
+        else if (state.subscription.creating === true)
+            throw new PermanentIntegrationError("Webhook creation has an uncertain outcome. Verify the remote subscription before cleanup.");
+        await state.saveSubscription({}, new Date(context.now.getTime() + 86_400_000));
+        return { outcome: "ready" };
+    }
+    if (hook == null) {
+        if (state.subscription.creating === true)
+            throw new PermanentIntegrationError("Webhook creation has an uncertain outcome. Verify the remote subscription before retrying.");
+        await state.saveSubscription({ creating: true }, context.now);
+        try {
+            hook = await operations.create();
+        }
+        catch (error) {
+            // A definite rejection did not create a resource; transport and malformed-response errors remain uncertain.
+            if (error instanceof PermanentIntegrationError)
+                await state.saveSubscription({}, context.now);
+            throw error;
+        }
+    }
+    const subscription = { hookId: hook.id, secret: hook.secret };
+    await state.saveSubscription(subscription, context.now);
+    await operations.align?.(hook.id);
+    await state.saveSubscription(subscription, new Date(context.now.getTime() + 86_400_000));
+    return { outcome: "ready" };
+}

package/src/triggers/request.d.ts

@@ -1,8 +1,12 @@
 import type { JsonValue } from "./common/types.ts";
+import type { SourceOperation } from "./sources/operation.ts";
 interface ConfigRequest {
     config: Readonly<Record<string, JsonValue>>;
 }
-export type TriggerRequest = (ConfigRequest & {
+export type TriggerRequest = {
+    operation: "source";
+    request: SourceOperation;
+} | (ConfigRequest & {
     operation: "options";
     field: string;
 }) | (ConfigRequest & {

package/src/triggers/request.js

@@ -1,9 +1,11 @@
 import { z } from "zod";
 import { HttpRequestError } from "../server/api/http-utils.js";
+import { sourceOperationSchema } from "./sources/operation.js";
 const config = z.record(z.string(), z.json());
 const subscriptionId = z.string().min(1).max(128);
 const requestKey = z.string().min(1).max(512);
 const requestSchema = z.discriminatedUnion("operation", [
+    z.strictObject({ operation: z.literal("source"), request: sourceOperationSchema }),
     z.strictObject({ operation: z.literal("options"), config, field: z.string().min(1).max(128) }),
     z.strictObject({ operation: z.literal("read"), config, checkpoint: z.json() }),
     z.strictObject({

package/src/triggers/resources.d.ts

@@ -1,12 +1,18 @@
 import type { IntegrationReconcileResult, ResourceDefinition } from "./common/integration.ts";
 import type { ConnectorProxy } from "./common/proxy.ts";
+import type { JsonValue } from "./common/types.ts";
 import type { TriggerRequest } from "./request.ts";
 import type { TriggerSubscription, TriggerStore } from "./store.ts";
 import type { SubscriptionOwner } from "./subscriptions.ts";
+interface ResourceSubscriptionResult extends IntegrationReconcileResult {
+    readonly subscription?: Readonly<Record<string, JsonValue>>;
+    readonly reconcileAt?: number;
+}
 export declare function executeResourceSubscription(store: TriggerStore, definition: ResourceDefinition, owner: SubscriptionOwner, input: Extract<TriggerRequest, {
     operation: "resource";
-}>, proxy: ConnectorProxy, signal: AbortSignal): Promise<IntegrationReconcileResult>;
+}>, proxy: ConnectorProxy, signal: AbortSignal): Promise<ResourceSubscriptionResult>;
 export declare function executeResourceSubscriptionOperation(store: TriggerStore, definition: ResourceDefinition, consumer: TriggerSubscription, saveConsumer: () => Promise<void>, input: Extract<TriggerRequest, {
     operation: "resource";
-}>, proxy: ConnectorProxy, signal: AbortSignal): Promise<IntegrationReconcileResult>;
+}>, proxy: ConnectorProxy, signal: AbortSignal): Promise<ResourceSubscriptionResult>;
 export declare function abandonResourceSubscription(store: TriggerStore, definition: ResourceDefinition, consumer: TriggerSubscription, signal: AbortSignal): Promise<void>;
+export {};

package/src/triggers/resources.js

@@ -52,6 +52,35 @@ export async function executeResourceSubscriptionOperation(store, definition, co
         consumer.status = "deleting";
         await saveConsumer();
     }
+    if ("reconcile" in definition) {
+        const result = await definition.reconcile({
+            active: input.active,
+            config: input.config,
+            connector: proxy,
+            signal,
+            now: new Date(),
+            endpointUrl: typeof input.config.endpointUrl === "string" ? input.config.endpointUrl : "",
+            callbackSecret: "",
+            idempotencyKey: member,
+            state: {
+                checkpoint: consumer.checkpoint,
+                subscription: consumer.subscription,
+                saveCheckpoint: async (checkpoint) => {
+                    consumer.checkpoint = checkpoint;
+                    await saveConsumer();
+                },
+                saveSubscription: async (subscription, reconcileAt) => {
+                    consumer.subscription = subscription;
+                    consumer.reconcileAt = reconcileAt.getTime();
+                    await saveConsumer();
+                },
+            },
+        });
+        if (!input.active && result.outcome === "ready")
+            consumer.status = "deleted";
+        await saveConsumer();
+        return { ...result, subscription: consumer.subscription, reconcileAt: consumer.reconcileAt };
+    }
     for (const resource of definition.subscriptions(input.config)) {
         const shared = { ...owner, tokenId: "shared-resource" };
         const id = await resourceSubscriptionId(owner, resource.key);
@@ -106,6 +135,8 @@ export async function executeResourceSubscriptionOperation(store, definition, co
     return { outcome: "ready" };
 }
 export async function abandonResourceSubscription(store, definition, consumer, signal) {
+    if ("reconcile" in definition)
+        return;
     for (const resource of definition.subscriptions(consumer.config)) {
         const id = await resourceSubscriptionId(consumer, resource.key);
         if (!(await store.getFlowTrigger(id)))

package/src/triggers/signature.d.ts

@@ -1,4 +1,4 @@
-export declare function bytes(value: string): Uint8Array;
+export declare function bytes(value: string): Uint8Array<ArrayBuffer>;
 export declare function sameSecret(candidate: string | undefined, expected: string): boolean;
-export declare function verifyBase64Hmac(secret: string, parts: readonly Uint8Array[], signature: string | undefined): Promise<boolean>;
-export declare function verifyHexHmac(secret: string, parts: readonly Uint8Array[], signature: string | undefined): Promise<boolean>;
+export declare function verifyBase64Hmac(secret: string | Uint8Array, parts: readonly Uint8Array[], signature: string | undefined): Promise<boolean>;
+export declare function verifyHexHmac(secret: string | Uint8Array, parts: readonly Uint8Array[], signature: string | undefined, hash?: string): Promise<boolean>;

package/src/triggers/signature.js

@@ -9,14 +9,12 @@ export async function verifyBase64Hmac(secret, parts, signature) {
     const candidate = signature == null ? undefined : base64(signature);
     return candidate != null && sameBytes(candidate, await hmac(secret, parts));
 }
-export async function verifyHexHmac(secret, parts, signature) {
+export async function verifyHexHmac(secret, parts, signature, hash = "SHA-256") {
     const candidate = signature == null ? undefined : hex(signature);
-    return candidate != null && sameBytes(candidate, await hmac(secret, parts));
+    return candidate != null && sameBytes(candidate, await hmac(secret, parts, hash));
 }
-async function hmac(secret, parts) {
-    const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { hash: "SHA-256", name: "HMAC" }, false, [
-        "sign",
-    ]);
+async function hmac(secret, parts, hash = "SHA-256") {
+    const key = await crypto.subtle.importKey("raw", typeof secret == "string" ? encoder.encode(secret) : secret, { hash, name: "HMAC" }, false, ["sign"]);
     const size = parts.reduce((total, part) => total + part.byteLength, 0);
     const source = new Uint8Array(size);
     let offset = 0;

package/src/triggers/sources/configuration-schema.d.ts

@@ -0,0 +1,5 @@
+import type { CreateEventSource, UpdateEventSource } from "./configuration.ts";
+import { z } from "zod";
+export declare const updateEventSourceSchema: z.ZodType<UpdateEventSource>;
+export declare const createEventSourceSchema: z.ZodType<CreateEventSource>;
+export declare function sourceCreateSchema(kind: string): z.ZodType<CreateEventSource>;

package/src/triggers/sources/configuration-schema.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+const id = z.string().min(1).max(256);
+const eventType = z.string().regex(/^[a-z][a-z0-9_.:]{0,127}$/);
+const name = z.string().trim().min(1).max(128);
+const secret = z.string().min(1).max(256);
+const createFeishuEventSourceSchema = z.strictObject({
+    kind: z.literal("feishu").optional(),
+    version: z.literal(1),
+    name,
+    connectionId: id,
+    teamId: id.nullable(),
+    verificationToken: secret,
+    encryptKey: secret,
+    eventTypes: z
+        .array(eventType)
+        .min(1)
+        .max(200)
+        .refine((values) => new Set(values).size == values.length),
+    manageSubscriptions: z.boolean(),
+});
+const createSchema = z.union([
+    createFeishuEventSourceSchema,
+    z.strictObject({
+        kind: z.literal("jira"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        project: id,
+        eventTypes: z
+            .array(z.enum(["jira:issue_created", "jira:issue_updated", "comment_created"]))
+            .min(1)
+            .max(3)
+            .refine((values) => new Set(values).size === values.length),
+    }),
+    z.strictObject({
+        kind: z.literal("fireflies"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        signingSecret: secret,
+        eventTypes: z
+            .array(z.enum(["meeting.transcribed", "meeting.summarized"]))
+            .min(1)
+            .max(2)
+            .refine((values) => new Set(values).size === values.length),
+    }),
+    z.strictObject({
+        kind: z.literal("zoom"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        appId: id,
+        signingSecret: secret,
+        eventTypes: z.array(z.literal("recording.completed")).length(1),
+    }),
+    z.strictObject({
+        kind: z.literal("sentry"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        appId: id,
+        installationId: id,
+        organizationId: id,
+        signingSecret: secret,
+        eventTypes: z.array(z.literal("issue.alert")).length(1),
+    }),
+    z.strictObject({
+        kind: z.literal("intercom"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        appId: id,
+        signingSecret: secret,
+        eventTypes: z
+            .array(z.enum(["conversation.user.created", "conversation.user.replied", "ticket.created"]))
+            .min(1)
+            .max(3)
+            .refine((values) => new Set(values).size === values.length),
+    }),
+    z.strictObject({
+        kind: z.literal("slack"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        appId: z.string().regex(/^A[A-Z0-9]+$/),
+        workspaceId: z.string().regex(/^T[A-Z0-9]+$/),
+        signingSecret: secret,
+        eventTypes: z
+            .array(z.enum(["app_mention", "message.im"]))
+            .min(1)
+            .max(2)
+            .refine((values) => new Set(values).size === values.length),
+    }),
+]);
+export const updateEventSourceSchema = z.strictObject({
+    version: z.literal(1),
+    expectedRevision: z.int().positive(),
+    name,
+    enabled: z.boolean(),
+    eventTypes: z
+        .array(eventType)
+        .min(1)
+        .max(200)
+        .refine((values) => new Set(values).size == values.length),
+    verificationToken: secret.optional(),
+    signingSecret: secret.optional(),
+    encryptKey: secret.optional(),
+});
+export const createEventSourceSchema = createSchema;
+export function sourceCreateSchema(kind) {
+    return createSchema.options.find((schema) => schema.shape.kind.safeParse(kind).success);
+}

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

@@ -0,0 +1,115 @@
+export interface CreateFeishuEventSource {
+    readonly kind?: "feishu";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly verificationToken: string;
+    readonly encryptKey: string;
+    readonly eventTypes: string[];
+    readonly manageSubscriptions: boolean;
+}
+export interface CreateSlackEventSource {
+    readonly kind: "slack";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly appId: string;
+    readonly workspaceId: string;
+    readonly signingSecret: string;
+    readonly eventTypes: string[];
+}
+export interface CreateIntercomEventSource {
+    readonly kind: "intercom";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly appId: string;
+    readonly signingSecret: string;
+    readonly eventTypes: string[];
+}
+export interface CreateSentryEventSource {
+    readonly kind: "sentry";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly appId: string;
+    readonly installationId: string;
+    readonly organizationId: string;
+    readonly signingSecret: string;
+    readonly eventTypes: string[];
+}
+export interface CreateZoomEventSource {
+    readonly kind: "zoom";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly appId: string;
+    readonly signingSecret: string;
+    readonly eventTypes: string[];
+}
+export interface CreateFirefliesEventSource {
+    readonly kind: "fireflies";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly signingSecret: string;
+    readonly eventTypes: string[];
+}
+export interface CreateJiraEventSource {
+    readonly kind: "jira";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly project: string;
+    readonly eventTypes: string[];
+}
+export type CreateEventSource = CreateFeishuEventSource | CreateSlackEventSource | CreateIntercomEventSource | CreateSentryEventSource | CreateZoomEventSource | CreateFirefliesEventSource | CreateJiraEventSource;
+export interface UpdateEventSource {
+    readonly signingSecret?: string;
+    readonly version: 1;
+    readonly expectedRevision: number;
+    readonly name: string;
+    readonly enabled: boolean;
+    readonly eventTypes: string[];
+    readonly verificationToken?: string;
+    readonly encryptKey?: string;
+}
+export interface EventSource {
+    readonly version: 1;
+    readonly sourceId: string;
+    readonly revision: number;
+    readonly name: string;
+    readonly provider: "feishu" | "feishu_app_bot" | "slackbot" | "intercom" | "sentry" | "zoom" | "fireflies" | "jira";
+    readonly appId: string;
+    readonly workspaceId?: string;
+    readonly installationId?: string;
+    readonly organizationId?: string;
+    readonly projectId?: string;
+    readonly projectKey?: string;
+    readonly subscriptionStatus?: "idle" | "pending" | "ready" | "error";
+    readonly lastError?: string;
+    readonly signingSecretConfigured?: boolean;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly enabled: boolean;
+    readonly eventTypes: string[];
+    readonly manageSubscriptions: boolean;
+    readonly verificationTokenConfigured: boolean;
+    readonly encryptKeyConfigured: boolean;
+    readonly endpointUrl: string | null;
+    readonly verifiedAt: string | null;
+    readonly lastReceivedAt: string | null;
+    readonly updatedAt: string;
+    readonly consumers: {
+        flowId: string;
+        flowName: string;
+        triggerNodeId: string;
+    }[];
+}

package/src/triggers/sources/configuration.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,61 @@
+import { PermanentIntegrationError } from "../common/integration.ts";
+type TriggerOperationRequest = {
+    operation: "sourceIdentity";
+    config: Readonly<Record<string, JsonValue>>;
+} | {
+    operation: "sourceReceive";
+    config: Readonly<Record<string, JsonValue>>;
+    headers: Readonly<Record<string, string>>;
+    rawBody: string;
+};
+import type { JsonValue } from "../common/types.ts";
+export interface SourceConfiguration {
+    readonly identity: string;
+    readonly eventTypes: string[];
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly secrets: Readonly<Record<string, JsonValue>>;
+    readonly state: Readonly<Record<string, JsonValue>>;
+}
+export interface SourceEvent {
+    readonly ordering?: {
+        readonly key: string;
+        readonly version: number;
+    };
+    readonly id: string;
+    readonly type: string;
+    readonly payload: Readonly<Record<string, JsonValue>>;
+}
+export interface SourceSubscription {
+    readonly key: string;
+    readonly config: Readonly<Record<string, JsonValue>>;
+}
+export interface EventSourceDefinition<Create, Update, View> {
+    readonly kind: string;
+    readonly provider: string;
+    readonly maximumBodyBytes: number;
+    readonly expiresAt?: (source: SourceConfiguration) => number | undefined;
+    readonly applicationIngress?: boolean;
+    readonly initialize: (input: Create, accountId: string | undefined) => SourceConfiguration;
+    readonly verifyIdentity?: (source: SourceConfiguration, read: (config: Readonly<Record<string, JsonValue>>) => Promise<unknown>) => Promise<SourceConfiguration>;
+    readonly update: (source: SourceConfiguration, input: Update) => SourceConfiguration;
+    readonly view: (source: SourceConfiguration, now?: number) => View;
+    readonly ready: (source: SourceConfiguration, now?: number) => boolean;
+    readonly receive: (source: SourceConfiguration, bytes: Uint8Array, headers: Headers, now: number, execute?: (request: Extract<TriggerOperationRequest, {
+        operation: "sourceIdentity" | "sourceReceive";
+    }>) => Promise<unknown>) => Promise<{
+        readonly response: Response;
+        readonly state: SourceConfiguration["state"];
+    } | {
+        readonly event: SourceEvent;
+        readonly state?: SourceConfiguration["state"];
+    }>;
+    readonly matches: (config: Readonly<Record<string, JsonValue>>, event: SourceEvent) => boolean;
+    readonly resources: {
+        readonly managed?: boolean;
+        readonly triggerId: string;
+        readonly requests: (source: SourceConfiguration, provider: string, config: Readonly<Record<string, JsonValue>>, endpointUrl?: string) => readonly SourceSubscription[];
+    };
+}
+export declare class SourceIdentityError extends PermanentIntegrationError {
+}
+export {};

package/src/triggers/sources/definition.js

@@ -0,0 +1,3 @@
+import { PermanentIntegrationError } from "../common/integration.js";
+export class SourceIdentityError extends PermanentIntegrationError {
+}

package/src/triggers/sources/feishu-demands.d.ts

@@ -0,0 +1,6 @@
+import type { JsonValue } from "../common/types.ts";
+export interface FeishuSubscription {
+    readonly key: string;
+    readonly config: Readonly<Record<string, JsonValue>>;
+}
+export declare function feishuSubscriptions(config: Readonly<Record<string, JsonValue>>, provider: string): readonly FeishuSubscription[];

package/src/triggers/sources/feishu-demands.js

@@ -0,0 +1,24 @@
+import { feishuResourceKind } from "../../providers/feishu_app_bot/trigger-config.js";
+import { PermanentIntegrationError } from "../common/integration.js";
+import { isJsonObject } from "../common/json.js";
+export function feishuSubscriptions(config, provider) {
+    if (config.resource == null)
+        return [];
+    if (!isJsonObject(config.resource))
+        throw new PermanentIntegrationError("Invalid Feishu resource.");
+    const { kind, id, documentType } = config.resource;
+    if (typeof id != "string" || id.length == 0 || kind != feishuResourceKind(config.eventTypes))
+        throw new PermanentIntegrationError("Invalid resource subscription.");
+    if (kind == "document") {
+        if (typeof documentType != "string" ||
+            !["doc", "docx", "sheet", "bitable", "file", "folder", "slides"].includes(documentType))
+            throw new PermanentIntegrationError("A supported document type is required.");
+        return config.eventTypes.map((eventType) => ({
+            key: JSON.stringify(["document", documentType, id, eventType]),
+            config: { ...config, eventTypes: [eventType] },
+        }));
+    }
+    if (kind == "calendar" || (kind == "approval" && provider == "feishu_app_bot"))
+        return [{ key: JSON.stringify([kind, id]), config }];
+    throw new PermanentIntegrationError("Unsupported Feishu resource subscription.");
+}

package/src/triggers/sources/feishu-events.d.ts

@@ -0,0 +1,19 @@
+import type { JsonValue } from "../common/types.ts";
+export interface FeishuEvent {
+    readonly id: string;
+    readonly type: string;
+    readonly appId: string;
+    readonly tenantKey: string;
+    readonly occurredAt: string | null;
+    readonly body: Readonly<Record<string, JsonValue>>;
+}
+export declare function receiveFeishuEvent(rawBody: Uint8Array, headers: Headers, source: {
+    readonly appId: string;
+    readonly verificationToken: string;
+    readonly encryptKey: string;
+}, now: number): Promise<{
+    readonly challenge: string;
+} | {
+    readonly event: FeishuEvent;
+}>;
+export declare function matchesFeishuEvent(config: Readonly<Record<string, JsonValue>>, event: Pick<FeishuEvent, "type" | "body">): boolean;