@floating-live/bilibili 0.15.3 → 0.16.1

package/plugin.d.ts

@@ -1,29 +1,42 @@
-import type { FloatingLive } from "floating-live";
-interface BilibiliLoginInfo {
-    credentials: string;
-    tokens: {
-        /** 用户uid */
-        userId: number;
-        /** buvid */
-        buvid: string;
-    };
-    userId: number;
-}
-declare module "floating-live" {
-    interface FloatingCommandMap {
-        "bilibili.credentials.check": (credentials: string) => Promise<BilibiliLoginInfo>;
-        "bilibili.login.qrcode.get": () => Promise<{
-            key: string;
-            url: string;
-        }>;
-        "bilibili.login.qrcode.poll": (key: string) => Promise<{
-            status: number;
-            credentials?: string;
-        }>;
-    }
-}
-export declare class PluginBilibili {
-    static pluginName: string;
-    constructor(main: FloatingLive);
-}
-export default PluginBilibili;
+import { AppPluginExposesMap, BasePlugin, PluginContext, UserInfo } from "floating-live";
+import { BilibiliApiClientEx } from "./utils/request";
+interface BilibiliLoginInfo {
+    credentials: string;
+    isLogin: boolean;
+    user: UserInfo | null;
+}
+declare module "floating-live" {
+    interface AppCommandMap {
+        /** 检测并更新登录cookie有效性 */
+        "bilibili.credentials.check": (credentials: string) => Promise<BilibiliLoginInfo>;
+        /** 设置UA */
+        "bilibili.client.userAgent": (credentials: string) => string;
+        /** 使用cookie登录 */
+        "bilibili.credentials.set": (credentials: string) => string;
+        /** 获取二维码 */
+        "bilibili.login.qrcode.get": () => Promise<{
+            key: string;
+            url: string;
+        }>;
+        /** 轮询二维码登录状态 */
+        "bilibili.login.qrcode.poll": (key: string) => Promise<{
+            status: number;
+            message?: string;
+            credentials?: string;
+        }>;
+    }
+}
+export interface PluginOptions {
+    userAgent: string;
+}
+export declare class PluginBilibili extends BasePlugin {
+    static pluginName: string;
+    apiClient: BilibiliApiClientEx;
+    room: AppPluginExposesMap["room"] | null;
+    init(ctx: PluginContext): void;
+    /** 设置登录凭证 */
+    setCredentials(cookie: string): string;
+    /** 设置UA */
+    setUserAgent(userAgent: string): string;
+}
+export default PluginBilibili;

package/plugin.js

@@ -1,67 +1,163 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginBilibili = void 0;
-const room_1 = require("./room");
-const utils_1 = require("./utils");
-const parser_1 = require("./parser");
-const platformInfo = {
-    name: "bilibili",
-    membership: {
-        id: "guard",
-        name: "大航海",
-        level: ["", "总督", "提督", "舰长"],
-    },
-    gift: {
-        action: "投喂",
-    },
-    currency: {
-        silver: {
-            name: "银瓜子",
-            ratio: 1,
-        },
-        gold: {
-            name: "电池",
-            ratio: 100,
-            money: 1000,
-        },
-    },
-    stats: {
-        view: "看过",
-        online: "在线",
-        like: "点赞",
-    },
-};
-class PluginBilibili {
-    constructor(main) {
-        main.command.register("bilibili.room.create", (id, options) => {
-            return new room_1.RoomBilibili(Number(id), options);
-        });
-        main.command.register("bilibili.room.info", async (id) => {
-            const rawInfo = await (0, utils_1.getInfoByRoom)(parseInt("" + id));
-            return (0, parser_1.parseInfo)(rawInfo);
-        });
-        main.command.register("bilibili.credentials.check", async (credentials) => {
-            const buvid = (await (0, utils_1.getBuvid)(credentials)) || "";
-            const userId = await (0, utils_1.getLoginUid)(credentials);
-            return {
-                credentials,
-                tokens: {
-                    userId,
-                    buvid,
-                },
-                userId,
-            };
-        });
-        main.manifest.register("platform", "bilibili", platformInfo);
-        main.command.register("bilibili.login.qrcode.get", () => {
-            return (0, utils_1.generateLoginQRcode)();
-        });
-        main.command.register("bilibili.login.qrcode.poll", async (key) => {
-            const [status, credentials] = await (0, utils_1.checkLoginQRcode)(key);
-            return { status, credentials };
-        });
-    }
-}
-exports.PluginBilibili = PluginBilibili;
-PluginBilibili.pluginName = "bilibili";
-exports.default = PluginBilibili;
+import { BasePlugin, } from "floating-live";
+import { RoomBilibili } from "./room";
+import { BilibiliApiClientEx, fetchLiveRoomData } from "./utils/request";
+import { RequestError } from "bilibili-live-danmaku";
+const platformInfo = {
+    name: "bilibili",
+    membership: {
+        id: "guard",
+        name: "大航海",
+        level: ["", "总督", "提督", "舰长"],
+    },
+    gift: {
+        action: "投喂",
+    },
+    currency: {
+        silver: {
+            name: "银瓜子",
+            ratio: 1,
+        },
+        gold: {
+            name: "电池",
+            ratio: 100,
+            money: 1000,
+        },
+    },
+    stats: {
+        view: "看过",
+        online: "在线",
+        like: "点赞",
+    },
+};
+export class PluginBilibili extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.apiClient = new BilibiliApiClientEx();
+        this.room = null;
+    }
+    init(ctx) {
+        ctx.whenRegister("platform", (platform) => {
+            platform.register("bilibili", platformInfo, ctx.signal);
+        });
+        ctx.whenRegister("room", (room) => {
+            this.room = room;
+            return () => {
+                this.room = null;
+            };
+        });
+        ctx.registerCommand("bilibili.room.create", (e, id, options) => {
+            return new RoomBilibili(Number(id), {
+                credentials: this.apiClient.cookie,
+                userAgent: this.apiClient.userAgent,
+                fetch: this.apiClient.fetch,
+                ...options,
+            });
+        });
+        ctx.registerCommand("bilibili.room.data", async (e, id) => {
+            return await fetchLiveRoomData(this.apiClient, parseInt(id.toString()));
+        });
+        ctx.registerCommand("bilibili.credentials.check", async (e, credentials) => {
+            const apiClient = new BilibiliApiClientEx({
+                cookie: credentials,
+                userAgent: this.apiClient.userAgent,
+                fetch: this.apiClient.fetch,
+            });
+            try {
+                // 检测cookie是否需要更新
+                const { refresh, timestamp } = (await apiClient.xpassportCookieInfo())
+                    .data;
+                if (refresh) {
+                    const refresh_token = apiClient.cookies.get("refresh_token");
+                    // 更新cookie
+                    const { refresh_token: new_refresh_token } = await apiClient.refreshCookie({
+                        timestamp,
+                        refresh_token,
+                    });
+                    apiClient.cookies.set("refresh_token", new_refresh_token);
+                }
+                // 检测登录状态
+                const data = (await apiClient.xapiNav()).data;
+                return {
+                    credentials,
+                    isLogin: true,
+                    user: {
+                        id: data.mid,
+                        name: data.uname,
+                        avatar: data.face,
+                    },
+                };
+            }
+            catch (e) {
+                if (e.ok && e.code == -101) {
+                    return {
+                        credentials,
+                        data: {},
+                        isLogin: false,
+                        user: null,
+                    };
+                }
+                else {
+                    throw e;
+                }
+            }
+        });
+        ctx.registerCommand("bilibili.credentials.set", (e, credentials) => {
+            return this.setCredentials(credentials);
+        });
+        ctx.registerCommand("bilibili.client.userAgent", (e, userAgent) => {
+            return this.setUserAgent(userAgent);
+        });
+        ctx.registerCommand("bilibili.login.qrcode.get", async () => {
+            const { qrcode_key, url } = (await this.apiClient.xpassportQrcodeGenerate()).data;
+            return { key: qrcode_key, url };
+        });
+        ctx.registerCommand("bilibili.login.qrcode.poll", async (e, key) => {
+            const data = await this.apiClient.xpassportQrcodePoll({
+                qrcode_key: key,
+            });
+            const { code, message, refresh_token } = data.data;
+            if (code == 86101) {
+                // 未扫码
+                return { status: 1, message };
+            }
+            else if (code == 86090) {
+                // 等待确认
+                return { status: 2, message };
+            }
+            else if (code == 0) {
+                // 扫码成功
+                this.apiClient.cookies.set("refresh_token", refresh_token);
+                return { status: 0, message, credentials: this.apiClient.cookie };
+            }
+            else if (code == 86038) {
+                // 二维码失效
+                return { status: -1, message };
+            }
+            else {
+                throw new RequestError({ ok: true, code, message });
+            }
+        });
+    }
+    /** 设置登录凭证 */
+    setCredentials(cookie) {
+        this.apiClient.setCookie(cookie);
+        this.room?.getList()
+            ?.filter((r) => r.platform == "bilibili")
+            .forEach((r) => {
+            r.setCredentials(cookie);
+        });
+        return cookie;
+    }
+    /** 设置UA */
+    setUserAgent(userAgent) {
+        this.apiClient.userAgent = userAgent;
+        this.room?.getList()
+            ?.filter((r) => r.platform == "bilibili")
+            .forEach((r) => {
+            r.userAgent = userAgent;
+        });
+        return userAgent;
+    }
+}
+PluginBilibili.pluginName = "bilibili";
+export default PluginBilibili;

package/room.d.ts

@@ -1,74 +1,105 @@
-import { BilibiliRoomInfo, ConnectTokens } from "./types";
-import { LiveRoom } from "floating-live";
-import { UserInfo, RoomStatsInfo, RoomDetail } from "floating-live";
-import { KeepLiveWS } from "bilibili-live-ws";
-/** 配置项 */
-export interface RoomOptions {
-    /** 生成房间后是否打开 */
-    open?: boolean;
-    /** 登录凭据 */
-    credentials?: string;
-    /** 连接凭证 */
-    tokens?: ConnectTokens;
-    /** 房间信息 */
-    info?: BilibiliRoomInfo;
-    /** 断线重连间隔(默认值为100ms) */
-    connectInterval?: number;
-}
-export declare class RoomBilibili extends LiveRoom implements BilibiliRoomInfo {
-    /** 平台id */
-    readonly platform: string;
-    /** 直播间号 */
-    readonly id: number;
-    /** 直播间room_id */
-    roomId: number;
-    /** 直播间短房号 */
-    shortId: number;
-    /** 房间信息 */
-    detail: RoomDetail;
-    stats: RoomStatsInfo;
-    /** 房间是否可用 */
-    available: boolean;
-    /** 是否连接上房间 */
-    connected: boolean;
-    /** 主播信息 */
-    anchor: UserInfo;
-    /** 直播间弹幕api模块 */
-    client: KeepLiveWS | null;
-    /** 断线重连间隔 */
-    connectInterval: number;
-    /** 连接凭证 */
-    private tokens;
-    /** 是否处于正在打开的状态 */
-    private opening;
-    /** 是否处于重连状态 */
-    private reconnecting;
-    constructor(
-    /** 房间id */
-    id: number, options?: RoomOptions);
-    /** 初始化 */
-    protected init(options?: RoomOptions): Promise<void>;
-    /** 获取房间信息 */
-    getInfo(): Promise<void>;
-    /** 请求房间信息 */
-    fetchInfo(): Promise<BilibiliRoomInfo>;
-    /** 更新直播间信息 */
-    updateInfo({ roomId, shortId, status, timestamp, detail, stats, anchor, liveId, available, }: BilibiliRoomInfo): void;
-    /** 开启直播间监听 */
-    open(): Promise<void>;
-    private openWS;
-    /** 设置登录凭据 */
-    setCredentials(credentials: string, userToken?: ConnectTokens): Promise<void>;
-    /** 请求连接tokens */
-    fetchTokens(credentials?: string, userToken?: ConnectTokens): Promise<ConnectTokens>;
-    /** 设置直播连接tokens */
-    setTokens(tokens: ConnectTokens): void;
-    /** 重连 */
-    reconnect(): void;
-    private emitConnention;
-    /** 创建直播弹幕客户端 */
-    private initClient;
-    /** 关闭直播间监听 */
-    close(): void;
-}
-export default RoomBilibili;
+import { BilibiliRoomData, ConnectTokens } from "./types";
+import { LiveWS } from "bilibili-live-danmaku";
+import { UserInfo, LiveRoomStatsInfo, LiveRoomDetailInfo, LiveRoom } from "floating-live";
+/** 配置项 */
+export interface RoomOptions {
+    /** 是否自动初始化(默认为true) */
+    init?: boolean;
+    /** 生成房间后是否立即打开 */
+    open?: boolean;
+    /** 自动重连(默认为false) */
+    autoReconnect?: boolean;
+    /** 登录凭据，若为空，则初始化时自动生成 */
+    credentials?: string;
+    /** 连接凭证，若为空，则初始化时自动生成 */
+    tokens?: ConnectTokens;
+    /** 用户代理，若为空，则使用默认值 */
+    userAgent?: string;
+    /** 预设置的房间数据，若设置，将不会自动更新直播间数据 */
+    data?: BilibiliRoomData;
+    /** 断线重连间隔(默认值为500ms) */
+    connectInterval?: number;
+    /** 连接超时阈值(默认值为45000ms) */
+    connectTimeout?: number;
+    /** 自定义fetchData */
+    customFetchData?: (id: number | string) => Promise<BilibiliRoomData>;
+    /** 自定义fetchTokens */
+    customFetchTokens?: (roomId: number) => Promise<ConnectTokens>;
+    /** 自定义fetch函数 */
+    fetch?: (input: string | URL, init?: RequestInit) => Promise<Response>;
+}
+declare const symbolAbortController: unique symbol;
+interface ClientWithAbortController extends LiveWS {
+    [symbolAbortController]: AbortController;
+}
+export declare class RoomBilibili extends LiveRoom implements BilibiliRoomData {
+    #private;
+    /** 平台id */
+    readonly platform: string;
+    /** 直播间号 */
+    readonly id: number;
+    /** 直播间room_id */
+    roomId: number;
+    /** 直播间短房号 */
+    shortId: number;
+    /** 房间信息 */
+    detail: LiveRoomDetailInfo;
+    stats: LiveRoomStatsInfo;
+    /** 是否连接上房间 */
+    connected: boolean;
+    /** 主播信息 */
+    anchor: UserInfo;
+    /** 直播间弹幕api客户端 */
+    client: ClientWithAbortController | null;
+    /** 断线重连间隔 */
+    connectInterval: number;
+    /** 连接超时阈值 */
+    connectTimeout: number;
+    /** 自动重连 */
+    autoReconnect: boolean;
+    /** 是否初始化 */
+    whenInit: Promise<RoomBilibili>;
+    get userAgent(): string;
+    set userAgent(ua: string);
+    /** 是否处于重连状态 */
+    private reconnecting;
+    /** 最后一次连接时间 */
+    private lastConnectionTime;
+    /** 自定义fetchData */
+    customFetchData?: (id: number | string) => BilibiliRoomData;
+    /** 自定义fetchTokens */
+    customFetchTokens?: (roomId: number, credentials: string) => Promise<ConnectTokens>;
+    constructor(
+    /** 房间id */
+    id: number, options?: RoomOptions);
+    /** 初始化
+     * 自动获取并设置 `credentials` ，自动获取房间信息和连接 `token`
+     */
+    protected init(options?: RoomOptions): Promise<void>;
+    /** 更新房间信息 */
+    update(): Promise<BilibiliRoomData>;
+    /** 获取房间信息 */
+    fetchData(): Promise<BilibiliRoomData>;
+    /** 设置直播间数据 */
+    setData({ roomId, shortId, status, timestamp, detail, stats, anchor, liveId, available, }: BilibiliRoomData): import("floating-live").LiveRoomData;
+    /** 开启直播间监听 */
+    open(): Promise<void>;
+    /** 设置登录凭据 */
+    setCredentials(credentials: string, updateTokens?: boolean): Promise<void>;
+    /** 更新连接tokens */
+    updateTokens(): Promise<void>;
+    /** 请求连接tokens */
+    fetchTokens(): Promise<ConnectTokens>;
+    /** 设置直播连接tokens */
+    setTokens(tokens: ConnectTokens): void;
+    /** 无缝重连 */
+    reconnect(): void;
+    private emitConnention;
+    /** 打开直播弹幕客户端 */
+    private openWebsocketClient;
+    /** 创建直播弹幕客户端 */
+    private initClient;
+    /** 关闭直播间监听 */
+    close(): void;
+}
+export default RoomBilibili;