@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/providers/calendly/trigger-on-booking-event.definition.js

@@ -0,0 +1,42 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const events = ["invitee.created", "invitee.canceled"];
+export const snapshot = {
+    key: "calendly.on_booking_event",
+    provider: "calendly",
+    name: "on_booking_event",
+    displayName: "Booking Created or Canceled",
+    description: "Receives bookings and cancellations, preserving reschedule links. Requires a Personal Access Token connection.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "scope",
+            jsonSchema: { type: "string", enum: ["user", "organization"], title: "Scope" },
+            nullable: false,
+            value: "user",
+        },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", enum: events },
+                minItems: 1,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: events,
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string", enum: events }, nullable: false },
+        { handle: "inviteeUri", jsonSchema: s.string(), nullable: false },
+        { handle: "createdAt", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/calendly/trigger-on-booking-event.js

@@ -0,0 +1,144 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { bytes, verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-booking-event.definition.js";
+function webhookId(uri) {
+    if (typeof uri != "string" || !uri.startsWith("https://api.calendly.com/webhook_subscriptions/"))
+        throw new TransientIntegrationError("Calendly returned an invalid subscription URI.");
+    const id = uri.slice("https://api.calendly.com/webhook_subscriptions/".length);
+    if (!id || id.includes("/") || id.includes("?") || id.includes("#"))
+        throw new TransientIntegrationError("Calendly returned an invalid subscription identity.");
+    return id;
+}
+export const calendlyBookingEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        // OAuth subscriptions use the application signing key; signing_key cannot override it.
+        if (context.connector.authType != "api_key")
+            throw new PermanentIntegrationError("Calendly Triggers require a Personal Access Token connection. OAuth application signing keys are not configured by this deployment.");
+        const current = await webhookRequest(context, { endpoint: "/users/me", method: "GET" });
+        if (!isJsonObject(current.data) ||
+            !isJsonObject(current.data.resource) ||
+            typeof current.data.resource.uri != "string" ||
+            typeof current.data.resource.current_organization != "string")
+            throw new TransientIntegrationError("Calendly returned an invalid current user.");
+        const organization = current.data.resource.current_organization;
+        const user = current.data.resource.uri;
+        const scope = String(context.config.scope);
+        const query = { organization, scope, count: 100 };
+        if (scope == "user")
+            query.user = user;
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const found = [];
+                const seen = new Set();
+                for (let page = 0; page < 100; page++) {
+                    const result = await webhookRequest(context, {
+                        endpoint: "/webhook_subscriptions",
+                        method: "GET",
+                        query,
+                    });
+                    if (!isJsonObject(result.data) ||
+                        !Array.isArray(result.data.collection) ||
+                        !isJsonObject(result.data.pagination))
+                        throw new TransientIntegrationError("Calendly returned an invalid webhook page.");
+                    for (const item of result.data.collection) {
+                        if (!isJsonObject(item) || typeof item.callback_url != "string")
+                            throw new TransientIntegrationError("Calendly returned an invalid webhook.");
+                        if (item.callback_url != context.endpointUrl)
+                            continue;
+                        if (item.organization != organization || item.scope != scope || (scope == "user" && item.user != user))
+                            throw new PermanentIntegrationError("Calendly webhook scope differs from this subscription.");
+                        if (context.active && item.state != "active")
+                            throw new PermanentIntegrationError("Calendly disabled this webhook. Restore it or remove the owned webhook before retrying.");
+                        if (context.active &&
+                            (!Array.isArray(item.events) ||
+                                item.events.length != context.config.eventTypes.length ||
+                                !context.config.eventTypes.every((event) => item.events.includes(event))))
+                            throw new PermanentIntegrationError("Calendly webhook events differ from this subscription. Remove the owned webhook before retrying.");
+                        found.push({ id: webhookId(item.uri), secret: context.callbackSecret });
+                    }
+                    const next = result.data.pagination.next_page_token;
+                    if (next == null)
+                        return found;
+                    if (typeof next != "string" || !next || seen.has(next))
+                        throw new TransientIntegrationError("Calendly webhook pagination did not advance.");
+                    seen.add(next);
+                    query.page_token = next;
+                }
+                throw new PermanentIntegrationError("The Calendly webhook list exceeds 10000 entries.");
+            },
+            async create() {
+                const body = {
+                    url: context.endpointUrl,
+                    events: context.config.eventTypes,
+                    organization,
+                    scope,
+                    signing_key: context.callbackSecret,
+                };
+                if (scope == "user")
+                    body.user = user;
+                const result = await webhookRequest(context, {
+                    endpoint: "/webhook_subscriptions",
+                    method: "POST",
+                    body,
+                });
+                if (!isJsonObject(result.data) || !isJsonObject(result.data.resource))
+                    throw new TransientIntegrationError("Calendly webhook creation returned no resource.");
+                return { id: webhookId(result.data.resource.uri), secret: context.callbackSecret };
+            },
+            async remove(id) {
+                await webhookRequest(context, {
+                    endpoint: `/webhook_subscriptions/${encodeURIComponent(id)}`,
+                    method: "DELETE",
+                });
+            },
+        });
+    },
+    async receive(context) {
+        const parts = context
+            .header("calendly-webhook-signature")
+            ?.split(",")
+            .map((part) => part.trim()) ?? [];
+        const timestamps = parts.filter((part) => part.startsWith("t="));
+        const timestamp = timestamps[0]?.slice(2);
+        let valid = false;
+        if (timestamps.length == 1 &&
+            timestamp &&
+            Number.isInteger(Number(timestamp)) &&
+            Math.abs(context.now.getTime() / 1000 - Number(timestamp)) <= 180) {
+            for (const part of parts) {
+                if (part.startsWith("v1=") &&
+                    (await verifyHexHmac(context.callbackSecret, [bytes(`${timestamp}.`), context.rawBody], part.slice(3)))) {
+                    valid = true;
+                    break;
+                }
+            }
+        }
+        if (!valid)
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const body = context.payload;
+        if (!isJsonObject(body) ||
+            typeof body.event != "string" ||
+            !context.config.eventTypes.includes(body.event))
+            return { outcome: "ignored", reason: "Calendly event does not match." };
+        if (!isJsonObject(body.payload) ||
+            typeof body.payload.uri != "string" ||
+            !body.payload.uri ||
+            typeof body.created_at != "string" ||
+            !body.created_at)
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: JSON.stringify([body.event, body.payload.uri, body.created_at]),
+            outputs: {
+                event: body.event,
+                inviteeUri: body.payload.uri,
+                createdAt: body.created_at,
+                body: body.payload,
+            },
+        };
+    },
+};

package/src/providers/captainbi/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalInteger as asOptionalInteger, optionalRecord as asOptionalObject, optionalString as asOptionalString, } from "../../core/cast.js";
-import { createProviderTimeout, providerUserAgent as connectorUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, providerUserAgent as connectorUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const captainBiApiBaseUrl = "https://openapi.captainbi.com";
 export const captainBiTokenUrl = `${captainBiApiBaseUrl}/oauth2/token`;
 const defaultPage = 1;
@@ -285,7 +285,7 @@ function mapCaptainBiHttpError(status, payload, phase, operation) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && [400, 401, 403].includes(status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 401 || (operation === "access token exchange" && [400, 403].includes(status))) {
         return new ProviderRequestError(401, message);
@@ -296,21 +296,21 @@ function mapCaptainBiHttpError(status, payload, phase, operation) {
     if ([400, 404, 409, 422].includes(status)) {
         return new ProviderRequestError(status === 404 ? 404 : 400, message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function mapCaptainBiBusinessError(code, payload, phase, operation) {
     const message = readString(payload, "msg", "message", "error") ??
         `CaptainBI ${operation} failed${code == null ? "" : ` with code ${code}`}`;
     switch (code) {
         case 100903:
-            return new ProviderRequestError(400, message);
+            return providerInputError(message);
         case 100904:
         case 100910:
             return new ProviderRequestError(429, message);
         case 100902:
         case 100906:
         case 100907:
-            return phase === "validate" ? new ProviderRequestError(400, message) : new ProviderRequestError(401, message);
+            return phase === "validate" ? providerInputError(message) : new ProviderRequestError(401, message);
         case 100901:
         case 100905:
         case 100908:
@@ -321,7 +321,7 @@ function mapCaptainBiBusinessError(code, payload, phase, operation) {
         case 100914:
             return new ProviderRequestError(403, message);
         default:
-            return new ProviderRequestError(502, message);
+            return providerResponseError(message);
     }
 }
 function readCaptainBiErrorMessage(payload) {

package/src/providers/castingwords/runtime.js

@@ -180,7 +180,7 @@ function createCastingwordsError(status, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (status === 400) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 401 || status === 403) {
         return new ProviderRequestError(phase === "validate" ? 401 : status, message);

package/src/providers/chatpdf/runtime.js

@@ -1,5 +1,5 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const chatpdfApiBaseUrl = "https://api.chatpdf.com/v1";
 export const chatpdfActionHandlers = {
     async add_source_url(input, context) {
@@ -98,7 +98,7 @@ function createChatpdfError(response, payload) {
         return new ProviderRequestError(429, message);
     }
     if (response.status === 400 || response.status === 404 || response.status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status >= 500 ? 502 : response.status, message);
 }
@@ -115,13 +115,13 @@ function extractErrorMessage(payload) {
 function requireObject(value, message) {
     const record = optionalRecord(value);
     if (!record) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return record;
 }
 function requireString(value, message) {
     if (typeof value !== "string" || value.length === 0) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return value;
 }

package/src/providers/check/executors.js

@@ -1,9 +1,8 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString, requiredRecord, requiredString, } from "../../core/cast.js";
-import { defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerResponseError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, } from "../provider-runtime.js";
+import { defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerResponseError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "check";
 const sandboxApiBaseUrl = "https://sandbox.checkhq.com";
 const productionApiBaseUrl = "https://api.checkhq.com";
-const requestTimeoutMs = 30_000;
 export const checkActionHandlers = {
     async validate_address(input, context) {
         const payload = await requestCheckJson({
@@ -110,8 +109,8 @@ export const credentialValidators = {
 };
 async function requestCheckJson(input) {
     const signal = input.context.signal
-        ? AbortSignal.any([input.context.signal, AbortSignal.timeout(requestTimeoutMs)])
-        : AbortSignal.timeout(requestTimeoutMs);
+        ? AbortSignal.any([input.context.signal, AbortSignal.timeout(defaultProviderRequestTimeoutMs)])
+        : AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     let response;
     let payload;
     try {

package/src/providers/checkly/executors.js

@@ -1,8 +1,7 @@
 import { optionalBoolean, optionalRecord, optionalString, requiredRecord, requiredString } from "../../core/cast.js";
-import { defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerResponseError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, } from "../provider-runtime.js";
+import { defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerResponseError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "checkly";
 const apiBaseUrl = "https://api.checklyhq.com";
-const requestTimeoutMs = 30_000;
 export const checklyActionHandlers = {
     async get_current_account(_input, context) {
         return { account: await requestChecklyJson({ context, path: "/v1/accounts/me", phase: "execute" }) };
@@ -134,8 +133,8 @@ export const proxy = defineProviderProxy({
 });
 async function requestChecklyJson(input) {
     const signal = input.context.signal
-        ? AbortSignal.any([input.context.signal, AbortSignal.timeout(requestTimeoutMs)])
-        : AbortSignal.timeout(requestTimeoutMs);
+        ? AbortSignal.any([input.context.signal, AbortSignal.timeout(defaultProviderRequestTimeoutMs)])
+        : AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     let response;
     let payload;
     try {

package/src/providers/chengxin/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, looseArray, optionalRecord as asOptionalObject, optionalString as asOptionalString, } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError } from "../provider-runtime.js";
 function requiredApiKey(input) {
     if (input.apiKey?.trim())
         return input.apiKey.trim();
@@ -238,10 +238,10 @@ function createChengxinError(input) {
         input.code === "3" ||
         input.code === "401" ||
         input.code === "403") {
-        return input.phase === "validate" ? new ProviderRequestError(400, message) : new ProviderRequestError(401, message);
+        return input.phase === "validate" ? providerInputError(message) : new ProviderRequestError(401, message);
     }
     if (input.status >= 400 && input.status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(input.status || 502, message);
 }

package/src/providers/cincopa/executors.js

@@ -1,9 +1,8 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString, requiredRecord, requiredString, } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "cincopa";
 const apiBaseUrl = "https://api.cincopa.com/v2";
 const validationPath = "/ping.json";
-const requestTimeoutMs = 30_000;
 export const cincopaActionHandlers = {
     async list_galleries(input, context) {
         const body = await requestBody({
@@ -110,8 +109,8 @@ async function requestBody(input, label) {
 }
 async function requestJson(input) {
     const signal = input.context.signal
-        ? AbortSignal.any([input.context.signal, AbortSignal.timeout(requestTimeoutMs)])
-        : AbortSignal.timeout(requestTimeoutMs);
+        ? AbortSignal.any([input.context.signal, AbortSignal.timeout(defaultProviderRequestTimeoutMs)])
+        : AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     let response;
     let payload;
     try {

package/src/providers/circle/executors.js

@@ -1,8 +1,7 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString, requiredRecord, } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerResponseError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerResponseError, providerUserAgent, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "circle";
 const apiBaseUrl = "https://app.circle.so/api/admin/v2";
-const requestTimeoutMs = 30_000;
 export const circleActionHandlers = {
     async get_community(_input, context) {
         return {
@@ -122,8 +121,8 @@ export const credentialValidators = {
 };
 async function requestCircleJson(input) {
     const signal = input.context.signal
-        ? AbortSignal.any([input.context.signal, AbortSignal.timeout(requestTimeoutMs)])
-        : AbortSignal.timeout(requestTimeoutMs);
+        ? AbortSignal.any([input.context.signal, AbortSignal.timeout(defaultProviderRequestTimeoutMs)])
+        : AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     let response;
     let payload;
     try {

package/src/providers/clearout/executors.js

@@ -2,7 +2,6 @@ import { compactObject, optionalNumber, optionalRecord, optionalString } from ".
 import { createProviderTimeout, defineProviderExecutors, defineProviderProxy, isAbortLikeError, ProviderRequestError, providerUserAgent, requireApiKeyCredential, } from "../provider-runtime.js";
 const service = "clearout";
 const clearoutDefaultBaseUrl = "https://api.clearout.io/v2";
-const clearoutDefaultRequestTimeoutMs = 30_000;
 export const clearoutActionHandlers = {
     get_available_credits(_input, context) {
         return requestClearoutJson({
@@ -105,7 +104,7 @@ function executeEmailAttributeCheck(input, context, path) {
     });
 }
 async function requestClearoutJson(input) {
-    const timeout = createProviderTimeout(input.context.signal, input.timeoutMs ?? clearoutDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(input.context.signal, input.timeoutMs);
     try {
         const response = await input.context.fetcher(buildUrl(input.context.baseUrl, input.path), {
             method: input.method,

package/src/providers/clickhelp/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { basicAuthorizationHeader, createProviderTimeout, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
+import { basicAuthorizationHeader, createProviderTimeout, ProviderRequestError, providerUserAgent, providerInputError, } from "../provider-runtime.js";
 import { createHash } from "node:crypto";
 const clickhelpRequestTimeoutMs = 60_000;
 export const clickhelpActionHandlers = {
@@ -186,10 +186,10 @@ export function normalizeClickhelpApiBaseUrl(value) {
     }
 }
 function resolveActionCredential(input) {
-    return resolveClickhelpCredential(requiredString(input.apiKey, "apiKey", (message) => new ProviderRequestError(400, message)), input.providerMetadata?.login ?? input.values?.login, input.providerMetadata?.apiBaseUrl ?? input.values?.portalUrl);
+    return resolveClickhelpCredential(requiredString(input.apiKey, "apiKey", providerInputError), input.providerMetadata?.login ?? input.values?.login, input.providerMetadata?.apiBaseUrl ?? input.values?.portalUrl);
 }
 function resolveClickhelpCredential(apiKeyInput, loginInput, portalUrlInput) {
-    const apiKey = requiredString(apiKeyInput, "apiKey", (message) => new ProviderRequestError(400, message)).trim();
+    const apiKey = requiredString(apiKeyInput, "apiKey", providerInputError).trim();
     if (!apiKey) {
         throw new ProviderRequestError(400, "apiKey is required");
     }
@@ -203,13 +203,13 @@ function resolveClickhelpCredential(apiKeyInput, loginInput, portalUrlInput) {
 }
 function mapClickhelpError(status, message, phase) {
     if (phase === "validate" && (status === 401 || status === 403 || status === 404)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && status === 401) {
         return new ProviderRequestError(401, message);
     }
     if ([400, 403, 404, 409, 422].includes(status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 429) {
         return new ProviderRequestError(429, message);

package/src/providers/clickhouse/runtime.js

@@ -1,7 +1,7 @@
 import { Buffer } from "node:buffer";
 import { compactObject, optionalInteger, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
 import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed } from "../../core/request.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, providerInputError, } from "../provider-runtime.js";
 const clickhouseDefaultDatabase = "default";
 const clickhouseValidationQuery = "SELECT currentDatabase() AS database, version() AS version";
 export const clickhouseActionHandlers = {
@@ -363,10 +363,10 @@ function parseClickhouseJson(text) {
 function createClickhouseError(status, responseText, phase) {
     const message = responseText.trim() || `ClickHouse request failed with ${status}`;
     if (phase === "validate" && [400, 401, 403].includes(status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if ([400, 404, 422].includes(status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 429) {
         return new ProviderRequestError(429, message);
@@ -377,7 +377,7 @@ export function normalizeClickhouseBaseUrl(value, allowPrivateNetwork = isPrivat
     const raw = requireCredentialString(value, "baseUrl");
     const url = assertPublicHttpUrl(raw, {
         fieldName: "baseUrl",
-        createError: (message) => new ProviderRequestError(400, message),
+        createError: providerInputError,
         allowPrivateNetwork,
     });
     url.hash = "";

package/src/providers/clickup/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/clickup/executors.js

@@ -1,5 +1,6 @@
 import { defineProviderExecutors, defineProviderProxy, ProviderRequestError } from "../provider-runtime.js";
 import { clickupActionHandlers, clickupApiOrigin, validateClickupCredential } from "./runtime.js";
+import { clickupTaskEvent } from "./trigger-on-task-event.js";
 const service = "clickup";
 export const executors = defineProviderExecutors({
     service,
@@ -52,3 +53,4 @@ export const credentialValidators = {
         return validateClickupCredential(input.accessToken, "oauth2", fetcher, signal);
     },
 };
+export const triggers = [clickupTaskEvent];

package/src/providers/clickup/trigger-on-task-event.d.ts

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

package/src/providers/clickup/trigger-on-task-event.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/clickup/trigger-on-task-event.definition.js

@@ -0,0 +1,41 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const events = ["taskCreated", "taskStatusUpdated", "taskCommentPosted"];
+export const snapshot = {
+    key: "clickup.on_task_event",
+    provider: "clickup",
+    name: "on_task_event",
+    displayName: "Task Event",
+    description: "Receives task creation, status changes, and new comments in a ClickUp Workspace or List.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "workspaceId",
+            jsonSchema: { type: "string", pattern: "^[0-9]+$", title: "Workspace ID" },
+            nullable: false,
+        },
+        { handle: "listId", jsonSchema: { type: "string", pattern: "^[0-9]+$", title: "List ID" }, nullable: true },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", enum: events },
+                minItems: 1,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: events,
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string", enum: events }, nullable: false },
+        { handle: "taskId", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/clickup/trigger-on-task-event.js

@@ -0,0 +1,94 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-task-event.definition.js";
+function webhook(value) {
+    if (!isJsonObject(value) ||
+        typeof value.id != "string" ||
+        !value.id ||
+        typeof value.secret != "string" ||
+        !value.secret)
+        throw new TransientIntegrationError("ClickUp returned an invalid webhook identity or secret.");
+    return { id: value.id, secret: value.secret };
+}
+export const clickupTaskEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const endpoint = `/team/${encodeURIComponent(String(context.config.workspaceId))}/webhook`;
+        const location = context.config.listId == null ? {} : { list_id: Number(context.config.listId) };
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const result = await webhookRequest(context, { endpoint, method: "GET" });
+                if (!isJsonObject(result.data) || !Array.isArray(result.data.webhooks))
+                    throw new TransientIntegrationError("ClickUp returned an invalid webhook list.");
+                return result.data.webhooks
+                    .filter((item) => {
+                    if (!isJsonObject(item) || typeof item.endpoint != "string")
+                        throw new TransientIntegrationError("ClickUp returned an invalid webhook.");
+                    if (item.endpoint !== context.endpointUrl)
+                        return false;
+                    if (context.active && String(item.list_id ?? "") !== String(context.config.listId ?? ""))
+                        throw new PermanentIntegrationError("The ClickUp webhook no longer matches the configured List. Remove the subscription before recreating it.");
+                    return true;
+                })
+                    .map(webhook);
+            },
+            async create() {
+                const result = await webhookRequest(context, {
+                    endpoint,
+                    method: "POST",
+                    body: { endpoint: context.endpointUrl, events: context.config.eventTypes, ...location },
+                });
+                if (!isJsonObject(result.data) || !isJsonObject(result.data.webhook))
+                    throw new TransientIntegrationError("ClickUp webhook creation returned no webhook.");
+                return webhook(result.data.webhook);
+            },
+            async align(id) {
+                await webhookRequest(context, {
+                    endpoint: `/webhook/${encodeURIComponent(id)}`,
+                    method: "PUT",
+                    body: {
+                        endpoint: context.endpointUrl,
+                        events: context.config.eventTypes,
+                        status: "active",
+                    },
+                });
+            },
+            async remove(id) {
+                await webhookRequest(context, {
+                    endpoint: `/webhook/${encodeURIComponent(id)}`,
+                    method: "DELETE",
+                });
+            },
+        });
+    },
+    async receive(context) {
+        const secret = context.state?.subscription.secret;
+        if (typeof secret != "string")
+            return { outcome: "respond", status: 503, body: "", contentType: "text/plain" };
+        if (!(await verifyHexHmac(secret, [context.rawBody], context.header("x-signature"))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const body = context.payload;
+        if (!isJsonObject(body) ||
+            body.webhook_id != context.state?.subscription.hookId ||
+            typeof body.event != "string" ||
+            !context.config.eventTypes.includes(body.event))
+            return { outcome: "ignored", reason: "ClickUp subscription or event does not match." };
+        if (typeof body.task_id != "string" ||
+            !body.task_id ||
+            (body.history_items != null &&
+                (!Array.isArray(body.history_items) ||
+                    body.history_items.some((item) => !isJsonObject(item) || typeof item.id != "string" || !item.id))))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        const historyIds = body.history_items?.map((item) => item.id).sort() ?? [];
+        if (historyIds.length == 0 && body.event != "taskCreated")
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: JSON.stringify([body.webhook_id, body.event, historyIds.length ? historyIds : body.task_id]),
+            outputs: { event: body.event, taskId: body.task_id, body },
+        };
+    },
+};