@oomol-lab/open-connector 1.6.4 → 1.7.0

package/src/providers/bilibili/executors.js

@@ -0,0 +1,262 @@
+import { compactObject, looseArray, optionalBoolean, optionalNumber, optionalRecord, optionalString, optionalStringArray, requiredString, } from "../../core/cast.js";
+import { combineProviderActionHandlers, defineProviderExecutors, providerInputError, providerResponseError, readTransitFileInput, requiredInputNumber, requiredInputString, requiredResponseRecord, } from "../provider-runtime.js";
+import { bilibiliArticleActionHandlers } from "./articles.js";
+import { assertAnyInputField, bilibiliApiRequest, bilibiliOAuthRefreshTokenUrl, createBilibiliContext, readBilibiliReplyIncrement, readBilibiliSigningMaterial, requestBilibiliOAuthToken, } from "./runtime.js";
+import { uploadBilibiliCover, uploadBilibiliVideo } from "./upload.js";
+const service = "bilibili";
+const bilibiliAccountActionHandlers = {
+    async get_user_info(_input, context) {
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, { path: "/user/account/info", label: "Bilibili user info" }), "Bilibili user info");
+        return compactObject({
+            name: optionalString(data.name),
+            face: optionalString(data.face),
+            openid: optionalString(data.openid),
+        });
+    },
+    async get_user_union_id(_input, context) {
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, {
+            method: "POST",
+            path: "/user/account/union_id",
+            label: "Bilibili user union id",
+        }), "Bilibili user union id");
+        return compactObject({ unionId: optionalString(data.union_id) });
+    },
+    async get_user_scopes(_input, context) {
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, { path: "/user/account/scopes", label: "Bilibili user scopes" }), "Bilibili user scopes");
+        return compactObject({
+            openid: optionalString(data.openid),
+            scopes: optionalStringArray(data.scopes) ?? [],
+        });
+    },
+    async get_user_stat(_input, context) {
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, { path: "/data/user/stat", label: "Bilibili user stat" }), "Bilibili user stat");
+        return compactObject({
+            following: optionalNumber(data.following),
+            follower: optionalNumber(data.follower),
+            arcPassedTotal: optionalNumber(data.arc_passed_total),
+        });
+    },
+    async list_archive_types(_input, context) {
+        const data = await bilibiliApiRequest(context, { path: "/archive/type/list", label: "Bilibili archive type list" });
+        return { types: looseArray(data) };
+    },
+    async upload_video(input, context) {
+        const title = requiredInputString(input.title, "title");
+        const tid = requiredInputNumber(input.tid, "tid");
+        const tag = requiredInputString(input.tag, "tag");
+        const copyright = requiredInputNumber(input.copyright, "copyright");
+        const source = optionalString(input.source);
+        if (copyright === 2 && !source) {
+            throw providerInputError("source is required when copyright is 2 (reposted content).");
+        }
+        const video = await readTransitFileInput(input.file, context);
+        const coverInput = input.cover === undefined ? undefined : await readTransitFileInput(input.cover, context);
+        const coverUrl = coverInput ? await uploadBilibiliCover(context, coverInput.file) : undefined;
+        const uploadToken = await uploadBilibiliVideo(context, video.file);
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, {
+            method: "POST",
+            path: "/archive/add-by-utoken",
+            query: { upload_token: uploadToken },
+            body: compactObject({
+                title,
+                tid,
+                tag,
+                copyright,
+                cover: coverUrl,
+                desc: optionalString(input.desc),
+                no_reprint: optionalBoolean(input.noReprint) === true ? 1 : 0,
+                source,
+            }),
+            label: "Bilibili archive submit",
+        }), "Bilibili archive submit");
+        return compactObject({
+            resourceId: requiredString(data.resource_id, "resource_id", providerResponseError),
+            coverUrl,
+        });
+    },
+    async list_archives(input, context) {
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, {
+            path: "/archive/viewlist",
+            query: {
+                pn: String(optionalNumber(input.pn) ?? 1),
+                ps: String(optionalNumber(input.ps) ?? 20),
+                status: optionalString(input.status),
+            },
+            label: "Bilibili archive list",
+        }), "Bilibili archive list");
+        const page = optionalRecord(data.page);
+        return {
+            archives: looseArray(data.list).map(normalizeBilibiliArchive),
+            page: compactObject({
+                pn: optionalNumber(page?.pn),
+                ps: optionalNumber(page?.ps),
+                total: optionalNumber(page?.total),
+            }),
+        };
+    },
+    async get_archive(input, context) {
+        const resourceId = requiredInputString(input.resourceId, "resourceId");
+        const data = await bilibiliApiRequest(context, {
+            path: "/archive/view",
+            query: { resource_id: resourceId },
+            label: "Bilibili archive view",
+        });
+        return normalizeBilibiliArchive(data);
+    },
+    async edit_archive(input, context) {
+        const resourceId = requiredInputString(input.resourceId, "resourceId");
+        assertAnyInputField(input, ["title", "tid", "coverUrl", "desc", "noReprint"]);
+        // Bilibili replaces every descriptive field on edit, so unchanged fields
+        // are refilled from the current archive before submitting.
+        const current = requiredResponseRecord(await bilibiliApiRequest(context, {
+            path: "/archive/view",
+            query: { resource_id: resourceId },
+            label: "Bilibili archive view",
+        }), "Bilibili archive view");
+        const title = optionalString(input.title) ?? optionalString(current.title);
+        const tid = optionalNumber(input.tid) ?? optionalNumber(current.tid);
+        if (!title || tid === undefined) {
+            throw providerInputError("title and tid are required when the current archive does not provide them.");
+        }
+        const noReprint = optionalBoolean(input.noReprint);
+        await bilibiliApiRequest(context, {
+            method: "POST",
+            path: "/archive/edit",
+            body: compactObject({
+                resource_id: resourceId,
+                title,
+                tid,
+                cover: optionalString(input.coverUrl) ?? optionalString(current.cover),
+                desc: optionalString(input.desc) ?? optionalString(current.desc),
+                no_reprint: noReprint === undefined ? optionalNumber(current.no_reprint) : noReprint ? 1 : 0,
+            }),
+            label: "Bilibili archive edit",
+        });
+        return { resourceId };
+    },
+    async delete_archive(input, context) {
+        const resourceId = requiredInputString(input.resourceId, "resourceId");
+        await bilibiliApiRequest(context, {
+            method: "POST",
+            path: "/archive/delete",
+            body: { resource_id: resourceId },
+            label: "Bilibili archive delete",
+        });
+        return { resourceId, deleted: true };
+    },
+    async get_archive_stat(input, context) {
+        const resourceId = requiredInputString(input.resourceId, "resourceId");
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, {
+            path: "/data/arc/stat",
+            query: { resource_id: resourceId },
+            label: "Bilibili archive stat",
+        }), "Bilibili archive stat");
+        return compactObject({
+            title: optionalString(data.title),
+            ptime: optionalNumber(data.ptime),
+            view: optionalNumber(data.view),
+            danmaku: optionalNumber(data.danmaku),
+            reply: optionalNumber(data.reply),
+            favorite: optionalNumber(data.favorite),
+            coin: optionalNumber(data.coin),
+            share: optionalNumber(data.share),
+            like: optionalNumber(data.like),
+        });
+    },
+    async get_archive_inc_stats(_input, context) {
+        const data = requiredResponseRecord(await bilibiliApiRequest(context, { path: "/data/arc/inc-stats", label: "Bilibili archive incremental stats" }), "Bilibili archive incremental stats");
+        return compactObject({
+            incClick: optionalNumber(data.inc_click),
+            incDanmaku: optionalNumber(data.inc_dm),
+            incReply: readBilibiliReplyIncrement(data),
+            incFavorite: optionalNumber(data.inc_fav),
+            incCoin: optionalNumber(data.inc_coin),
+            incShare: optionalNumber(data.inc_share),
+            incLike: optionalNumber(data.inc_like),
+            incElec: optionalNumber(data.inc_elec),
+        });
+    },
+};
+function normalizeBilibiliArchive(value) {
+    const record = optionalRecord(value) ?? {};
+    const review = optionalRecord(record.addit_info);
+    const video = optionalRecord(record.video_info);
+    return compactObject({
+        resourceId: optionalString(record.resource_id),
+        title: optionalString(record.title),
+        cover: optionalString(record.cover),
+        tid: optionalNumber(record.tid),
+        tag: optionalString(record.tag),
+        desc: optionalString(record.desc),
+        copyright: optionalNumber(record.copyright),
+        noReprint: optionalNumber(record.no_reprint),
+        state: optionalNumber(review?.state),
+        stateDesc: optionalString(review?.state_desc),
+        rejectReason: optionalString(review?.reject_reason),
+        ctime: optionalNumber(record.ctime),
+        ptime: optionalNumber(record.ptime),
+        video: video === undefined
+            ? undefined
+            : compactObject({
+                cid: optionalNumber(video.cid),
+                filename: optionalString(video.filename),
+                duration: optionalNumber(video.duration),
+                shareUrl: optionalString(video.share_url),
+                iframeUrl: optionalString(video.iframe_url),
+            }),
+    });
+}
+export const bilibiliActionHandlers = combineProviderActionHandlers(service, bilibiliAccountActionHandlers, bilibiliArticleActionHandlers);
+export const executors = defineProviderExecutors({
+    service,
+    handlers: bilibiliActionHandlers,
+    // Both API hosts are hardcoded literals: member.bilibili.com and openupos.bilivideo.com.
+    skipDnsValidation: true,
+    createContext: createBilibiliContext,
+});
+export const oauth = {
+    async exchangeCode(input) {
+        return requestBilibiliOAuthToken({
+            url: input.tokenUrl,
+            fields: {
+                client_id: input.clientConfig.clientId,
+                client_secret: input.clientConfig.clientSecret,
+                grant_type: "authorization_code",
+                code: input.code,
+            },
+            fetcher: input.fetcher,
+            signal: input.signal,
+            createError: input.createError,
+        });
+    },
+    async refreshAccessToken(input) {
+        return requestBilibiliOAuthToken({
+            url: bilibiliOAuthRefreshTokenUrl,
+            fields: {
+                client_id: input.clientConfig.clientId,
+                client_secret: input.clientConfig.clientSecret,
+                grant_type: "refresh_token",
+                refresh_token: input.refreshToken,
+            },
+            fetcher: input.fetcher,
+            createError: input.createError,
+        });
+    },
+};
+export const credentialValidators = {
+    async oauth2(input, { fetcher, signal }) {
+        const signing = readBilibiliSigningMaterial(input.metadata);
+        if (!signing) {
+            return;
+        }
+        const data = requiredResponseRecord(await bilibiliApiRequest({ accessToken: input.accessToken, clientId: signing.clientId, appSecret: signing.appSecret, fetcher, signal }, { path: "/user/account/info", label: "Bilibili credential validation" }), "Bilibili credential validation");
+        const openid = optionalString(data.openid);
+        return {
+            profile: {
+                accountId: openid ?? "bilibili:oauth2",
+                displayName: optionalString(data.name) ?? openid ?? "Bilibili OAuth Credential",
+                grantedScopes: optionalStringArray(input.metadata.scopes) ?? [],
+            },
+        };
+    },
+};

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

@@ -0,0 +1,95 @@
+import type { ExecutionContext, TransitFileWriter } from "../../core/types.ts";
+import type { OAuthTokenResult } from "../../oauth/oauth-token.ts";
+import type { ProviderFetch, ProviderRuntimeHandler } from "../provider-runtime.ts";
+export declare const bilibiliUposBaseUrl = "https://openupos.bilivideo.com";
+export declare const bilibiliOAuthRefreshTokenUrl = "https://api.bilibili.com/x/account-oauth2/v1/refresh_token";
+export interface BilibiliActionContext {
+    accessToken: string;
+    clientId: string;
+    appSecret: string;
+    fetcher: ProviderFetch;
+    transitFiles?: TransitFileWriter;
+    signal?: AbortSignal;
+}
+/** Provider-native handler shape for Bilibili actions. */
+export type BilibiliActionHandler = ProviderRuntimeHandler<BilibiliActionContext>;
+/**
+ * Reject an edit call that carries no editable field: it would resubmit
+ * unchanged content and still cost a provider-side review round.
+ */
+export declare function assertAnyInputField(input: Record<string, unknown>, fields: readonly string[]): void;
+/** Read the signing material stored on the connection metadata by the OAuth client config. */
+export declare function readBilibiliSigningMaterial(metadata: Record<string, unknown>): {
+    clientId: string;
+    appSecret: string;
+} | undefined;
+/**
+ * Resolve the access token plus the signing material of the configured OAuth
+ * client. The Bilibili signature signs with the application App Secret, which
+ * the OAuth client config stores as the `appSecret` secretExtra field.
+ */
+export declare function createBilibiliContext(context: ExecutionContext, fetcher: ProviderFetch): Promise<BilibiliActionContext>;
+export interface BilibiliSignedHeadersInput {
+    clientId: string;
+    appSecret: string;
+    accessToken: string;
+    /** Exact request body string; GET and empty-body requests sign the MD5 of "". */
+    body?: string;
+}
+/**
+ * Create the signed common header set (signature version 2.0) for one arcopen
+ * request. The HMAC-SHA256 signature covers the sorted x-bili-* header lines
+ * joined by "\n"; per Bilibili's official demos the trailing newline of the
+ * last line is trimmed before signing.
+ */
+export declare function createBilibiliSignedHeaders(input: BilibiliSignedHeadersInput): Record<string, string>;
+export interface BilibiliApiRequestOptions {
+    method?: "GET" | "POST";
+    /** Endpoint path under https://member.bilibili.com/arcopen/fn, for example /archive/viewlist. */
+    path: string;
+    query?: Record<string, string | undefined>;
+    body?: Record<string, unknown>;
+    /** Short request label used in error messages. */
+    label: string;
+}
+/** Call one signed member.bilibili.com arcopen endpoint and unwrap its data envelope. */
+export declare function bilibiliApiRequest(context: BilibiliActionContext, options: BilibiliApiRequestOptions): Promise<unknown>;
+export interface BilibiliFormRequestOptions {
+    /** Endpoint path under https://member.bilibili.com/arcopen/fn. */
+    path: string;
+    /** Form fields; undefined values are skipped. */
+    fields?: Record<string, string | undefined>;
+    /** Optional file part, sent as the `file` form field. */
+    file?: File;
+    /** Short request label used in error messages. */
+    label: string;
+}
+/**
+ * POST one arcopen endpoint as multipart/form-data. Bilibili article
+ * endpoints take form fields instead of JSON, and per the signing rules the
+ * content MD5 of a form body is computed over an empty string.
+ */
+export declare function bilibiliFormRequest(context: BilibiliActionContext, options: BilibiliFormRequestOptions): Promise<unknown>;
+/** Read one arcopen/openupos response into its envelope data, mapping HTTP and envelope failures. */
+export declare function readBilibiliApiResponse(response: Response, label: string): Promise<unknown>;
+/** Unwrap the shared Bilibili { code, message, data } envelope of arcopen and openupos responses. */
+export declare function readBilibiliEnvelopeData(payload: unknown, label: string): unknown;
+/**
+ * Read the comment increment of an inc-stats response. The field table of the
+ * official document spells this counter icn_reply; the sample payload uses inc_reply.
+ */
+export declare function readBilibiliReplyIncrement(data: Record<string, unknown>): number | undefined;
+export interface BilibiliOAuthTokenRequest {
+    url: string;
+    fields: Record<string, string>;
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+    createError: (message: string) => Error;
+}
+/**
+ * Exchange or refresh a Bilibili OAuth token. Two Bilibili quirks force this
+ * provider-local request: the parameters travel in the URL query (the
+ * documents list them as url 参数), and `expires_in` is an absolute UTC Unix
+ * timestamp rather than a lifetime in seconds.
+ */
+export declare function requestBilibiliOAuthToken(input: BilibiliOAuthTokenRequest): Promise<OAuthTokenResult>;

package/src/providers/bilibili/runtime.js

@@ -0,0 +1,236 @@
+import { createHash, createHmac, randomUUID } from "node:crypto";
+import { compactObject, optionalNumber, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
+import { ProviderRequestError, createProviderTimeout, isAbortLikeError, providerInputError, providerResponseError, providerUserAgent, readProviderErrorTextBody, readProviderJsonBody, requireOAuthCredential, requiredResponseRecord, runProviderRequest, setSearchParams, } from "../provider-runtime.js";
+const bilibiliMemberBaseUrl = "https://member.bilibili.com";
+export const bilibiliUposBaseUrl = "https://openupos.bilivideo.com";
+export const bilibiliOAuthRefreshTokenUrl = "https://api.bilibili.com/x/account-oauth2/v1/refresh_token";
+const bilibiliApiBasePath = "/arcopen/fn";
+const bilibiliSignatureMethod = "HMAC-SHA256";
+const bilibiliSignatureVersion = "2.0";
+// Business codes from the 接口签名实现标准和状态码 document. -101 is the
+// main-site "not logged in" code that arcopen also returns for a dead token.
+const bilibiliCredentialErrorCodes = new Set([-101, 127000, 127001, 127002, 127004]);
+const bilibiliPermissionErrorCodes = new Set([123001, 127005, 127006, 127007, 127011, 127304, 127305]);
+const bilibiliRateLimitErrorCodes = new Set([127009, 127306]);
+const bilibiliInvalidInputErrorCodes = new Set([
+    4000, 123003, 123004, 123005, 123008, 123009, 123010, 123012, 123013, 123014, 123015, 123016, 123017, 123018, 123024,
+    123029, 123030, 123038, 123040, 123041, 129000, 129001, 129002, 129003, 129004, 129005, 129006, 129009, 129010,
+    129012, 129015, 129018,
+]);
+/**
+ * Reject an edit call that carries no editable field: it would resubmit
+ * unchanged content and still cost a provider-side review round.
+ */
+export function assertAnyInputField(input, fields) {
+    if (!fields.some((field) => input[field] !== undefined)) {
+        throw providerInputError(`Provide at least one field to edit: ${fields.join(", ")}.`);
+    }
+}
+/** Read the signing material stored on the connection metadata by the OAuth client config. */
+export function readBilibiliSigningMaterial(metadata) {
+    const clientId = optionalString(metadata.oauthClientId);
+    const appSecret = optionalString(optionalRecord(metadata.oauthClientSecretExtra)?.appSecret);
+    return clientId && appSecret ? { clientId, appSecret } : undefined;
+}
+/**
+ * Resolve the access token plus the signing material of the configured OAuth
+ * client. The Bilibili signature signs with the application App Secret, which
+ * the OAuth client config stores as the `appSecret` secretExtra field.
+ */
+export async function createBilibiliContext(context, fetcher) {
+    const credential = await requireOAuthCredential(context, "bilibili");
+    const signing = readBilibiliSigningMaterial(credential.metadata);
+    if (!signing) {
+        throw new ProviderRequestError(401, "Bilibili OAuth client is missing clientId or appSecret. Reconfigure the Bilibili OAuth client first.");
+    }
+    return {
+        accessToken: credential.accessToken,
+        clientId: signing.clientId,
+        appSecret: signing.appSecret,
+        fetcher,
+        transitFiles: context.transitFiles,
+        signal: context.signal,
+    };
+}
+/**
+ * Create the signed common header set (signature version 2.0) for one arcopen
+ * request. The HMAC-SHA256 signature covers the sorted x-bili-* header lines
+ * joined by "\n"; per Bilibili's official demos the trailing newline of the
+ * last line is trimmed before signing.
+ */
+export function createBilibiliSignedHeaders(input) {
+    const contentMd5 = createHash("md5")
+        .update(input.body ?? "")
+        .digest("hex");
+    const nonce = randomUUID();
+    const timestamp = Math.floor(Date.now() / 1000).toString();
+    const signedLines = [
+        `x-bili-accesskeyid:${input.clientId}`,
+        `x-bili-content-md5:${contentMd5}`,
+        `x-bili-signature-method:${bilibiliSignatureMethod}`,
+        `x-bili-signature-nonce:${nonce}`,
+        `x-bili-signature-version:${bilibiliSignatureVersion}`,
+        `x-bili-timestamp:${timestamp}`,
+    ];
+    const authorization = createHmac("sha256", input.appSecret).update(signedLines.join("\n")).digest("hex");
+    return {
+        accept: "application/json",
+        "access-token": input.accessToken,
+        authorization,
+        "x-bili-accesskeyid": input.clientId,
+        "x-bili-content-md5": contentMd5,
+        "x-bili-signature-method": bilibiliSignatureMethod,
+        "x-bili-signature-nonce": nonce,
+        "x-bili-signature-version": bilibiliSignatureVersion,
+        "x-bili-timestamp": timestamp,
+    };
+}
+/** Call one signed member.bilibili.com arcopen endpoint and unwrap its data envelope. */
+export async function bilibiliApiRequest(context, options) {
+    const method = options.method ?? "GET";
+    const url = new URL(`${bilibiliMemberBaseUrl}${bilibiliApiBasePath}${options.path}`);
+    setSearchParams(url, options.query ?? {});
+    const body = options.body === undefined ? undefined : JSON.stringify(options.body);
+    const headers = createBilibiliSignedHeaders({
+        clientId: context.clientId,
+        appSecret: context.appSecret,
+        accessToken: context.accessToken,
+        body,
+    });
+    // The document's samples send Content-Type: application/json on every
+    // JSON-channel request, including GETs and body-less POSTs.
+    headers["content-type"] = "application/json";
+    return runProviderRequest({ signal: context.signal, label: options.label }, async (signal) => readBilibiliApiResponse(await context.fetcher(url.toString(), { method, headers, body, signal }), options.label));
+}
+/**
+ * POST one arcopen endpoint as multipart/form-data. Bilibili article
+ * endpoints take form fields instead of JSON, and per the signing rules the
+ * content MD5 of a form body is computed over an empty string.
+ */
+export async function bilibiliFormRequest(context, options) {
+    const url = new URL(`${bilibiliMemberBaseUrl}${bilibiliApiBasePath}${options.path}`);
+    const form = new FormData();
+    for (const [key, value] of Object.entries(options.fields ?? {})) {
+        if (value !== undefined) {
+            form.set(key, value);
+        }
+    }
+    if (options.file) {
+        form.set("file", options.file, options.file.name);
+    }
+    const headers = createBilibiliSignedHeaders({
+        clientId: context.clientId,
+        appSecret: context.appSecret,
+        accessToken: context.accessToken,
+    });
+    return runProviderRequest({ signal: context.signal, label: options.label }, async (signal) => readBilibiliApiResponse(await context.fetcher(url.toString(), { method: "POST", headers, body: form, signal }), options.label));
+}
+/** Read one arcopen/openupos response into its envelope data, mapping HTTP and envelope failures. */
+export async function readBilibiliApiResponse(response, label) {
+    if (!response.ok) {
+        const text = await readProviderErrorTextBody(response, `${label} error response`);
+        throw new ProviderRequestError(response.status >= 500 ? 502 : response.status, text || `${label} failed with HTTP ${response.status}`);
+    }
+    const payload = await readProviderJsonBody(response, {
+        emptyBody: {},
+        invalidJsonMessage: `${label} returned invalid JSON`,
+    });
+    return readBilibiliEnvelopeData(payload, label);
+}
+/** Unwrap the shared Bilibili { code, message, data } envelope of arcopen and openupos responses. */
+export function readBilibiliEnvelopeData(payload, label) {
+    const envelope = requiredResponseRecord(payload, label);
+    const code = optionalNumber(envelope.code);
+    if (code === 0) {
+        return envelope.data;
+    }
+    const message = optionalString(envelope.message) ?? "unknown error";
+    if (code !== undefined && bilibiliCredentialErrorCodes.has(code)) {
+        throw new ProviderRequestError(401, `Bilibili credential expired or invalid (code ${code}): ${message}`, envelope);
+    }
+    const status = code === undefined ? 502 : mapBilibiliErrorStatus(code);
+    if (status === 502) {
+        throw providerResponseError(`${label} failed (code ${code ?? "unknown"}): ${message}`);
+    }
+    throw new ProviderRequestError(status, `${label} failed (code ${code}): ${message}`, envelope);
+}
+/** Map a documented non-zero business code to the runtime status it means; unknown codes stay upstream failures. */
+function mapBilibiliErrorStatus(code) {
+    if (bilibiliPermissionErrorCodes.has(code)) {
+        return 403;
+    }
+    if (bilibiliRateLimitErrorCodes.has(code)) {
+        return 429;
+    }
+    if (bilibiliInvalidInputErrorCodes.has(code)) {
+        return 400;
+    }
+    return 502;
+}
+/**
+ * Read the comment increment of an inc-stats response. The field table of the
+ * official document spells this counter icn_reply; the sample payload uses inc_reply.
+ */
+export function readBilibiliReplyIncrement(data) {
+    return optionalNumber(data.inc_reply) ?? optionalNumber(data.icn_reply);
+}
+/**
+ * Exchange or refresh a Bilibili OAuth token. Two Bilibili quirks force this
+ * provider-local request: the parameters travel in the URL query (the
+ * documents list them as url 参数), and `expires_in` is an absolute UTC Unix
+ * timestamp rather than a lifetime in seconds.
+ */
+export async function requestBilibiliOAuthToken(input) {
+    const url = new URL(input.url);
+    setSearchParams(url, input.fields);
+    const timeout = createProviderTimeout(input.signal);
+    let response;
+    try {
+        response = await input.fetcher(url.toString(), {
+            method: "POST",
+            headers: {
+                accept: "application/json",
+                "content-type": "application/x-www-form-urlencoded",
+                "user-agent": providerUserAgent,
+            },
+            redirect: "manual",
+            signal: timeout.signal,
+        });
+    }
+    catch (error) {
+        timeout.cleanup();
+        if (input.signal?.aborted) {
+            throw input.createError("Bilibili OAuth token request was cancelled.");
+        }
+        if (timeout.didTimeout() || isAbortLikeError(error)) {
+            throw input.createError("Bilibili OAuth token request timed out.");
+        }
+        throw input.createError("Bilibili OAuth token request failed without an HTTP response.");
+    }
+    try {
+        const payload = optionalRecord(await readProviderJsonBody(response, {
+            emptyBody: {},
+            invalidJsonMessage: "Bilibili OAuth token request returned invalid JSON",
+        }));
+        const code = optionalNumber(payload?.code);
+        if (!response.ok || code !== 0) {
+            throw input.createError(optionalString(payload?.message) ?? `Bilibili OAuth token request failed (HTTP ${response.status}).`);
+        }
+        const data = optionalRecord(payload?.data);
+        const accessToken = requiredString(data?.access_token, "access_token", input.createError);
+        return {
+            accessToken,
+            refreshToken: optionalString(data?.refresh_token),
+            tokenType: "Bearer",
+            expiresAt: readBilibiliExpiresAt(optionalNumber(data?.expires_in)),
+            metadata: compactObject({ scopes: data?.scopes }),
+        };
+    }
+    finally {
+        timeout.cleanup();
+    }
+}
+function readBilibiliExpiresAt(expiresAtUnixSeconds) {
+    const millis = (expiresAtUnixSeconds ?? 0) * 1000;
+    return millis > 0 && millis <= 8.64e15 ? new Date(millis).toISOString() : undefined;
+}

package/src/providers/bilibili/upload.d.ts

@@ -0,0 +1,14 @@
+import type { BilibiliActionContext } from "./runtime.ts";
+/**
+ * Upload one video through Bilibili's upload-token flow: initialize, then a
+ * single openupos upload (files up to 100MB) or equal-sized 10MB parts plus
+ * the merge call. Returns the upload token used by archive submission.
+ */
+export declare function uploadBilibiliVideo(context: BilibiliActionContext, file: File): Promise<string>;
+/** Upload one cover image (jpeg/png, up to 5MB) and return its Bilibili-hosted URL. */
+export declare function uploadBilibiliCover(context: BilibiliActionContext, file: File): Promise<string>;
+/** Upload one article image (jpg/png, up to 5MB) and return its Bilibili-hosted URL. */
+export declare function uploadBilibiliArticleImage(context: BilibiliActionContext, file: File, watermark?: boolean): Promise<{
+    url: string;
+    size?: number;
+}>;