@oomol-lab/open-connector 1.6.2 → 1.6.4

package/src/providers/buzzsprout/executors.js

@@ -0,0 +1,21 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { buzzsproutActionHandlers, buzzsproutApiBaseUrl, validateBuzzsproutCredential } from "./runtime.js";
+const service = "buzzsprout";
+export const executors = defineApiKeyProviderExecutors(service, buzzsproutActionHandlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: buzzsproutApiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Token token=" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        return validateBuzzsproutCredential(input.apiKey, fetcher, signal);
+    },
+};

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

@@ -0,0 +1,12 @@
+import type { ApiKeyProviderContext, ProviderActionHandlers } from "../provider-runtime.ts";
+export declare const buzzsproutApiBaseUrl = "https://www.buzzsprout.com/api";
+type Handler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
+export declare const buzzsproutActionHandlers: ProviderActionHandlers<"buzzsprout", Handler>;
+export declare function validateBuzzsproutCredential(apiKey: string, fetcher: typeof fetch, signal?: AbortSignal): Promise<{
+    profile: {
+        displayName: string;
+    };
+    grantedScopes: string[];
+    metadata: Record<string, unknown>;
+}>;
+export {};

package/src/providers/buzzsprout/runtime.js

@@ -0,0 +1,237 @@
+import { compactObject, objectArray, optionalInteger, optionalRecord, optionalString, rawStringOrNull, requiredBoolean, requiredNumber, requiredRecord, requiredString, } from "../../core/cast.js";
+import { readProviderTextBody } from "../provider-runtime.js";
+import { providerResponseError, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+export const buzzsproutApiBaseUrl = "https://www.buzzsprout.com/api";
+export const buzzsproutActionHandlers = {
+    async list_podcasts(_input, context) {
+        return { podcasts: objects(await request("/podcasts", context), "Buzzsprout podcasts").map(normalizePodcast) };
+    },
+    async get_podcast(input, context) {
+        return { podcast: normalizePodcast(await request(`/podcasts/${id(input.podcastId, "podcastId")}`, context)) };
+    },
+    async update_podcast(input, context) {
+        return {
+            podcast: normalizePodcast(await request(`/podcasts/${id(input.podcastId, "podcastId")}`, context, "PATCH", podcastBody(input))),
+        };
+    },
+    async list_episodes(input, context) {
+        return {
+            episodes: objects(await request(`/${id(input.podcastId, "podcastId")}/episodes`, context), "Buzzsprout episodes").map(normalizeEpisode),
+        };
+    },
+    async get_episode(input, context) {
+        return {
+            episode: normalizeEpisode(await request(`/${id(input.podcastId, "podcastId")}/episodes/${id(input.episodeId, "episodeId")}`, context)),
+        };
+    },
+    async create_episode(input, context) {
+        return {
+            episode: normalizeEpisode(await request(`/${id(input.podcastId, "podcastId")}/episodes`, context, "POST", episodeBody(input))),
+        };
+    },
+    async update_episode(input, context) {
+        return {
+            episode: normalizeEpisode(await request(`/${id(input.podcastId, "podcastId")}/episodes/${id(input.episodeId, "episodeId")}`, context, "PATCH", episodeBody(input))),
+        };
+    },
+    async list_podcast_downloads(input, context) {
+        const payload = objects(await request(`/${id(input.podcastId, "podcastId")}/downloads`, context, "GET", undefined, {
+            date: optionalString(input.date),
+        }), "Buzzsprout podcast downloads");
+        return {
+            downloads: payload.map((value) => {
+                const record = requiredRecord(value, "Buzzsprout podcast download", providerResponseError);
+                return {
+                    episodeId: positive(record.episode_id, "Buzzsprout download episode_id"),
+                    total: nonNegative(record.total, "Buzzsprout download total"),
+                };
+            }),
+        };
+    },
+    async list_episode_downloads(input, context) {
+        const payload = requiredRecord(await request(`/${id(input.podcastId, "podcastId")}/${id(input.episodeId, "episodeId")}/downloads`, context, "GET", undefined, { date: optionalString(input.date), page: stringInteger(input.page), per_page: stringInteger(input.perPage) }), "Buzzsprout episode downloads", providerResponseError);
+        const episode = objects(payload.episodes, "Buzzsprout episode downloads episodes")[0];
+        if (!episode)
+            throw providerResponseError("Buzzsprout episode downloads response is empty");
+        const pagination = requiredRecord(payload.pagination, "Buzzsprout pagination", providerResponseError);
+        return {
+            episodeId: positive(episode.id, "Buzzsprout episode id"),
+            downloads: objects(episode.downloads, "Buzzsprout downloads").map(normalizeDownload),
+            page: positive(pagination.page, "Buzzsprout pagination page"),
+            perPage: positive(pagination.per_page, "Buzzsprout pagination per_page"),
+            hasMore: requiredBoolean(pagination.has_more, "Buzzsprout pagination has_more", providerResponseError),
+            nextPage: pagination.next_page == null ? null : positive(pagination.next_page, "Buzzsprout pagination next_page"),
+        };
+    },
+};
+export async function validateBuzzsproutCredential(apiKey, fetcher, signal) {
+    const context = { apiKey, fetcher, signal };
+    const podcasts = objects(await request("/podcasts", context), "Buzzsprout podcasts");
+    return {
+        profile: { displayName: optionalString(optionalRecord(podcasts[0])?.title) ?? "Buzzsprout API Token" },
+        grantedScopes: [],
+        metadata: { apiBaseUrl: buzzsproutApiBaseUrl, validationEndpoint: "/podcasts", podcastCount: podcasts.length },
+    };
+}
+function podcastBody(input) {
+    return compactObject({
+        title: input.title,
+        description: input.description,
+        keywords: input.keywords,
+        author: input.author,
+        explicit: input.explicit,
+        language: input.language,
+        timezone: input.timezone,
+        website_address: input.websiteAddress,
+        contact_email: input.contactEmail,
+        category: input.category,
+        category2: input.category2,
+        category3: input.category3,
+        artwork_url: input.artworkUrl,
+    });
+}
+function episodeBody(input) {
+    return compactObject({
+        title: input.title,
+        description: input.description,
+        artist: input.artist,
+        tags: input.tags,
+        published_at: input.publishedAt,
+        season_number: input.seasonNumber,
+        episode_number: input.episodeNumber,
+        episode_type: input.episodeType,
+        explicit: input.explicit,
+        private: input.private,
+        custom_url: input.customUrl,
+        artwork_url: input.artworkUrl,
+    });
+}
+async function request(path, context, method = "GET", body, query) {
+    const url = new URL(`${buzzsproutApiBaseUrl}${path}`);
+    for (const [key, value] of Object.entries(query ?? {}))
+        if (value !== undefined)
+            url.searchParams.set(key, value);
+    const response = await context.fetcher(url, {
+        method,
+        headers: {
+            accept: "application/json",
+            authorization: `Token token=${context.apiKey}`,
+            "content-type": "application/json; charset=utf-8",
+            "user-agent": providerUserAgent,
+        },
+        body: body ? JSON.stringify(body) : undefined,
+        signal: context.signal,
+    });
+    const text = await readProviderTextBody(response, "Buzzsprout response");
+    let payload = null;
+    try {
+        payload = text ? JSON.parse(text) : null;
+    }
+    catch {
+        if (response.ok)
+            throw providerResponseError("Buzzsprout returned invalid JSON");
+        payload = text;
+    }
+    if (!response.ok)
+        throw new ProviderRequestError(response.status, errorMessage(payload) ?? `Buzzsprout request failed with status ${response.status}`, payload);
+    return payload;
+}
+function errorMessage(payload) {
+    if (typeof payload === "string")
+        return payload.trim() || undefined;
+    const record = optionalRecord(payload), nested = optionalRecord(record?.error);
+    return optionalString(nested?.message) ?? optionalString(record?.message) ?? optionalString(record?.error);
+}
+function normalizePodcast(value) {
+    const r = requiredRecord(value, "Buzzsprout podcast", providerResponseError);
+    return {
+        id: positive(r.id, "podcast id"),
+        title: requiredString(r.title, "podcast title", providerResponseError),
+        author: rawStringOrNull(r.author),
+        description: rawStringOrNull(r.description),
+        websiteAddress: rawStringOrNull(r.website_address),
+        websiteUrl: rawStringOrNull(r.website_url),
+        contactEmail: rawStringOrNull(r.contact_email),
+        keywords: rawStringOrNull(r.keywords),
+        explicit: requiredBoolean(r.explicit, "podcast explicit", providerResponseError),
+        mainCategory: rawStringOrNull(r.main_category),
+        subCategory: rawStringOrNull(r.sub_category),
+        mainCategory2: rawStringOrNull(r.main_category2),
+        subCategory2: rawStringOrNull(r.sub_category2),
+        mainCategory3: rawStringOrNull(r.main_category3),
+        subCategory3: rawStringOrNull(r.sub_category3),
+        language: rawStringOrNull(r.language),
+        timezone: rawStringOrNull(r.timezone),
+        artworkUrl: rawStringOrNull(r.artwork_url),
+        backgroundUrl: rawStringOrNull(r.background_url),
+        rssUrl: rawStringOrNull(r.rss_url),
+        raw: r,
+    };
+}
+function normalizeEpisode(value) {
+    const r = requiredRecord(value, "Buzzsprout episode", providerResponseError);
+    return {
+        id: positive(r.id, "episode id"),
+        title: requiredString(r.title, "episode title", providerResponseError),
+        audioUrl: rawStringOrNull(r.audio_url),
+        artworkUrl: rawStringOrNull(r.artwork_url),
+        description: rawStringOrNull(r.description),
+        artist: rawStringOrNull(r.artist),
+        tags: rawStringOrNull(r.tags),
+        publishedAt: rawStringOrNull(r.published_at),
+        duration: optionalIntegerAtLeast(r.duration, "episode duration", -1),
+        guid: rawStringOrNull(r.guid),
+        customUrl: rawStringOrNull(r.custom_url),
+        episodeNumber: optionalIntegerAtLeast(r.episode_number, "episode number", 0),
+        seasonNumber: optionalIntegerAtLeast(r.season_number, "season number", 0),
+        episodeType: rawStringOrNull(r.episode_type),
+        explicit: requiredBoolean(r.explicit, "episode explicit", providerResponseError),
+        private: requiredBoolean(r.private, "episode private", providerResponseError),
+        totalPlays: optionalIntegerAtLeast(r.total_plays, "episode total plays", 0),
+        raw: r,
+    };
+}
+function normalizeDownload(value) {
+    const r = requiredRecord(value, "Buzzsprout download", providerResponseError);
+    return {
+        app: requiredString(r.app, "download app", providerResponseError),
+        device: requiredString(r.device, "download device", providerResponseError),
+        deviceType: requiredString(r.device_type, "download device_type", providerResponseError),
+        countryCode: rawStringOrNull(r.country_code),
+        region: rawStringOrNull(r.region),
+        city: rawStringOrNull(r.city),
+        continent: rawStringOrNull(r.continent),
+        mediaType: requiredString(r.media_type, "download media_type", providerResponseError),
+    };
+}
+function objects(value, label) {
+    return objectArray(value, label, providerResponseError);
+}
+function id(value, label) {
+    return positive(value, label);
+}
+function positive(value, label) {
+    const number = requiredNumber(value, label, providerResponseError);
+    if (!Number.isInteger(number) || number <= 0)
+        throw providerResponseError(`${label} must be a positive integer`);
+    return number;
+}
+function nonNegative(value, label) {
+    const number = requiredNumber(value, label, providerResponseError);
+    if (!Number.isInteger(number) || number < 0)
+        throw providerResponseError(`${label} must be a non-negative integer`);
+    return number;
+}
+function stringInteger(value) {
+    const number = optionalInteger(value);
+    return number === undefined ? undefined : String(number);
+}
+function optionalIntegerAtLeast(value, label, minimum) {
+    if (value == null)
+        return null;
+    const number = requiredNumber(value, label, providerResponseError);
+    if (!Number.isInteger(number) || number < minimum) {
+        throw providerResponseError(`${label} must be an integer of at least ${minimum}`);
+    }
+    return number;
+}

package/src/providers/dropbox/executors.js

@@ -209,6 +209,24 @@ async function getMetadata(input, accessToken, fetcher) {
         metadata: mapDropboxMetadata(payload),
     };
 }
+/**
+ * Serialize a `Dropbox-API-Arg` header value.
+ *
+ * Dropbox requires this header to be ASCII: its own docs say `0x7F` and every
+ * non-ASCII character must be escaped as `\uXXXX`, which is also the range the
+ * official JS SDK escapes. `JSON.stringify` does not escape, and Node's `Headers`
+ * refuses a value outside ByteString, so a path containing any non-ASCII
+ * character threw `TypeError: Cannot convert argument to a ByteString` inside
+ * the runtime BEFORE the request was made. `provider-runtime.ts`'s fallback
+ * then reported it as a bare `internal_error`, discarding the cause.
+ *
+ * Measured 2026-09-18 against a real account: `/kkndme 天涯.pdf` failed in 1ms
+ * with no network call, while ASCII-path siblings downloaded in ~400ms. Dropbox
+ * itself accepts either spelling on the wire; only the header build was broken.
+ */
+function dropboxApiArg(arg) {
+    return JSON.stringify(arg).replace(/[\u007f-\uffff]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
 async function downloadFile(input, context) {
     const { accessToken, fetcher, transitFiles } = context;
     if (!transitFiles) {
@@ -218,7 +236,7 @@ async function downloadFile(input, context) {
         method: "POST",
         headers: {
             ...dropboxAuthHeaders(accessToken),
-            "Dropbox-API-Arg": JSON.stringify({
+            "Dropbox-API-Arg": dropboxApiArg({
                 path: requireString(input.path, "dropbox download path"),
             }),
         },
@@ -251,7 +269,7 @@ async function uploadFile(input, accessToken, fetcher) {
         headers: {
             ...dropboxAuthHeaders(accessToken),
             "Content-Type": source.mimeType || "application/octet-stream",
-            "Dropbox-API-Arg": JSON.stringify(arg),
+            "Dropbox-API-Arg": dropboxApiArg(arg),
         },
         body: Buffer.from(source.bytes),
     });
@@ -491,7 +509,7 @@ async function getSharedLinkFile(input, context) {
         method: "POST",
         headers: {
             ...dropboxAuthHeaders(accessToken),
-            "Dropbox-API-Arg": JSON.stringify(arg),
+            "Dropbox-API-Arg": dropboxApiArg(arg),
         },
         signal: context.signal,
     });

package/src/providers/feishu/shared/drive-actions.d.ts

@@ -1,6 +1,7 @@
 import type { ActionDefinition } from "../../../core/types.ts";
 export declare const feishuDriveProviderScopes: {
     metadataRead: string;
+    folderList: string;
     search: string;
     folderCreate: string;
     copy: string;

package/src/providers/feishu/shared/drive-actions.js

@@ -2,6 +2,7 @@ import { s } from "../../../core/json-schema.js";
 import { defineProviderAction } from "../../../core/provider-definition.js";
 export const feishuDriveProviderScopes = {
     metadataRead: "drive:drive.metadata:readonly",
+    folderList: "space:document:retrieve",
     search: "search:docs:read",
     folderCreate: "space:folder:create",
     copy: "docs:document:copy",
@@ -12,7 +13,7 @@ export const feishuDriveProviderScopes = {
     commentCreate: "docs:document.comment:create",
     commentUpdate: "docs:document.comment:update",
     commentDelete: "docs:document.comment:delete",
-    permissionRead: "docs:permission.member:readonly",
+    permissionRead: "docs:permission.member:retrieve",
     permissionCreate: "docs:permission.member:create",
     permissionUpdate: "docs:permission.member:update",
     permissionDelete: "docs:permission.member:delete",
@@ -154,8 +155,11 @@ export function createFeishuDriveActions(service) {
             name: "list_drive_files",
             operationType: "read",
             description: "List files, folders, and online documents inside a Feishu Drive folder.",
-            requiredScopes: [feishuDriveProviderScopes.metadataRead],
-            providerPermissions: [feishuDriveProviderScopes.metadataRead],
+            // Measured against Feishu with a user_access_token on 2026-09-14:
+            // metadataRead is rejected with 99991679, which names folderList as the
+            // narrowest accepted permission for this endpoint.
+            requiredScopes: [feishuDriveProviderScopes.folderList],
+            providerPermissions: [feishuDriveProviderScopes.folderList],
             inputSchema: s.object("Choose a folder, sort order, and page.", {
                 folderToken: s.string("The folder token to list; omit it to list the caller's root folder.", {
                     minLength: 1,
@@ -381,7 +385,7 @@ export function createFeishuDriveActions(service) {
             inputSchema: permissionResourceSchema({
                 fields: s.string("A comma-separated projection of permission member fields."),
                 permType: s.stringEnum("The Wiki permission scope.", ["container", "single_page"]),
-            }),
+            }, ["fields", "permType"]),
             outputSchema: s.object("The permission members on a Drive resource.", {
                 members: s.array("The permission members.", permissionSchema),
             }, {
@@ -405,7 +409,7 @@ export function createFeishuDriveActions(service) {
                     "wiki_space_editor",
                 ]),
                 needNotification: s.boolean("Whether Feishu should notify the collaborator."),
-            }),
+            }, ["permType", "memberKind", "needNotification"]),
             outputSchema: s.object("The granted Drive permission.", {
                 member: {
                     ...permissionSchema,
@@ -426,7 +430,7 @@ export function createFeishuDriveActions(service) {
                 memberType: memberTypeSchema,
                 permission: permissionRoleSchema,
                 needNotification: s.boolean("Whether Feishu should notify the collaborator."),
-            }),
+            }, ["needNotification"]),
             outputSchema: s.object("The updated Drive permission.", {
                 member: {
                     ...permissionSchema,
@@ -446,7 +450,7 @@ export function createFeishuDriveActions(service) {
                 memberId: s.string("The collaborator identifier.", { minLength: 1 }),
                 memberType: memberTypeSchema,
                 permType: s.stringEnum("The Wiki permission scope.", ["container", "single_page"]),
-            }),
+            }, ["permType"]),
             outputSchema: deletionOutputSchema("Whether the Drive permission was removed."),
         }),
     ];
@@ -491,12 +495,12 @@ function commentIdentitySchema(extra) {
         optional: [],
     });
 }
-function permissionResourceSchema(extra) {
+function permissionResourceSchema(extra, optional) {
     return s.object("Identify a Feishu Drive permission resource and operation.", {
         token: resourceTokenSchema,
         resourceType: permissionResourceTypeSchema,
         ...extra,
     }, {
-        optional: [],
+        optional,
     });
 }

package/src/providers/feishu/shared/drive-runtime.js

@@ -295,9 +295,21 @@ async function listDrivePermissions(input, request) {
             perm_type: optionalString(input.permType),
         },
     });
-    return {
-        members: Array.isArray(data.members) ? data.members : [],
-    };
+    // Feishu answers `GET /drive/v1/permissions/:token/members` with the
+    // collaborators under `data.items`, not `data.members`. Reading the output
+    // name as if it were the wire key missed every time, and the `: []` below
+    // turned the miss into a successful empty list — so every ACL read reported
+    // that nobody has access, with `success: true`.
+    //
+    // Every other list endpoint in this file already names the wire key
+    // explicitly (`normalizePage(data, "files")`, `normalizePage(data,
+    // "items")`); this one assumed it matched the field it returns, and was the
+    // only place that did.
+    //
+    // `members` is still read after `items`, so a wire that ever answers under
+    // that name keeps working rather than breaking in the other direction.
+    const rows = Array.isArray(data.items) ? data.items : Array.isArray(data.members) ? data.members : [];
+    return { members: rows };
 }
 async function addDrivePermission(input, request) {
     const memberType = requireString(input.memberType, "memberType");

package/src/providers/feishu/shared/wiki-actions.js

@@ -101,8 +101,10 @@ export function createFeishuWikiActions(service) {
             name: "get_wiki_node",
             operationType: "read",
             description: "Resolve and get a Feishu Wiki node by token and object type.",
-            requiredScopes: ["wiki:node:retrieve"],
-            providerPermissions: ["wiki:node:retrieve"],
+            // Feishu refuses `wiki:node:retrieve` for this endpoint with 99991679
+            // and names `wiki:node:read` as the narrow accepted permission.
+            requiredScopes: ["wiki:node:read"],
+            providerPermissions: ["wiki:node:read"],
             inputSchema: s.object("Identify the Wiki node.", {
                 token: s.string("A Wiki node_token or document obj_token.", { minLength: 1 }),
                 objectType,

package/src/providers/feishu_app_bot/scopes.js

@@ -15,6 +15,6 @@ export const feishuAppBotScopes = {
     groupAtReadonly: "im:message.group_at_msg:readonly",
     groupAtWithBotReadonly: "im:message.group_at_msg.include_bot:readonly",
     groupReadonly: "im:message.group_msg:readonly",
-    applicationRead: "application:application:readonly",
+    applicationRead: "application:application:self_manage",
     applicationVersionRead: "application:application.app_version:readonly",
 };