@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/core/cast.js

@@ -196,9 +196,12 @@ export function optionalNumber(value) {
 /**
  * Return a finite number from a number or numeric string when present. Examples:
  * `optionalNumberLike("1.5") => 1.5`, `optionalNumberLike("x") => undefined`.
+ *
+ * A blank or whitespace-only string is reported as missing rather than parsed, because
+ * `Number(" ")` is `0` and a blank field would otherwise surface as a real zero.
  */
 export function optionalNumberLike(value) {
-    const parsed = typeof value === "number" ? value : typeof value === "string" && value !== "" ? Number(value) : Number.NaN;
+    const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
     return Number.isFinite(parsed) ? parsed : undefined;
 }
 /**
@@ -309,6 +312,20 @@ export function pickOptionalInteger(input, ...keys) {
 export function nullableString(value) {
     return value === null ? null : optionalString(value);
 }
+/**
+ * Return a string exactly as provided, null, or undefined when the value is not a string. Examples:
+ * `nullableRawString(null) => null`, `nullableRawString("") => ""`, `nullableRawString(1) => undefined`.
+ */
+export function nullableRawString(value) {
+    return value === null ? null : optionalRawString(value);
+}
+/**
+ * Return a boolean, null, or undefined when the value is not a boolean. Examples:
+ * `nullableBoolean(null) => null`, `nullableBoolean(false) => false`, `nullableBoolean("true") => undefined`.
+ */
+export function nullableBoolean(value) {
+    return value === null ? null : optionalBoolean(value);
+}
 /**
  * Return a string or null when the value is not a string.
  */

package/src/core/guarded-fetch.d.ts

@@ -24,8 +24,12 @@ export interface GuardedFetchOptions {
      * load are honored.
      */
     allowPrivateNetwork?: boolean | (() => boolean);
+    /** Whether deployment trusted hosts may bypass private DNS answers. Defaults to true. */
+    allowTrustedHosts?: boolean;
     /** Error factory for guard violations. Defaults to TypeError. */
     createError?: (message: string) => Error;
+    /** Error factory for DNS lookup failures. Defaults to createError. */
+    createResolutionError?: (message: string) => Error;
     /** Maximum redirect hops followed before the request fails. */
     maxRedirects?: number;
     /**
@@ -132,12 +136,16 @@ export declare function unwrapGuardedFetch(fetcher: typeof fetch | undefined): t
  *   so this layer applies there too. Only on a runtime without `node:dns` does it
  *   degrade to a no-op, leaving the URL-literal and redirect-`Location` checks.
  *
- * Callers that pass `redirect: "manual"` or `redirect: "error"` keep native
- * semantics: the first response (or native redirect error) is returned after
- * the initial URL and its resolved addresses are validated.
+ * Callers that pass `redirect: "manual"` keep native semantics: the first
+ * response, including an unfollowed 3xx, is returned after the initial URL and
+ * its resolved addresses are validated, so the caller's `!response.ok` check
+ * rejects a redirect. Use "manual" rather than `redirect: "error"` to refuse
+ * redirects: Cloudflare Workers does not implement "error" and throws
+ * `TypeError: Invalid redirect value` before sending the request.
  */
 export declare function createGuardedFetch(options?: GuardedFetchOptions): typeof fetch;
 export interface GuardedEgressUrlOptions {
+    allowTrustedHosts?: boolean;
     /** Field name used in guard violation messages, e.g. `"request URL"`. */
     fieldName: string;
     /** Error factory for guard violations. */

package/src/core/guarded-fetch.js

@@ -125,9 +125,12 @@ export function unwrapGuardedFetch(fetcher) {
  *   so this layer applies there too. Only on a runtime without `node:dns` does it
  *   degrade to a no-op, leaving the URL-literal and redirect-`Location` checks.
  *
- * Callers that pass `redirect: "manual"` or `redirect: "error"` keep native
- * semantics: the first response (or native redirect error) is returned after
- * the initial URL and its resolved addresses are validated.
+ * Callers that pass `redirect: "manual"` keep native semantics: the first
+ * response, including an unfollowed 3xx, is returned after the initial URL and
+ * its resolved addresses are validated, so the caller's `!response.ok` check
+ * rejects a redirect. Use "manual" rather than `redirect: "error"` to refuse
+ * redirects: Cloudflare Workers does not implement "error" and throws
+ * `TypeError: Invalid redirect value` before sending the request.
  */
 export function createGuardedFetch(options = {}) {
     const baseFetch = unwrapGuardedFetch(options.fetch);
@@ -151,7 +154,14 @@ export function createGuardedFetch(options = {}) {
             : options.lookup === undefined
                 ? await resolveDefaultLookup()
                 : options.lookup;
-        const guardHop = (value, fieldName) => assertGuardedEgressUrl(value, { fieldName, createError, allowPrivateNetwork, lookup });
+        const guardHop = (value, fieldName) => assertGuardedEgressUrl(value, {
+            fieldName,
+            createError,
+            allowPrivateNetwork,
+            lookup,
+            allowTrustedHosts: options.allowTrustedHosts,
+            createResolutionError: options.createResolutionError,
+        });
         const request = input instanceof Request ? input : undefined;
         let url = await guardHop(request?.url ?? (input instanceof URL ? input.href : String(input)), "request URL");
         const redirectMode = init?.redirect ?? request?.redirect ?? "follow";
@@ -252,6 +262,7 @@ export async function resolveGuardedEgressTarget(value, options) {
         createError: options.createError,
         createResolutionError: options.createResolutionError ?? options.createError,
         lookup,
+        allowTrustedHosts: options.allowTrustedHosts !== false,
     });
     return { url, addresses };
 }
@@ -286,7 +297,7 @@ async function assertResolvedAddressesAllowed(hostname, fieldName, policy) {
     // Deployment-level trusted-host setting, resolved per request so a bootstrap that
     // configures it after module load is honored. It may open private and
     // VPN-mapped results, while unsafe special-use targets remain blocked.
-    const trustedHost = isEgressTrustedHost(hostname);
+    const trustedHost = policy.allowTrustedHosts && isEgressTrustedHost(hostname);
     for (const entry of results) {
         if (entry && typeof entry.address === "string") {
             const addressClass = classifyIpAddress(entry.address);
@@ -308,8 +319,9 @@ async function assertResolvedAddressesAllowed(hostname, fieldName, policy) {
             // would turn the guard into a DNS/internal-range probe oracle, a property
             // src/mail/imap-smtp/host-pinning.test.ts asserts.
             throw policy.createError(`${fieldName} must not resolve to private or reserved IP addresses ` +
-                `(if this host is reached through a corporate VPN or split DNS, add it to ` +
-                `OOMOL_CONNECT_EGRESS_TRUSTED_HOSTS)`);
+                (policy.allowTrustedHosts
+                    ? `(if this host is reached through a corporate VPN or split DNS, add it to OOMOL_CONNECT_EGRESS_TRUSTED_HOSTS)`
+                    : `(check proxy Fake-IP and DNS settings; this request requires a public address)`));
         }
     }
     return results;

package/src/core/provider-scenarios.js

@@ -16,15 +16,26 @@ const scenarioByService = new Map([
     ["aliyunoss", "data-storage"],
     ["amap", "productivity"],
     ["aivoov", "ai"],
+    ["aifinmarket", "investment"],
+    ["alpaca", "investment"],
+    ["alphavantage", "investment"],
     ["anthropic", "ai"],
     ["apininjas", "developer"],
     ["awss3", "data-storage"],
     ["asindataapi", "cross-border-ecommerce"],
     ["baselinker", "cross-border-ecommerce"],
+    ["beaconchain", "investment"],
+    ["benzinga", "investment"],
     ["bigcommerce", "cross-border-ecommerce"],
     ["captainbi", "cross-border-ecommerce"],
     ["cin7core", "cross-border-ecommerce"],
     ["circleci", "developer"],
+    ["coinbase", "investment"],
+    ["coingecko", "investment"],
+    ["coinmarketcal", "investment"],
+    ["coinmarketcap", "investment"],
+    ["coinranking", "investment"],
+    ["cryptoapis", "investment"],
     ["clickup", "productivity"],
     ["cloudflaredns", "developer"],
     ["cloudflarer2", "data-storage"],
@@ -39,15 +50,22 @@ const scenarioByService = new Map([
     ["dockerhub", "developer"],
     ["elevenlabs", "ai"],
     ["easypost", "cross-border-ecommerce"],
+    ["eodhdapis", "investment"],
     ["exa", "ai"],
     ["falai", "ai"],
     ["feishu", "communication"],
     ["feishuappbot", "communication"],
     ["feishucustombot", "communication"],
     ["figma", "productivity"],
+    ["finage", "investment"],
+    ["finchina", "investment"],
+    ["financialmodelingprep", "investment"],
     ["firecrawl", "developer"],
+    ["futunn", "investment"],
+    ["gangtise", "investment"],
     ["gemini", "ai"],
     ["giphy", "marketing"],
+    ["gildata", "investment"],
     ["github", "developer"],
     ["gitlab", "developer"],
     ["gmail", "communication"],
@@ -55,18 +73,29 @@ const scenarioByService = new Map([
     ["googlebigquery", "data-storage"],
     ["googlecalendar", "productivity"],
     ["googleforms", "productivity"],
-    ["googlephotos", "docs"],
+    ["googlephotos", "communication"],
     ["googlesearchconsole", "marketing"],
     ["googlesheets", "productivity"],
     ["googletasks", "productivity"],
     ["hubspot", "marketing"],
     ["helium10", "cross-border-ecommerce"],
+    ["hithinkfinance", "investment"],
+    ["investodaymcp", "investment"],
+    ["intrinio", "investment"],
+    ["jin10", "investment"],
     ["jumpseller", "cross-border-ecommerce"],
     ["linkfox", "cross-border-ecommerce"],
     ["lingxingmcp", "cross-border-ecommerce"],
+    ["longbridge", "investment"],
+    ["luno", "investment"],
     ["mailchimp", "marketing"],
     ["mailgun", "communication"],
+    ["marketstack", "investment"],
+    ["metatraderapi", "investment"],
     ["monday", "productivity"],
+    ["nasdaq", "investment"],
+    ["polygonio", "investment"],
+    ["quantdata", "investment"],
     ["openai", "ai"],
     ["outlook", "communication"],
     ["perplexity", "ai"],
@@ -80,7 +109,11 @@ const scenarioByService = new Map([
     ["storecensus", "cross-border-ecommerce"],
     ["storeleads", "cross-border-ecommerce"],
     ["telegram", "communication"],
+    ["tokenmetrics", "investment"],
+    ["tongdaxin", "investment"],
     ["trello", "productivity"],
+    ["tushare", "investment"],
+    ["twelvedata", "investment"],
     ["twilio", "communication"],
     ["triplewhale", "cross-border-ecommerce"],
     ["vercel", "developer"],
@@ -93,26 +126,32 @@ const scenarioByService = new Map([
     ["shippo", "cross-border-ecommerce"],
     ["shipstation", "cross-border-ecommerce"],
     ["vtex", "cross-border-ecommerce"],
+    ["uniswapapi", "investment"],
+    ["yingmimcp", "investment"],
     ["woocommerce", "cross-border-ecommerce"],
-    ["box", "docs"],
-    ["confluence", "docs"],
-    ["crowdin", "docs"],
-    ["docparser", "docs"],
-    ["dropbox", "docs"],
-    ["googledocs", "docs"],
-    ["googledrive", "docs"],
-    ["googleslides", "docs"],
-    ["notion", "docs"],
-    ["onlyofficedocspace", "docs"],
+    ["box", "communication"],
+    ["confluence", "communication"],
+    ["crowdin", "communication"],
+    ["docparser", "communication"],
+    ["dropbox", "communication"],
+    ["googledocs", "communication"],
+    ["googledrive", "communication"],
+    ["googleslides", "communication"],
+    ["notion", "communication"],
+    ["onlyofficedocspace", "communication"],
 ]);
 const scenarioByCategory = new Map([
     ["ai", "ai"],
     ["communication", "communication"],
+    ["collaboration", "communication"],
     ["data", "data-storage"],
     ["dataanalytics", "data-storage"],
     ["developertools", "developer"],
+    ["docs", "communication"],
+    ["documents", "communication"],
     ["infrastructure", "developer"],
     ["marketing", "marketing"],
+    ["knowledge", "communication"],
     ["productivity", "productivity"],
     ["security", "developer"],
     ["social", "marketing"],
@@ -121,8 +160,23 @@ const scenarioByCategory = new Map([
 const scenarioKeywords = [
     ["ai", ["agent", "ai", "embedding", "llm", "model", "prompt", "transcrib", "vector"]],
     ["cross-border-ecommerce", ["ecommerce", "marketplace", "order fulfillment", "seller", "storefront"]],
-    ["communication", ["chat", "email", "inbox", "messaging", "notification", "sms", "video meeting"]],
-    ["docs", ["document", "knowledge base", "wiki"]],
+    ["investment", ["brokerage", "crypto", "investment", "market data", "portfolio", "stock market", "trading"]],
+    [
+        "communication",
+        [
+            "chat",
+            "document",
+            "drive",
+            "email",
+            "inbox",
+            "knowledge base",
+            "messaging",
+            "notification",
+            "sms",
+            "video meeting",
+            "wiki",
+        ],
+    ],
     ["productivity", ["calendar", "project management", "schedule", "task management", "todo"]],
     ["marketing", ["advertising", "analytics", "crm", "lead generation", "marketing", "seo"]],
     ["data-storage", ["database", "data warehouse", "object storage", "search index"]],

package/src/core/remote-http.d.ts

@@ -0,0 +1,33 @@
+export type RemoteHttpFailure = "invalid_url" | "dns" | "redirect" | "network" | "invalid_json" | "too_large";
+export declare class RemoteHttpError extends Error {
+    readonly kind: RemoteHttpFailure;
+    constructor(kind: RemoteHttpFailure, message: string);
+}
+export interface RemoteHttpOptions {
+    url: string | URL;
+    label: string;
+    init?: RequestInit;
+    timeoutMs?: number;
+    fetcher?: typeof fetch;
+    requireHttps?: boolean;
+    allowTrustedHosts?: boolean;
+}
+export interface RemoteJsonOptions {
+    label: string;
+    maxBytes: number;
+    signal?: AbortSignal;
+}
+/** Keep the request budget active through response consumption; never follow redirects with a service key. */
+export declare function requestRemote<T>(options: RemoteHttpOptions, consume: (response: Response, signal: AbortSignal | undefined) => Promise<T>): Promise<T>;
+/** Limits decoded transport bytes, including chunked and error responses, without exposing raw JSON errors. */
+export declare function readRemoteJson(response: Response, options: RemoteJsonOptions): Promise<unknown>;
+export declare function isSuccessEnvelope(value: unknown): value is {
+    success: true;
+    data: unknown;
+};
+export declare function isFailureEnvelope(value: unknown): value is {
+    success: false;
+    message: string;
+    errorCode: string;
+    data: unknown;
+};

package/src/core/remote-http.js

@@ -0,0 +1,104 @@
+import { isAbortLikeError } from "../providers/provider-runtime.js";
+import { optionalRecord } from "./cast.js";
+import { createGuardedFetch } from "./guarded-fetch.js";
+import { assertPublicHttpUrl, readBoundedResponseBytes } from "./request.js";
+export class RemoteHttpError extends Error {
+    kind;
+    constructor(kind, message) {
+        super(message);
+        this.kind = kind;
+    }
+}
+/** Keep the request budget active through response consumption; never follow redirects with a service key. */
+export async function requestRemote(options, consume) {
+    const url = assertPublicHttpUrl(String(options.url), {
+        fieldName: `${options.label} URL`,
+        createError: (message) => new RemoteHttpError("invalid_url", message),
+    });
+    if (options.requireHttps !== false && url.protocol !== "https:") {
+        throw new RemoteHttpError("invalid_url", `${options.label} requires HTTPS.`);
+    }
+    if (url.username || url.password || url.hash) {
+        throw new RemoteHttpError("invalid_url", `${options.label} does not allow URL credentials or fragments.`);
+    }
+    const signals = [
+        options.init?.signal,
+        options.timeoutMs === undefined ? undefined : AbortSignal.timeout(options.timeoutMs),
+    ].filter((signal) => signal != null);
+    const signal = signals.length ? AbortSignal.any(signals) : undefined;
+    signal?.throwIfAborted();
+    const guardOptions = {
+        fetch: options.fetcher,
+        allowTrustedHosts: options.allowTrustedHosts ?? false,
+        createError: (message) => new RemoteHttpError("invalid_url", message),
+        createResolutionError: (message) => new RemoteHttpError("dns", message),
+    };
+    const run = async () => {
+        let response;
+        try {
+            response = await createGuardedFetch(guardOptions)(url, { ...options.init, redirect: "manual", signal });
+        }
+        catch (error) {
+            signal?.throwIfAborted();
+            if (error instanceof RemoteHttpError || isAbortLikeError(error))
+                throw error;
+            throw new RemoteHttpError("network", `${options.label} request failed.`);
+        }
+        try {
+            signal?.throwIfAborted();
+            if (response.status >= 300 && response.status < 400) {
+                throw new RemoteHttpError("redirect", `${options.label} redirects are not allowed.`);
+            }
+            return await consume(response, signal);
+        }
+        finally {
+            if (!response.bodyUsed)
+                void response.body?.cancel().catch(() => undefined);
+        }
+    };
+    if (!signal)
+        return run();
+    let abort = () => undefined;
+    const aborted = new Promise((_resolve, reject) => {
+        abort = () => reject(signal.reason);
+        signal.addEventListener("abort", abort, { once: true });
+    });
+    try {
+        return await Promise.race([run(), aborted]);
+    }
+    finally {
+        signal.removeEventListener("abort", abort);
+    }
+}
+/** Limits decoded transport bytes, including chunked and error responses, without exposing raw JSON errors. */
+export async function readRemoteJson(response, options) {
+    let bytes;
+    try {
+        bytes = await readBoundedResponseBytes(response, {
+            maxBytes: options.maxBytes,
+            fieldName: options.label,
+            signal: options.signal,
+            createError: (message) => new RemoteHttpError("too_large", message),
+        });
+    }
+    catch (error) {
+        options.signal?.throwIfAborted();
+        if (error instanceof RemoteHttpError || isAbortLikeError(error))
+            throw error;
+        throw new RemoteHttpError("network", `${options.label} could not be read.`);
+    }
+    try {
+        return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw new RemoteHttpError("invalid_json", `${options.label} is not valid JSON.`);
+    }
+}
+export function isSuccessEnvelope(value) {
+    const record = optionalRecord(value);
+    return record?.success === true && "data" in record;
+}
+export function isFailureEnvelope(value) {
+    const record = optionalRecord(value);
+    return record?.success === false && typeof record.message === "string" && typeof record.errorCode === "string";
+}

package/src/core/request.d.ts

@@ -31,6 +31,7 @@ export interface BoundedResponseBytesOptions {
     maxBytes: number;
     fieldName: string;
     createError: (message: string) => Error;
+    signal?: AbortSignal;
 }
 /**
  * Read a response body into memory while enforcing a byte limit.

package/src/core/request.js

@@ -58,8 +58,12 @@ export function compactJson(value) {
  * Read a response body into memory while enforcing a byte limit.
  */
 export async function readBoundedResponseBytes(response, options) {
+    options.signal?.throwIfAborted();
     const contentLength = parseContentLength(response.headers.get("content-length"));
     if (contentLength !== undefined) {
+        if (contentLength > options.maxBytes) {
+            void response.body?.cancel().catch(() => undefined);
+        }
         assertMaxBytes(contentLength, options);
     }
     if (!response.body) {
@@ -68,23 +72,29 @@ export async function readBoundedResponseBytes(response, options) {
         return bytes;
     }
     const reader = response.body.getReader();
+    const abort = () => {
+        void reader.cancel().catch(() => undefined);
+    };
+    options.signal?.addEventListener("abort", abort, { once: true });
     const chunks = [];
     let totalBytes = 0;
     try {
         while (true) {
             const { done, value } = await reader.read();
+            options.signal?.throwIfAborted();
             if (done) {
                 break;
             }
             totalBytes += value.byteLength;
             if (totalBytes > options.maxBytes) {
-                await reader.cancel().catch(() => undefined);
+                void reader.cancel().catch(() => undefined);
                 throw options.createError(`${options.fieldName} exceeds ${options.maxBytes} bytes`);
             }
             chunks.push(value);
         }
     }
     finally {
+        options.signal?.removeEventListener("abort", abort);
         reader.releaseLock();
     }
     const bytes = new Uint8Array(totalBytes);

package/src/core/types.d.ts

@@ -1,3 +1,5 @@
+import type { TriggerKeySnapshot } from "../triggers/common/types.ts";
+import type { TriggerPermission } from "../triggers/metadata.ts";
 /**
  * JSON Schema object used for action input and output contracts.
  *
@@ -17,7 +19,7 @@ export type AuthType = "no_auth" | "api_key" | "custom_credential" | "oauth2";
  * Provider definitions do not need to repeat this field: the catalog builder
  * adds it to runtime entries through the shared scenario resolver.
  */
-export type ProviderScenario = "ai" | "cross-border-ecommerce" | "communication" | "docs" | "productivity" | "marketing" | "data-storage" | "developer" | "other";
+export type ProviderScenario = "ai" | "cross-border-ecommerce" | "investment" | "communication" | "productivity" | "marketing" | "data-storage" | "developer" | "other";
 /**
  * A single credential field that users can configure for a provider.
  */
@@ -248,6 +250,8 @@ export type ProviderDefinition = {
     iconUrl?: string;
     /** Public action catalog for this provider. */
     actions: readonly ActionDefinition[];
+    triggers?: readonly TriggerKeySnapshot[];
+    triggerPermissions?: readonly TriggerPermission[];
 };
 /**
  * A credential resolved for action execution.

package/src/marketplace/marketplace-service.d.ts

@@ -85,5 +85,4 @@ export declare class MarketplaceService {
     private discover;
     private validateApiKey;
     private ensureProviderPreferences;
-    private fetch;
 }