@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/typeform/trigger-on-form-response.definition.js

@@ -0,0 +1,40 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const snapshot = {
+    key: "typeform.on_form_response",
+    provider: "typeform",
+    name: "on_form_response",
+    displayName: "Completed Form Response",
+    description: "Receives complete Typeform submissions through an automatically managed signed webhook.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "formId",
+            jsonSchema: { type: "string", minLength: 1, maxLength: 128, title: "Form ID" },
+            nullable: false,
+        },
+    ],
+    outputs: [
+        {
+            handle: "response",
+            nullable: false,
+            jsonSchema: {
+                type: "object",
+                properties: {
+                    eventId: s.string(),
+                    form_id: s.string(),
+                    token: s.string(),
+                    submitted_at: s.string(),
+                    answers: { type: "array", items: { type: "object" } },
+                    definition: { type: "object" },
+                },
+                required: ["eventId", "form_id", "token", "submitted_at", "answers"],
+            },
+        },
+    ],
+};

package/src/providers/typeform/trigger-on-form-response.js

@@ -0,0 +1,68 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { bytes, verifyBase64Hmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-form-response.definition.js";
+export const typeformResponse = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        if (context.state == null)
+            throw new PermanentIntegrationError("Typeform subscription state is missing.");
+        const formId = context.config.formId;
+        if (typeof formId != "string" || !formId)
+            throw new PermanentIntegrationError("Choose a Typeform form.");
+        // A stable tag makes retries update the same webhook after a lost response.
+        const hash = await crypto.subtle.digest("SHA-256", bytes(context.endpointUrl));
+        const tag = `oomol-${Array.from(new Uint8Array(hash), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+        const endpoint = `/forms/${encodeURIComponent(formId)}/webhooks/${tag}`;
+        context.signal?.throwIfAborted();
+        const result = await context.connector.execute({
+            endpoint,
+            method: context.active ? "PUT" : "DELETE",
+            body: context.active
+                ? {
+                    url: context.endpointUrl,
+                    enabled: true,
+                    secret: context.callbackSecret,
+                    event_types: { form_response: true, form_response_partial: false },
+                }
+                : undefined,
+        }, context.signal);
+        context.signal?.throwIfAborted();
+        if (!(result.status >= 200 && result.status < 300) && !(!context.active && result.status == 404)) {
+            const message = `Typeform webhook operation failed (HTTP ${result.status}). Check form access and webhook permissions.`;
+            if (result.status >= 400 && result.status < 500 && result.status != 429)
+                throw new PermanentIntegrationError(message);
+            throw new TransientIntegrationError(message);
+        }
+        await context.state.saveSubscription(context.active ? { tag } : {}, new Date(context.now.getTime() + 24 * 60 * 60 * 1000));
+        return { outcome: "ready" };
+    },
+    async receive(context) {
+        const signature = context.header("typeform-signature");
+        if (!signature?.startsWith("sha256=") ||
+            !(await verifyBase64Hmac(context.callbackSecret, [context.rawBody], signature.slice(7))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) || payload.event_type != "form_response")
+            return { outcome: "ignored", reason: "Only complete form responses are supported." };
+        const response = payload.form_response;
+        if (!isJsonObject(response) || response.form_id != context.config.formId)
+            return { outcome: "ignored", reason: "Typeform form does not match this subscription." };
+        if (typeof payload.event_id != "string" ||
+            !payload.event_id ||
+            typeof response.token != "string" ||
+            !response.token ||
+            typeof response.submitted_at != "string" ||
+            !response.submitted_at ||
+            !Array.isArray(response.answers) ||
+            response.answers.some((answer) => !isJsonObject(answer)) ||
+            ("definition" in response && !isJsonObject(response.definition)))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: response.token,
+            outputs: { response: { ...response, eventId: payload.event_id } },
+        };
+    },
+};

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

@@ -0,0 +1,40 @@
+import { defineProviderExecutors, defineProviderProxy, requireApiKeyCredential } from "../provider-runtime.js";
+import { readUrlhausError } from "./runtime.js";
+import { urlhausActionHandlers, urlhausApiBaseUrl, urlhausValidationPath, validateUrlhausAuthKey } from "./runtime.js";
+const service = "urlhaus";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: urlhausActionHandlers,
+    skipDnsValidation: true,
+    async createContext(context, fetcher) {
+        const credential = await requireApiKeyCredential(context, service);
+        return {
+            apiKey: credential.apiKey,
+            fetcher,
+            signal: context.signal,
+        };
+    },
+});
+export const proxy = defineProviderProxy({
+    readError: readUrlhausError,
+    service,
+    baseUrl: urlhausApiBaseUrl,
+    auth: { type: "api_key_header", name: "Auth-Key" },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await validateUrlhausAuthKey(input.apiKey, fetcher, signal);
+        return {
+            profile: {
+                accountId: "urlhaus-auth-key",
+                displayName: "URLhaus Auth-Key",
+            },
+            grantedScopes: [],
+            metadata: {
+                apiBaseUrl: urlhausApiBaseUrl,
+                validationEndpoint: urlhausValidationPath,
+            },
+        };
+    },
+};

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

@@ -0,0 +1,15 @@
+import type { ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export declare const urlhausApiBaseUrl = "https://urlhaus-api.abuse.ch";
+export declare const urlhausValidationPath = "/v1/urls/recent/limit/1/";
+export interface UrlhausRuntimeContext {
+    apiKey: string;
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}
+type UrlhausActionHandler = (input: Record<string, unknown>, context: UrlhausRuntimeContext) => Promise<unknown>;
+export declare const urlhausActionHandlers: ProviderActionHandlers<"urlhaus", UrlhausActionHandler>;
+/** Lightweight credential check: lists one recent URL; HTTP failures retain their provider error semantics. */
+export declare function validateUrlhausAuthKey(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<void>;
+export declare function readUrlhausError(response: Response): Promise<ProviderRequestError>;
+export {};

package/src/providers/urlhaus/runtime.js

@@ -0,0 +1,142 @@
+import { optionalInteger, optionalObjectArray, optionalRecord, optionalString, optionalStringArray, } from "../../core/cast.js";
+import { parseProviderJsonBodyText, providerInputError, ProviderRequestError, providerUserAgent, readProviderErrorTextBody, readProviderTextBody, requiredInputString, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const urlhausApiBaseUrl = "https://urlhaus-api.abuse.ch";
+export const urlhausValidationPath = "/v1/urls/recent/limit/1/";
+export const urlhausActionHandlers = {
+    async lookup_url(input, context) {
+        const url = lookupUrlParam(input.url);
+        const payload = await requestUrlhaus({ context, url });
+        const record = optionalRecord(payload);
+        const queryStatus = optionalString(record?.query_status) ?? "";
+        if (queryStatus === "no_results") {
+            return { found: false, query_status: queryStatus, entry: undefined };
+        }
+        if (queryStatus === "invalid_url") {
+            throw providerInputError("URLhaus rejected the url as invalid.");
+        }
+        if (queryStatus !== "ok" || !record) {
+            throw new ProviderRequestError(502, `URLhaus returned an unexpected query_status: ${queryStatus || "missing"}`);
+        }
+        return { found: true, query_status: queryStatus, entry: normalizeUrlEntry(record) };
+    },
+};
+/**
+ * The queried value travels to URLhaus as POST data and is never fetched, so
+ * only the scheme and general shape are validated here; URLhaus itself
+ * reports `invalid_url` for anything it cannot parse.
+ */
+function lookupUrlParam(value) {
+    const url = requiredInputString(value, "url").trim();
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw providerInputError("url must be a valid absolute URL, for example https://example.com/payload.exe.");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw providerInputError("url must use the http or https scheme.");
+    }
+    return url;
+}
+async function requestUrlhaus(request) {
+    const endpoint = new URL("/v1/url/", urlhausApiBaseUrl);
+    return runProviderRequest({ label: "URLhaus", signal: request.context.signal }, async (signal) => {
+        const response = await request.context.fetcher(endpoint, {
+            method: "POST",
+            headers: {
+                "Auth-Key": request.context.apiKey,
+                accept: "application/json",
+                // URLhaus expects form-encoded POST data (see urlhaus-api.abuse.ch docs),
+                // not JSON: a JSON body yields HTTP 200 with an empty response.
+                "content-type": "application/x-www-form-urlencoded",
+                "user-agent": providerUserAgent,
+            },
+            body: new URLSearchParams({ url: request.url }).toString(),
+            signal,
+        });
+        if (!response.ok) {
+            throw await readUrlhausError(response);
+        }
+        return parseProviderJsonBodyText(await readProviderTextBody(response, "URLhaus response"), {
+            emptyBody: null,
+            invalidJsonMessage: "URLhaus returned malformed JSON",
+        });
+    });
+}
+/** Lightweight credential check: lists one recent URL; HTTP failures retain their provider error semantics. */
+export async function validateUrlhausAuthKey(apiKey, fetcher, signal) {
+    await runProviderRequest({ label: "URLhaus", signal }, async (requestSignal) => {
+        const response = await fetcher(new URL(urlhausValidationPath, urlhausApiBaseUrl), {
+            headers: {
+                "Auth-Key": apiKey,
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+            },
+            signal: requestSignal,
+        });
+        if (!response.ok) {
+            throw await readUrlhausError(response);
+        }
+        const payload = optionalRecord(parseProviderJsonBodyText(await readProviderTextBody(response, "URLhaus validation response"), {
+            emptyBody: null,
+            invalidJsonMessage: "URLhaus returned malformed JSON",
+        }));
+        if (optionalString(payload?.query_status) !== "ok") {
+            throw new ProviderRequestError(502, "URLhaus validation returned an unexpected response");
+        }
+    });
+}
+function normalizeUrlEntry(record) {
+    const blacklists = optionalRecord(record.blacklists) ?? {};
+    const idValue = record.id;
+    return {
+        ...record,
+        id: typeof idValue === "string" ? idValue : typeof idValue === "number" ? String(idValue) : "",
+        urlhaus_reference: optionalString(record.urlhaus_reference) ?? "",
+        url: optionalString(record.url) ?? "",
+        url_status: optionalString(record.url_status) ?? "",
+        host: optionalString(record.host) ?? "",
+        date_added: optionalString(record.date_added) ?? "",
+        last_online: optionalString(record.last_online) ?? null,
+        threat: optionalString(record.threat) ?? "",
+        blacklists: {
+            ...blacklists,
+            surbl: optionalString(blacklists.surbl) ?? "",
+            spamhaus_dbl: optionalString(blacklists.spamhaus_dbl) ?? "",
+        },
+        reporter: optionalString(record.reporter) ?? "",
+        larted: optionalString(record.larted) ?? "",
+        takedown_time_seconds: optionalInteger(record.takedown_time_seconds) ?? null,
+        tags: optionalStringArray(record.tags) ?? [],
+        payloads: (optionalObjectArray(record.payloads) ?? []).map(normalizePayload),
+    };
+}
+function normalizePayload(item) {
+    return {
+        ...item,
+        firstseen: optionalString(item.firstseen) ?? "",
+        filename: optionalString(item.filename) ?? null,
+        file_type: optionalString(item.file_type) ?? "",
+        response_size: stringifySize(item.response_size),
+        response_md5: optionalString(item.response_md5) ?? "",
+        response_sha256: optionalString(item.response_sha256) ?? "",
+        urlhaus_download: optionalString(item.urlhaus_download) ?? "",
+        signature: optionalString(item.signature) ?? null,
+    };
+}
+/** URLhaus reports the payload size inconsistently as a string or a number. */
+function stringifySize(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return String(Math.trunc(value));
+    }
+    return optionalString(value) ?? "";
+}
+// HTTP status alone cannot distinguish an invalid key from access or subscription restrictions.
+export async function readUrlhausError(response) {
+    const text = (await readProviderErrorTextBody(response, "URLhaus error response")).trim();
+    const message = text.slice(0, 200) || `URLhaus request failed with HTTP ${response.status}`;
+    const status = response.status;
+    const code = status === 429 ? "rate_limited" : "provider_error";
+    return new ProviderRequestError(status, message, withRetryAfterSeconds(response, {}), code);
+}

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

@@ -0,0 +1,13 @@
+import type { ActionDefinition } from "../../core/types.ts";
+interface VaquillOperation {
+    name: string;
+    method: string;
+    path: string;
+    query: string[];
+    pathKeys: string[];
+    action: ActionDefinition;
+}
+declare const vaquillOperations: readonly VaquillOperation[];
+export declare const vaquillActions: ActionDefinition[];
+export declare const vaquillOperationByName: Map<string, (typeof vaquillOperations)[number]>;
+export {};