@oomol-lab/open-connector 1.6.2 → 1.6.4

package/src/providers/walletap/runtime.js

@@ -0,0 +1,147 @@
+import { compactObject, optionalInteger, optionalString } from "../../core/cast.js";
+import { readProviderTextBody } from "../provider-runtime.js";
+import { providerInputError, providerUserAgent, ProviderRequestError, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
+export const walletapApiBaseUrl = "https://api.walletap.io";
+export const walletapActionHandlers = {
+    list_templates(input, context) {
+        return requestWalletapData({
+            apiKey: context.apiKey,
+            path: "/api/templates",
+            query: { limit: optionalInteger(input.limit), starting_after: optionalString(input.startingAfter) },
+            fetcher: context.fetcher,
+            signal: context.signal,
+        });
+    },
+    get_template(input, context) {
+        return requestWalletapData({
+            apiKey: context.apiKey,
+            path: `/api/templates/${encodeURIComponent(requiredInputString(input.templateId, "templateId"))}`,
+            fetcher: context.fetcher,
+            signal: context.signal,
+        });
+    },
+    list_passes(input, context) {
+        return requestWalletapData({
+            apiKey: context.apiKey,
+            path: "/api/passes",
+            query: {
+                templateId: requiredInputString(input.templateId, "templateId"),
+                limit: optionalInteger(input.limit),
+                startAfter: optionalString(input.startAfter),
+                endBefore: optionalString(input.endBefore),
+                status: optionalString(input.status),
+            },
+            fetcher: context.fetcher,
+            signal: context.signal,
+        });
+    },
+    search_passes(input, context) {
+        return requestWalletapData({
+            apiKey: context.apiKey,
+            path: "/api/passes/search",
+            query: {
+                templateId: requiredInputString(input.templateId, "templateId"),
+                searchQuery: requiredInputString(input.searchQuery, "searchQuery"),
+            },
+            fetcher: context.fetcher,
+            signal: context.signal,
+        });
+    },
+    get_pass(input, context) {
+        requirePassIdentifier(input);
+        return requestWalletapData({
+            apiKey: context.apiKey,
+            path: "/api/pass",
+            query: compactObject({
+                id: optionalString(input.id),
+                externalId: optionalString(input.externalId),
+                templateId: optionalString(input.templateId),
+                includeTemplate: typeof input.includeTemplate === "boolean" ? input.includeTemplate : undefined,
+                locale: optionalString(input.locale),
+            }),
+            fetcher: context.fetcher,
+            signal: context.signal,
+        });
+    },
+    create_pass(input, context) {
+        return requestWalletapData({
+            apiKey: context.apiKey,
+            method: "POST",
+            path: "/api/pass",
+            body: input,
+            fetcher: context.fetcher,
+            signal: context.signal,
+        });
+    },
+    update_pass(input, context) {
+        requirePassIdentifier(input);
+        return requestWalletapData({
+            apiKey: context.apiKey,
+            method: "PATCH",
+            path: "/api/pass",
+            body: input,
+            fetcher: context.fetcher,
+            signal: context.signal,
+        });
+    },
+    notify_pass(input, context) {
+        const passId = requiredInputString(input.passId, "passId");
+        const { passId: _, ...body } = input;
+        return requestWalletapData({
+            apiKey: context.apiKey,
+            method: "POST",
+            path: `/api/pass/${encodeURIComponent(passId)}/notify`,
+            body,
+            fetcher: context.fetcher,
+            signal: context.signal,
+        });
+    },
+};
+export async function validateWalletapCredential(apiKey, fetcher, signal) {
+    await requestWalletapData({ apiKey, path: "/api/templates", query: { limit: 1 }, fetcher, signal });
+    return { profile: { accountId: "walletap", displayName: "Walletap API Key" }, grantedScopes: [], metadata: {} };
+}
+function requirePassIdentifier(input) {
+    if (optionalString(input.id) || (optionalString(input.externalId) && optionalString(input.templateId)))
+        return;
+    throw providerInputError("id or externalId together with templateId is required");
+}
+async function requestWalletapData(input) {
+    return runProviderRequest({ label: "Walletap", signal: input.signal }, async (signal) => {
+        const url = new URL(input.path, walletapApiBaseUrl);
+        for (const [key, value] of Object.entries(input.query ?? {}))
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        const response = await input.fetcher(url, {
+            method: input.method ?? "GET",
+            headers: {
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+                "x-api-key": input.apiKey,
+            },
+            body: input.body === undefined ? undefined : JSON.stringify(input.body),
+            signal,
+        });
+        const payload = parseWalletapPayload(await readProviderTextBody(response, "Walletap response"));
+        if (!response.ok)
+            throw new ProviderRequestError(response.status, readWalletapError(payload) ?? `Walletap request failed with HTTP ${response.status}`, payload);
+        return { data: payload };
+    });
+}
+function parseWalletapPayload(text) {
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new ProviderRequestError(502, "Walletap returned an invalid JSON response");
+    }
+}
+function readWalletapError(payload) {
+    if (typeof payload !== "object" || payload === null)
+        return undefined;
+    const record = payload;
+    return optionalString(record.error) ?? optionalString(record.message);
+}

package/src/providers/weixin_official_account/access-token.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { optionalInteger, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
 import { ProviderRequestError, providerResponseError, providerUserAgent, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
 const wechatStableTokenUrl = "https://api.weixin.qq.com/cgi-bin/stable_token";
@@ -6,6 +7,10 @@ const accessTokenRefreshSkewMs = 120_000;
 const ipWhitelistHint = "Add this runtime's public egress IP to the official account's API IP whitelist in the 微信开发者平台 console (公众号 → 基础信息 → 开发密钥 → API IP白名单) and try again.";
 const accessTokenCache = new Map();
 const accessTokenInFlight = new Map();
+const accessTokenRefreshInFlight = new Map();
+function accessTokenCacheKey(credential) {
+    return createHash("sha256").update(credential.appId).update("\0").update(credential.appSecret).digest("hex");
+}
 export function readWechatOfficialAccountCredential(values) {
     return {
         appId: requiredInputString(values.appId, "appId"),
@@ -20,18 +25,37 @@ export function readWechatOfficialAccountCredential(values) {
  * one invalidates the previous token, so duplicate mints must not happen.
  */
 export async function getWechatAccessToken(input) {
-    const cacheKey = `${input.credential.appId}\0${input.credential.appSecret}`;
+    const cacheKey = accessTokenCacheKey(input.credential);
+    const refreshPending = accessTokenRefreshInFlight.get(cacheKey);
+    if (refreshPending)
+        return refreshPending;
     const pending = accessTokenInFlight.get(cacheKey);
-    if (pending) {
-        return pending;
+    if (!input.forceRefresh) {
+        if (pending)
+            return pending;
+        const request = mintAndCacheAccessToken(input, cacheKey);
+        accessTokenInFlight.set(cacheKey, request);
+        try {
+            return await request;
+        }
+        finally {
+            if (accessTokenInFlight.get(cacheKey) === request)
+                accessTokenInFlight.delete(cacheKey);
+        }
     }
-    const request = mintAndCacheAccessToken(input, cacheKey);
-    accessTokenInFlight.set(cacheKey, request);
+    const refresh = (async () => {
+        if (pending)
+            await pending.catch(() => undefined);
+        return mintAndCacheAccessToken(input, cacheKey);
+    })();
+    accessTokenRefreshInFlight.set(cacheKey, refresh);
     try {
-        return await request;
+        return await refresh;
     }
     finally {
-        accessTokenInFlight.delete(cacheKey);
+        if (accessTokenRefreshInFlight.get(cacheKey) === refresh) {
+            accessTokenRefreshInFlight.delete(cacheKey);
+        }
     }
 }
 async function mintAndCacheAccessToken(input, cacheKey) {

package/src/providers/weixin_store/access-token.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { optionalInteger, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
 import { ProviderRequestError, providerResponseError, providerUserAgent, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
 const wechatStableTokenUrl = "https://api.weixin.qq.com/cgi-bin/stable_token";
@@ -5,6 +6,7 @@ const defaultAccessTokenTtlSeconds = 7200;
 const accessTokenRefreshSkewMs = 120_000;
 const accessTokenCache = new Map();
 const accessTokenInFlight = new Map();
+const accessTokenRefreshInFlight = new Map();
 export function readWeixinStoreCredential(values) {
     return {
         appId: requiredInputString(values.appId, "appId"),
@@ -24,18 +26,42 @@ export function readWeixinStoreCredential(values) {
  * follow-up request; the shared mint still runs under the default 30 s timeout.
  */
 export async function getWechatAccessToken(input) {
-    const cacheKey = `${input.credential.appId}\0${input.credential.appSecret}`;
+    const cacheKey = createHash("sha256")
+        .update(input.credential.appId)
+        .update("\0")
+        .update(input.credential.appSecret)
+        .digest("hex");
+    const refreshPending = accessTokenRefreshInFlight.get(cacheKey);
+    if (refreshPending)
+        return refreshPending;
     const pending = accessTokenInFlight.get(cacheKey);
-    if (pending) {
-        return pending;
+    if (input.rejectedToken === undefined) {
+        if (pending)
+            return pending;
+        const request = mintAndCacheAccessToken(input, cacheKey);
+        accessTokenInFlight.set(cacheKey, request);
+        try {
+            return await request;
+        }
+        finally {
+            if (accessTokenInFlight.get(cacheKey) === request)
+                accessTokenInFlight.delete(cacheKey);
+        }
     }
-    const request = mintAndCacheAccessToken(input, cacheKey);
-    accessTokenInFlight.set(cacheKey, request);
+    const refresh = (async () => {
+        const pendingToken = pending ? await pending.catch(() => undefined) : undefined;
+        if (pendingToken !== undefined && pendingToken !== input.rejectedToken)
+            return pendingToken;
+        return mintAndCacheAccessToken(input, cacheKey);
+    })();
+    accessTokenRefreshInFlight.set(cacheKey, refresh);
     try {
-        return await request;
+        return await refresh;
     }
     finally {
-        accessTokenInFlight.delete(cacheKey);
+        if (accessTokenRefreshInFlight.get(cacheKey) === refresh) {
+            accessTokenRefreshInFlight.delete(cacheKey);
+        }
     }
 }
 async function mintAndCacheAccessToken(input, cacheKey) {

package/src/providers/xiaohongshu_store/executors.js

@@ -36,6 +36,15 @@ const actionMethodByName = {
     list_categories: "common.getCategories",
     get_category_attributes: "common.getAttributeLists",
     list_express_companies: "common.getExpressCompanyList",
+    list_item_skus: "product.getDetailSkuList",
+    create_item: "product.createItemAndSku",
+    update_item: "product.updateItemAndSku",
+    upload_material: "material.uploadMaterial",
+    list_materials: "material.queryMaterial",
+    search_brands: "common.brandSearch",
+    list_carriage_templates: "common.getCarriageTemplateList",
+    list_logistics_plans: "common.getLogisticsList",
+    list_address_records: "common.getAddressRecord",
 };
 const handlers = mapProviderActionSources("xiaohongshu_store", actionMethodByName, (actionName, method) => async (input, context) => {
     const data = await requestXiaohongshuStore({
@@ -147,9 +156,14 @@ async function requestXiaohongshuStore(input) {
 function isXiaohongshuStoreSuccess(payload) {
     if (payload.success === false)
         return false;
-    if (payload.success === true)
-        return true;
-    return (optionalInteger(payload.error_code) ?? optionalInteger(payload.errorCode)) === 0;
+    const errorCode = optionalInteger(payload.error_code) ?? optionalInteger(payload.errorCode);
+    // The item publish APIs report some business rejections as { success: true, error_code: 50209,
+    // error_msg: "..." } with no data; without this check the message would be lost behind a generic
+    // "invalid item" response error.
+    if (payload.success === true) {
+        return payload.data != null || errorCode === undefined || errorCode === 0;
+    }
+    return errorCode === 0;
 }
 // The newer after-sale APIs wrap their payload in a second { code, msg, success, data }
 // envelope inside the standard one; both layers have to succeed.
@@ -383,6 +397,61 @@ function buildActionParameters(actionName, input) {
         }
         case "adjust_sku_stock":
             return { skuId: requiredInputString(input.skuId, "skuId"), qty: integer(input.qty, "qty", providerInputError) };
+        case "list_item_skus":
+            return compactObject({
+                id: optionalString(input.id),
+                createTimeFrom: optionalInteger(input.createTimeFrom),
+                createTimeTo: optionalInteger(input.createTimeTo),
+                updateTimeFrom: optionalInteger(input.updateTimeFrom),
+                updateTimeTo: optionalInteger(input.updateTimeTo),
+                buyable: optionalBoolean(input.buyable),
+                stockGte: optionalInteger(input.stockGte),
+                stockLte: optionalInteger(input.stockLte),
+                barcode: optionalString(input.barcode),
+                scSkucode: optionalString(input.scSkucode),
+                singlePackOnly: optionalBoolean(input.singlePackOnly),
+                lastId: optionalString(input.lastId),
+                isChannel: optionalBoolean(input.isChannel),
+                pageNo: optionalInteger(input.pageNo) ?? 1,
+                pageSize: optionalInteger(input.pageSize) ?? 50,
+            });
+        case "create_item":
+            return buildItemParameters(input, false);
+        case "update_item":
+            return buildItemParameters(input, true);
+        case "upload_material":
+            return {
+                name: requiredInputString(input.name, "name"),
+                type: requiredInputString(input.type, "type"),
+                materialContent: requiredInputString(input.contentBase64, "contentBase64"),
+            };
+        case "list_materials":
+            return compactObject({
+                materialId: optionalString(input.materialId),
+                name: optionalString(input.name),
+                type: optionalString(input.type),
+                status: optionalInteger(input.status),
+                createTimeFrom: optionalInteger(input.createTimeFrom),
+                createTimeTo: optionalInteger(input.createTimeTo),
+                ascByCreateTime: optionalBoolean(input.ascByCreateTime),
+                pageNo: optionalInteger(input.pageNo) ?? 1,
+                pageSize: optionalInteger(input.pageSize) ?? 50,
+            });
+        case "search_brands":
+            return {
+                categoryId: requiredInputString(input.categoryId, "categoryId"),
+                keyword: optionalString(input.keyword),
+                pageNo: optionalInteger(input.pageNo) ?? 1,
+                pageSize: optionalInteger(input.pageSize) ?? 20,
+            };
+        case "list_carriage_templates":
+        case "list_address_records":
+            return {
+                pageIndex: optionalInteger(input.pageIndex) ?? 1,
+                pageSize: optionalInteger(input.pageSize) ?? 20,
+            };
+        case "list_logistics_plans":
+            return {};
         case "list_categories":
             return compactObject({ categoryId: optionalString(input.categoryId) });
         case "get_category_attributes":
@@ -488,6 +557,50 @@ function normalizeActionOutput(actionName, data) {
             if (!record)
                 throw providerResponseError("Xiaohongshu returned an invalid SKU stock result");
             return { stock: record };
+        case "list_item_skus":
+            if (!record)
+                throw providerResponseError("Xiaohongshu returned an invalid item SKU list");
+            return {
+                items: requireArray(record.data, "item SKU list"),
+                total: requireNonNegativeInteger(record.total, "item total"),
+                pageNo: optionalInteger(record.pageNO) ?? 1,
+                pageSize: optionalInteger(record.pageSize) ?? 50,
+            };
+        case "create_item":
+        case "update_item":
+            if (!record)
+                throw providerResponseError("Xiaohongshu returned an invalid item");
+            return { item: record };
+        case "upload_material":
+            if (!record)
+                throw providerResponseError("Xiaohongshu returned an invalid material");
+            return { material: record };
+        case "list_materials":
+            if (!record)
+                throw providerResponseError("Xiaohongshu returned an invalid material list");
+            return { materials: requireArray(record.materialDetailList, "material list") };
+        case "search_brands":
+            if (!record)
+                throw providerResponseError("Xiaohongshu returned an invalid brand list");
+            return { brands: requireArray(record.brands, "brand list") };
+        case "list_carriage_templates":
+            if (!record)
+                throw providerResponseError("Xiaohongshu returned an invalid carriage template list");
+            return {
+                templates: requireArray(record.carriageTemplateList, "carriage template list"),
+                total: requireNonNegativeInteger(record.totalCount, "carriage template total"),
+            };
+        case "list_logistics_plans":
+            if (!record)
+                throw providerResponseError("Xiaohongshu returned an invalid logistics plan list");
+            return { plans: requireArray(record.logisticsPlans, "logistics plan list") };
+        case "list_address_records":
+            if (!record)
+                throw providerResponseError("Xiaohongshu returned an invalid address record list");
+            return {
+                addresses: requireArray(record.sellerAddressRecordList, "address record list"),
+                total: requireNonNegativeInteger(record.total, "address record total"),
+            };
         case "list_categories":
             if (!record)
                 throw providerResponseError("Xiaohongshu returned an invalid category list");
@@ -510,6 +623,42 @@ function normalizeActionOutput(actionName, data) {
             return { success: true };
     }
 }
+function buildItemParameters(input, update) {
+    const images = looseArray(input.images);
+    if (images.length === 0) {
+        throw providerInputError("images must be a non-empty array");
+    }
+    const skuListField = update ? "updateSkuList" : "createSkuList";
+    const skuList = looseArray(input[skuListField]);
+    if (skuList.length === 0) {
+        throw providerInputError(`${skuListField} must be a non-empty array`);
+    }
+    return compactObject({
+        itemId: update ? requiredInputString(input.itemId, "itemId") : undefined,
+        name: requiredInputString(input.name, "name"),
+        categoryId: requiredInputString(input.categoryId, "categoryId"),
+        shippingTemplateId: requiredInputString(input.shippingTemplateId, "shippingTemplateId"),
+        shippingGrossWeight: optionalInteger(input.shippingGrossWeight),
+        images,
+        brandId: optionalString(input.brandId),
+        attributes: optionalNonEmptyArray(input.attributes),
+        variantIds: optionalStringArray(input.variantIds),
+        articleNo: optionalString(input.articleNo),
+        description: optionalString(input.description),
+        itemShortTitle: optionalString(input.itemShortTitle),
+        deliveryMode: optionalInteger(input.deliveryMode),
+        freeReturn: optionalInteger(input.freeReturn),
+        videos: optionalNonEmptyArray(input.videos),
+        imageDescriptions: optionalNonEmptyArray(input.imageDescriptions),
+        createSkuList: update ? optionalNonEmptyArray(input.createSkuList) : undefined,
+        deleteSkuIdList: update ? optionalStringArray(input.deleteSkuIdList) : undefined,
+        [skuListField]: skuList,
+    });
+}
+function optionalNonEmptyArray(value) {
+    const items = looseArray(value);
+    return items.length > 0 ? items : undefined;
+}
 function requireOrderListTimestamp(value, fieldName) {
     const timestamp = integer(value, fieldName, providerInputError);
     // Anything this large is a millisecond timestamp, which the order list would silently misread.

package/src/server/api/openapi.js

@@ -419,6 +419,9 @@ export function createOpenApiDocument(providers, options = {}) {
                     service: jsonSchema.string({ description: "Provider service identifier." }),
                     authType: jsonSchema.string({ description: "Connection authentication type." }),
                     configured: jsonSchema.boolean({ description: "Whether the provider is connected." }),
+                    oauthAuthorizationId: jsonSchema.string({
+                        description: "Completed OAuth consent state. Omitted for legacy and non-OAuth connections.",
+                    }),
                     virtual: jsonSchema.boolean({
                         description: "Whether the connection needs no stored secret.",
                     }),

package/src/server/connector-assets.d.ts

@@ -0,0 +1,4 @@
+/** Directory to include in a host's Bun compile.assets. Its basename keeps connector assets namespaced. */
+export declare function getConnectorAssetDirectory(): string;
+/** Only Bun defines the `Bun` global; Node and workerd never do, so the read is safe everywhere. */
+export declare function isStandaloneExecutable(): boolean;

package/src/server/connector-assets.js

@@ -0,0 +1,12 @@
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Directory to include in a host's Bun compile.assets. Its basename keeps connector assets namespaced. */
+export function getConnectorAssetDirectory() {
+    return isStandaloneExecutable()
+        ? join(import.meta.dirname, "open-connector")
+        : fileURLToPath(new URL("../../assets/open-connector/", import.meta.url));
+}
+/** Only Bun defines the `Bun` global; Node and workerd never do, so the read is safe everywhere. */
+export function isStandaloneExecutable() {
+    return globalThis.Bun?.isStandaloneExecutable === true;
+}

package/src/server/connector-build.d.ts

@@ -0,0 +1,33 @@
+export interface ConnectorBuildOptions {
+    /** Omit to include all providers. An empty array includes none. */
+    providers?: readonly string[];
+}
+export interface ConnectorBuild {
+    /** Pass to Bun.build's compile.assets. */
+    assets: string[];
+    /** Pass to Bun.build alongside plugins. */
+    external: string[];
+    plugins: ConnectorBuildPlugin[];
+    /** Remove staged assets after the build, including when it fails. */
+    dispose(): Promise<void>;
+}
+interface ConnectorBuildPlugin {
+    name: string;
+    setup(build: ConnectorBuildHooks): void;
+}
+interface ConnectorBuildHooks {
+    onLoad(options: {
+        filter: RegExp;
+    }, callback: (args: {
+        path: string;
+    }) => {
+        contents: string;
+        loader: "js";
+    } | undefined): unknown;
+    onEnd(callback: (result: {
+        success: boolean;
+    }) => void): unknown;
+}
+/** Prepare a headless Bun executable with only the requested provider code and catalog entries. */
+export declare function getConnectorBuildOptions(options?: ConnectorBuildOptions): Promise<ConnectorBuild>;
+export {};

package/src/server/connector-build.js

@@ -0,0 +1,73 @@
+import { access, cp, mkdir, mkdtemp, readdir, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { catalogIndexFileName, createCatalogIndex } from "../catalog-index.js";
+import { assertProviderId } from "../core/provider-id.js";
+import { getConnectorAssetDirectory } from "./connector-assets.js";
+/** Prepare a headless Bun executable with only the requested provider code and catalog entries. */
+export async function getConnectorBuildOptions(options = {}) {
+    const sourceAssets = getConnectorAssetDirectory();
+    const external = ["proxy-agent"];
+    if (options.providers === undefined) {
+        return { assets: [sourceAssets], external, plugins: [], dispose: () => Promise.resolve() };
+    }
+    const services = [...new Set(options.providers)].sort();
+    const catalogDir = join(sourceAssets, "catalog/apps");
+    const files = new Set(await readdir(catalogDir));
+    for (const service of services) {
+        assertProviderId(service);
+        if (!files.has(`${service}.json`))
+            throw new Error(`Unknown provider: ${service}`);
+    }
+    const directory = await mkdtemp(join(tmpdir(), "open-connector-build-"));
+    const dispose = () => rm(directory, { recursive: true, force: true });
+    try {
+        const assets = join(directory, "open-connector");
+        const apps = join(assets, "catalog/apps");
+        await mkdir(apps, { recursive: true });
+        const providerDir = fileURLToPath(new URL("../providers/", import.meta.url));
+        const extension = extname(import.meta.filename);
+        const registry = await realpath(join(providerDir, `registry.generated${extension}`));
+        const sources = [];
+        for (const service of services) {
+            await access(join(providerDir, service, `executors${extension}`));
+            const file = `${service}.json`;
+            const content = await readFile(join(catalogDir, file));
+            const provider = JSON.parse(content.toString());
+            if (provider.service !== service)
+                throw new Error(`Catalog service does not match ${file}`);
+            await writeFile(join(apps, file), content);
+            sources.push({ file, bytes: content.byteLength, provider });
+        }
+        // Bun embeds files, so preserve the directory that the runtime reads even with no providers.
+        if (!services.length)
+            await writeFile(join(apps, "empty"), "");
+        await writeFile(join(assets, "catalog", catalogIndexFileName), JSON.stringify(createCatalogIndex(sources)));
+        await cp(join(sourceAssets, "migrations"), join(assets, "migrations"), { recursive: true });
+        const contents = `export const executorModules = {\n${services
+            .map((service) => `${JSON.stringify(service)}: () => import(${JSON.stringify(`./${service}/executors${extension}`)}),`)
+            .join("\n")}\n};`;
+        const plugin = {
+            name: "open-connector-providers",
+            setup(build) {
+                let replaced = false;
+                build.onLoad({ filter: /[/\\]providers[/\\]registry\.generated\.[jt]s$/ }, ({ path }) => {
+                    if (path !== registry)
+                        return;
+                    replaced = true;
+                    return { contents, loader: "js" };
+                });
+                build.onEnd((result) => {
+                    if (result.success && !replaced)
+                        throw new Error("The build did not load Open Connector's executor registry.");
+                });
+            },
+        };
+        return { assets: [assets], external, plugins: [plugin], dispose };
+    }
+    catch (error) {
+        await dispose();
+        throw error;
+    }
+}

package/src/server/connector-runtime.d.ts

@@ -79,8 +79,7 @@ export interface ConnectorRuntime {
     /** Abort active requests, wait for their handlers, and close owned resources. Safe to call repeatedly. */
     close(): Promise<void>;
 }
-/** Directory to include in a host's Bun compile.assets. Its basename keeps connector assets namespaced. */
-export declare function getConnectorAssetDirectory(): string;
+export { getConnectorAssetDirectory } from "./connector-assets.ts";
 /** Create a headless runtime without opening a listener or installing process signal handlers. */
 export declare function createConnectorRuntime(options: ConnectorRuntimeOptions): Promise<ConnectorRuntime>;
 export type { RuntimeProviderSetup } from "./api/runtime-api.ts";

package/src/server/connector-runtime.js

@@ -1,6 +1,5 @@
 import { mkdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 import { loadCatalog } from "../catalog-store.js";
 import { ActionPolicyService } from "../core/action-policy.js";
 import { setEgressTrustedHosts, setPrivateNetworkAccessAllowed } from "../core/request.js";
@@ -8,20 +7,15 @@ import { ProviderLoader } from "../providers/provider-loader.js";
 import { executorModules } from "../providers/registry.generated.js";
 import { createRuntimeJwtVerifier } from "./api/runtime-jwt.js";
 import { createConnectApp } from "./connect-app.js";
+import { getConnectorAssetDirectory } from "./connector-assets.js";
 import { cleanupStagedTransitFiles, createNodeTransitFileUpload } from "./files/node-transit-file-upload.js";
 import { TransitFileService } from "./files/transit-files.js";
 import { createSecretCodec } from "./secrets/secret-codec.js";
-import { isStandaloneExecutable } from "./server-assets.js";
 import { createDirectoryMigrationSource } from "./storage/migration-source.js";
 import { createNodeRuntimeDatabase } from "./storage/node-runtime-database.js";
 import { DEFAULT_RUN_LIMIT } from "./storage/runtime-store.js";
 let runtimeActive = false;
-/** Directory to include in a host's Bun compile.assets. Its basename keeps connector assets namespaced. */
-export function getConnectorAssetDirectory() {
-    return isStandaloneExecutable()
-        ? join(import.meta.dirname, "open-connector")
-        : fileURLToPath(new URL("../../assets/open-connector/", import.meta.url));
-}
+export { getConnectorAssetDirectory } from "./connector-assets.js";
 /** Create a headless runtime without opening a listener or installing process signal handlers. */
 export async function createConnectorRuntime(options) {
     if (runtimeActive)