@oomol-lab/open-connector 1.9.1 → 1.9.2

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

@@ -1,5 +1,6 @@
 import { defineOAuthProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { sentryActionHandlers, sentryApiBaseUrl, validateSentryCredential } from "./runtime.js";
+import { sentryIssueAlert } from "./trigger-on-issue-alert.js";
 const service = "sentry";
 export const executors = defineOAuthProviderExecutors(service, sentryActionHandlers);
 export const proxy = defineProviderProxy({
@@ -12,3 +13,4 @@ export const credentialValidators = {
         return validateSentryCredential(input.accessToken, fetcher);
     },
 };
+export const triggers = [sentryIssueAlert];

package/src/providers/sentry/trigger-on-issue-alert.d.ts

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

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

@@ -0,0 +1,64 @@
+export const snapshot = {
+    key: "sentry.on_issue_alert",
+    provider: "sentry",
+    name: "on_issue_alert",
+    displayName: "Issue Alert",
+    description: "Receives Issue Alert Rule notifications from a verified Sentry Custom Integration installation.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "projectIds",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", pattern: "^[0-9]+$" },
+                uniqueItems: true,
+                title: "Project IDs",
+            },
+            nullable: true,
+        },
+        {
+            handle: "ruleNames",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", minLength: 1 },
+                uniqueItems: true,
+                title: "Alert rule names",
+            },
+            nullable: true,
+        },
+        {
+            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: ["issue.alert"],
+                },
+                minItems: 1,
+                maxItems: 1,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["issue.alert"],
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "organizationId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "issueId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/sentry/trigger-on-issue-alert.js

@@ -0,0 +1,80 @@
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { webhookRequest } from "../../triggers/managed-webhook.js";
+import { sentryApplication } from "../../triggers/sources/sentry.js";
+import { snapshot } from "./trigger-on-issue-alert.definition.js";
+export const sentryIssueAlert = {
+    snapshot,
+    eventSource: "sentry",
+    source: sentryApplication,
+    async sourceIdentity(context) {
+        const accountId = context.connector.providerAccountId;
+        const { appId, installationId, organizationId } = context.config;
+        if (!accountId ||
+            typeof organizationId !== "string" ||
+            !organizationId ||
+            typeof appId !== "string" ||
+            !appId ||
+            typeof installationId !== "string" ||
+            !installationId)
+            throw new PermanentIntegrationError("Sentry requires a verified organization, application UUID and installation UUID.");
+        const organizationResponse = await webhookRequest(context, {
+            method: "GET",
+            endpoint: `/organizations/${encodeURIComponent(organizationId)}/`,
+        });
+        const organization = organizationResponse.data;
+        if (!isJsonObject(organization) || typeof organization.id !== "string" || typeof organization.slug !== "string")
+            throw new PermanentIntegrationError("Invalid Sentry organization response.");
+        const seen = new Set();
+        let cursor;
+        for (;;) {
+            const result = await webhookRequest(context, {
+                method: "GET",
+                endpoint: `/organizations/${encodeURIComponent(organizationId)}/sentry-app-installations/`,
+                query: cursor == null ? {} : { cursor },
+            });
+            if (!Array.isArray(result.data))
+                throw new PermanentIntegrationError("Invalid Sentry installations response.");
+            for (const item of result.data) {
+                if (!isJsonObject(item) || !isJsonObject(item.app) || !isJsonObject(item.organization))
+                    throw new PermanentIntegrationError("Invalid Sentry installation.");
+                if (item.uuid !== installationId)
+                    continue;
+                if (item.app.uuid !== appId || item.status !== "installed" || item.organization.slug !== organization.slug)
+                    throw new PermanentIntegrationError("Sentry integration is not installed in the connected organization.");
+                return {
+                    accountId,
+                    organizationId: organization.id,
+                    organizationSlug: organization.slug,
+                    appId,
+                    installationId,
+                };
+            }
+            const next = (result.headers?.link ?? "")
+                .split(",")
+                .find((link) => /rel="next"/.test(link) && /results="true"/.test(link));
+            if (next == null)
+                break;
+            const match = /cursor="([^"]+)"/.exec(next);
+            if (!match || seen.has(match[1]))
+                throw new PermanentIntegrationError("Invalid Sentry installation pagination.");
+            cursor = match[1];
+            seen.add(cursor);
+        }
+        throw new PermanentIntegrationError("Install the selected Sentry integration in the connected organization first.");
+    },
+    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 Sentry event.");
+        return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+    },
+    async reconcile() {
+        throw new PermanentIntegrationError("This deployment does not support shared Sentry event sources.");
+    },
+};

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

@@ -1,6 +1,5 @@
 import type { CredentialValidationResult } from "../../core/types.ts";
 import type { ProviderFetch, ProviderRuntimeHandler } from "../provider-runtime.ts";
-export declare const sfExpressApiBaseUrl = "https://bspgw.sf-express.com/std/service";
 type SfExpressPhase = "validate" | "execute";
 /**
  * The msgDigest algorithm a partnerID is bound to. SF fixes the choice when the
@@ -27,21 +26,6 @@ export declare function optionalFlagNumber(value: unknown): 1 | 0 | undefined;
 /** Read an optional value-added service list (name + value…value4) from action input. */
 export declare function readServiceValueList(value: unknown, fieldName: string): Array<Record<string, unknown>> | undefined;
 export declare function validateSfExpressCredential(values: Record<string, string>, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
-/**
- * Sign one request with the algorithm the application was created against. All
- * three sign the same `msgData + timestamp + checkWord` string and differ only
- * in how they turn it into msgDigest:
- *
- * - `standard_md5` runs it through `URLEncoder.encode(text, "UTF-8")`
- *   first, then Base64(MD5(...)). Skipping that step fails verification for
- *   every payload, because JSON always carries characters the encoder rewrites.
- * - `simple_md5` is the same Base64(MD5(...)) over the raw string.
- * - `sm3` is the lowercase hexadecimal SM3 digest of the raw string.
- *
- * Standard MD5 is the default because SF used it before offering
- * the choice and what every application created back then still uses.
- */
-export declare function signSfExpressPayload(msgData: string, timestamp: string, checkWord: string, algorithm?: SfExpressSignatureAlgorithm): string;
 /**
  * Call one SF Express Open Platform service: POST form-urlencoded with the
  * business JSON in msgData, signed by {@link signSfExpressPayload}. msgData is

package/src/providers/sf_express/runtime.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { compactObject, objectArray, optionalBoolean, optionalNumberLike, optionalRecord, optionalString, } from "../../core/cast.js";
 import { sm3Hex } from "../../core/sm3.js";
 import { parseProviderJsonBodyText, ProviderRequestError, providerInputError, providerResponseError, providerUserAgent, readProviderJson, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
-export const sfExpressApiBaseUrl = "https://bspgw.sf-express.com/std/service";
+const sfExpressApiBaseUrl = "https://bspgw.sf-express.com/std/service";
 /** The sandbox gateway; every documented sandbox-environment row names this host. */
 const sfExpressSandboxBaseUrl = "https://sfapi-sbox.sf-express.com/std/service";
 /** Endpoints whose production URL differs from the default gateway, per their documented common-parameters sections. */
@@ -157,7 +157,7 @@ function javaFormUrlEncode(value) {
  * Standard MD5 is the default because SF used it before offering
  * the choice and what every application created back then still uses.
  */
-export function signSfExpressPayload(msgData, timestamp, checkWord, algorithm = "standard_md5") {
+function signSfExpressPayload(msgData, timestamp, checkWord, algorithm = "standard_md5") {
     const text = msgData + timestamp + checkWord;
     if (algorithm === "sm3") {
         return sm3Hex(text);

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

@@ -2,11 +2,16 @@ import type { CredentialValidators, ProviderExecutors } from "../../core/types.t
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { OAuthProviderContext } from "../provider-runtime.ts";
 export declare const slackApiBaseUrl = "https://slack.com/api";
-type SlackActionContext = Omit<OAuthProviderContext, "providerSecret" | "tokenType">;
+interface SlackActionContext extends Omit<OAuthProviderContext, "providerSecret" | "tokenType"> {
+    /** Stored OAuth response metadata; empty for API-key credentials. */
+    metadata: Record<string, unknown>;
+}
 type SlackOAuthTokenKind = "bot" | "user";
 export type SlackActionHandler = (input: Record<string, unknown>, context: SlackActionContext) => Promise<unknown>;
 /** Build Slack executors that reject credentials issued for the other authorization path. */
 export declare function defineSlackProviderExecutors(service: "slack" | "slackbot", tokenKind: SlackOAuthTokenKind, handlers: Record<string, SlackActionHandler>): ProviderExecutors;
 export declare const slackActionHandlers: ProviderActionHandlers<"slack", SlackActionHandler>;
 export declare const slackCredentialValidators: CredentialValidators;
+/** Read the workspace and installer from stored OAuth metadata. */
+export declare function slackbotInstallationHandler(_input: Record<string, unknown>, context: SlackActionContext): Promise<unknown>;
 export {};

package/src/providers/slack/runtime.js

@@ -12,11 +12,13 @@ export function defineSlackProviderExecutors(service, tokenKind, handlers) {
         async createContext(context, fetcher) {
             const credential = await context.getCredential(service);
             let accessToken;
+            let metadata = {};
             if (credential?.authType === "oauth2") {
                 if (readSlackTokenKind(credential.accessToken, credential.metadata) != tokenKind) {
                     throw new ProviderRequestError(401, `Reconnect ${service} with ${tokenKind} authorization before running its actions.`);
                 }
                 accessToken = credential.accessToken;
+                metadata = credential.metadata;
             }
             else if (credential?.authType === "api_key") {
                 // A pasted token was authorized by no OAuth flow, so the user/bot flow
@@ -31,6 +33,7 @@ export function defineSlackProviderExecutors(service, tokenKind, handlers) {
             const providerContext = {
                 accessToken,
                 fetcher,
+                metadata,
                 signal: context.signal,
             };
             if (context.transitFiles) {
@@ -176,6 +179,24 @@ async function slackGetCurrentUser(context) {
     const identity = readSlackAuthTestIdentity(await slackAuthTest(context));
     return { teamId: identity.teamId, userId: identity.userId, isBot: identity.botId !== undefined };
 }
+/** Read the workspace and installer from stored OAuth metadata. */
+export async function slackbotInstallationHandler(_input, context) {
+    const team = optionalRecord(context.metadata.team);
+    const authedUser = optionalRecord(context.metadata.authed_user);
+    const teamId = optionalString(team?.id);
+    const authedUserId = optionalString(authedUser?.id);
+    const botUserId = optionalString(context.metadata.bot_user_id);
+    if (!teamId || !authedUserId || !botUserId) {
+        return null;
+    }
+    return {
+        teamId,
+        teamName: optionalString(team?.name) ?? null,
+        authedUserId,
+        botUserId,
+        appId: optionalString(context.metadata.app_id) ?? null,
+    };
+}
 async function slackListChannels(input, context) {
     const url = slackApiUrl("conversations.list");
     if (input.limit != null) {

package/src/providers/slackbot/actions.js

@@ -1,7 +1,8 @@
+import { s } from "../../core/json-schema.js";
 import { defineProviderAction } from "../../core/provider-definition.js";
 import { slackActions } from "../slack/actions.js";
 const service = "slackbot";
-export const slackbotActions = slackActions
+const sharedActions = slackActions
     .filter((action) => action.name != "search_messages" && action.name != "search_context" && action.name != "get_current_user")
     .map((action) => defineProviderAction(service, {
     name: action.name,
@@ -11,3 +12,18 @@ export const slackbotActions = slackActions
     inputSchema: action.inputSchema,
     outputSchema: action.outputSchema,
 }));
+const getInstallation = defineProviderAction(service, {
+    name: "get_installation",
+    operationType: "read",
+    description: "Get the workspace and authorizing user from stored OAuth metadata. This information is available only for OAuth connections. Returns null for API-key connections or incomplete OAuth metadata. OAuth credentials may be refreshed before execution.",
+    requiredScopes: [],
+    inputSchema: s.object({}),
+    outputSchema: s.nullable(s.object({
+        teamId: s.nonEmptyString("The Slack workspace ID the app was installed in."),
+        teamName: s.nullable(s.string({ description: "The workspace display name, when the install carried one." })),
+        authedUserId: s.nonEmptyString("The Slack user ID of the person who approved the install."),
+        botUserId: s.nonEmptyString("The Slack user ID of the app's bot user."),
+        appId: s.nullable(s.string({ description: "The Slack app ID, when the install carried one." })),
+    }, { required: ["teamId", "teamName", "authedUserId", "botUserId", "appId"] })),
+});
+export const slackbotActions = [...sharedActions, getInstallation];

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

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

package/src/providers/slackbot/executors.js

@@ -1,8 +1,11 @@
 import { getProviderActionHandler, mapProviderActionHandlers } from "../provider-runtime.js";
-import { defineSlackProviderExecutors, slackActionHandlers, slackCredentialValidators } from "../slack/runtime.js";
+import { defineSlackProviderExecutors, slackActionHandlers, slackbotInstallationHandler, slackCredentialValidators, } from "../slack/runtime.js";
 import { slackbotActions } from "./actions.js";
+import { slackBotEvents } from "./trigger-on-event.js";
 const service = "slackbot";
 const slackbotActionHandlers = mapProviderActionHandlers(service, slackbotActions, (action) => {
+    if (action.name === "get_installation")
+        return slackbotInstallationHandler;
     const handler = getProviderActionHandler(slackActionHandlers, action.name);
     if (!handler) {
         throw new Error(`Missing shared Slack handler for action: ${action.name}`);
@@ -11,3 +14,4 @@ const slackbotActionHandlers = mapProviderActionHandlers(service, slackbotAction
 });
 export const executors = defineSlackProviderExecutors(service, "bot", slackbotActionHandlers);
 export const credentialValidators = slackCredentialValidators;
+export const triggers = [slackBotEvents];

package/src/providers/slackbot/trigger-on-event.d.ts

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

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

@@ -0,0 +1,57 @@
+export const snapshot = {
+    key: "slackbot.on_event",
+    provider: "slackbot",
+    name: "on_event",
+    displayName: "Mention or Direct Message",
+    description: "Receives user mentions and new direct messages through a shared Slack application event source. Slack Connect events 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: ["app_mention", "message.im"] },
+                minItems: 1,
+                maxItems: 2,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["app_mention", "message.im"],
+        },
+        {
+            handle: "channelIds",
+            jsonSchema: {
+                type: "array",
+                items: { type: "string", minLength: 1 },
+                maxItems: 100,
+                uniqueItems: true,
+                title: "Channel IDs",
+            },
+            nullable: true,
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "appId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "teamId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "channel", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "user", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "text", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "ts", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "threadTs", jsonSchema: { type: "string" }, nullable: true },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

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

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

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

@@ -0,0 +1,21 @@
+import type { ActionDefinition, JsonSchema } from "../../core/types.ts";
+export interface SurfRoute {
+    path: string;
+    method: string;
+    parameters: Array<{
+        name: string;
+        in: string;
+        field: string;
+    }>;
+    body: boolean;
+}
+export interface SurfActionDefinition {
+    name: string;
+    description: string;
+    operationType: ActionDefinition["operationType"];
+    route: SurfRoute;
+    inputSchema: JsonSchema;
+    outputSchema: JsonSchema;
+}
+export declare const surfRoutes: Record<string, SurfRoute>;
+export declare const surfActions: ActionDefinition[];

package/src/providers/surf/actions.js

@@ -0,0 +1,26 @@
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { discoveryDefinitions } from "./discovery-definitions.js";
+import { equityDefinitions } from "./equity-definitions.js";
+import { marketDefinitions } from "./market-definitions.js";
+import { onchainDefinitions } from "./onchain-definitions.js";
+import { predictionDefinitions } from "./prediction-definitions.js";
+const actionLifecycles = {
+    onchain_sql_job_create: { startActionId: "surf.onchain_sql_job_create", statusActionId: "surf.onchain_sql_job_get" },
+};
+const definitions = [
+    ...marketDefinitions,
+    ...equityDefinitions,
+    ...discoveryDefinitions,
+    ...onchainDefinitions,
+    ...predictionDefinitions,
+];
+export const surfRoutes = Object.fromEntries(definitions.map((definition) => [definition.name, definition.route]));
+export const surfActions = definitions.map((definition) => defineProviderAction("surf", {
+    name: definition.name,
+    description: definition.description,
+    operationType: definition.operationType,
+    requiredScopes: [],
+    inputSchema: definition.inputSchema,
+    outputSchema: definition.outputSchema,
+    asyncLifecycle: actionLifecycles[definition.name],
+}));

package/src/providers/surf/discovery-definitions.d.ts

@@ -0,0 +1,2 @@
+import type { SurfActionDefinition } from "./actions.ts";
+export declare const discoveryDefinitions: SurfActionDefinition[];