@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/appgrowing_mcp/actions.js

@@ -0,0 +1,175 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const service = "appgrowing_mcp";
+const resultSchema = s.requiredObject("The AppGrowing Global MCP tool result.", {
+    result: s.unknown("Structured MCP content when available; otherwise the complete MCP content envelope. Data availability and Credits depend on the connected AppGrowing Global account."),
+});
+const category = s.array("Store categories for the selected product type; obtain IDs from filterOptions.", s.nullableInteger("Store category ID."));
+const appStyle = s.array("App styles for the selected product type; obtain IDs from filterOptions.", s.nullableInteger("App style ID."));
+const area = s.array("Countries to include; obtain codes from filterOptions.", s.nullableString("Country code."));
+const page = s.integer("Page number, starting at 1. Each page contains up to 100 results.", { minimum: 1 });
+const creativeSearchInput = s.object("Advertising creative filters. Omit filters that do not apply to the selected product type.", {
+    purpose: s.withEnum(s.integer("Promoted product: 1 game, 2 app, 3 website."), [1, 2, 3]),
+    startDate: s.date("First date to include."),
+    endDate: s.date("Last date to include."),
+    isAllDate: s.integer("Use 1 to search all dates, or 0 to use the date range."),
+    category,
+    resourceElement: s.array("Visual element tags for games or apps.", s.nullableInteger("Visual element tag ID from filterOptions.")),
+    appStyle,
+    media: s.array("Advertising channels for the selected product type.", s.nullableInteger("Media channel ID from filterOptions.")),
+    area,
+    format: s.array("Advertising formats for the selected product type.", s.nullableInteger("Ad format ID from filterOptions.")),
+    platform: s.array("Promotion platforms for games or apps.", s.nullableInteger("Promotion platform ID from filterOptions.")),
+    language: s.array("Creative languages.", s.nullableString("Language value from filterOptions.")),
+    videoTime: s.integer("Video duration filter ID from filterOptions, not seconds."),
+    minDuration: s.string("Minimum advertising days as a numeric string.", { pattern: "^[0-9]*$" }),
+    maxDuration: s.string("Maximum advertising days as a numeric string.", { pattern: "^[0-9]*$" }),
+    accurateSearch: s.integer("Use 1 for an exact ordered keyword match, or 0 for broad matching."),
+    isNew: s.integer("Use 1 for new creatives only, or 0 to include existing creatives."),
+    isNewAd: s.integer("Use 1 for new advertisements only, or 0 to include existing advertisements."),
+    resolution: s.integer("Use 1 for high-definition creatives, or 0 to include other resolutions."),
+    keyword: s.string("Search keyword."),
+    order: s.stringEnum("Sort order.", [
+        "_score_desc",
+        "max_dt_desc",
+        "max_dt",
+        "min_dt_desc",
+        "min_dt",
+        "cnt_ad_id_desc",
+        "cnt_dt_desc",
+        "cnt_dt",
+        "impression_inc_2y_desc",
+        "similar_cnt_desc",
+    ]),
+    page,
+    isCreative: s.integer("Use 1 for innovative game or app creatives, or 0 for other creatives."),
+    gender: s.array("Audience genders for games or apps.", s.nullableInteger("Gender: 1 male, 2 female, 3 unknown.")),
+    ageRange: s.array("Audience age groups for games or apps.", s.nullableString("Age group: 13-17, 18-24, 25-34, 35-44, 45-54, 55-64 or 65+.")),
+    isW2a: s.integer("Use 1 for web-to-app promotion; omit to leave it unfiltered."),
+    excludeW2a: s.integer("For games or apps, use 0 with isW2a=1 or 1 with isW2a=0; otherwise omit."),
+    campaignTypeCombine: s.integer("Use 1 when filtering game or app promotion types; otherwise omit."),
+    campaignType: s.array("Game or app promotion types.", s.nullableInteger("Promotion type: 101/201/298/295 app downloads, 299 web-to-APK, 297 PWA/H5; omit for web-to-app.")),
+    platformCampaignType: s.array("Platform-specific promotion types.", s.nullableInteger("App platform: 201 Google Play, 295 Galaxy, 298 RuStore, 299 APK, 101 App Store.")),
+    appCashWay: s.array("Game or app monetization methods.", s.nullable(s.stringEnum("Monetization method: ads, purchases, mixed, or subscriptions.", [
+        "iaa",
+        "iap",
+        "iaa_iap",
+        "subscribable",
+    ]))),
+    materialRatio: s.array("Creative aspect ratios.", s.nullableString("Aspect ratio from filterOptions.")),
+    blockIds: s.array("Creative IDs to exclude.", s.nullableString("Creative ID.")),
+    blockAppIds: s.array("Promoted product IDs to exclude.", s.nullableString("Product ID.")),
+    isPre: s.integer("Use 1 for games with preregistration campaigns, or 0 for other games."),
+    asr: s.integer("Use 1 for narrated creatives, or 0 for creatives without narration."),
+    asrLanguage: s.string("Narration language from filterOptions."),
+    searchDsl: s.array("Field-level search conditions. The upstream equal operator may not narrow results; prefer contain when appropriate.", s.nullable(s.object("A field-level search condition.", {
+        key: s.stringEnum("Field to search.", [
+            "campaign_name",
+            "appid",
+            "slogan",
+            "asr",
+            "brands_name",
+            "developer_name",
+            "website",
+        ]),
+        type: s.stringEnum("Matching operator.", ["contain", "exclude", "equal", "notEqual"]),
+        value: s.string("Value to match."),
+    }, { required: ["key", "type", "value"] }))),
+    isViolation: s.integer("Use 1 for policy-violating game or app advertisements, or 0 for other advertisements."),
+    hasCooperate: s.integer("Use 1 for ads featuring a collaborating creator, or 0 for other ads."),
+    marketingWord: s.string("Game or app selling-point word returned by creativeSellingPointTrends."),
+    singleArea: s.integer("Use 1 for ads running in a single region, or 0 for other ads."),
+    postpage: s.integer("Use 1 to filter original advertising posts, or 0 for other creatives."),
+    hasPpid: s.integer("Custom product page filter for games or apps."),
+    excludeLowQuality: s.integer("Use 1 to exclude low-quality creatives, or 0 to include them. The provider excludes them by default."),
+}, { required: ["purpose", "order"] });
+const sellingPointInput = s.object("Selling-point trend filters for games and apps.", {
+    purpose: s.withEnum(s.integer("Promoted product: 1 game, 2 app."), [1, 2]),
+    category,
+    appStyle,
+    area,
+    wordAttr: s.array("Selling-point categories.", s.nullableString("Selling-point category from filterOptions.")),
+    keyword: s.string("Search keyword."),
+    order: s.stringEnum("Sort order.", [
+        "adverts_desc",
+        "material_cnt_desc",
+        "shot_cnt_desc",
+        "product_cnt_desc",
+        "ratio_desc",
+    ]),
+    page,
+}, { required: ["purpose"] });
+export const appgrowingMcpActions = [
+    defineProviderAction(service, {
+        name: "filterOptions",
+        operationType: "read",
+        description: "List the advertising filters available to your AppGrowing account. Business queries consume account credits.",
+        requiredScopes: [],
+        inputSchema: s.object("No input is required.", {}),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction(service, {
+        name: "creativeResourceUrl",
+        operationType: "read",
+        description: "Refresh expired creative download links using the resource filenames, including their extensions.",
+        requiredScopes: [],
+        inputSchema: s.object("Resources whose download links should be refreshed.", {
+            key: s.array("Resource filenames from expired URLs, not resource IDs.", s.nullableString("Resource filename including its extension."), { minItems: 1 }),
+        }, { required: ["key"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction(service, {
+        name: "searchAdCreatives",
+        operationType: "read",
+        description: "Find global advertising creatives by product, audience and campaign filters. Use filterOptions for valid IDs and page to continue through results.",
+        requiredScopes: [],
+        inputSchema: creativeSearchInput,
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction(service, {
+        name: "creativeSellingPointTrends",
+        operationType: "read",
+        description: "Compare selling-point trends for games and apps by category, style and country.",
+        requiredScopes: [],
+        inputSchema: sellingPointInput,
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction(service, {
+        name: "creativeAIAnalysisData",
+        operationType: "read",
+        description: "Read narration, selling points and AI analysis for up to 100 creative resources. Pair each resource ID with one of its ad format IDs.",
+        requiredScopes: [],
+        inputSchema: s.object("Creative resources to analyze.", {
+            ids: s.array("Resource IDs from material.creative.resource[].id, in their original form.", s.string("Creative resource ID."), { minItems: 1, maxItems: 100 }),
+            format: s.array("One material.format[].id for each resource, in the same order as ids.", s.integer("Ad format ID."), { minItems: 1, maxItems: 100 }),
+        }, { required: ["ids", "format"] }),
+        outputSchema: resultSchema,
+    }),
+    defineProviderAction(service, {
+        name: "list_tools",
+        operationType: "read",
+        description: "Discover current AppGrowing Global MCP tools, live argument schemas and behavior annotations for advertising creative, app, publisher and developer research.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("No input is required.", {}),
+        outputSchema: s.requiredObject("The live AppGrowing Global MCP tool catalog.", {
+            tools: s.array("Tools available to the connected AppGrowing Global account.", s.object("One AppGrowing Global MCP tool.", {
+                name: s.nonEmptyString("The exact tool name."),
+                description: s.string("The current official tool description."),
+                annotations: s.looseObject("Official MCP behavior annotations."),
+                inputSchema: s.looseObject("The current JSON Schema for tool arguments."),
+            }, { optional: ["description", "annotations"] })),
+        }),
+        followUpActions: ["appgrowing_mcp.call_tool"],
+    }),
+    defineProviderAction(service, {
+        name: "call_tool",
+        operationType: "destructive",
+        description: "Call any current AppGrowing Global MCP tool after inspecting list_tools. Arguments must match the live schema. Calls may consume AppGrowing credits; inspect behavior annotations before invoking newly added tools.",
+        requiredScopes: [],
+        inputSchema: s.object("Call a live AppGrowing Global MCP tool.", {
+            toolName: s.nonEmptyString("The exact tool name returned by list_tools."),
+            arguments: s.looseObject("Arguments matching the selected tool's live input schema."),
+        }, { optional: ["arguments"] }),
+        outputSchema: resultSchema,
+    }),
+];

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

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

package/src/providers/appgrowing_mcp/executors.js

@@ -0,0 +1,66 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { recordOrEmpty } from "../../core/cast.js";
+import { callMcpTool, listMcpTools } from "../mcp-tools.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, requiredInputString, ProviderRequestError, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { appgrowingMcpActions } from "./actions.js";
+const origin = "https://api-appgrowing-global.youcloud.com";
+const endpoint = `${origin}/mcp`;
+const defaultHeaders = {
+    accept: "application/json, text/event-stream",
+    "content-type": "application/json",
+    "accept-language": "en",
+};
+const handlers = mapProviderActionHandlers("appgrowing_mcp", appgrowingMcpActions, (action) => async (input, context) => {
+    if (action.name === "creativeAIAnalysisData" &&
+        input.ids.length !== input.format.length)
+        throw new ProviderRequestError(400, "ids and format must have the same length");
+    const connection = {
+        service: "AppGrowing",
+        endpoint,
+        headers: { ...defaultHeaders, authorization: `Bearer ${requiredInputString(context.apiKey, "API Key")}` },
+        fetcher: context.fetcher,
+        signal: context.signal,
+        // Cloudflare Workers rejects `redirect: "error"`; a 3xx under "manual" still fails the MCP request.
+        redirect: "manual",
+        maxResponseBytes: 16 * 1024 * 1024,
+        terminateSession: true,
+    };
+    if (action.name === "list_tools")
+        return { tools: await listMcpTools(connection, { includeAnnotations: true }) };
+    return {
+        result: await callMcpTool({
+            ...connection,
+            toolName: action.name === "call_tool" ? requiredInputString(input.toolName, "toolName") : action.name,
+            arguments: action.name === "call_tool" ? recordOrEmpty(input.arguments) : input,
+        }),
+    };
+});
+export const executors = defineApiKeyProviderExecutors("appgrowing_mcp", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input) {
+        const hash = sha256Hex(requiredInputString(input.apiKey, "API Key"));
+        return {
+            profile: { accountId: `appgrowing-mcp:${hash}`, displayName: `AppGrowing Global · ${hash.slice(-6)}` },
+            metadata: { mcpEndpoint: endpoint, validationMode: "local_non_empty_key" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "appgrowing_mcp",
+    baseUrl: origin,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    redirect: "manual",
+    customizeRequest({ url, headers }) {
+        if (url.href !== endpoint)
+            throw new ProviderRequestError(400, "AppGrowing proxy only supports the official /mcp endpoint without query parameters");
+        for (const [name, value] of Object.entries(defaultHeaders))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "MCP proxy request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

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

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

package/src/providers/arcmira/executors.js

@@ -0,0 +1,8 @@
+import { defineApiKeyProviderExecutors } from "../provider-runtime.js";
+import { arcmiraActionHandlers, validateArcmiraCredential } from "./runtime.js";
+export const executors = defineApiKeyProviderExecutors("arcmira", arcmiraActionHandlers);
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateArcmiraCredential({ apiKey: input.apiKey, fetcher, signal });
+    },
+};

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

@@ -0,0 +1,6 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers } from "../provider-runtime.ts";
+type Handler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
+export declare const arcmiraActionHandlers: ProviderActionHandlers<"arcmira", Handler>;
+export declare function validateArcmiraCredential(context: ApiKeyProviderContext): Promise<CredentialValidationResult>;
+export {};

package/src/providers/arcmira/runtime.js

@@ -0,0 +1,41 @@
+import { optionalRecord, optionalString, requiredString, requiredStringArray } from "../../core/cast.js";
+import { ProviderRequestError, providerResponseError, readProviderJsonBody, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+async function requestArcmira(context, path, input = {}) {
+    const url = new URL(`https://api.arcmira.com/v1/${path}`);
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    return runProviderRequest({ label: "Arcmira", signal: context.signal }, async (signal) => {
+        const response = await context.fetcher(url.toString(), {
+            headers: { Authorization: `Bearer ${context.apiKey}`, Accept: "application/json" },
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "Arcmira returned invalid JSON",
+        });
+        if (!response.ok) {
+            const error = optionalRecord(optionalRecord(payload)?.error);
+            const status = response.status;
+            throw new ProviderRequestError(status, optionalString(error?.message) ?? `Arcmira returned HTTP ${response.status}`, withRetryAfterSeconds(response, payload), status === 402 ? "insufficient_credit" : status === 429 ? "rate_limited" : "provider_error");
+        }
+        return payload;
+    });
+}
+export const arcmiraActionHandlers = {
+    get_account: (_input, context) => requestArcmira(context, "me"),
+    resolve_entity: (input, context) => requestArcmira(context, "entities/resolve", input),
+    search_transcripts: (input, context) => requestArcmira(context, "search", input),
+    get_transcript: ({ video_id, ...query }, context) => requestArcmira(context, `transcripts/${encodeURIComponent(requiredString(video_id, "video_id"))}`, query),
+};
+export async function validateArcmiraCredential(context) {
+    const payload = optionalRecord(await requestArcmira(context, "me", {}));
+    const account = optionalRecord(payload?.account);
+    const accountId = requiredString(account?.id, "Arcmira account ID", providerResponseError);
+    return {
+        profile: { accountId, displayName: optionalString(account?.name) ?? accountId },
+        grantedScopes: requiredStringArray(payload?.scopes, "Arcmira scopes", providerResponseError),
+    };
+}

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

@@ -8,6 +8,7 @@ import { taskActionHandlers } from "./runtime-tasks.js";
 import { workspaceUserTeamActionHandlers } from "./runtime-workspaces-users-teams.js";
 import { asanaApiBaseUrl, requestAsana } from "./runtime.js";
 import { readAsanaGrantedScopes } from "./scopes.js";
+import { asanaTaskEvent } from "./trigger-on-task-event.js";
 const service = "asana";
 const asanaValidationPath = "/users/me";
 export const executors = defineBearerProviderExecutors(service, combineProviderActionHandlers(service, workspaceUserTeamActionHandlers, projectSectionActionHandlers, taskActionHandlers, storyTagActionHandlers, customFieldActionHandlers, attachmentActionHandlers));
@@ -60,3 +61,4 @@ async function validateAsanaCredential(accessToken, grantedScopes, fetcher, sign
         }),
     };
 }
+export const triggers = [asanaTaskEvent];

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

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

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

@@ -0,0 +1,42 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const snapshot = {
+    key: "asana.on_task_event",
+    provider: "asana",
+    name: "on_task_event",
+    displayName: "Project Task Event",
+    description: "Receives tasks added to a project, completion changes, and selected custom field changes. Task details represent current state, not historical state.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: { methods: ["POST"], body: { formats: ["json"], allowArray: false, allowEmpty: true }, successStatus: 200 },
+    configInputs: [
+        { handle: "projectId", jsonSchema: { type: "string", minLength: 1, title: "Project ID" }, nullable: false },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", enum: ["task.added", "task.completed", "task.field_changed"] },
+                minItems: 1,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["task.added", "task.completed"],
+        },
+        { handle: "customFieldId", jsonSchema: { type: "string", minLength: 1, title: "Custom field ID" }, nullable: true },
+    ],
+    outputs: [
+        { handle: "projectId", jsonSchema: s.string(), nullable: false },
+        {
+            handle: "events",
+            jsonSchema: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: { event: s.string(), task: { type: "object" }, change: { type: "object" } },
+                    required: ["event", "task", "change"],
+                },
+            },
+            nullable: false,
+        },
+    ],
+};

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

@@ -0,0 +1,160 @@
+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-task-event.definition.js";
+export const asanaTaskEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const projectId = String(context.config.projectId);
+        const selected = context.config.eventTypes;
+        if (selected.includes("task.field_changed") && typeof context.config.customFieldId != "string")
+            throw new PermanentIntegrationError("Select a custom field for task field changes.");
+        const project = await webhookRequest(context, {
+            endpoint: `/projects/${encodeURIComponent(projectId)}`,
+            method: "GET",
+            query: { opt_fields: "workspace.gid" },
+        });
+        if (!isJsonObject(project.data) ||
+            !isJsonObject(project.data.data) ||
+            !isJsonObject(project.data.data.workspace) ||
+            typeof project.data.data.workspace.gid != "string")
+            throw new TransientIntegrationError("Asana returned no project workspace.");
+        const workspace = project.data.data.workspace.gid;
+        const remove = async (id) => {
+            await webhookRequest(context, { endpoint: `/webhooks/${encodeURIComponent(id)}`, method: "DELETE" });
+        };
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const found = [];
+                const query = {
+                    workspace,
+                    resource: projectId,
+                    limit: 100,
+                    opt_fields: "gid,target,resource.gid",
+                };
+                const seen = new Set();
+                for (let page = 0; page < 100; page++) {
+                    const response = await webhookRequest(context, { endpoint: "/webhooks", method: "GET", query });
+                    if (!isJsonObject(response.data) || !Array.isArray(response.data.data))
+                        throw new TransientIntegrationError("Asana returned an invalid webhook list.");
+                    for (const item of response.data.data) {
+                        if (!isJsonObject(item) || typeof item.target != "string" || typeof item.gid != "string")
+                            throw new TransientIntegrationError("Asana returned an invalid webhook.");
+                        if (item.target != context.endpointUrl)
+                            continue;
+                        if (!isJsonObject(item.resource) || item.resource.gid != projectId)
+                            throw new PermanentIntegrationError("Asana webhook project does not match.");
+                        found.push({
+                            id: item.gid,
+                            secret: context.state?.subscription.hookId == item.gid && typeof context.state.subscription.secret == "string"
+                                ? context.state.subscription.secret
+                                : "",
+                        });
+                    }
+                    const next = response.data.next_page;
+                    if (next == null)
+                        break;
+                    if (!isJsonObject(next) || typeof next.offset != "string" || seen.has(next.offset))
+                        throw new TransientIntegrationError("Asana webhook pagination did not advance.");
+                    seen.add(next.offset);
+                    query.offset = next.offset;
+                    if (page == 99)
+                        throw new PermanentIntegrationError("The Asana webhook list exceeds 10000 entries.");
+                }
+                if (found.length == 1 && !found[0].secret && context.active) {
+                    // Recover the unique owned orphan by deleting it before recreating its unreadable secret.
+                    await remove(found[0].id);
+                    await context.state.saveSubscription({}, context.now);
+                    return [];
+                }
+                return found;
+            },
+            async create() {
+                const response = await webhookRequest(context, {
+                    endpoint: "/webhooks",
+                    method: "POST",
+                    body: {
+                        data: {
+                            resource: projectId,
+                            target: context.endpointUrl,
+                            filters: [
+                                { resource_type: "task", action: "added" },
+                                { resource_type: "task", action: "changed", fields: ["completed", "custom_fields"] },
+                            ],
+                        },
+                    },
+                });
+                if (!isJsonObject(response.data) ||
+                    !isJsonObject(response.data.data) ||
+                    typeof response.data.data.gid != "string" ||
+                    typeof response.data["X-Hook-Secret"] != "string" ||
+                    !response.data["X-Hook-Secret"])
+                    throw new TransientIntegrationError("Asana webhook creation returned no identity or signing secret.");
+                return { id: response.data.data.gid, secret: response.data["X-Hook-Secret"] };
+            },
+            remove,
+        });
+    },
+    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-hook-signature"))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) || !Array.isArray(payload.events))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        const events = [];
+        const identities = [];
+        const selected = context.config.eventTypes;
+        for (const item of payload.events) {
+            if (!isJsonObject(item) || !isJsonObject(item.resource) || item.resource.resource_type != "task")
+                continue;
+            if (typeof item.resource.gid != "string" || typeof item.created_at != "string")
+                return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+            let event;
+            if (item.action == "added" && isJsonObject(item.parent) && item.parent.gid == context.config.projectId)
+                event = "task.added";
+            if (item.action == "changed" && isJsonObject(item.change)) {
+                if (item.change.field == "completed")
+                    event = "task.completed";
+                if (item.change.field == "custom_fields" &&
+                    isJsonObject(item.change.new_value) &&
+                    item.change.new_value.gid == context.config.customFieldId)
+                    event = "task.field_changed";
+            }
+            if (!event || !selected.includes(event))
+                continue;
+            const response = await context.connector.execute({
+                endpoint: `/tasks/${encodeURIComponent(item.resource.gid)}`,
+                method: "GET",
+                query: { opt_fields: "gid,name,completed,memberships.project.gid,custom_fields" },
+            }, context.signal);
+            if (response.status == 404)
+                continue;
+            if (response.status < 200 || response.status >= 300)
+                throw new TransientIntegrationError(`Asana task lookup failed (HTTP ${response.status}).`);
+            if (!isJsonObject(response.data) ||
+                !isJsonObject(response.data.data) ||
+                !Array.isArray(response.data.data.memberships))
+                throw new TransientIntegrationError("Asana returned invalid task details.");
+            const task = response.data.data;
+            if (!task.memberships.some((member) => isJsonObject(member) && isJsonObject(member.project) && member.project.gid == context.config.projectId))
+                continue;
+            if (event == "task.completed" && task.completed !== true)
+                continue;
+            events.push({ event, task, change: item });
+            identities.push(JSON.stringify(item));
+        }
+        if (!events.length)
+            return { outcome: "ignored", reason: "No matching project task changes." };
+        const digest = await crypto.subtle.digest("SHA-256", bytes(JSON.stringify(identities.sort())));
+        return {
+            outcome: "event",
+            dedupeKey: Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join(""),
+            outputs: { projectId: context.config.projectId, events },
+        };
+    },
+};

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

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const bainiuActions: ActionDefinition[];