@oomol-lab/open-connector 1.9.0 → 1.9.2

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

@@ -0,0 +1,8 @@
+import type { ApiKeyProviderContext } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export interface RakurakuContext extends ApiKeyProviderContext {
+    baseUrl: string;
+}
+export declare function normalizeBaseUrl(value: unknown): string;
+export declare function executeRakurakuSeisanAction(action: string, input: Record<string, unknown>, context: RakurakuContext): Promise<unknown>;
+export declare function readRakurakuError(response: Response): Promise<ProviderRequestError>;

package/src/providers/rakuraku_seisan/runtime.js

@@ -0,0 +1,251 @@
+import { optionalRecord, optionalString, looseArray } from "../../core/cast.js";
+import { assertPublicHttpUrl, readBoundedResponseBytes, storeResponseInTransit } from "../../core/request.js";
+import { ProviderRequestError, providerInputError, providerResponseError, providerFetch, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export function normalizeBaseUrl(value) {
+    const raw = requiredInputString(value, "baseUrl");
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw providerInputError("baseUrl must be a valid HTTPS company URL");
+    }
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (url.protocol !== "https:" ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash ||
+        segments.length !== 1 ||
+        segments[0]?.includes("%"))
+        throw providerInputError("baseUrl must be an HTTPS company URL with one account path and no credentials, query, or fragment");
+    assertPublicHttpUrl(url.toString(), { fieldName: "baseUrl", createError: providerInputError });
+    return `${url.origin}/${segments[0]}`;
+}
+function parsePayload(bytes) {
+    try {
+        return requiredResponseRecord(JSON.parse(new TextDecoder().decode(bytes)), "Rakuraku Seisan response");
+    }
+    catch (error) {
+        if (error instanceof ProviderRequestError)
+            throw error;
+        throw providerResponseError("Rakuraku Seisan returned invalid JSON");
+    }
+}
+function checkResponse(response, bytes) {
+    const prefix = new TextDecoder().decode(bytes.subarray(0, 1024)).trimStart();
+    if (prefix.split("\n", 1)[0]?.includes("Status: 503 Maintenance mode"))
+        throw new ProviderRequestError(503, "Rakuraku Seisan is under maintenance", undefined, "provider_error");
+    const isJson = response.headers.get("content-type")?.includes("json") || prefix.startsWith("{");
+    if (!response.ok || isJson) {
+        const payload = isJson ? parsePayload(bytes) : undefined;
+        if (!response.ok || payload?.status === "error") {
+            const errors = optionalRecord(payload?.errors);
+            const code = optionalString(errors?.code);
+            const details = looseArray(errors?.description)
+                .map((value) => {
+                const detail = optionalRecord(value);
+                return [optionalString(detail?.name), optionalString(detail?.msg)].filter(Boolean).join(": ");
+            })
+                .filter(Boolean)
+                .join("; ");
+            const message = `Rakuraku Seisan: ${optionalString(errors?.msg) ?? `HTTP ${response.status}`}${code ? ` (code ${code})` : ""}${details ? `: ${details}` : ""}`;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, message, undefined, response.status === 401 && code === "1"
+                ? "authorization_failed"
+                : response.status === 429
+                    ? "rate_limited"
+                    : "provider_error");
+        }
+    }
+    if (prefix.startsWith("<"))
+        throw providerResponseError("Rakuraku Seisan returned HTML instead of API data");
+}
+async function readApiResponse(response, signal) {
+    const bytes = await readBoundedResponseBytes(response, {
+        maxBytes: 1024 * 1024,
+        fieldName: "Rakuraku Seisan response",
+        createError: providerResponseError,
+        signal,
+    });
+    checkResponse(response, bytes);
+    return parsePayload(bytes);
+}
+/** Inspect a small prefix without buffering the journal export. */
+async function journalResponse(response, signal) {
+    if (!response.ok || response.headers.get("content-type")?.includes("json")) {
+        await readApiResponse(response, signal);
+        throw providerResponseError("Rakuraku Seisan returned JSON instead of a journal file");
+    }
+    if (!response.body)
+        return response;
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    let done = false;
+    let isJson = false;
+    try {
+        while (size < 1024) {
+            signal.throwIfAborted();
+            const next = await reader.read();
+            if (next.done) {
+                done = true;
+                break;
+            }
+            chunks.push(next.value);
+            size += next.value.byteLength;
+        }
+        const prefix = new Uint8Array(Math.min(size, 1024));
+        let offset = 0;
+        for (const chunk of chunks) {
+            const part = chunk.subarray(0, prefix.length - offset);
+            prefix.set(part, offset);
+            offset += part.length;
+        }
+        const text = new TextDecoder().decode(prefix).trimStart();
+        isJson = text.startsWith("{");
+        if (!isJson)
+            checkResponse(response, prefix);
+    }
+    catch (error) {
+        await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+        throw error;
+    }
+    const replay = new Response(new ReadableStream({
+        async pull(controller) {
+            try {
+                signal.throwIfAborted();
+                const buffered = chunks.shift();
+                if (buffered) {
+                    controller.enqueue(buffered);
+                    return;
+                }
+                if (done) {
+                    reader.releaseLock();
+                    controller.close();
+                    return;
+                }
+                const next = await reader.read();
+                if (next.done) {
+                    reader.releaseLock();
+                    controller.close();
+                }
+                else
+                    controller.enqueue(next.value);
+            }
+            catch (error) {
+                await reader.cancel().catch(() => undefined);
+                reader.releaseLock();
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            await reader.cancel(reason);
+            reader.releaseLock();
+        },
+    }), { headers: response.headers, status: response.status });
+    if (isJson) {
+        await readApiResponse(replay, signal);
+        throw providerResponseError("Rakuraku Seisan returned JSON instead of a journal file");
+    }
+    return replay;
+}
+export async function executeRakurakuSeisanAction(action, input, context) {
+    return runProviderRequest({
+        label: "Rakuraku Seisan",
+        signal: context.signal,
+        timeoutMs: action === "download_journal_file" ? 300_000 : undefined,
+    }, async (signal) => {
+        const request = (path, body) => context.fetcher(`${context.baseUrl}/api/v1/${path}`, {
+            method: body ? "POST" : "GET",
+            headers: { "X-RS-apitoken": context.apiKey },
+            body,
+            signal,
+            redirect: "manual",
+        });
+        if (action === "download_journal_file") {
+            if (!context.transitFiles)
+                throw new ProviderRequestError(503, "Journal downloads require configured transit storage", undefined, "provider_error");
+            const response = await journalResponse(await request(`fileGenerate/${input.fileGenerateId}/result`), signal);
+            const filename = (response.headers.get("content-disposition") ?? "")
+                .split(";")
+                .map((part) => part.trim())
+                .find((part) => part.startsWith("filename="))
+                ?.slice(9)
+                .split('"')
+                .join("");
+            const name = filename?.split("/").pop()?.split("\\").pop() || `journal-${input.fileGenerateId}.dat`;
+            const mimeType = response.headers.get("content-type")?.split(";", 1)[0] ?? "application/octet-stream";
+            return {
+                file: await storeResponseInTransit(response, context.transitFiles, {
+                    name,
+                    mimeType,
+                    maxBytes: 64 * 1024 * 1024,
+                    fieldName: "Rakuraku Seisan file",
+                    createError: providerResponseError,
+                    signal,
+                }),
+            };
+        }
+        if (action === "import_master_csv") {
+            if (input.masterId === 18 && input.duplicateKey === 0)
+                throw providerInputError("Approver imports require duplicateKey 1");
+            const source = await providerFetch(requiredInputString(input.fileUrl, "fileUrl"), { signal });
+            if (!source.ok) {
+                await source.body?.cancel();
+                throw new ProviderRequestError(source.status, `CSV download failed with HTTP ${source.status}`, undefined, "provider_error");
+            }
+            const bytes = await readBoundedResponseBytes(source, {
+                maxBytes: 5 * 1024 * 1024,
+                fieldName: "Rakuraku Seisan CSV",
+                createError: providerResponseError,
+                signal,
+            });
+            if (!bytes.byteLength)
+                throw providerInputError("CSV file must not be empty");
+            const body = new FormData();
+            body.set("json", JSON.stringify({
+                masterId: input.masterId,
+                duplicateKey: input.duplicateKey ?? (input.masterId === 18 ? 1 : 0),
+                sendPasswordEmail: input.sendPasswordEmail ? 1 : 0,
+                createCategory: input.createCategory ? 1 : 0,
+            }));
+            body.set("uploadFile", new Blob([Uint8Array.from(bytes)], { type: "application/octet-stream" }), "import.csv");
+            const payload = await readApiResponse(await request("csvimport", body), signal);
+            const processId = optionalString(payload.processId);
+            if (!processId)
+                throw providerResponseError("Rakuraku Seisan response is missing processId");
+            return { processId };
+        }
+        const payload = await readApiResponse(await request(`csvimportprocess/${encodeURIComponent(requiredInputString(input.processId, "processId"))}`), signal);
+        const processStatus = optionalString(payload.processStatus);
+        if (!processStatus)
+            throw providerResponseError("Rakuraku Seisan response is missing processStatus");
+        const items = optionalRecord(payload.items);
+        return {
+            processStatus,
+            successCount: readCount(items?.successCount),
+            failureCount: readCount(items?.failureCount),
+            raw: payload,
+        };
+    });
+}
+function readCount(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const number = typeof value === "number" ? value : Number(optionalString(value));
+    if (!Number.isInteger(number) || number < 0 || value === "")
+        throw providerResponseError("Rakuraku Seisan returned an invalid import count");
+    return number;
+}
+export async function readRakurakuError(response) {
+    try {
+        await readApiResponse(response);
+    }
+    catch (error) {
+        if (error instanceof ProviderRequestError)
+            return error;
+        throw error;
+    }
+    return new ProviderRequestError(response.status, "Rakuraku Seisan request failed", undefined, "provider_error");
+}

package/src/providers/redfox/actions-account.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const accountActions: ActionDefinition[];

package/src/providers/redfox/actions-account.js

@@ -0,0 +1,24 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { responseSchema } from "./schemas.js";
+export const accountActions = [
+    defineProviderAction("redfox", {
+        name: "get_account_balance",
+        operationType: "read",
+        description: "Get the points balance associated with the connected RedFoxHub API key.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Request parameters.", {}),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "list_api_usage",
+        operationType: "read",
+        description: "List API consumption records associated with the connected RedFoxHub API key.",
+        requiredScopes: [],
+        inputSchema: s.object("Request parameters.", {
+            pageNum: s.nonEmptyString("Page number, starting at 1."),
+            pageSize: s.nonEmptyString("Number of results per page."),
+        }, { optional: ["pageNum", "pageSize"] }),
+        outputSchema: responseSchema,
+    }),
+];

package/src/providers/redfox/actions-autohome.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const autohomeActions: ActionDefinition[];

package/src/providers/redfox/actions-autohome.js

@@ -0,0 +1,51 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { responseSchema } from "./schemas.js";
+export const autohomeActions = [
+    defineProviderAction("redfox", {
+        name: "search_autohome_works",
+        operationType: "read",
+        description: "Search Autohome posts by keyword.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Request parameters.", {
+            keyword: s.nonEmptyString("Search keyword."),
+            offset: s.nonEmptyString("Pagination offset. Start with 0 and increase by 10."),
+            page: s.nonEmptyString("Page number, starting at 1."),
+            sourceType: s.stringEnum("Content source type.", ["club", "article", "video"]),
+        }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "get_autohome_article",
+        operationType: "read",
+        description: "Get the content and metadata of an Autohome article.",
+        requiredScopes: [],
+        inputSchema: s.object("Request parameters.", {
+            workId: s.nonEmptyString("Work ID."),
+            page: s.withDefault(s.integer("Page number, starting at 0.", { minimum: 0 }), 0),
+        }, { optional: ["page"] }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "get_autohome_video",
+        operationType: "read",
+        description: "Get details of an Autohome video.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Request parameters.", {
+            videoId: s.nonEmptyString("Video ID."),
+            videoType: s.withEnum(s.integer("Video type: 0 = original account, 4 = Chejiahao."), [0, 4]),
+        }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "list_autohome_user_works",
+        operationType: "read",
+        description: "List posts published by an Autohome account.",
+        requiredScopes: [],
+        inputSchema: s.object("Request parameters.", {
+            authorId: s.nonEmptyString("Author ID."),
+            page: s.withDefault(s.integer("Page number, starting at 0.", { minimum: 0 }), 0),
+        }, { optional: ["page"] }),
+        outputSchema: responseSchema,
+    }),
+];

package/src/providers/redfox/actions-baijiahao.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const baijiahaoActions: ActionDefinition[];

package/src/providers/redfox/actions-baijiahao.js

@@ -0,0 +1,58 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { responseSchema } from "./schemas.js";
+export const baijiahaoActions = [
+    defineProviderAction("redfox", {
+        name: "get_baijiahao_article",
+        operationType: "read",
+        description: "Get the content and metadata of a Baijiahao article.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Request parameters.", {
+            articleId: s.nonEmptyString("Article ID."),
+        }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "get_baijiahao_video",
+        operationType: "read",
+        description: "Get details of a Baijiahao video.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Request parameters.", {
+            svId: s.nonEmptyString("Baijiahao video ID."),
+        }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "get_baijiahao_user",
+        operationType: "read",
+        description: "Get details of a Baijiahao account.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Request parameters.", {
+            uk: s.nonEmptyString("Baijiahao account uk identifier."),
+        }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "search_baijiahao_works",
+        operationType: "read",
+        description: "Search Baijiahao posts by keyword.",
+        requiredScopes: [],
+        inputSchema: s.object("Request parameters.", {
+            sort: s.nonEmptyString("Sort order."),
+            pn: s.nonEmptyString("Pagination offset. Start with 0 and increase by 10."),
+            keyWord: s.nonEmptyString("Search keyword."),
+        }, { optional: ["sort"] }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "search_baijiahao_users",
+        operationType: "read",
+        description: "Search Baijiahao accounts by keyword.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Request parameters.", {
+            page: s.nonEmptyString("Page cursor encoded as a string. Start with 0, then use the page returned by the previous response."),
+            keyword: s.nonEmptyString("Search keyword."),
+        }),
+        outputSchema: responseSchema,
+    }),
+];

package/src/providers/redfox/actions-bilibili.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const bilibiliActions: ActionDefinition[];

package/src/providers/redfox/actions-bilibili.js

@@ -0,0 +1,67 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { responseSchema } from "./schemas.js";
+export const bilibiliActions = [
+    defineProviderAction("redfox", {
+        name: "get_bilibili_work",
+        operationType: "read",
+        description: "Get a Bilibili work by its BV ID or URL. Uses the curated database. Data is updated on a T+1 schedule, not in real time.",
+        requiredScopes: [],
+        inputSchema: s.requireAnyProperty(s.object("Request parameters.", {
+            bvId: s.nonEmptyString("Bilibili BV ID."),
+            workUrl: s.nonEmptyString("Work URL."),
+        }, { optional: ["bvId", "workUrl"] }), ["bvId", "workUrl"]),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "get_bilibili_user",
+        operationType: "read",
+        description: "Get details about a Bilibili account. Uses the curated database. Data is updated on a T+1 schedule, not in real time.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Request parameters.", {
+            mid: s.nonEmptyString("Bilibili user MID."),
+        }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "search_bilibili_users",
+        operationType: "read",
+        description: "Search Bilibili accounts by keyword. Uses the curated database. Data is updated on a T+1 schedule, not in real time.",
+        requiredScopes: [],
+        inputSchema: s.object("Request parameters.", {
+            keyword: s.nonEmptyString("Search keyword."),
+            page: s.nonEmptyString("Page number, starting at 1."),
+            pageSize: s.integer("Number of results per page.", { minimum: 1, maximum: 50 }),
+            order: s.stringEnum("Sort order.", ["follower", "like"]),
+        }, { optional: ["pageSize", "order"] }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "search_bilibili_works",
+        operationType: "read",
+        description: "Search Bilibili works by keyword. Uses the curated database. Data is updated on a T+1 schedule, not in real time.",
+        requiredScopes: [],
+        inputSchema: s.object("Request parameters.", {
+            keyword: s.nonEmptyString("Search keyword."),
+            exactMatch: s.boolean("Require the entire keyword phrase in the title, summary, content or author instead of token matching."),
+            page: s.nonEmptyString("Page number, starting at 1."),
+            pageSize: s.integer("Number of results per page.", { minimum: 1, maximum: 50 }),
+            order: s.stringEnum("Sort order.", ["time", "play", "like", "comment", "favorite"]),
+        }, { optional: ["exactMatch", "pageSize", "order"] }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "list_bilibili_user_works",
+        operationType: "read",
+        description: "List works published by a Bilibili account. Uses the curated database. Data is updated on a T+1 schedule, not in real time.",
+        requiredScopes: [],
+        inputSchema: s.requireAnyProperty(s.object("Request parameters.", {
+            mid: s.nonEmptyString("Bilibili user MID."),
+            accountUrl: s.nonEmptyString("Account profile URL."),
+            page: s.integer("Page number, starting at 1.", { minimum: 1 }),
+            pageSize: s.integer("Number of results per page.", { minimum: 1, maximum: 50 }),
+            order: s.stringEnum("Sort order.", ["time", "play", "like"]),
+        }, { optional: ["mid", "accountUrl", "page", "pageSize", "order"] }), ["mid", "accountUrl"]),
+        outputSchema: responseSchema,
+    }),
+];

package/src/providers/redfox/actions-dongchedi.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const dongchediActions: ActionDefinition[];

package/src/providers/redfox/actions-dongchedi.js

@@ -0,0 +1,49 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { responseSchema } from "./schemas.js";
+export const dongchediActions = [
+    defineProviderAction("redfox", {
+        name: "search_dongchedi_works",
+        operationType: "read",
+        description: "Search Dongchedi posts by keyword.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Request parameters.", {
+            keyword: s.nonEmptyString("Search keyword."),
+            offset: s.nonEmptyString("Pagination offset. Start with 0 and increase by 20."),
+            sourceType: s.stringEnum("Content source type.", ["1", "2"]),
+        }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "get_dongchedi_work",
+        operationType: "read",
+        description: "Get details of a Dongchedi post.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Request parameters.", {
+            workId: s.nonEmptyString("Work ID."),
+            workType: s.stringEnum("Work type: video or article.", ["video", "article"]),
+        }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "search_dongchedi_users",
+        operationType: "read",
+        description: "Search Dongchedi accounts by keyword.",
+        requiredScopes: [],
+        inputSchema: s.object("Request parameters.", {
+            keyword: s.nonEmptyString("Search keyword."),
+            offset: s.withDefault(s.integer("Pagination offset. Start with 0 and use the offset or next cursor returned by the previous response.", { minimum: 0 }), 0),
+        }, { optional: ["offset"] }),
+        outputSchema: responseSchema,
+    }),
+    defineProviderAction("redfox", {
+        name: "get_dongchedi_user_works",
+        operationType: "read",
+        description: "List posts published by a Dongchedi account.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("Request parameters.", {
+            userId: s.nonEmptyString("User ID."),
+        }),
+        outputSchema: responseSchema,
+    }),
+];

package/src/providers/redfox/actions-douyin.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const douyinActions: ActionDefinition[];