@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/futunn/executors.js

@@ -0,0 +1,24 @@
+import { defineOAuthProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { futunnActions } from "./actions.js";
+import { executeFutunnAction } from "./runtime.js";
+import { futunnApiBaseUrl } from "./transport.js";
+const service = "futunn";
+function createHandler(actionName) {
+    return (input, context) => executeFutunnAction({
+        actionName,
+        input,
+        accessToken: context.accessToken,
+        signal: context.signal,
+    }, context.fetcher);
+}
+const handlers = Object.fromEntries(futunnActions.map((action) => [action.name, createHandler(action.name)]));
+export const executors = defineOAuthProviderExecutors(service, handlers);
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: futunnApiBaseUrl,
+    auth: { type: "oauth_bearer" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});

package/src/providers/futunn/runtime-research.d.ts

@@ -0,0 +1,3 @@
+import type { FutunnActionInput } from "./transport.ts";
+export declare function isFutunnResearchAction(name: string): boolean;
+export declare function executeFutunnResearchAction(input: FutunnActionInput, fetcher: typeof fetch): Promise<unknown>;

package/src/providers/futunn/runtime-research.js

@@ -0,0 +1,133 @@
+import { optionalNumber, optionalRecord } from "../../core/cast.js";
+import { ProviderRequestError, requiredInputString, requiredResponseRecord } from "../provider-runtime.js";
+import { futunnResearchActions } from "./actions.research.js";
+import { readFutunnData, readFutunnList, requestFutunn } from "./transport.js";
+const researchNames = new Set(futunnResearchActions.map((action) => action.name));
+export function isFutunnResearchAction(name) {
+    return researchNames.has(name);
+}
+export async function executeFutunnResearchAction(input, fetcher) {
+    const v = input.input;
+    const request = (path, query, body, allowNoData = false) => requestFutunn(input, fetcher, path, query, body, allowNoData);
+    const securityPath = (suffix) => `/api/v1.0/quote/${encodeURIComponent(requiredInputString(v.symbol, "symbol"))}/${suffix}`;
+    switch (input.actionName) {
+        case "search_news":
+        case "search_community": {
+            const news = input.actionName === "search_news";
+            const envelope = await request(`/api/v1.0/quote/${news ? "find-news" : "find-community"}`, {
+                symbol: v.keyword,
+                size: v.size,
+                [news ? "news_type" : "community_type"]: v.type,
+                sort_type: v.sortType,
+                lang: v.language,
+            });
+            return { items: readFutunnList(readFutunnData(envelope), "search results") };
+        }
+        case "get_security_info": {
+            const data = requiredResponseRecord(readFutunnData(await request("/api/v1.0/quote/stock-basicinfo", {}, { code_list: v.symbols })), "Futunn security info");
+            return { securities: readFutunnList(data.basic_list, "basic_list") };
+        }
+        case "get_market_state": {
+            const data = requiredResponseRecord(readFutunnData(await request("/api/v1.0/quote/market-state", {}, {
+                code_list: v.symbols,
+                is_contain_ba: v.includePreAfterMarket,
+                is_contain_overnight: v.includeOvernight,
+                is_need_crypto_multi_broker: v.includeCryptoBrokers,
+            })), "Futunn market state");
+            return { states: readFutunnList(data.market_state_list, "market_state_list") };
+        }
+        case "screen_stocks": {
+            const envelope = await request("/api/v1.0/quote/stock-screen", {}, {
+                screen_queries: v.screenQueries,
+                retrieve_queries: v.retrieveQueries,
+                sort: v.sort,
+                sorts: v.sorts,
+                next_key: v.nextKey,
+                limit: v.limit,
+                watchlist_stock_ids: v.watchlistStockIds,
+                holding_stock_ids: v.holdingStockIds,
+                user_stock_list_mode: v.userStockListMode,
+            });
+            const data = requiredResponseRecord(readFutunnData(envelope), "Futunn screening data");
+            return {
+                items: readFutunnList(data.items, "screening items"),
+                pagination: optionalRecord(envelope.pagination) ?? null,
+            };
+        }
+        case "get_financial_statements": {
+            const envelope = await request(securityPath("financials/statements"), {
+                statement_type: v.statementType,
+                financial_type: v.financialType,
+                currency_code: v.currencyCode,
+                next_key: v.nextKey,
+                limit: v.limit,
+            }, undefined, true);
+            const noData = envelope.ret_code === -10;
+            const data = noData ? null : requiredResponseRecord(readFutunnData(envelope), "Futunn financial statements");
+            return {
+                reports: data === null ? [] : readFutunnList(data.report_list, "report_list"),
+                pagination: optionalRecord(envelope.pagination) ?? null,
+                noData,
+            };
+        }
+        case "get_revenue_breakdown": {
+            const envelope = await request(securityPath("financials/revenue-breakdown"), { date: v.date, financial_type: v.financialType, currency_code: v.currencyCode }, undefined, true);
+            const noData = envelope.ret_code === -10;
+            return {
+                revenue: noData ? null : requiredResponseRecord(readFutunnData(envelope), "Futunn revenue breakdown"),
+                noData,
+            };
+        }
+        case "get_operational_efficiency": {
+            const envelope = await request(securityPath("company/operational-efficiency"), {
+                limit: v.limit,
+                financial_type: v.financialType,
+                currency_code: v.currencyCode,
+                next_key: v.nextKey,
+            }, undefined, true);
+            const noData = envelope.ret_code === -10;
+            return {
+                efficiency: noData ? null : requiredResponseRecord(readFutunnData(envelope), "Futunn operational efficiency"),
+                pagination: optionalRecord(envelope.pagination) ?? null,
+                noData,
+            };
+        }
+        case "get_valuation":
+            return {
+                valuation: requiredResponseRecord(readFutunnData(await request(securityPath("valuation/detail"), {
+                    valuation_type: v.valuationType,
+                    interval_type: v.intervalType,
+                })), "Futunn valuation"),
+            };
+        case "get_capital_flow": {
+            const data = requiredResponseRecord(readFutunnData(await request(securityPath("capital-flow"), { section: v.section })), "Futunn capital flow");
+            return {
+                flows: readFutunnList(data.flow_list, "flow_list"),
+                lastValidTime: optionalNumber(data.last_valid_time) ?? null,
+            };
+        }
+        case "get_capital_flow_history": {
+            const envelope = await request(securityPath("capital-flow/history"), {
+                period_type: v.periodType,
+                start: v.start,
+                end: v.end,
+                count: v.count,
+            });
+            const data = requiredResponseRecord(readFutunnData(envelope), "Futunn capital flow history");
+            return {
+                flows: readFutunnList(data.flow_list, "flow_list"),
+                pagination: optionalRecord(envelope.pagination) ?? null,
+            };
+        }
+        case "get_capital_distribution": {
+            const envelope = await request(securityPath("capital-distribution"), {}, undefined, true);
+            const noData = envelope.ret_code === -10;
+            return {
+                distribution: noData ? null : requiredResponseRecord(readFutunnData(envelope), "Futunn capital distribution"),
+                noData,
+            };
+        }
+        default:
+            throw new ProviderRequestError(400, `Unknown Futunn research action: ${input.actionName}`);
+    }
+}

package/src/providers/futunn/runtime-trading.d.ts

@@ -0,0 +1,3 @@
+import type { FutunnActionInput } from "./transport.ts";
+export declare function isFutunnTradingAction(name: string): boolean;
+export declare function executeFutunnTradingAction(input: FutunnActionInput, fetcher: typeof fetch): Promise<unknown>;

package/src/providers/futunn/runtime-trading.js

@@ -0,0 +1,39 @@
+import { optionalBoolean, optionalString } from "../../core/cast.js";
+import { ProviderRequestError, requiredInputString, requiredResponseRecord } from "../provider-runtime.js";
+import { futunnTradingActions } from "./actions.trading.js";
+import { readFutunnData, readFutunnList, requestFutunn } from "./transport.js";
+const tradingNames = new Set(futunnTradingActions.map((action) => action.name));
+export function isFutunnTradingAction(name) {
+    return tradingNames.has(name);
+}
+const listEndpoints = {
+    list_open_orders: { path: "orders", field: "orders", history: false },
+    list_history_orders: { path: "orders_history", field: "orders", history: true },
+    list_today_deals: { path: "order_fills", field: "order_fills", history: false },
+    list_history_deals: { path: "fills_history", field: "order_fills", history: true },
+};
+export async function executeFutunnTradingAction(input, fetcher) {
+    const v = input.input;
+    const path = `/api/v1.0/accounts/${encodeURIComponent(requiredInputString(v.accountId, "accountId"))}`;
+    if (input.actionName === "get_order_details") {
+        const envelope = await requestFutunn(input, fetcher, `${path}/orders/detail`, {}, { exchange: v.exchange, order_ids: v.orderIds });
+        return { orders: readFutunnList(readFutunnData(envelope), "order details") };
+    }
+    const endpoint = listEndpoints[input.actionName];
+    if (!endpoint)
+        throw new ProviderRequestError(400, `Unknown Futunn trading action: ${input.actionName}`);
+    const envelope = await requestFutunn(input, fetcher, `${path}/${endpoint.path}`, {
+        trd_market: v.market,
+        page_flag: v.pageFlag ?? "",
+        page_size: v.pageSize,
+        code: endpoint.history ? v.code : undefined,
+        start: endpoint.history ? v.start : undefined,
+        end: endpoint.history ? v.end : undefined,
+    });
+    const data = requiredResponseRecord(readFutunnData(envelope), "Futunn account records");
+    return {
+        [endpoint.field === "orders" ? "orders" : "deals"]: readFutunnList(data[endpoint.field], endpoint.field),
+        pageFlag: optionalString(data.page_flag) ?? null,
+        completed: optionalBoolean(data.completed) ?? null,
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { FutunnActionInput } from "./transport.ts";
+export declare function executeFutunnAction(input: FutunnActionInput, fetcher: typeof fetch): Promise<unknown>;

package/src/providers/futunn/runtime.js

@@ -0,0 +1,50 @@
+import { optionalNumber } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord } from "../provider-runtime.js";
+import { executeFutunnResearchAction, isFutunnResearchAction } from "./runtime-research.js";
+import { executeFutunnTradingAction, isFutunnTradingAction } from "./runtime-trading.js";
+import { readFutunnData, readFutunnList, requestFutunn } from "./transport.js";
+export async function executeFutunnAction(input, fetcher) {
+    const values = input.input;
+    const request = (path, query, body) => requestFutunn(input, fetcher, path, query, body).then(readFutunnData);
+    if (isFutunnResearchAction(input.actionName))
+        return executeFutunnResearchAction(input, fetcher);
+    if (isFutunnTradingAction(input.actionName))
+        return executeFutunnTradingAction(input, fetcher);
+    switch (input.actionName) {
+        case "get_market_snapshot": {
+            const data = requiredResponseRecord(await request("/api/v1.0/quote/snapshot", {}, { code_list: values.symbols }), "Futunn snapshot data");
+            return { snapshots: readFutunnList(data.snapshot_list, "snapshot_list") };
+        }
+        case "get_history_kline": {
+            const data = requiredResponseRecord(await request(`/api/v1.0/quote/${encodeURIComponent(requiredInputString(values.symbol, "symbol"))}/history-kline`, {
+                start: values.start,
+                end: values.end,
+                ktype: values.ktype,
+                autype: values.autype,
+                num: values.num,
+                extended_time: values.extendedTime,
+            }), "Futunn history data");
+            return {
+                bars: readFutunnList(data.kline_list, "kline_list"),
+                nextTime: optionalNumber(data.next_time) ?? null,
+                volumePrecision: optionalNumber(data.volume_precision) ?? null,
+            };
+        }
+        case "list_trading_days": {
+            const data = requiredResponseRecord(await request("/api/v1.0/quote/trading-days", values), "Futunn calendar data");
+            return { tradingDays: readFutunnList(data.trading_days, "trading_days") };
+        }
+        case "list_accounts": {
+            const data = requiredResponseRecord(await request("/api/v1.0/accounts/authorized_trd_accs"), "Futunn account data");
+            return { accounts: readFutunnList(data.accounts, "accounts") };
+        }
+        case "get_account_funds":
+            return {
+                funds: requiredResponseRecord(await request(`/api/v1.0/accounts/${encodeURIComponent(requiredInputString(values.accountId, "accountId"))}/funds`, { currency: values.currency }), "Futunn funds"),
+            };
+        case "list_positions":
+            return {
+                positions: readFutunnList(await request(`/api/v1.0/accounts/${encodeURIComponent(requiredInputString(values.accountId, "accountId"))}/positions`, { code: values.code, pl_ratio_min: values.plRatioMin, pl_ratio_max: values.plRatioMax }), "positions"),
+            };
+    }
+}

package/src/providers/futunn/transport.d.ts

@@ -0,0 +1,11 @@
+export interface FutunnActionInput {
+    actionName: string;
+    input: Record<string, unknown>;
+    accessToken: string;
+    signal?: AbortSignal;
+}
+export declare const futunnApiBaseUrl = "https://webapi.futunn.com";
+export declare function readFutunnResponse(response: Response, allowNoData?: boolean): Promise<Record<string, unknown>>;
+export declare function requestFutunn(input: FutunnActionInput, fetcher: typeof fetch, path: string, query?: Record<string, unknown>, body?: unknown, allowNoData?: boolean): Promise<Record<string, unknown>>;
+export declare function readFutunnList(value: unknown, label: string): unknown[];
+export declare function readFutunnData(envelope: Record<string, unknown>): unknown;

package/src/providers/futunn/transport.js

@@ -0,0 +1,76 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { ProviderRequestError, providerUserAgent, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const futunnApiBaseUrl = "https://webapi.futunn.com";
+export async function readFutunnResponse(response, allowNoData = false) {
+    let payload;
+    try {
+        payload = JSON.parse(await response.text(), (key, value, context) => {
+            // Preserve the source decimal text of uint64 trading account IDs during JSON parsing.
+            if (key !== "account_id" || typeof value !== "number")
+                return value;
+            if (!Number.isInteger(value))
+                throw new Error("Invalid Futunn account ID");
+            if (Number.isSafeInteger(value))
+                return String(value);
+            if (!context?.source)
+                throw new Error("Futunn account ID source is unavailable");
+            return BigInt(context.source).toString();
+        });
+    }
+    catch {
+        throw new ProviderRequestError(response.ok ? 502 : response.status, "Futunn returned invalid JSON");
+    }
+    const envelope = requiredResponseRecord(payload, "Futunn response");
+    if (response.ok && allowNoData && envelope.ret_code === -10)
+        return envelope;
+    const error = optionalRecord(envelope.error);
+    if (!response.ok ||
+        envelope.s === "error" ||
+        (envelope.ret_code !== undefined && envelope.ret_code !== 0) ||
+        envelope.error) {
+        const message = optionalString(envelope.errmsg) ??
+            optionalString(envelope.ret_msg) ??
+            optionalString(envelope.error_description) ??
+            optionalString(error?.message) ??
+            optionalString(envelope.error) ??
+            "request failed";
+        const code = envelope.errcode ?? envelope.ret_code ?? error?.code;
+        throw new ProviderRequestError(response.ok ? 502 : response.status, `Futunn${code === undefined ? "" : ` (${String(code)})`}: ${message}`);
+    }
+    return envelope;
+}
+export async function requestFutunn(input, fetcher, path, query = {}, body, allowNoData = false) {
+    const url = new URL(path, futunnApiBaseUrl);
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined)
+            url.searchParams.set(key, String(value));
+    }
+    return runProviderRequest({ label: "Futunn", signal: input.signal }, async (signal) => {
+        const response = await fetcher(url, {
+            method: body === undefined ? "GET" : "POST",
+            headers: {
+                authorization: `Bearer ${input.accessToken}`,
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal,
+            redirect: "manual",
+        });
+        const envelope = await readFutunnResponse(response, allowNoData);
+        if (envelope.s === "ok" || envelope.ret_code === 0 || (allowNoData && envelope.ret_code === -10))
+            return envelope;
+        throw new ProviderRequestError(502, "Futunn response is missing its success envelope");
+    });
+}
+export function readFutunnList(value, label) {
+    if (!Array.isArray(value))
+        throw new ProviderRequestError(502, `Futunn ${label} must be an array`);
+    return value;
+}
+export function readFutunnData(envelope) {
+    if (envelope.ret_code === -10)
+        return null;
+    return envelope.s === "ok" ? envelope.d : envelope.data;
+}

package/src/providers/gildata/executors.js

@@ -202,7 +202,7 @@ function buildGildataMcpInput(serverType, apiKey, fetcher, parentSignal, request
             }
             return response;
         },
-        redirect: "error",
+        redirect: "manual",
         terminateSession: true,
         signal: parentSignal,
         requestTimeoutMs,

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

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

package/src/providers/github/executors.js

@@ -6,6 +6,8 @@ import { releaseActionHandlers } from "./runtime-release.js";
 import { repositoryActionHandlers } from "./runtime-repository.js";
 import { searchActionHandlers } from "./runtime-search.js";
 import { githubApiBaseUrl, githubApiVersion, githubDefaultAcceptHeader, githubRequestJson } from "./runtime-shared.js";
+import { githubRepoEvent } from "./trigger-on-repo-event.js";
+import { githubPullRequestListener } from "./trigger-watch-pull-request.js";
 const service = "github";
 export const executors = defineProviderExecutors({
     service,
@@ -57,3 +59,7 @@ async function validateGitHubToken(accessToken, fetcher) {
         },
     };
 }
+export const triggers = [
+    githubRepoEvent,
+    githubPullRequestListener,
+];

package/src/providers/github/trigger-on-repo-event.d.ts

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

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

@@ -0,0 +1,94 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const events = [
+    "*",
+    "branch_protection_configuration",
+    "branch_protection_rule",
+    "check_run",
+    "check_suite",
+    "code_scanning_alert",
+    "commit_comment",
+    "create",
+    "custom_property_values",
+    "delete",
+    "dependabot_alert",
+    "deploy_key",
+    "deployment",
+    "deployment_status",
+    "discussion",
+    "discussion_comment",
+    "fork",
+    "gollum",
+    "issue_comment",
+    "issue_dependencies",
+    "issues",
+    "label",
+    "member",
+    "meta",
+    "milestone",
+    "package",
+    "page_build",
+    "project",
+    "project_card",
+    "project_column",
+    "public",
+    "pull_request",
+    "pull_request_review",
+    "pull_request_review_comment",
+    "pull_request_review_thread",
+    "push",
+    "registry_package",
+    "release",
+    "repository",
+    "repository_advisory",
+    "repository_import",
+    "repository_ruleset",
+    "repository_vulnerability_alert",
+    "secret_scanning_alert",
+    "secret_scanning_alert_location",
+    "secret_scanning_scan",
+    "security_and_analysis",
+    "star",
+    "status",
+    "sub_issues",
+    "team_add",
+    "watch",
+    "workflow_job",
+    "workflow_run",
+];
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.stringEnum(events), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+        },
+        { handle: "insecureSsl", jsonSchema: s.boolean(), nullable: false, value: false },
+        {
+            handle: "owner",
+            jsonSchema: s.string({ pattern: "^[a-zA-Z0-9](?:[a-zA-Z0-9]|-(?=[a-zA-Z0-9])){0,38}$" }),
+            nullable: false,
+        },
+        {
+            handle: "repo",
+            jsonSchema: s.string({ pattern: "^(?!\\.{1,2}$)[a-zA-Z0-9._-]{1,100}$" }),
+            nullable: false,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when selected GitHub webhook events occur in a repository.",
+    displayName: "Repository Event",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "github.on_repo_event",
+    name: "on_repo_event",
+    outputs: [
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+    ],
+    provider: "github",
+    type: "integration",
+};

package/src/providers/github/trigger-on-repo-event.js

@@ -0,0 +1,168 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-repo-event.definition.js";
+export const githubRepoEvent = {
+    initialState: { checkpoint: null, subscription: {} },
+    snapshot,
+    async receive(context) {
+        const signature = context.header("x-hub-signature-256");
+        if (!signature?.startsWith("sha256=") ||
+            !(await verifyHexHmac(context.callbackSecret, [context.rawBody], signature.slice(7)))) {
+            return { body: "", contentType: "text/plain", outcome: "respond", status: 404 };
+        }
+        const event = context.header("x-github-event")?.trim();
+        if (!event)
+            return { outcome: "ignored", reason: "GitHub event header is missing." };
+        if (event == "ping")
+            return { outcome: "ignored", reason: "GitHub ping handshake." };
+        const config = resolveConfig(context.config);
+        if (!config.events.includes("*") && !config.events.includes(event)) {
+            return { outcome: "ignored", reason: "GitHub event is not subscribed." };
+        }
+        const deliveryId = context.header("x-github-delivery") ?? "";
+        return {
+            dedupeKey: deliveryId.length == 0 ? undefined : deliveryId,
+            outcome: "event",
+            outputs: { body: context.payload, deliveryId, event },
+        };
+    },
+    async reconcile(context) {
+        const state = requireState(context.state);
+        const config = resolveConfig(context.config);
+        let hookId = subscriptionId(state);
+        if (!context.active) {
+            if (hookId == null)
+                hookId = await findByUrl(context, config);
+            if (hookId != null) {
+                const result = await request(context, "hook delete", {
+                    endpoint: `${endpoint(config)}/${hookId}`,
+                    method: "DELETE",
+                });
+                if (result.status != 404)
+                    success(result, "hook delete");
+            }
+            await state.saveSubscription({}, later(context.now));
+            return { outcome: "ready" };
+        }
+        const desired = body(context.endpointUrl, context.callbackSecret, config);
+        if (hookId == null) {
+            const result = await request(context, "hook create", {
+                body: desired,
+                endpoint: endpoint(config),
+                method: "POST",
+            });
+            if (result.status == 201)
+                hookId = id(result.data);
+            else if (result.status == 422) {
+                hookId = await findByUrl(context, config);
+                if (hookId == null)
+                    throw new PermanentIntegrationError("GitHub rejected the webhook configuration.");
+            }
+            else {
+                success(result, "hook create");
+                throw new TransientIntegrationError(`GitHub hook create returned unexpected status ${result.status}.`);
+            }
+        }
+        await state.saveSubscription({ hookId }, context.now);
+        const aligned = await request(context, "hook update", {
+            body: desired,
+            endpoint: `${endpoint(config)}/${hookId}`,
+            method: "PATCH",
+        });
+        if (aligned.status == 404) {
+            await state.saveSubscription({}, context.now);
+            return { outcome: "pending" };
+        }
+        success(aligned, "hook update");
+        await state.saveSubscription({ hookId }, later(context.now));
+        return { outcome: "ready" };
+    },
+};
+function resolveConfig(value) {
+    return {
+        events: [...new Set(value.events)],
+        insecureSsl: value.insecureSsl,
+        owner: value.owner,
+        repo: value.repo,
+    };
+}
+function endpoint(config) {
+    return `/repos/${encodeURIComponent(config.owner)}/${encodeURIComponent(config.repo)}/hooks`;
+}
+function body(url, secret, config) {
+    return {
+        active: true,
+        config: { content_type: "json", insecure_ssl: config.insecureSsl ? "1" : "0", secret, url },
+        events: config.events,
+        name: "web",
+    };
+}
+async function findByUrl(context, config) {
+    for (let page = 1; page <= 10; page += 1) {
+        const result = await request(context, "hook list", {
+            endpoint: endpoint(config),
+            method: "GET",
+            query: { page, per_page: 100 },
+        });
+        if (result.status == 404)
+            return null;
+        success(result, "hook list");
+        const hooks = Array.isArray(result.data) ? result.data : [];
+        for (const hook of hooks) {
+            const value = record(hook);
+            if (record(value?.config)?.url === context.endpointUrl &&
+                (typeof value?.id == "number" || typeof value?.id == "string")) {
+                return String(value.id);
+            }
+        }
+        if (hooks.length < 100)
+            return null;
+    }
+    return null;
+}
+async function request(context, operation, value) {
+    try {
+        return await context.connector.execute(value, context.signal);
+    }
+    catch (cause) {
+        if (cause instanceof IntegrationConnectionError)
+            throw cause;
+        throw new TransientIntegrationError(`GitHub ${operation} request failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    const message = record(result.data)?.message;
+    if (result.status == 403 && typeof message == "string" && /rate limit/i.test(message)) {
+        throw new TransientIntegrationError(`GitHub ${operation} was rate limited.`);
+    }
+    if ([401, 403].includes(result.status))
+        throw new IntegrationConnectionError(`GitHub ${operation} rejected the Connection.`);
+    if ([404, 422].includes(result.status))
+        throw new PermanentIntegrationError(`GitHub ${operation} rejected the subscription.`);
+    throw new TransientIntegrationError(`GitHub ${operation} failed with status ${result.status}.`);
+}
+function id(data) {
+    const value = record(data)?.id;
+    if (typeof value != "number" && typeof value != "string")
+        throw new TransientIntegrationError("GitHub hook response is missing its ID.");
+    return String(value);
+}
+function requireState(value) {
+    if (value == null)
+        throw new PermanentIntegrationError("GitHub Integration state is missing.");
+    return value;
+}
+function subscriptionId(state) {
+    const value = state.subscription.hookId;
+    return typeof value == "string" && value.length > 0 ? value : null;
+}
+function later(now) {
+    return new Date(now.getTime() + 30 * 24 * 60 * 60 * 1_000);
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/src/providers/github/trigger-watch-pull-request.d.ts

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