@oomol-lab/open-connector 1.9.1 → 1.9.2

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

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const credentialValidators: CredentialValidators;
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/fundable/executors.js

@@ -0,0 +1,74 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { requiredResponseRecord, runProviderRequest, ProviderRequestError, providerInputError, defineApiKeyProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { fundableActions } from "./actions.js";
+import { fundableRoutes } from "./actions.js";
+const fundableApiBaseUrl = "https://www.tryfundable.ai/api/v1";
+async function requestFundable(path, method, parameters, apiKey, fetcher, validating = false, parentSignal) {
+    const url = new URL(`${fundableApiBaseUrl}${path}`);
+    if (method === "GET") {
+        for (const [key, value] of Object.entries(parameters)) {
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        }
+    }
+    return runProviderRequest({ label: "fundable", signal: parentSignal }, async (signal) => {
+        const headers = new Headers({ accept: "application/json", authorization: `Bearer ${apiKey}` });
+        if (method === "POST")
+            headers.set("content-type", "application/json");
+        const response = await fetcher(url.toString(), {
+            method,
+            headers,
+            body: method === "POST" ? JSON.stringify(parameters) : undefined,
+            signal,
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, response.ok ? "fundable returned malformed JSON" : `fundable request failed (${response.status})`, undefined, "provider_error");
+        }
+        const object = optionalRecord(payload);
+        if (!response.ok || object?.success === false || object?.error != null) {
+            const error = optionalRecord(object?.error);
+            const code = optionalString(error?.code);
+            const message = optionalString(error?.message) ??
+                optionalString(object?.error) ??
+                optionalString(object?.message) ??
+                `fundable request failed (${response.status})`;
+            const detail = code ? `${code}: ${message}` : message;
+            if (code === "INVALID_API_KEY" || code === "INACTIVE_API_KEY") {
+                throw new ProviderRequestError(validating ? 400 : 409, detail, undefined, validating ? "invalid_input" : "authorization_failed");
+            }
+            throw new ProviderRequestError(response.ok ? 502 : response.status, detail, undefined, "provider_error");
+        }
+        return requiredResponseRecord(payload, "Fundable response");
+    });
+}
+async function execute(actionName, values, context) {
+    const { apiKey, fetcher } = context;
+    const route = fundableRoutes[actionName];
+    if (!route)
+        throw providerInputError("Unknown action route");
+    const path = route.path.replace("{id}", encodeURIComponent(String(values.id)));
+    const parameters = { ...values };
+    if (route.path.includes("{id}"))
+        delete parameters.id;
+    return requestFundable(path, route.method, parameters, apiKey, fetcher, undefined, context.signal);
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await requestFundable("/industry/search", "GET", { name: "software" }, input.apiKey, fetcher, true, signal);
+        return { profile: { displayName: "Fundable API Key" }, grantedScopes: [], metadata: {} };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("fundable", Object.fromEntries(fundableActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "fundable",
+    baseUrl: fundableApiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});

package/src/providers/gmail/message.d.ts

@@ -2,7 +2,7 @@ export interface GmailMessageHeader {
     name: string;
     value: string;
 }
-export interface GmailMessagePart {
+interface GmailMessagePart {
     partId?: string;
     mimeType?: string;
     filename?: string;
@@ -80,11 +80,6 @@ export interface GmailReplyHeaders {
 export declare function resolveReplyHeaders(resource: GmailMessageResource): GmailReplyHeaders;
 /** Gmail requires a reply's subject to match its target after ordinary Re: prefixes. */
 export declare function assertMatchingReplySubject(subject: string, targetSubject: string): void;
-interface GmailBodyContent {
-    body: string;
-    isHtml: boolean;
-}
-export declare function extractBodyContent(payload: GmailMessagePart | null): GmailBodyContent;
 export declare function normalizeThreadId(value: unknown): string;
 export declare function normalizeMessageId(value: unknown): string;
 interface RecipientsInput {

package/src/providers/gmail/message.js

@@ -171,7 +171,7 @@ function parseAddressList(value) {
 function firstAddress(value) {
     return parseAddressList(value)[0] ?? "";
 }
-export function extractBodyContent(payload) {
+function extractBodyContent(payload) {
     return extractPartBody(payload, true);
 }
 function extractPartBody(payload, isBodyRoot) {

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

@@ -1,5 +1,6 @@
 import { defineProviderExecutors, defineProviderProxy, requireOAuthCredential } from "../provider-runtime.js";
 import { intercomActionHandlers, intercomAllowedApiBaseUrls, intercomApiVersion, resolveIntercomApiBaseUrl, validateIntercomOAuthCredential, } from "./runtime.js";
+import { intercomConversationEvents } from "./trigger-on-conversation-event.js";
 const service = "intercom";
 export const executors = defineProviderExecutors({
     service,
@@ -32,3 +33,4 @@ export const credentialValidators = {
         return validateIntercomOAuthCredential(input, fetcher, signal);
     },
 };
+export const triggers = [intercomConversationEvents];

package/src/providers/intercom/trigger-on-conversation-event.d.ts

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

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

@@ -0,0 +1,42 @@
+import { s } from "../../core/json-schema.js";
+export const snapshot = {
+    key: "intercom.on_conversation_event",
+    provider: "intercom",
+    name: "on_conversation_event",
+    displayName: "Customer Conversation or Ticket",
+    description: "Receives customer conversations, customer replies and new tickets from a verified Intercom application event source. Administrator replies are excluded.",
+    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: ["conversation.user.created", "conversation.user.replied", "ticket.created"] },
+                minItems: 1,
+                maxItems: 3,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["conversation.user.created", "conversation.user.replied", "ticket.created"],
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "workspaceId", jsonSchema: s.string(), nullable: false },
+        { handle: "objectId", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: s.object({}, { additionalProperties: true }), nullable: false },
+    ],
+};

package/src/providers/intercom/trigger-on-conversation-event.js

@@ -0,0 +1,23 @@
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { intercomApplication } from "../../triggers/sources/intercom.js";
+import { snapshot } from "./trigger-on-conversation-event.definition.js";
+export const intercomConversationEvents = {
+    snapshot,
+    eventSource: "intercom",
+    source: intercomApplication,
+    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 Intercom event.");
+        return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+    },
+    async reconcile() {
+        throw new PermanentIntegrationError("This deployment does not support shared Intercom event sources.");
+    },
+};

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

@@ -1,4 +1,5 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 type JiraActionContext = {
     accessToken: string;
@@ -22,4 +23,5 @@ export declare const credentialValidators: CredentialValidators;
  * suffix this provider speaks, so a pasted API URL is not double-appended.
  */
 export declare function normalizeJiraServerApiBaseUrl(value: unknown, allowPrivateNetwork?: boolean): string;
+export declare const triggers: readonly IntegrationDefinition[];
 export {};

package/src/providers/jira/executors.js

@@ -1,6 +1,7 @@
 import { compactObject, optionalBoolean, optionalInteger as asOptionalInteger, optionalRecord as asOptionalObject, optionalString as asOptionalString, optionalStringArray, } from "../../core/cast.js";
 import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed } from "../../core/request.js";
 import { createProviderFetch, ProviderRequestError, defineProviderExecutors, defineProviderProxy, providerUserAgent, } from "../provider-runtime.js";
+import { jiraIssueEvents } from "./trigger-on-issue-event.js";
 const jiraApiOrigin = "https://api.atlassian.com";
 const jiraAccessibleResourcesUrl = "https://api.atlassian.com/oauth/token/accessible-resources";
 const jiraCurrentUserPath = "/myself";
@@ -944,3 +945,4 @@ function trimLeadingSlash(value) {
     }
     return value.slice(index);
 }
+export const triggers = [jiraIssueEvents];

package/src/providers/jira/trigger-on-issue-event.d.ts

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

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

@@ -0,0 +1,44 @@
+export const snapshot = {
+    key: "jira.on_issue_event",
+    provider: "jira",
+    name: "on_issue_event",
+    displayName: "Issue or Comment Event",
+    description: "Receives Jira Cloud issue creation, issue updates and new comments through a shared project webhook with automatic renewal.",
+    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: ["jira:issue_created", "jira:issue_updated", "comment_created"],
+                },
+                minItems: 1,
+                maxItems: 3,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["jira:issue_created", "jira:issue_updated", "comment_created"],
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "cloudId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "issueId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/jira/trigger-on-issue-event.js

@@ -0,0 +1,116 @@
+import { jwtVerify } from "jose";
+import { IntegrationConnectionError } 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 { jiraProject } from "../../triggers/sources/jira.js";
+import { snapshot } from "./trigger-on-issue-event.definition.js";
+import { reconcileJiraResource, requireJiraCloud, jiraEvents } from "./trigger-resource.js";
+export const jiraIssueEvents = {
+    snapshot,
+    eventSource: "jira",
+    source: jiraProject,
+    resources: { reconcile: reconcileJiraResource },
+    async sourceIdentity(context) {
+        const cloudId = requireJiraCloud(context.connector);
+        const project = context.config.projectId ?? context.config.project;
+        if (typeof project !== "string" || !project || project.length > 256)
+            throw new PermanentIntegrationError("Choose a Jira project.");
+        const [projectResult, userResult, siteResult] = await Promise.all([
+            webhookRequest(context, { method: "GET", endpoint: `/project/${encodeURIComponent(project)}` }),
+            webhookRequest(context, { method: "GET", endpoint: "/myself" }),
+            webhookRequest(context, { method: "GET", endpoint: "/serverInfo" }),
+        ]);
+        const item = projectResult.data, user = userResult.data, site = siteResult.data;
+        if (!isJsonObject(item) ||
+            typeof item.id !== "string" ||
+            !/^\d+$/.test(item.id) ||
+            typeof item.key !== "string" ||
+            !isJsonObject(user) ||
+            typeof user.accountId !== "string" ||
+            !isJsonObject(site) ||
+            typeof site.baseUrl !== "string")
+            throw new PermanentIntegrationError("Jira did not return a verified project, user and site.");
+        const url = new URL(site.baseUrl);
+        if (url.protocol !== "https:" || url.username || url.password)
+            throw new PermanentIntegrationError("Invalid Jira Cloud site URL.");
+        return {
+            accountId: context.connector.providerAccountId,
+            cloudId,
+            userId: user.accountId,
+            projectId: item.id,
+            projectKey: item.key,
+            siteUrl: url.origin,
+        };
+    },
+    async sourceReceive(context) {
+        const cloudId = requireJiraCloud(context.connector);
+        if (context.config.cloudId !== cloudId)
+            throw new IntegrationConnectionError("The Jira connection belongs to another site.");
+        const authorization = context.headers.authorization ?? "";
+        if (!authorization.startsWith("Bearer "))
+            return { outcome: "unauthorized" };
+        try {
+            await jwtVerify(authorization.slice(7), new TextEncoder().encode(context.connector.oauthClientConfig.clientSecret), { algorithms: ["HS256"], currentDate: context.now, requiredClaims: ["exp"] });
+        }
+        catch {
+            return { outcome: "unauthorized" };
+        }
+        let payload;
+        try {
+            payload = JSON.parse(context.rawBody);
+        }
+        catch {
+            return { outcome: "unauthorized" };
+        }
+        if (!isJsonObject(payload) ||
+            typeof payload.webhookEvent !== "string" ||
+            !jiraEvents.includes(payload.webhookEvent))
+            return { outcome: "ignored" };
+        if (!Array.isArray(payload.matchedWebhookIds) || !payload.matchedWebhookIds.includes(context.config.webhookId))
+            return { outcome: "ignored" };
+        const issue = payload.issue;
+        if (!isJsonObject(issue) ||
+            typeof issue.id !== "string" ||
+            typeof issue.self !== "string" ||
+            !isJsonObject(issue.fields) ||
+            !isJsonObject(issue.fields.project) ||
+            issue.fields.project.id !== context.config.projectId)
+            return { outcome: "ignored" };
+        let issueUrl;
+        try {
+            issueUrl = new URL(issue.self);
+        }
+        catch {
+            return { outcome: "ignored" };
+        }
+        if (issueUrl.origin !== context.config.siteUrl)
+            return { outcome: "ignored" };
+        const id = context.headers["x-atlassian-webhook-identifier"];
+        if (!id || id.length > 256)
+            return { outcome: "unauthorized" };
+        if (payload.webhookEvent === "comment_created" &&
+            (!isJsonObject(payload.comment) || typeof payload.comment.id !== "string"))
+            return { outcome: "unauthorized" };
+        return {
+            outcome: "event",
+            id,
+            type: payload.webhookEvent,
+            payload: { event: payload.webhookEvent, deliveryId: id, cloudId, issueId: issue.id, body: payload },
+        };
+    },
+    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 Jira event.");
+        return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+    },
+    async reconcile() {
+        throw new PermanentIntegrationError("This deployment does not support shared Jira event sources.");
+    },
+};

package/src/providers/jira/trigger-resource.d.ts

@@ -0,0 +1,4 @@
+import type { IntegrationReconcileContext, IntegrationReconcileResult } from "../../triggers/common/integration.ts";
+export declare const jiraEvents: string[];
+export declare function requireJiraCloud(connector: IntegrationReconcileContext["connector"]): string;
+export declare function reconcileJiraResource(context: IntegrationReconcileContext): Promise<IntegrationReconcileResult>;

package/src/providers/jira/trigger-resource.js

@@ -0,0 +1,141 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { webhookRequest } from "../../triggers/managed-webhook.js";
+export const jiraEvents = ["jira:issue_created", "jira:issue_updated", "comment_created"];
+const day = 86_400_000;
+export function requireJiraCloud(connector) {
+    const cloudId = /^jira:([^:]+)(?::|$)/.exec(connector.providerAccountId ?? "")?.[1];
+    if (connector.authType !== "oauth2" || !cloudId || !connector.oauthClientConfig?.clientSecret)
+        throw new IntegrationConnectionError("Jira Cloud OAuth and the matching application client secret are required. Reconnect with webhook permissions.");
+    return cloudId;
+}
+async function webhooks(context) {
+    const items = [];
+    let startAt = 0;
+    for (;;) {
+        const { data } = await webhookRequest(context, {
+            method: "GET",
+            endpoint: "/webhook",
+            query: { startAt, maxResults: 100 },
+        });
+        if (!isJsonObject(data) || !Array.isArray(data.values) || typeof data.isLast !== "boolean")
+            throw new TransientIntegrationError("Invalid Jira webhook page.");
+        for (const item of data.values) {
+            if (!isJsonObject(item) ||
+                !Number.isSafeInteger(item.id) ||
+                Number(item.id) <= 0 ||
+                typeof item.url !== "string" ||
+                typeof item.jqlFilter !== "string" ||
+                !Array.isArray(item.events) ||
+                !item.events.every((event) => typeof event === "string") ||
+                typeof item.expirationDate !== "string")
+                throw new TransientIntegrationError("Invalid Jira webhook record.");
+            const expiresAt = Date.parse(item.expirationDate);
+            if (!Number.isFinite(expiresAt))
+                throw new TransientIntegrationError("Invalid Jira webhook expiration.");
+            items.push({
+                id: Number(item.id),
+                url: item.url,
+                jqlFilter: item.jqlFilter,
+                events: item.events,
+                expiresAt,
+            });
+        }
+        if (data.isLast)
+            return items;
+        if (data.values.length === 0 || data.startAt !== startAt)
+            throw new TransientIntegrationError("Invalid Jira webhook pagination.");
+        startAt += data.values.length;
+    }
+}
+export async function reconcileJiraResource(context) {
+    requireJiraCloud(context.connector);
+    const { projectId } = context.config;
+    if (typeof projectId !== "string" || !/^\d+$/.test(projectId))
+        throw new PermanentIntegrationError("A verified Jira project ID is required.");
+    let endpoint;
+    try {
+        endpoint = new URL(context.endpointUrl);
+    }
+    catch {
+        throw new PermanentIntegrationError("A public HTTPS callback URL is required.");
+    }
+    if (endpoint.protocol !== "https:" || endpoint.username || endpoint.password || endpoint.hash)
+        throw new PermanentIntegrationError("Jira requires a public HTTPS callback without credentials or a fragment.");
+    const now = context.now.getTime();
+    const state = context.state;
+    const saved = state.subscription;
+    if (context.active &&
+        typeof saved.checkedAt === "number" &&
+        typeof saved.expiresAt === "number" &&
+        saved.checkedAt + day > now &&
+        saved.expiresAt - 7 * day > now)
+        return { outcome: "ready" };
+    const save = (value) => state.saveSubscription(value, new Date(now + day));
+    let all = await webhooks(context);
+    const own = () => {
+        const matches = all.filter((item) => item.url === endpoint.href);
+        if (matches.length > 1)
+            throw new PermanentIntegrationError("Multiple Jira webhooks use this source callback. Resolve the duplicate subscriptions before retrying.");
+        return matches[0];
+    };
+    let hook = own();
+    if (!context.active) {
+        if (hook)
+            await webhookRequest(context, { method: "DELETE", endpoint: "/webhook", body: { webhookIds: [hook.id] } });
+        else if (saved.creating === true)
+            throw new PermanentIntegrationError("Jira registration is still uncertain. Confirm the remote webhook before cleanup.", "trigger_subscription_uncertain");
+        await save({});
+        return { outcome: "ready" };
+    }
+    if (!hook) {
+        if (saved.creating === true)
+            throw new PermanentIntegrationError("Jira registration is uncertain and no matching webhook is visible. Retry after checking Jira; do not create another source.", "trigger_subscription_uncertain");
+        if (all.length >= 5)
+            throw new PermanentIntegrationError("Jira OAuth webhook quota reached: five subscriptions per application, user and site. Remove an unused subscription, then retry.", "trigger_quota_exceeded");
+        await save({ creating: true });
+        const result = await context.connector.execute({
+            method: "POST",
+            endpoint: "/webhook",
+            body: { url: endpoint.href, webhooks: [{ jqlFilter: `project = ${projectId}`, events: jiraEvents }] },
+        }, context.signal);
+        context.signal?.throwIfAborted();
+        if (result.status < 200 || result.status >= 300) {
+            if (result.status >= 400 && result.status < 500)
+                await save({});
+            const message = `Jira webhook registration failed (HTTP ${result.status}). Check OAuth scopes, callback domain and webhook quota.`;
+            if (result.status === 429 || result.status >= 500)
+                throw new TransientIntegrationError(message);
+            throw new PermanentIntegrationError(message);
+        }
+        const results = isJsonObject(result.data) ? result.data.webhookRegistrationResult : undefined;
+        if (!Array.isArray(results) || results.length !== 1 || !isJsonObject(results[0]))
+            throw new TransientIntegrationError("Jira registration returned no confirmed webhook ID.");
+        const created = results[0];
+        if (Array.isArray(created.errors) && created.errors.length) {
+            await save({});
+            throw new PermanentIntegrationError(`Jira rejected the webhook: ${created.errors.filter((value) => typeof value === "string").join("; ")}`);
+        }
+        if (!Number.isSafeInteger(created.createdWebhookId) || Number(created.createdWebhookId) <= 0)
+            throw new TransientIntegrationError("Jira registration returned no confirmed webhook ID.");
+        await save({ creating: true, webhookId: Number(created.createdWebhookId) });
+        all = await webhooks(context);
+        hook = own();
+        if (!hook || hook.id !== created.createdWebhookId)
+            throw new TransientIntegrationError("The newly registered Jira webhook is not yet visible.");
+    }
+    if (hook.jqlFilter !== `project = ${projectId}` ||
+        hook.events.length !== jiraEvents.length ||
+        !jiraEvents.every((event) => hook.events.includes(event)))
+        throw new PermanentIntegrationError("The Jira webhook no longer matches this source's project and events. Remove the source subscription before recreating it.");
+    if (hook.expiresAt - 7 * day <= now) {
+        await webhookRequest(context, { method: "PUT", endpoint: "/webhook/refresh", body: { webhookIds: [hook.id] } });
+        const previousId = hook.id;
+        all = await webhooks(context);
+        hook = own();
+        if (!hook || hook.id !== previousId || hook.expiresAt - 7 * day <= now)
+            throw new TransientIntegrationError("Jira did not confirm the renewed webhook expiration.");
+    }
+    await save({ webhookId: hook.id, expiresAt: hook.expiresAt, checkedAt: now });
+    return { outcome: "ready" };
+}

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

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;
+export declare const credentialValidators: CredentialValidators;

package/src/providers/keenable/executors.js

@@ -0,0 +1,20 @@
+import { defineProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { createKeenableContext, keenableActionHandlers, keenableApiBaseUrl, keenableAppTitle, validateKeenableCredential, } from "./runtime.js";
+const service = "keenable";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: keenableActionHandlers,
+    createContext: createKeenableContext,
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: keenableApiBaseUrl,
+    auth: { type: "optional_api_key_header", name: "X-API-Key" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("x-keenable-title"))
+            headers.set("x-keenable-title", keenableAppTitle);
+    },
+});
+export const credentialValidators = { apiKey: validateKeenableCredential };

package/src/providers/keenable/runtime.d.ts

@@ -0,0 +1,26 @@
+import type { CredentialValidationResult, ExecutionContext } from "../../core/types.ts";
+import type { ProviderFetch } from "../provider-runtime.ts";
+export declare const keenableApiBaseUrl = "https://api.keenable.ai";
+/** Keenable requires keyless callers to name their app in the X-Keenable-Title header. */
+export declare const keenableAppTitle = "OpenConnector";
+interface KeenableContext {
+    apiKey?: string;
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}
+type KeenableActionHandler = (input: Record<string, unknown>, context: KeenableContext) => Promise<unknown>;
+export declare const keenableActionHandlers: Record<string, KeenableActionHandler>;
+/**
+ * Build the action context. A no_auth connection has no key and uses the keyless endpoints.
+ */
+export declare function createKeenableContext(context: ExecutionContext, fetcher: ProviderFetch): Promise<KeenableContext>;
+/**
+ * Validate a key through a one-result search on the keyed endpoint.
+ */
+export declare function validateKeenableCredential(input: {
+    apiKey: string;
+}, options: {
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}): Promise<CredentialValidationResult>;
+export {};