@lumia.wang/koishi-plugin-adapter-bilibili 0.1.0 → 0.1.2

package/docs/video-toolkit.md

@@ -5,6 +5,7 @@ Other plugins can use these methods on an authenticated `bot.internal` without m
 | Method | Result |
 | --- | --- |
 | `getVideoSubtitle(bvid)` | `{ bvid, cid, language, text }`; `text` is empty when no subtitle track exists |
+| `getVideoAudio(bvid, { maxDuration?, maxBytes? })` | Since 0.1.2: `{ bvid, cid, duration, mime: 'audio/mp4', data: Buffer }` for the first part's AAC track |
 | `getVideoComments(bvid, options?)` | Normalized comments with string IDs, text, author, likes and mention presence |
 | `getUserVideos(uid, { days?, pages? })` | Recent submissions, ordered by publication time |
 | `getRelatedVideos(bvid)` | Related videos as `VideoBrief[]` |
@@ -15,6 +16,7 @@ Other plugins can use these methods on an authenticated `bot.internal` without m
 
 `getVideoComments` accepts `limit` (1–60), `root` (thread root ID), `sort` (`hot` or `time`), and `anonymous`.
 `getUserVideos` accepts `days` (1–90, default 7) and `pages` (1–5, default 2).
+`getVideoAudio` defaults to 600 seconds and 32 MiB. Callers may choose smaller limits, up to 1800 seconds and 64 MiB. Invalid limits, excessive duration, an unavailable AAC track, empty downloads and excessive download size throw errors. Interrupted/oversized streams are closed. Audio downloads use the context HTTP client without the adapter Cookie, while playback URL requests reuse the account and WBI signature. No external downloader or media process is started.
 Mention objects are `{ id: 'numeric UID', name: 'exact nickname' }`; include the matching `@nickname` in the text. IDs should be passed as strings.
 
 These new APIs propagate request failures and Bilibili error codes instead of treating them as empty content. A missing comment receipt does not trigger a retry. Existing `sendComment` behavior is unchanged: it remains a reply-only API for received comment targets.

package/lib/bilibiliAPI/apis/comment.d.ts

@@ -0,0 +1,51 @@
+import { Context } from 'koishi';
+import type { BilibiliDmBot } from '../../bot/bot';
+export interface BilibiliCommentNotification {
+    id: string;
+    oid: number;
+    type: 1 | 11;
+    channelId: string;
+    userId: string;
+    userName: string;
+    userAvatar: string;
+    content: string;
+    timestamp: number;
+    rpid: number;
+    root: number;
+    parent: number;
+    mentions: BilibiliMention[];
+}
+export interface BilibiliMention {
+    id: string;
+    name: string;
+}
+export interface BilibiliCommentTarget {
+    oid: number;
+    type: 1 | 11;
+    rpid: number;
+    root: number;
+    parent: number;
+}
+export interface BilibiliCommentMention {
+    id: string;
+    name: string;
+}
+export declare class CommentAPI {
+    private readonly bot;
+    private readonly ctx;
+    private intervalId;
+    private isPolling;
+    private initialized;
+    private requestActive;
+    private readonly processedIds;
+    private readonly unavailableVideos;
+    constructor(bot: BilibiliDmBot, ctx: Context);
+    startPolling(interval: number): void;
+    stopPolling(): void;
+    isPollingActive(): boolean;
+    sendComment(channelId: string, content: string, target?: BilibiliCommentTarget, mentions?: BilibiliCommentMention[]): Promise<string | null>;
+    private poll;
+    private fetchNotifications;
+    private parseNotification;
+    private createNotification;
+}

package/lib/bilibiliAPI/apis/dynamic.d.ts

@@ -0,0 +1,108 @@
+import { BilibiliDmBot } from '../../bot/bot';
+import { Context } from 'koishi';
+import { DynamicItem, DynamicSummary } from './types';
+export declare class DynamicAPI {
+    private bot;
+    private ctx;
+    private pollIntervalId;
+    private isPolling;
+    private pollInterval;
+    private lastDynamicBaseline;
+    private recentDynamics;
+    private maxRecentCount;
+    private dataFilePath;
+    constructor(bot: BilibiliDmBot, ctx: Context);
+    /**
+     * 确保数据目录存在
+     */
+    private ensureDataDir;
+    /**
+     * 加载最近动态数据
+     */
+    private loadRecentDynamics;
+    /**
+     * 保存最近动态数据
+     */
+    private saveRecentDynamics;
+    /**
+     * 生成动态内容的hash
+     */
+    private generateDynamicHash;
+    /**
+     * 将动态转换为摘要信息
+     */
+    private dynamicToSummary;
+    /**
+     * 获取指定 UP 主的动态
+     * @param uid UP 主的 UID
+     * @param offset 分页偏移量
+     * @returns Promise<DynamicItem[]> 指定 UP 主的动态列表
+     */
+    getPersonalDynamics(uid: string, offset?: string): Promise<DynamicItem[]>;
+    /**
+     * 获取动态详情
+     * @param dynamicId 动态 ID
+     * @returns Promise<DynamicItem | null> 动态详情
+     */
+    getDynamicDetail(dynamicId: string): Promise<DynamicItem | null>;
+    /**
+     * 获取所有关注的 UP 主的动态
+     * @param offset 分页偏移量
+     * @param updateBaseline 更新基线
+     * @returns Promise<DynamicItem[]> 所有关注的 UP 主的动态列表
+     */
+    getAllFollowedDynamics(offset?: string, updateBaseline?: string): Promise<DynamicItem[]>;
+    /**
+     * 开始监听动态更新
+     * @param interval 轮询间隔（毫秒），默认60秒
+     */
+    startDynamicPolling(interval?: number): void;
+    /**
+     * 停止监听动态更新
+     */
+    stopDynamicPolling(): void;
+    /**
+     * 初始化最近动态列表
+     */
+    private initializeRecentDynamics;
+    /**
+     * 检查新动态
+     */
+    private checkForNewDynamics;
+    /**
+     * 触发动态事件
+     */
+    private emitDynamicEvent;
+    /**
+     * 解析动态内容
+     */
+    private parseDynamicContent;
+    /**
+     * 根据动态类型获取事件名称
+     */
+    private getDynamicEventName;
+    /**
+     * 获取监听状态
+     */
+    isPollingActive(): boolean;
+    /**
+     * 设置轮询间隔
+     */
+    setPollInterval(interval: number): void;
+    /**
+     * 获取当前基线
+     */
+    getCurrentBaseline(): string;
+    /**
+     * 设置基线
+     */
+    setBaseline(baseline: string): void;
+    /**
+     * 获取最近动态摘要（用于调试）
+     */
+    getRecentDynamicsSummary(): DynamicSummary[];
+    /**
+     * 手动触发一次检查
+     */
+    manualCheck(): Promise<void>;
+}

package/lib/bilibiliAPI/apis/live.d.ts

@@ -0,0 +1,91 @@
+import { BilibiliDmBot } from '../../bot/bot';
+import { Context } from 'koishi';
+import { LiveUser, LiveSummary } from './types';
+export declare class LiveAPI {
+    private bot;
+    private ctx;
+    private pollIntervalId;
+    private isPolling;
+    private pollInterval;
+    private currentLiveUsers;
+    private dataFilePath;
+    constructor(bot: BilibiliDmBot, ctx: Context);
+    /**
+     * 确保数据目录存在
+     */
+    private ensureDataDir;
+    /**
+     * 加载当前直播用户数据
+     */
+    private loadCurrentLiveUsers;
+    /**
+     * 保存当前直播用户数据
+     */
+    private saveCurrentLiveUsers;
+    /**
+     * 生成直播用户的hash
+     */
+    private generateLiveUserHash;
+    /**
+     * 将直播用户转换为摘要信息
+     */
+    private liveUserToSummary;
+    /**
+     * 获取当前正在直播的UP主列表
+     * @returns Promise<LiveUser[] | null> 正在直播的UP主列表，网络错误时返回null
+     */
+    getLiveUsers(): Promise<LiveUser[] | null>;
+    /**
+     * 开始监听直播状态更新
+     * @param interval 轮询间隔（毫秒），默认30秒
+     */
+    startLivePolling(interval?: number): void;
+    /**
+     * 停止监听直播状态更新
+     */
+    stopLivePolling(): void;
+    /**
+     * 初始化当前直播列表
+     */
+    private initializeCurrentLiveUsers;
+    /**
+     * 检查直播状态变化
+     */
+    private checkForLiveStatusChanges;
+    /**
+     * 触发开播事件
+     */
+    private emitLiveStartEvent;
+    /**
+     * 触发下播事件
+     */
+    private emitLiveEndEvent;
+    /**
+     * 触发直播信息更新事件
+     */
+    private emitLiveUpdateEvent;
+    /**
+     * 获取监听状态
+     */
+    isPollingActive(): boolean;
+    /**
+     * 设置轮询间隔
+     */
+    setPollInterval(interval: number): void;
+    /**
+     * 获取当前直播用户摘要（用于调试）
+     */
+    getCurrentLiveUsersSummary(): LiveSummary[];
+    /**
+     * 手动触发一次检查
+     */
+    manualCheck(): Promise<void>;
+    /**
+     * 获取指定UP主的直播状态
+     */
+    getUserLiveStatus(mid: number): Promise<LiveUser | null>;
+    /**
+     * 检查指定UP主是否正在直播
+     */
+    isUserLive(mid: number): Promise<boolean | null>;
+}

package/lib/bilibiliAPI/apis/liveRoom.d.ts

@@ -0,0 +1,10 @@
+import { LiveRoomInfo } from './types';
+import { BilibiliDmBot } from '../../bot/bot';
+export declare class LiveRoomAPI {
+    private bot;
+    constructor(bot: BilibiliDmBot);
+    getRoomInfo(roomId: number): Promise<LiveRoomInfo>;
+    enterRoom(roomId: number): Promise<void>;
+    heartbeat(roomId: number): Promise<void>;
+    getDanmakuInfo(roomId: number): Promise<any>;
+}

package/lib/bilibiliAPI/apis/liveWebSocket.d.ts

@@ -0,0 +1,41 @@
+import { BilibiliDmBot } from '../../bot/bot';
+import { LiveChatEventData } from './types';
+export declare class LiveWebSocketManager {
+    private bot;
+    private onMessage;
+    private ws;
+    private heartbeatTimer;
+    private currentRoomId;
+    private isConnected;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private liveRoomAPI;
+    private disposed;
+    private autoReconnect;
+    constructor(bot: BilibiliDmBot, onMessage: (data: LiveChatEventData) => void);
+    dispose(): void;
+    setLiveRoomAPI(liveRoomAPI: any): void;
+    enterRoom(roomId: number): Promise<void>;
+    leaveRoom(): Promise<void>;
+    private connectWebSocket;
+    private sendAuthPacket;
+    private generateBuvid;
+    private generateQueueUuid;
+    private createPacket;
+    private parseHeader;
+    private handleMessage;
+    private processPacket;
+    private handleLiveMessage;
+    private parseRawMessage;
+    private processLiveMessage;
+    private parseDanmuMsg;
+    private parseSendGift;
+    private parseWelcome;
+    private parseInteractWord;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private disconnect;
+    getCurrentRoomId(): number | null;
+    isConnectedToRoom(): boolean;
+}

package/lib/bilibiliAPI/apis/search.d.ts

@@ -0,0 +1,16 @@
+import { BilibiliDmBot } from '../../bot/bot';
+import { ComprehensiveSearchResponse, SearchArticle, SearchLiveRoom, SearchLiveUser, SearchOptions, SearchUser, SearchVideo } from './types';
+export declare class SearchAPI {
+    private bot;
+    constructor(bot: BilibiliDmBot);
+    comprehensiveSearch(keyword: string): Promise<ComprehensiveSearchResponse | null>;
+    searchUsers(keyword: string, options?: SearchOptions): Promise<SearchUser[]>;
+    searchVideos(keyword: string, options?: SearchOptions): Promise<SearchVideo[]>;
+    searchLive(keyword: string, options?: SearchOptions): Promise<{
+        liveRooms: SearchLiveRoom[];
+        liveUsers: SearchLiveUser[];
+    }>;
+    searchArticles(keyword: string, options?: SearchOptions): Promise<SearchArticle[]>;
+    searchUsersByName(username: string, exactMatch?: boolean): Promise<SearchUser[]>;
+    searchUpUsers(keyword: string, options?: SearchOptions): Promise<SearchUser[]>;
+}

package/lib/bilibiliAPI/apis/user.d.ts

@@ -0,0 +1,48 @@
+import { BilibiliDmBot } from '../../bot/bot';
+import { FollowingUser } from './types';
+export declare class UserAPI {
+    private bot;
+    constructor(bot: BilibiliDmBot);
+    /**
+     * 关注指定 UP 主
+     * @param uid UP 主的 UID
+     * @returns Promise<boolean> 是否成功关注
+     */
+    followUser(uid: string): Promise<boolean>;
+    /**
+     * 取消关注指定 UP 主
+     * @param uid UP 主的 UID
+     * @returns Promise<boolean> 是否成功取消关注
+     */
+    unfollowUser(uid: string): Promise<boolean>;
+    /**
+     * 获取关注的用户列表
+     * @param maxPages 最大页数，默认10页
+     * @returns Promise<FollowingUser[]> 关注的用户列表
+     */
+    getFollowedUsers(maxPages?: number): Promise<FollowingUser[]>;
+    /**
+     * 获取用户信息
+     * @param uid 用户UID
+     * @returns Promise<any> 用户信息
+     */
+    getUserInfo(uid: string): Promise<any>;
+    /**
+     * 检查是否关注了指定用户
+     * @param uid 用户UID
+     * @returns Promise<boolean> 是否已关注
+     */
+    isFollowing(uid: string): Promise<boolean>;
+    /**
+     * 批量检查关注状态
+     * @param uids 用户UID列表
+     * @returns Promise<Record<string, boolean>> UID到关注状态的映射
+     */
+    batchCheckFollowing(uids: string[]): Promise<Record<string, boolean>>;
+    /**
+     * 获取指定UID的登录cookie数据
+     * @param uid 登录bot的UID
+     * @returns Promise<any | null> 返回cookie数据，如果文件不存在则返回null
+     */
+    getTokenByUid(uid: string): Promise<any | null>;
+}

package/lib/bilibiliAPI/apis/video.d.ts

@@ -0,0 +1,9 @@
+import { BilibiliDmBot } from '../../bot/bot';
+import { ExternalParseResponse, VideoConclusionData, VideoData } from './types';
+export declare class VideoAPI {
+    private bot;
+    constructor(bot: BilibiliDmBot);
+    getVideoInfo(bvid: string): Promise<VideoData | null>;
+    parseExternalUrl(url: string, accessKey?: string): Promise<ExternalParseResponse | null>;
+    getVideoConclusion(bvid: string, cid: number, up_mid: number): Promise<VideoConclusionData | null>;
+}

package/lib/bilibiliAPI/apis/videoToolkit.d.ts

@@ -45,7 +45,19 @@ export interface FavoriteFolder {
     id: number;
     title: string;
 }
+export interface VideoAudioOptions {
+    maxDuration?: number;
+    maxBytes?: number;
+}
+export interface VideoAudio {
+    bvid: string;
+    cid: number;
+    duration: number;
+    mime: 'audio/mp4';
+    data: Buffer;
+}
 export interface VideoToolkit {
+    getVideoAudio(bvid: string, options?: VideoAudioOptions): Promise<VideoAudio>;
     getVideoSubtitle(bvid: string): Promise<VideoSubtitle>;
     getVideoComments(bvid: string, options?: VideoCommentOptions): Promise<VideoComment[]>;
     getUserVideos(uid: string, options?: UserVideoOptions): Promise<VideoBrief[]>;
@@ -64,6 +76,8 @@ export declare class VideoToolkitAPI implements VideoToolkit {
     private post;
     private info;
     getVideoSubtitle(bvid: string): Promise<VideoSubtitle>;
+    /** Downloads one bounded AAC track for Node-based audio processing. */
+    getVideoAudio(bvid: string, options?: VideoAudioOptions): Promise<VideoAudio>;
     getVideoComments(bvid: string, options?: VideoCommentOptions): Promise<VideoComment[]>;
     getUserVideos(uid: string, options?: UserVideoOptions): Promise<VideoBrief[]>;
     getRelatedVideos(bvid: string): Promise<VideoBrief[]>;

package/lib/bilibiliAPI/internal.d.ts

@@ -1,6 +1,6 @@
 import { Context } from 'koishi';
 import { BilibiliDmBot } from '../bot/bot';
-import { VideoCommentOptions, UserVideoOptions } from './apis/videoToolkit';
+import { VideoCommentOptions, UserVideoOptions, VideoAudioOptions } from './apis/videoToolkit';
 import { BilibiliCommentMention, BilibiliCommentTarget } from './apis/comment';
 import { DynamicItem, FollowingUser, InternalInterface, SearchUser, SearchVideo, SearchLiveRoom, SearchLiveUser, SearchArticle, ComprehensiveSearchResponse, SearchOptions, VideoData, ExternalParseResponse, VideoConclusionData } from './apis/types';
 export declare class Internal implements InternalInterface {
@@ -21,6 +21,7 @@ export declare class Internal implements InternalInterface {
     isCommentPollingActive(): boolean;
     sendComment(channelId: string, content: string, target?: BilibiliCommentTarget, mentions?: BilibiliCommentMention[]): Promise<string | null>;
     getVideoSubtitle(bvid: string): Promise<import(".").VideoSubtitle>;
+    getVideoAudio(bvid: string, options?: VideoAudioOptions): Promise<import(".").VideoAudio>;
     getVideoComments(bvid: string, options?: VideoCommentOptions): Promise<import(".").VideoComment[]>;
     getUserVideos(uid: string, options?: UserVideoOptions): Promise<import(".").VideoBrief[]>;
     getRelatedVideos(bvid: string): Promise<import(".").VideoBrief[]>;

package/lib/bilibiliAPI/temp_error_codes.d.ts

@@ -0,0 +1 @@
+export declare function getBilibiliErrorMessage(code: number): string;

package/lib/bot/adapter.d.ts

@@ -0,0 +1,17 @@
+import { BilibiliService } from './service';
+import { Adapter, Context } from 'koishi';
+import { PluginConfig } from './types';
+import { BilibiliDmBot } from './bot';
+export interface BilibiliAdapterConfig extends PluginConfig {
+    service: BilibiliService;
+}
+export declare class BilibiliDmAdapter extends Adapter<Context, BilibiliDmBot> {
+    config: BilibiliAdapterConfig;
+    static immediate: boolean;
+    private readonly services;
+    constructor(ctx: Context, config: BilibiliAdapterConfig);
+    start(): Promise<void>;
+    fork(parent?: Context, config?: any, error?: any): Promise<this>;
+    dispose(): Promise<void>;
+    startBot(pluginConfig: PluginConfig, service: BilibiliService): Promise<void>;
+}

package/lib/bot/bot.d.ts

@@ -0,0 +1,173 @@
+import { Bot, Context, Fragment, Universal } from 'koishi';
+import { BilibiliMessageEncoder } from './messageEncoder';
+import { Internal } from '../bilibiliAPI/internal';
+import { BilibiliCookie } from './types';
+import { BilibiliCommentMention, BilibiliCommentNotification } from '../bilibiliAPI/apis/comment';
+import { PluginConfig } from './types';
+import { HttpClient } from './http';
+import type { BilibiliService } from './service';
+declare module 'koishi' {
+    interface Context {
+        internal: Internal;
+    }
+    interface Events {
+        'bilibili/live'(data: {
+            id: string;
+            uid: string;
+            name: string;
+            avatar: string;
+            timestamp: number;
+            action: string;
+            type: string;
+            room_id: string;
+            title: string;
+            cover: string;
+            jump_url: string;
+        }): void;
+        'bilibili/dynamic'(data: {
+            id: string;
+            uid: string;
+            name: string;
+            avatar: string;
+            timestamp: number;
+            action: string;
+            type: string;
+            text: string;
+            jump_url: string;
+            cover: string;
+            title?: string;
+            description?: string;
+            bvid?: string;
+            aid?: string;
+            images?: string[];
+            cvid?: number;
+        }): void;
+        'bilibili/live-chat'(data: {
+            roomId: number;
+            roomInfo: {
+                title: string;
+                uname: string;
+                face: string;
+                area_name: string;
+                online: number;
+            };
+            message: {
+                type: 'danmaku' | 'gift' | 'welcome' | 'guard_buy' | 'super_chat' | 'other' | 'interact' | 'entry_effect' | 'watched_change';
+                data: any;
+                timestamp: number;
+                raw: any;
+            };
+        }): void;
+    }
+}
+export declare class BilibiliDmBot extends Bot<Context, PluginConfig> {
+    ctx: Context;
+    private readonly service;
+    static inject: string[];
+    static MessageEncoder: typeof BilibiliMessageEncoder;
+    private lastPollTs;
+    private processedMsgIds;
+    private readonly _maxCacheSize;
+    private cleanupFunctions;
+    private isStopping;
+    private botOnlineTimestamp;
+    private consecutiveFailures;
+    private currentPollInterval;
+    private readonly _msgIdExpireTime;
+    private startTask;
+    private loginReady;
+    private loginCancelled;
+    private readonly loginReadyPromise;
+    private resolveLoginReady;
+    private readonly commentTargets;
+    readonly http: HttpClient;
+    readonly pluginConfig: PluginConfig;
+    readonly internal: Internal;
+    constructor(ctx: Context, config: PluginConfig, service: BilibiliService);
+    addCleanup(fn: () => void): void;
+    markLoginReady(): void;
+    cancelLogin(): void;
+    private handlePollSuccess;
+    private handlePollFailure;
+    private autoShutdown;
+    private startPolling;
+    private startDynamicPolling;
+    private startLivePolling;
+    private startCommentPolling;
+    private startContinuousPolling;
+    private poll;
+    /**
+     * 根据消息来源获取消息前缀
+     */
+    private getMessagePrefix;
+    private adaptMessage;
+    start(): Promise<void>;
+    private startInternal;
+    stop(): Promise<void>;
+    /**
+     * 启动消息ID定期清理
+     */
+    private startMessageIdCleanup;
+    saveCookie(cookie: BilibiliCookie): Promise<void>;
+    getSelf(): Promise<Universal.User>;
+    getUser(userId: string): Promise<Universal.User>;
+    /**
+     * 创建私聊频道
+     * @param userId 用户ID
+     * @returns 频道信息
+     */
+    createDirectChannel(userId: string): Promise<{
+        id: string;
+        type: Universal.Channel.Type;
+    }>;
+    /**
+     * 获取登录信息
+     * @returns 登录信息
+     */
+    toJSON(): Universal.Login;
+    getLogin(): Promise<Universal.Login>;
+    /**
+     * 获取好友列表
+     * @returns 好友列表
+     */
+    getFriendList(): Promise<{
+        data: any[];
+    }>;
+    sendMessage(channelId: string, content: Fragment): Promise<string[]>;
+    sendComment(channelId: string, content: string, mentions?: BilibiliCommentMention[]): Promise<string | null>;
+    receiveComment(notification: BilibiliCommentNotification): Promise<void>;
+    private parseCommentContent;
+    private preprocessContent;
+    sendPrivateMessage(userId: string, content: Fragment): Promise<string[]>;
+    getMessage(channelId: string, messageId: string): Promise<Universal.Message | undefined>;
+    /**
+     * 获取消息列表
+     * @param channelId 频道ID
+     * @param next 分页参数
+     * @param direction 方向
+     * @param limit 限制数量
+     * @param order 排序
+     * @returns 消息列表
+     */
+    getMessageList(channelId: string, next?: string, direction?: Universal.Direction, limit?: number, order?: Universal.Order): Promise<{
+        data: Universal.Message[];
+    }>;
+    deleteMessage(channelId: string, messageId: string): Promise<void>;
+    /**
+     * 进入指定直播间
+     * @param roomId 直播间ID
+     */
+    enterLiveRoom(roomId: number): Promise<void>;
+    /**
+     * 退出当前直播间
+     */
+    leaveLiveRoom(): Promise<void>;
+    /**
+     * 获取当前所在的直播间ID
+     */
+    getCurrentLiveRoomId(): number | null;
+    /**
+     * 检查是否已连接到直播间
+     */
+    isConnectedToLiveRoom(): boolean;
+}