@oomol-lab/open-connector 1.9.1 → 1.9.2

package/src/providers/feishu_app_bot/trigger-on-event.js

@@ -1,10 +1,12 @@
 import { PermanentIntegrationError } from "../../triggers/common/integration.js";
 import { isJsonObject } from "../../triggers/common/json.js";
+import { feishuApplication } from "../../triggers/sources/feishu.js";
 import { additionalSnapshot0 } from "./trigger-on-event.definition.js";
 import { feishuSubscriptions, feishuResponse } from "./trigger-subscriptions.js";
 export const feishuEvents = [
     {
         eventSource: "feishu",
+        source: feishuApplication,
         resources: { subscriptions: (config) => feishuSubscriptions(config, "feishu_app_bot"), response: feishuResponse },
         snapshot: additionalSnapshot0,
         receive(context) {

package/src/providers/fireflies/executors.d.ts

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/fireflies/executors.js

@@ -1,5 +1,6 @@
 import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { firefliesActionHandlers, firefliesGraphqlBaseUrl, validateFirefliesCredential } from "./runtime.js";
+import { firefliesMeetingReady } from "./trigger-on-meeting-ready.js";
 const service = "fireflies";
 export const executors = defineApiKeyProviderExecutors(service, firefliesActionHandlers);
 export const proxy = defineProviderProxy({
@@ -13,3 +14,4 @@ export const credentialValidators = {
         return validateFirefliesCredential(input.apiKey, fetcher, signal);
     },
 };
+export const triggers = [firefliesMeetingReady];

package/src/providers/fireflies/trigger-on-meeting-ready.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const firefliesMeetingReady: IntegrationDefinition;

package/src/providers/fireflies/trigger-on-meeting-ready.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/fireflies/trigger-on-meeting-ready.definition.js

@@ -0,0 +1,44 @@
+export const snapshot = {
+    key: "fireflies.on_meeting_ready",
+    provider: "fireflies",
+    name: "on_meeting_ready",
+    displayName: "Meeting Transcript or Summary Ready",
+    description: "Receives separate transcript and summary readiness events through Fireflies Webhooks V2 after checking meeting access.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "sourceId",
+            jsonSchema: { type: "string", pattern: "^source_[0-9a-f]{32}$", title: "Event source" },
+            nullable: false,
+        },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: ["meeting.transcribed", "meeting.summarized"],
+                },
+                minItems: 1,
+                maxItems: 2,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["meeting.transcribed", "meeting.summarized"],
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "accountId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "meetingId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/fireflies/trigger-on-meeting-ready.js

@@ -0,0 +1,60 @@
+import { TransientIntegrationError } from "../../triggers/common/integration.js";
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { webhookRequest } from "../../triggers/managed-webhook.js";
+import { firefliesAccount } from "../../triggers/sources/fireflies.js";
+import { snapshot } from "./trigger-on-meeting-ready.definition.js";
+export const firefliesMeetingReady = {
+    snapshot,
+    eventSource: "fireflies",
+    source: firefliesAccount,
+    async sourceIdentity(context) {
+        const accountId = context.connector.providerAccountId;
+        if (!accountId)
+            throw new PermanentIntegrationError("Fireflies requires a verified connection identity.");
+        const meetingId = context.config.meetingId;
+        if (meetingId == null)
+            return { accountId };
+        if (typeof meetingId !== "string" || !meetingId || meetingId.length > 256)
+            throw new PermanentIntegrationError("Invalid Fireflies meeting ID.");
+        const result = await webhookRequest(context, {
+            method: "POST",
+            endpoint: "/graphql",
+            body: {
+                query: "query TriggerMeeting($id: String!) { transcript(id: $id) { id } }",
+                variables: { id: meetingId },
+            },
+        });
+        if (!isJsonObject(result.data))
+            throw new TransientIntegrationError("Invalid Fireflies access response.");
+        if (Array.isArray(result.data.errors) && result.data.errors.length) {
+            const denied = result.data.errors.every((error) => isJsonObject(error) &&
+                ["object_not_found", "forbidden", "not_in_team"].includes(String(isJsonObject(error.extensions) ? error.extensions.code : error.code)));
+            if (denied)
+                return { accountId, meetingId, accessible: false };
+            throw new TransientIntegrationError("Fireflies could not verify meeting access. Check API permissions, plan and availability.");
+        }
+        if (!isJsonObject(result.data.data))
+            throw new TransientIntegrationError("Invalid Fireflies access response.");
+        const transcript = result.data.data.transcript;
+        if (transcript == null)
+            return { accountId, meetingId, accessible: false };
+        if (!isJsonObject(transcript) || transcript.id !== meetingId)
+            throw new TransientIntegrationError("Fireflies returned a different meeting.");
+        return { accountId, meetingId, accessible: true };
+    },
+    receive(context) {
+        if (context.eventSourceId !== context.config.sourceId)
+            return { outcome: "respond", status: 404, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) ||
+            typeof payload.deliveryId !== "string" ||
+            !payload.deliveryId ||
+            !isJsonObject(payload.body))
+            throw new PermanentIntegrationError("Invalid shared Fireflies event.");
+        return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+    },
+    async reconcile() {
+        throw new PermanentIntegrationError("This deployment does not support shared Fireflies event sources.");
+    },
+};

package/src/providers/fundable/actions.d.ts

@@ -0,0 +1,8 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const fundableActions: ActionDefinition[];
+interface FundableRoute {
+    method: "GET" | "POST";
+    path: string;
+}
+export declare const fundableRoutes: Record<string, FundableRoute>;
+export {};