koishi-plugin-bilibili-notify 2.0.0-alpha.8 → 3.0.0-alpha.0

package/lib/biliAPI.d.ts

@@ -26,6 +26,22 @@ declare class BiliAPI extends Service {
     }): Promise<string>;
     encrypt(text: string): string;
     decrypt(text: string): string;
+    getTheUserWhoIsLiveStreaming(): Promise<{
+        count: number;
+        group: string;
+        items: [
+            {
+                face: string;
+                is_reserve_recall: boolean;
+                jump_url: string;
+                mid: number;
+                room_id: number;
+                title: string;
+                uname: string;
+            }
+        ];
+    }>;
+    getLiveRoomInfoStreamKey(roomId: string): Promise<any>;
     getServerUTCTime(): Promise<number>;
     getTimeNow(): Promise<any>;
     getAllGroup(): Promise<any>;
@@ -53,6 +69,7 @@ declare class BiliAPI extends Service {
     createNewClient(): void;
     getTimeOfUTC8(): number;
     getCookies(): string;
+    getCookiesForHeader(): Promise<string>;
     getLoginInfoIsLoaded(): boolean;
     getLoginInfoFromDB(): Promise<{
         cookies: any;

package/lib/biliAPI.js

@@ -34,6 +34,8 @@ const GET_LIVE_ROOM_INFO = 'https://api.live.bilibili.com/room/v1/Room/get_info'
 const GET_MASTER_INFO = 'https://api.live.bilibili.com/live_user/v1/Master/info';
 const GET_TIME_NOW = 'https://api.bilibili.com/x/report/click/now';
 const GET_SERVER_UTC_TIME = 'https://interface.bilibili.com/serverdate.js';
+// 最近更新UP
+const GET_LATEST_UPDATED_UPS = 'https://api.bilibili.com/x/polymer/web-dynamic/v1/portal';
 // 操作
 const MODIFY_RELATION = 'https://api.bilibili.com/x/relation/modify';
 const CREATE_GROUP = 'https://api.bilibili.com/x/relation/tag/create';
@@ -41,6 +43,8 @@ const MODIFY_GROUP_MEMBER = 'https://api.bilibili.com/x/relation/tags/addUsers';
 const GET_ALL_GROUP = 'https://api.bilibili.com/x/relation/tags';
 const COPY_USER_TO_GROUP = 'https://api.bilibili.com/x/relation/tags/copyUsers';
 const GET_RELATION_GROUP_DETAIL = 'https://api.bilibili.com/x/relation/tag';
+// 直播
+const GET_LIVE_ROOM_INFO_STREAM_KEY = 'https://api.live.bilibili.com/xlive/web-room/v1/index/getDanmuInfo';
 class BiliAPI extends koishi_1.Service {
     static inject = ['database', 'notifier'];
     jar;
@@ -103,6 +107,28 @@ class BiliAPI extends koishi_1.Service {
         return decrypted.toString();
     }
     // BA API
+    async getTheUserWhoIsLiveStreaming() {
+        try {
+            // 获取直播间信息流密钥
+            const { data: { live_users } } = await this.client.get(GET_LATEST_UPDATED_UPS);
+            // 返回data
+            return live_users;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
+    }
+    async getLiveRoomInfoStreamKey(roomId) {
+        try {
+            // 获取直播间信息流密钥
+            const { data } = await this.client.get(`${GET_LIVE_ROOM_INFO_STREAM_KEY}?id=${roomId}`);
+            // 返回data
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
+    }
     async getServerUTCTime() {
         try {
             const { data } = await this.client.get(GET_SERVER_UTC_TIME);
@@ -362,6 +388,21 @@ class BiliAPI extends koishi_1.Service {
         const cookies = JSON.stringify(this.jar.serializeSync().cookies);
         return cookies;
     }
+    async getCookiesForHeader() {
+        try {
+            // 获取cookies对象
+            const cookies = this.jar.serializeSync().cookies;
+            // 将每个 cookie 对象转换为 "key=value" 形式，并用 "; " 连接起来
+            const cookieHeader = cookies
+                .map(cookie => `${cookie.key}=${cookie.value}`)
+                .join('; ');
+            return cookieHeader;
+        }
+        catch (e) {
+            console.error("无效的 JSON 格式：", e);
+            return "";
+        }
+    }
     getLoginInfoIsLoaded() {
         return this.loginInfoIsLoaded;
     }

package/lib/blive.d.ts

@@ -0,0 +1,24 @@
+import { Awaitable, Context, Schema, Service } from "koishi";
+import { type MsgHandler } from 'blive-message-listener';
+declare module 'koishi' {
+    interface Context {
+        bl: BLive;
+    }
+}
+declare class BLive extends Service {
+    static inject: string[];
+    private blConfig;
+    private listenerRecord;
+    private timerRecord;
+    constructor(ctx: Context, config: BLive.Config);
+    protected stop(): Awaitable<void>;
+    startLiveRoomListener(roomId: string, handler: MsgHandler, danmakuPushTime: () => void): Promise<void>;
+    closeListener(roomId: string): void;
+}
+declare namespace BLive {
+    interface Config {
+        danmakuPushTime: number;
+    }
+    const Config: Schema<Config>;
+}
+export default BLive;

package/lib/blive.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const koishi_1 = require("koishi");
+const blive_message_listener_1 = require("blive-message-listener");
+class BLive extends koishi_1.Service {
+    // 必要服务
+    static inject = ['ba'];
+    // 配置
+    blConfig;
+    // 定义类属性
+    listenerRecord = {};
+    timerRecord = {};
+    constructor(ctx, config) {
+        // Extends super
+        super(ctx, 'bl');
+        // 将config赋值给类属性
+        this.blConfig = config;
+    }
+    // 注册插件dispose逻辑
+    stop() {
+        // 清除所有监听器
+        for (const key of Object.keys(this.listenerRecord)) {
+            this.closeListener(key);
+        }
+    }
+    async startLiveRoomListener(roomId, handler, danmakuPushTime) {
+        // 获取cookieStr
+        const cookiesStr = await this.ctx.ba.getCookiesForHeader();
+        // 获取自身信息
+        const mySelfInfo = await this.ctx.ba.getMyselfInfo();
+        // 创建实例并保存到Record中
+        this.listenerRecord[roomId] = (0, blive_message_listener_1.startListen)(parseInt(roomId), handler, {
+            ws: {
+                headers: {
+                    Cookie: cookiesStr
+                },
+                uid: mySelfInfo.data.mid
+            }
+        });
+        // 默认30s推送一次弹幕消息到群组并将dispose函数保存到Record中
+        this.timerRecord[roomId] = this.ctx.setInterval(danmakuPushTime, this.blConfig.danmakuPushTime * 1000 * 60);
+        // logger
+        this.logger.info(`${roomId}直播间弹幕监听已开启`);
+    }
+    closeListener(roomId) {
+        // 判断直播间监听器是否关闭
+        if (!this.listenerRecord || !this.listenerRecord[roomId] || !this.listenerRecord[roomId].closed) {
+            // 输出logger
+            this.logger.info(`${roomId}直播间弹幕监听器无需关闭`);
+        }
+        // 判断消息发送定时器是否关闭
+        if (!this.timerRecord || !this.timerRecord[roomId]) {
+            // 输出logger
+            this.logger.info(`${roomId}直播间消息发送定时器无需关闭`);
+        }
+        // 关闭直播间监听器
+        this.listenerRecord[roomId].close();
+        // 关闭消息发送定时器
+        this.timerRecord[roomId]();
+        // 判断是否关闭成功
+        if (this.listenerRecord[roomId].closed) {
+            // 删除直播间监听器
+            delete this.listenerRecord[roomId];
+            // 删除消息发送定时器
+            delete this.timerRecord[roomId];
+            // 输出logger
+            this.logger.info(`${roomId}直播间弹幕监听已关闭`);
+            // 直接返回 
+            return;
+        }
+        // 未关闭成功
+        this.logger.warn(`${roomId}直播间弹幕监听未成功关闭`);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (BLive) {
+    BLive.Config = koishi_1.Schema.object({
+        danmakuPushTime: koishi_1.Schema.number().required()
+    });
+})(BLive || (BLive = {}));
+exports.default = BLive;

package/lib/comRegister.d.ts

@@ -1,8 +1,21 @@
 import { Bot, Context, FlatPick, Logger, Schema, Session } from "koishi";
 import { Notifier } from "@koishijs/plugin-notifier";
 import { LoginBili } from "./database";
+declare enum LiveType {
+    NotLiveBroadcast = 0,
+    StartBroadcasting = 1,
+    LiveBroadcast = 2,
+    StopBroadcast = 3
+}
+type ChannelIdArr = Array<{
+    channelId: string;
+    dynamic: boolean;
+    live: boolean;
+    liveDanmaku: boolean;
+    atAll: boolean;
+}>;
 type TargetItem = {
-    idArr: Array<string>;
+    channelIdArr: ChannelIdArr;
     platform: string;
 };
 type Target = Array<TargetItem>;
@@ -14,7 +27,6 @@ type SubItem = {
     platform: string;
     live: boolean;
     dynamic: boolean;
-    liveDispose: Function;
 };
 type SubManager = Array<SubItem>;
 declare class ComRegister {
@@ -26,40 +38,70 @@ declare class ComRegister {
     num: number;
     rebootCount: number;
     subNotifier: Notifier;
+    ctx: Context;
     subManager: SubManager;
     loginDBData: FlatPick<LoginBili, "dynamic_group_id">;
     privateBot: Bot<Context>;
     dynamicDispose: Function;
-    sendMsgFunc: (bot: Bot<Context, any>, guild: string, content: any) => Promise<void>;
+    sendMsgFunc: (bot: Bot<Context, any>, channelId: string, content: any) => Promise<void>;
     constructor(ctx: Context, config: ComRegister.Config);
-    splitMultiPlatformStr(str: string): Array<{
-        idArr: Array<string>;
-        platform: string;
-    }>;
-    getBot(ctx: Context, pf: string): Bot<Context, any>;
+    init(config: ComRegister.Config): Promise<void>;
+    splitMultiPlatformStr(str: string): Target;
+    getBot(pf: string): Bot<Context, any>;
     sendPrivateMsg(content: string): Promise<void>;
-    sendPrivateMsgAndRebootService(ctx: Context): Promise<void>;
-    sendPrivateMsgAndStopService(ctx: Context): Promise<void>;
-    sendMsg(ctx: Context, targets: Target, content: any): Promise<void>;
-    dynamicDetect(ctx: Context): () => Promise<void>;
-    debug_dynamicDetect(ctx: Context): () => Promise<void>;
-    liveDetect(ctx: Context, roomId: string, target: Target): () => Promise<void>;
+    sendPrivateMsgAndRebootService(): Promise<void>;
+    sendPrivateMsgAndStopService(): Promise<void>;
+    sendMsg(targets: Target, content: any, live?: boolean): Promise<void>;
+    dynamicDetect(): () => Promise<void>;
+    debug_dynamicDetect(): () => Promise<void>;
+    sendLiveNotifyCard(info: {
+        username: string;
+        userface: string;
+        target: Target;
+        data: any;
+    }, liveType: LiveType, liveNotifyMsg?: string): Promise<void>;
+    useMasterInfo(uid: string): Promise<{
+        username: string;
+        userface: string;
+        roomId: number;
+    }>;
+    useLiveRoomInfo(roomId: string): Promise<any>;
+    liveDetectWithAPI(): Promise<() => Promise<void>>;
+    liveDetectWithListener(roomId: string, target: Target): Promise<void>;
     subShow(): string;
     checkIfNeedSub(liveSub: boolean, dynamicSub: boolean, session: Session, liveRoomData: any): Promise<Array<boolean>>;
-    updateSubNotifier(ctx: Context): void;
-    checkIfLoginInfoIsLoaded(ctx: Context): Promise<unknown>;
-    subUserInBili(ctx: Context, mid: string): Promise<{
+    updateSubNotifier(): void;
+    checkIfLoginInfoIsLoaded(): Promise<unknown>;
+    subUserInBili(mid: string): Promise<{
         flag: boolean;
         msg: string;
     }>;
-    getSubFromDatabase(ctx: Context): Promise<void>;
-    unsubSingle(ctx: Context, id: string, type: number): string;
+    loadSubFromConfig(subs: ComRegister.Config["sub"]): Promise<void>;
+    loadSubFromDatabase(): Promise<void>;
+    checkIfDynamicDetectIsNeeded(): void;
+    enableDynamicDetect(): void;
+    unsubSingle(id: string, type: number): string;
     checkIfUserIsTheLastOneWhoSubDyn(): void;
-    unsubAll(ctx: Context, uid: string): void;
-    checkIfIsLogin(ctx: Context): Promise<boolean>;
+    unsubAll(uid: string): void;
+    checkIfIsLogin(): Promise<boolean>;
 }
 declare namespace ComRegister {
     interface Config {
+        sub: Array<{
+            uid: string;
+            dynamic: boolean;
+            live: boolean;
+            target: Array<{
+                channelIdArr: Array<{
+                    channelId: string;
+                    dynamic: boolean;
+                    live: boolean;
+                    liveDanmaku: boolean;
+                    atAll: boolean;
+                }>;
+                platform: string;
+            }>;
+        }>;
         master: {
             enable: boolean;
             platform: string;
@@ -68,8 +110,6 @@ declare namespace ComRegister {
         };
         unlockSubLimits: boolean;
         automaticResend: boolean;
-        changeMasterInfoApi: boolean;
-        liveStartAtAll: boolean;
         restartPush: boolean;
         pushTime: number;
         liveLoopTime: number;