koishi-plugin-bilibili-notify 3.0.0-alpha.14 → 3.0.0-alpha.16

package/lib/biliAPI.d.ts

@@ -67,7 +67,6 @@ declare class BiliAPI extends Service {
     disposeNotifier(): void;
     getRandomUserAgent(): string;
     createNewClient(): void;
-    getTimeOfUTC8(): number;
     getCookies(): string;
     getCookiesForHeader(): Promise<string>;
     getLoginInfoIsLoaded(): boolean;

package/lib/biliAPI.js

@@ -16,7 +16,6 @@ const axios_1 = __importDefault(require("axios"));
 const tough_cookie_1 = require("tough-cookie");
 const axios_cookiejar_support_1 = require("axios-cookiejar-support");
 const jsdom_1 = require("jsdom");
-const luxon_1 = require("luxon");
 const retry_1 = __importDefault(require("./utils/retry"));
 const mixinKeyEncTab = [
     46, 47, 18, 2, 53, 8, 23, 32, 15, 50, 10, 31, 58, 3, 45, 35, 27, 43, 5, 49,
@@ -297,9 +296,6 @@ class BiliAPI extends koishi_1.Service {
             },
         }));
     }
-    getTimeOfUTC8() {
-        return Math.floor(luxon_1.DateTime.now().setZone("UTC+8").toSeconds());
-    }
     getCookies() {
         const cookies = JSON.stringify(this.jar.serializeSync().cookies);
         return cookies;

package/lib/comRegister.d.ts

@@ -1,4 +1,4 @@
-import { type Bot, type Context, type FlatPick, type Logger, Schema, type Session } from "koishi";
+import { type Bot, type Context, type FlatPick, type Logger, Schema } from "koishi";
 import type { Notifier } from "@koishijs/plugin-notifier";
 import type { LoginBili } from "./database";
 declare enum LiveType {
@@ -47,7 +47,6 @@ declare class ComRegister {
     sendMsgFunc: (bot: Bot<Context, any>, channelId: string, content: any) => Promise<void>;
     constructor(ctx: Context, config: ComRegister.Config);
     init(config: ComRegister.Config): Promise<void>;
-    splitMultiPlatformStr(str: string): Target;
     getBot(pf: string): Bot<Context, any>;
     sendPrivateMsg(content: string): Promise<void>;
     sendPrivateMsgAndRebootService(): Promise<void>;
@@ -70,7 +69,6 @@ declare class ComRegister {
     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(): void;
     checkIfLoginInfoIsLoaded(): Promise<unknown>;
     subUserInBili(mid: string): Promise<{
@@ -78,12 +76,8 @@ declare class ComRegister {
         msg: string;
     }>;
     loadSubFromConfig(subs: ComRegister.Config["sub"]): Promise<void>;
-    loadSubFromDatabase(): Promise<void>;
     checkIfDynamicDetectIsNeeded(): void;
     enableDynamicDetect(): void;
-    unsubSingle(id: string, type: number): string;
-    checkIfUserIsTheLastOneWhoSubDyn(): void;
-    unsubAll(uid: string): void;
     checkIfIsLogin(): Promise<boolean>;
 }
 declare namespace ComRegister {
@@ -109,7 +103,6 @@ declare namespace ComRegister {
             masterAccount: string;
             masterAccountGuildId: string;
         };
-        unlockSubLimits: boolean;
         automaticResend: boolean;
         liveDetectMode: "API" | "WS";
         restartPush: boolean;

package/lib/comRegister.js

@@ -183,8 +183,6 @@ class ComRegister {
                         this.loginTimer();
                         // 订阅手动订阅中的订阅
                         await this.loadSubFromConfig(config.sub);
-                        // 订阅之前的订阅
-                        await this.loadSubFromDatabase();
                         // 清除控制台通知
                         ctx.ba.disposeNotifier();
                         // 发送成功登录推送
@@ -201,366 +199,13 @@ class ComRegister {
             }, 1000);
         });
         biliCom
-            .subcommand(".unsub <uid:string>", "取消订阅UP主动态、直播或全部")
-            .usage("取消订阅，加-l为取消直播订阅，加-d为取消动态订阅，什么都不加则为全部取消")
-            .option("live", "-l")
-            .option("dynamic", "-d")
-            .example("bili unsub 用户UID -ld")
-            .action(async ({ session, options }, uid) => {
-            this.logger.info("调用bili.unsub指令");
-            // 若用户UID为空则直接返回
-            if (!uid)
-                return "用户UID不能为空";
-            // -d -l两个选项不能同时存在
-            if (options.dynamic && options.live)
-                return "需要取消订阅该UP主请直接使用指令bili unsub 用户UID";
-            // 定义是否存在
-            let exist;
-            await Promise.all(this.subManager.map(async (sub, i) => {
-                if (sub.uid === uid) {
-                    // 取消单个订阅
-                    if (options.live || options.dynamic) {
-                        if (options.live)
-                            await session.send(this.unsubSingle(sub.roomId, 0)); /* 0为取消订阅Live */
-                        if (options.dynamic)
-                            await session.send(this.unsubSingle(sub.uid, 1)); /* 1为取消订阅Dynamic */
-                        // 将存在flag设置为true
-                        exist = true;
-                        // 结束循环
-                        return;
-                    }
-                    // 从数据库中删除订阅
-                    await ctx.database.remove("bilibili", {
-                        uid: this.subManager[i].uid,
-                    });
-                    // 将该订阅对象从订阅管理对象中移除
-                    this.subManager.splice(i, 1);
-                    // 将订阅对象移出订阅关注组
-                    const removeUserFromGroupData = await ctx.ba.removeUserFromGroup(sub.uid);
-                    // 判断是否移出成功 22105关注对象为自己
-                    if (removeUserFromGroupData.code !== 0 &&
-                        removeUserFromGroupData.code !== 22105) {
-                        // 移出失败
-                        await session.send("取消订阅对象失败，请稍后重试");
-                        // 将存在flag设置为true
-                        exist = true;
-                        // 结束循环
-                        return;
-                    }
-                    // id--
-                    this.num--;
-                    // 判断是否还有动态订阅
-                    this.checkIfUserIsTheLastOneWhoSubDyn();
-                    // 发送成功通知
-                    await session.send("已取消订阅该用户");
-                    // 更新控制台提示
-                    this.updateSubNotifier();
-                    // 将存在flag设置为true
-                    exist = true;
-                }
-            }));
-            // 未订阅该用户，无需取消订阅
-            if (!exist)
-                await session.send("未订阅该用户，无需取消订阅");
-        });
-        biliCom
-            .subcommand(".show", "展示订阅对象")
+            .subcommand(".list", "展示订阅对象")
             .usage("展示订阅对象")
-            .example("bili show")
+            .example("bili list")
             .action(() => {
             const subTable = this.subShow();
             return subTable;
         });
-        biliCom
-            .subcommand(".sub <mid:string> [...groupId:string]", "订阅用户动态和直播通知")
-            .option("multiplatform", "-m <value:string>", {
-            type: /^(?:-?[A-Za-z0-9]+@?(?:,-?[A-Za-z0-9]+@?)*\.[A-Za-z0-9]+)(?:;(?:-?[A-Za-z0-9]+@?(?:,-?[A-Za-z0-9]+@?)*\.[A-Za-z0-9]+))*$/,
-        })
-            .option("live", "-l")
-            .option("dynamic", "-d")
-            .option("atAll", "-a")
-            .usage("订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d")
-            .example("bili sub 1194210119 目标群号或频道号 -l -d 订阅UID为1194210119的UP主的动态和直播")
-            .action(async ({ session, options }, mid, ...groupId) => {
-            this.logger.info("调用bili.sub指令");
-            // 先判断是否订阅直播，再判断是否解锁订阅限制，最后判断直播订阅是否已超三个
-            if (options.live &&
-                !this.config.unlockSubLimits &&
-                this.subManager.reduce((acc, cur) => acc + (cur.live ? 1 : 0), 0) >= 3) {
-                return "直播订阅已达上限，请取消部分直播订阅后再进行订阅";
-            }
-            // 检查是否登录
-            if (!(await this.checkIfIsLogin())) {
-                // 未登录直接返回
-                return "请使用指令bili login登录后再进行订阅操作";
-            }
-            // 检查必选参数是否已填
-            if (!mid)
-                return "请输入用户uid";
-            // 订阅对象
-            const subUserData = await this.subUserInBili(mid);
-            // 判断是否订阅对象存在
-            if (!subUserData.flag)
-                return "订阅对象失败，请稍后重试！";
-            // 定义目标变量
-            let target = [];
-            // 判断是否使用了多群组推送
-            if (groupId.length > 0) {
-                // 定义channelIdArr
-                const channelIdArr = [];
-                // 遍历输入的群组
-                for (const group of groupId) {
-                    channelIdArr.push({
-                        channelId: group,
-                        dynamic: true,
-                        live: true,
-                        liveGuardBuy: false,
-                        atAll: options.atAll,
-                    });
-                }
-                target.push({
-                    channelIdArr,
-                    platform: session.event.platform,
-                });
-            }
-            else {
-                // 判断是否使用多平台功能
-                if (options.multiplatform) {
-                    // 分割字符串，赋值给target
-                    target = this.splitMultiPlatformStr(options.multiplatform);
-                }
-                // 判断是否使用了多平台
-                if (target.length > 0) {
-                    for (const [index, { channelIdArr, platform },] of target.entries()) {
-                        if (channelIdArr.length > 0) {
-                            // 输入了推送群号或频道号
-                            // 拿到对应的bot
-                            const bot = this.getBot(platform);
-                            // 判断是否配置了对应平台的机器人
-                            if (!ctx.bots.some((bot) => bot.platform === platform)) {
-                                // 发送提示消息
-                                await session.send("您未配置对应平台的机器人，不能在该平台进行订阅操作");
-                                // 直接返回
-                                return;
-                            }
-                            // 判断是否需要加入的群全部推送
-                            if (channelIdArr[0].channelId !== "all") {
-                                // 定义满足条件的群组数组
-                                const targetArr = [];
-                                // 获取机器人加入的群组
-                                const guildList = await bot.getGuildList();
-                                // 遍历target数组
-                                for (const channelId of channelIdArr) {
-                                    // 定义是否加入群组标志
-                                    let flag = false;
-                                    // 遍历群组
-                                    for (const guild of guildList.data) {
-                                        // 获取频道列表
-                                        const channelList = await bot.getChannelList(guild.id);
-                                        // 判断机器人是否加入群聊或频道
-                                        if (channelList.data.some((channel) => channel.id === channelId.channelId)) {
-                                            // 加入群聊或频道
-                                            targetArr.push(channelId);
-                                            // 设置标志位为true
-                                            flag = true;
-                                            // 结束循环
-                                            break;
-                                        }
-                                    }
-                                    if (!flag) {
-                                        // 不满足条件发送错误提示
-                                        await session.send(`您的机器未加入${channelId.channelId}，无法对该群或频道进行推送`);
-                                    }
-                                }
-                                // 判断targetArr是否为空
-                                if (target.length === 0) {
-                                    // 为空则默认为当前环境
-                                    target = [
-                                        {
-                                            channelIdArr: [
-                                                {
-                                                    channelId: session.event.channel.id,
-                                                    dynamic: true,
-                                                    live: true,
-                                                    liveGuardBuy: false,
-                                                    atAll: options.atAll ? options.atAll : false,
-                                                },
-                                            ],
-                                            platform: session.event.platform,
-                                        },
-                                    ];
-                                    // 没有满足条件的群组或频道
-                                    await session.send("没有满足条件的群组或频道，默认订阅到当前聊天环境");
-                                }
-                                // 将符合条件的群组添加到target中
-                                target[index].channelIdArr = targetArr;
-                            }
-                            // 如果为all则全部推送，不需要进行处理
-                        }
-                        else {
-                            // 未填写群号或频道号，默认为当前环境
-                            target = [
-                                {
-                                    channelIdArr: [
-                                        {
-                                            channelId: session.event.channel.id,
-                                            dynamic: true,
-                                            live: true,
-                                            liveGuardBuy: false,
-                                            atAll: options.atAll ? options.atAll : false,
-                                        },
-                                    ],
-                                    platform: session.event.platform,
-                                },
-                            ];
-                            // 发送提示消息
-                            await session.send("没有填写群号或频道号，默认订阅到当前聊天环境");
-                        }
-                    }
-                }
-                else {
-                    // 用户直接订阅，将当前环境赋值给target
-                    target = [
-                        {
-                            channelIdArr: [
-                                {
-                                    channelId: session.event.channel.id,
-                                    dynamic: true,
-                                    live: true,
-                                    liveGuardBuy: false,
-                                    atAll: options.atAll ? options.atAll : false,
-                                },
-                            ],
-                            platform: session.event.platform,
-                        },
-                    ];
-                }
-            }
-            // 定义外围变量
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            let content;
-            try {
-                // 获取用户信息
-                content = await ctx.ba.getUserInfo(mid);
-            }
-            catch (e) {
-                // 返回错误信息
-                return `bili sub getUserInfo() 发生了错误，错误为：${e.message}`;
-            }
-            // 判断是否成功获取用户信息
-            if (content.code !== 0) {
-                // 定义错误消息
-                let msg;
-                // 判断错误代码
-                switch (content.code) {
-                    case -400:
-                        msg = "请求错误";
-                        break;
-                    case -403:
-                        msg = "访问权限不足，请尝试重新登录";
-                        break;
-                    case -404:
-                        msg = "用户不存在";
-                        break;
-                    case -352:
-                        msg = "风控校验失败，请尝试更换UA";
-                        break;
-                    default:
-                        msg = `未知错误，错误信息：${content.message}`;
-                        break;
-                }
-                // 返回错误信息
-                return msg;
-            }
-            // 获取data
-            const { data } = content;
-            // 判断是否需要订阅直播和动态
-            const [liveMsg, dynamicMsg] = await this.checkIfNeedSub(options.live, options.dynamic, session, data.live_room);
-            // 判断是否未订阅任何消息
-            if (!liveMsg && !dynamicMsg)
-                return "您未订阅该UP的任何消息";
-            // 获取到对应的订阅对象
-            const subUser = this.subManager.find((sub) => sub.uid === mid);
-            // 判断要订阅的用户是否已经存在于订阅管理对象中
-            if (subUser) {
-                // 已存在，判断是否重复订阅直播通知
-                if (liveMsg && subUser.live) {
-                    return "已订阅该用户直播通知，请勿重复订阅";
-                }
-                // 已存在，判断是否重复订阅动态通知
-                if (dynamicMsg && subUser.dynamic) {
-                    return "已订阅该用户动态通知，请勿重复订阅";
-                }
-            }
-            // 获取直播房间号
-            const roomId = data.live_room?.roomid.toString();
-            // 获取用户信息
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            let userData;
-            try {
-                const { data } = await ctx.ba.getMasterInfo(mid);
-                userData = data;
-            }
-            catch (e) {
-                this.logger.error(`bili sub指令 getMasterInfo() 发生了错误，错误为：${e.message}`);
-                return "订阅出错啦，请重试";
-            }
-            const liveDetectModeSelector = {
-                API: async () => {
-                    // 判断是否已开启直播检测
-                    if (!this.liveDispose) {
-                        // 未开启直播检测
-                        // 开启直播检测并保存销毁函数
-                        this.liveDispose = await this.liveDetectWithAPI();
-                    }
-                },
-                WS: async () => {
-                    // 连接到服务器
-                    await this.liveDetectWithListener(roomId, target);
-                },
-            };
-            // 订阅直播
-            if (liveMsg) {
-                // 判断直播订阅方式
-                await liveDetectModeSelector[this.config.liveDetectMode]();
-                // 发送订阅消息通知
-                await session.send(`订阅${userData.info.uname}直播通知`);
-            }
-            // 订阅动态
-            if (dynamicMsg) {
-                // 判断是否开启动态监测
-                if (!this.dynamicDispose) {
-                    // 开启动态监测
-                    this.enableDynamicDetect();
-                }
-                // 发送订阅消息通知
-                await session.send(`订阅${userData.info.uname}动态通知`);
-            }
-            // 保存到数据库中
-            const sub = await ctx.database.create("bilibili", {
-                uid: mid,
-                room_id: roomId,
-                dynamic: dynamicMsg ? 1 : 0,
-                live: liveMsg ? 1 : 0,
-                target: JSON.stringify(target),
-                platform: session.event.platform,
-                time: new Date(),
-            });
-            // 订阅数+1
-            this.num++;
-            // 保存新订阅对象
-            this.subManager.push({
-                id: sub.id,
-                uid: mid,
-                roomId,
-                target,
-                platform: session.event.platform,
-                live: liveMsg,
-                dynamic: dynamicMsg,
-            });
-            // 新增订阅展示到控制台
-            this.updateSubNotifier();
-        });
         biliCom
             .subcommand(".status <roomId:string>", "查询主播当前直播状态", {
             hidden: true,
@@ -630,7 +275,6 @@ class ComRegister {
             this.ctx.notifier.create({
                 content: "您未配置私人机器人，将无法向您推送机器人状态！",
             });
-            this.logger.error("您未配置私人机器人，将无法向您推送机器人状态！");
         }
         // 判断消息发送方式
         if (config.automaticResend) {
@@ -689,14 +333,12 @@ class ComRegister {
         }
         // 从配置获取订阅
         config.sub && (await this.loadSubFromConfig(config.sub));
-        // 从数据库获取订阅
-        await this.loadSubFromDatabase();
         // 检查是否需要动态监测
         this.checkIfDynamicDetectIsNeeded();
         // 在控制台中显示订阅对象
         this.updateSubNotifier();
-        // Test
-        const testTarget = [
+        /* // Test
+        const testTarget: Target = [
             {
                 channelIdArr: [
                     {
@@ -710,27 +352,9 @@ class ComRegister {
                 platform: "qqguild",
             },
         ];
+
         const buffer = await this.ctx.gi.generateWordCloudImg();
-        this.sendMsg(testTarget, koishi_1.h.image(buffer, "image/png"));
-    }
-    splitMultiPlatformStr(str) {
-        return str
-            .split(";")
-            .map((cv) => cv.split("."))
-            .map(([idStr, platform]) => {
-            const channelIdArr = idStr.split(",").map((id) => {
-                const atAll = /@$/.test(id); // 使用正则表达式检查 id 是否以 @ 结尾
-                const channelId = atAll ? id.slice(0, -1) : id; // 去除末尾的 @
-                return {
-                    channelId,
-                    dynamic: true,
-                    live: true,
-                    liveGuardBuy: false,
-                    atAll,
-                };
-            });
-            return { channelIdArr, platform };
-        });
+        this.sendMsg(testTarget, h.image(buffer, "image/png")); */
     }
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     getBot(pf) {
@@ -1652,12 +1276,6 @@ class ComRegister {
         }
         // 构建消息处理函数
         const handler = {
-            onOpen: () => {
-                this.logger.info("直播间连接成功");
-            },
-            onClose: () => {
-                this.logger.info("直播间连接已断开");
-            },
             onIncomeDanmu: ({ body }) => {
                 // 保存消息到数组
                 currentLiveDanmakuArr.push(body.content);
@@ -1776,38 +1394,6 @@ class ComRegister {
         }
         return table ? table : "没有订阅任何UP";
     }
-    async checkIfNeedSub(liveSub, dynamicSub, session, 
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    liveRoomData) {
-        // 定义方法：用户直播间是否存在
-        const liveRoom = async () => {
-            if (!liveRoomData) {
-                // 未开通直播间
-                await session.send("该用户未开通直播间，无法订阅直播");
-                // 返回false
-                return true;
-            }
-            return false;
-        };
-        // 如果两者都为true或者都为false则直接返回
-        if ((liveSub && dynamicSub) || (!liveSub && !dynamicSub)) {
-            // 判断是否存在直播间
-            if (await liveRoom())
-                return [false, true];
-            // 返回
-            return [true, true];
-        }
-        // 如果只订阅直播
-        if (liveSub) {
-            // 判断是否存在直播间
-            if (await liveRoom())
-                return [false, false];
-            // 返回
-            return [true, false];
-        }
-        // 只订阅动态
-        return [false, true];
-    }
     updateSubNotifier() {
         // 更新控制台提示
         if (this.subNotifier)
@@ -2027,147 +1613,6 @@ class ComRegister {
             });
         }
     }
-    async loadSubFromDatabase() {
-        // 从数据库中获取数据
-        const subData = await this.ctx.database.get("bilibili", { id: { $gt: 0 } });
-        // 定义变量：订阅直播数
-        let liveSubNum = 0;
-        // 循环遍历
-        for (const sub of subData) {
-            // 判断是否存在没有任何订阅的数据
-            if (!sub.dynamic && !sub.live) {
-                // 存在未订阅任何项目的数据
-                // 删除该条数据
-                this.ctx.database.remove("bilibili", { id: sub.id });
-                // log
-                this.logger.warn(`UID:${sub.uid} 该条数据没有任何订阅数据，自动取消订阅`);
-                // 跳过下面的步骤
-                continue;
-            }
-            // 判断用户是否在B站中订阅了
-            const subUserData = await this.subUserInBili(sub.uid);
-            // 判断是否订阅
-            if (!subUserData.flag) {
-                // log
-                this.logger.warn(`UID:${sub.uid} ${subUserData.msg}，自动取消订阅`);
-                // 发送私聊消息
-                await this.sendPrivateMsg(`UID:${sub.uid} ${subUserData.msg}，自动取消订阅`);
-                // 删除该条数据
-                await this.ctx.database.remove("bilibili", { id: sub.id });
-                // 跳过下面的步骤
-                continue;
-            }
-            // 获取推送目标数组
-            const target = JSON.parse(sub.target);
-            /* 判断数据库是否被篡改 */
-            // 获取用户信息
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            let content;
-            const attempts = 3;
-            for (let i = 0; i < attempts; i++) {
-                try {
-                    // 获取用户信息
-                    content = await this.ctx.ba.getUserInfo(sub.uid);
-                    // 成功则跳出循环
-                    break;
-                }
-                catch (e) {
-                    this.logger.error(`getSubFromDatabase() getUserInfo() 发生了错误，错误为：${e.message}`);
-                    if (i === attempts - 1) {
-                        // 已尝试三次
-                        // 发送私聊消息并重启服务
-                        return await this.sendPrivateMsgAndStopService();
-                    }
-                }
-            }
-            // 获取data
-            const { data } = content;
-            // 定义函数删除数据和发送提示
-            const deleteSub = async () => {
-                // 从数据库删除该条数据
-                await this.ctx.database.remove("bilibili", { id: sub.id });
-                // 给用户发送提示
-                await this.sendPrivateMsg(`UID:${sub.uid} 数据库内容被篡改，已取消对该UP主的订阅`);
-            };
-            // 判断是否有其他问题
-            if (content.code !== 0) {
-                switch (content.code) {
-                    case -352:
-                    case -403: {
-                        await this.sendPrivateMsg("你的登录信息已过期，请重新登录Bilibili");
-                        return;
-                    }
-                    default: {
-                        await deleteSub();
-                        // PrivateMsg
-                        await this.sendPrivateMsg(`UID:${sub.uid} 数据出现问题，自动取消订阅`);
-                        // log
-                        this.logger.info(`UID:${sub.uid} 数据出现问题，自动取消订阅`);
-                        return;
-                    }
-                }
-            }
-            // 检测房间号是否被篡改
-            if (sub.live &&
-                // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-                (!data.live_room || data.live_room.roomid != sub.room_id)) {
-                // 房间号被篡改，删除该订阅
-                await deleteSub();
-                // log
-                this.logger.info(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
-                // Send msg
-                await this.sendPrivateMsg(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
-                // 直接返回
-                return;
-            }
-            // 构建订阅对象
-            const subManagerItem = {
-                id: sub.id,
-                uid: sub.uid,
-                roomId: sub.room_id,
-                target,
-                platform: sub.platform,
-                live: sub.live === 1,
-                dynamic: sub.dynamic === 1,
-                liveDispose: null,
-            };
-            // 定义直播模式监测器
-            const liveDetectModeSelector = {
-                API: async () => {
-                    // 判断是否已开启直播检测
-                    if (!this.liveDispose) {
-                        // 未开启直播检测
-                        // 开启直播检测并保存销毁函数
-                        this.liveDispose = await this.liveDetectWithAPI();
-                    }
-                },
-                WS: async () => {
-                    // 判断订阅直播数是否超过限制
-                    if (!this.config.unlockSubLimits && liveSubNum >= 3) {
-                        // 将live改为false
-                        subManagerItem.live = false;
-                        // log
-                        this.logger.warn(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
-                        // 发送错误消息
-                        await this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
-                    }
-                    else {
-                        // 直播订阅数+1
-                        liveSubNum++;
-                        // 订阅直播，开始循环检测
-                        await this.liveDetectWithListener(sub.room_id, target);
-                    }
-                },
-            };
-            // 判断是否订阅直播
-            if (sub.live) {
-                // 启动直播监测
-                await liveDetectModeSelector[this.config.liveDetectMode]();
-            }
-            // 保存新订阅对象
-            this.subManager.push(subManagerItem);
-        }
-    }
     checkIfDynamicDetectIsNeeded() {
         // 检查是否有订阅对象需要动态监测
         if (this.subManager.some((sub) => sub.dynamic))
@@ -2182,136 +1627,6 @@ class ComRegister {
             this.dynamicDispose = this.ctx.setInterval(this.dynamicDetect(), this.config.dynamicLoopTime * 1000);
         }
     }
-    unsubSingle(id /* UID或RoomId */, type /* 0取消Live订阅，1取消Dynamic订阅 */) {
-        // 定义返回消息
-        let msg;
-        // 定义方法：检查是否没有任何订阅
-        const checkIfNoSubExist = (sub) => !sub.dynamic && !sub.live;
-        // 定义方法：将订阅对象从订阅管理对象中移除
-        const removeSub = (index) => {
-            // 从管理对象中移除
-            this.subManager.splice(index, 1);
-            // 从数据库中删除
-            this.ctx.database.remove("bilibili", [this.subManager[index].id]);
-            // num--
-            this.num--;
-            // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-            this.checkIfUserIsTheLastOneWhoSubDyn();
-        };
-        try {
-            switch (type) {
-                case 0: {
-                    // 取消Live订阅
-                    // 获取订阅对象所在的索引
-                    const index = this.subManager.findIndex((sub) => sub.roomId === id);
-                    // 获取订阅对象
-                    const sub = this.subManager.find((sub) => sub.roomId === id);
-                    // 判断是否存在订阅对象
-                    if (!sub) {
-                        msg = "未订阅该用户，无需取消订阅";
-                        return msg;
-                    }
-                    // 取消订阅
-                    sub.live = false;
-                    // 判断直播检测方式
-                    switch (this.config.liveDetectMode) {
-                        case "API": {
-                            msg = "请手动删除订阅，并重启插件";
-                            break;
-                        }
-                        case "WS": {
-                            // 取消直播监听
-                            this.ctx.bl.closeListener(sub.roomId);
-                        }
-                    }
-                    // 如果没有对这个UP的任何订阅，则移除
-                    if (checkIfNoSubExist(sub)) {
-                        // 从管理对象中移除
-                        removeSub(index);
-                        return "已取消订阅该用户";
-                    }
-                    // 更新数据库
-                    this.ctx.database.upsert("bilibili", [
-                        {
-                            id: +`${sub.id}`,
-                            live: 0,
-                        },
-                    ]);
-                    return "已取消订阅Live";
-                }
-                case 1: {
-                    // 取消Dynamic订阅
-                    // 获取订阅对象所在的索引
-                    const index = this.subManager.findIndex((sub) => sub.uid === id);
-                    // 获取订阅对象
-                    const sub = this.subManager.find((sub) => sub.uid === id);
-                    // 判断是否存在订阅对象
-                    if (!sub) {
-                        msg = "未订阅该用户，无需取消订阅";
-                        return msg;
-                    }
-                    // 取消订阅
-                    this.subManager[index].dynamic = false;
-                    // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-                    this.checkIfUserIsTheLastOneWhoSubDyn();
-                    // 如果没有对这个UP的任何订阅，则移除
-                    if (checkIfNoSubExist(sub)) {
-                        // 从管理对象中移除
-                        removeSub(index);
-                        return "已取消订阅该用户";
-                    }
-                    // 更新数据库
-                    this.ctx.database.upsert("bilibili", [
-                        {
-                            id: sub.id,
-                            dynamic: 0,
-                        },
-                    ]);
-                    return "已取消订阅Dynamic";
-                }
-            }
-        }
-        finally {
-            // 执行完该方法后，保证执行一次updateSubNotifier()
-            this.updateSubNotifier();
-        }
-    }
-    checkIfUserIsTheLastOneWhoSubDyn() {
-        if (this.dynamicDispose && !this.subManager.some((sub) => sub.dynamic)) {
-            // 停止动态监测
-            this.dynamicDispose();
-            this.dynamicDispose = null;
-        }
-    }
-    unsubAll(uid) {
-        this.subManager
-            .filter((sub) => sub.uid === uid)
-            .map(async (sub, i) => {
-            // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-            this.checkIfUserIsTheLastOneWhoSubDyn();
-            switch (this.config.liveDetectMode) {
-                case "API": {
-                    break;
-                }
-                case "WS": {
-                    // 停止直播检测
-                    this.ctx.bl.closeListener(sub.roomId);
-                }
-            }
-            // 从数据库中删除订阅
-            await this.ctx.database.remove("bilibili", {
-                uid: this.subManager[i].uid,
-            });
-            // 将该订阅对象从订阅管理对象中移除
-            this.subManager.splice(i, 1);
-            // id--
-            this.num--;
-            // 发送成功通知
-            this.sendPrivateMsg(`UID:${uid}，已取消订阅该用户`);
-            // 更新控制台提示
-            this.updateSubNotifier();
-        });
-    }
     async checkIfIsLogin() {
         if ((await this.ctx.database.get("loginBili", 1)).length !== 0) {
             // 数据库中有数据
@@ -2349,7 +1664,6 @@ class ComRegister {
             masterAccount: koishi_1.Schema.string(),
             masterAccountGuildId: koishi_1.Schema.string(),
         }),
-        unlockSubLimits: koishi_1.Schema.boolean().required(),
         automaticResend: koishi_1.Schema.boolean().required(),
         liveDetectMode: koishi_1.Schema.union([
             koishi_1.Schema.const("API"),

package/lib/database.d.ts

@@ -1,20 +1,9 @@
 import type { Context } from "koishi";
 declare module "koishi" {
     interface Tables {
-        bilibili: Bilibili;
         loginBili: LoginBili;
     }
 }
-export interface Bilibili {
-    id: number;
-    uid: string;
-    room_id: string;
-    dynamic: number;
-    live: number;
-    target: string;
-    platform: string;
-    time: Date;
-}
 export interface LoginBili {
     id: number;
     bili_cookies: string;

package/lib/database.js

@@ -4,17 +4,6 @@ exports.name = void 0;
 exports.apply = apply;
 exports.name = "Database";
 function apply(ctx) {
-    // 新增Bilibili表
-    ctx.model.extend("bilibili", {
-        id: "unsigned",
-        uid: "string",
-        room_id: "string",
-        dynamic: "unsigned",
-        live: "unsigned",
-        target: "string",
-        platform: "string",
-        time: "timestamp",
-    }, { autoInc: true });
     // 新增LoginBili表
     ctx.model.extend("loginBili", {
         id: "unsigned",

package/lib/generateImg.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const koishi_1 = require("koishi");
+const luxon_1 = require("luxon");
 const node_path_1 = require("node:path");
 const node_url_1 = require("node:url");
 // 动态类型
@@ -1487,22 +1488,39 @@ class GenerateImg extends koishi_1.Service {
     }
     async getTimeDifference(dateString) {
         // 将日期字符串转换为Date对象
-        const date = new Date(dateString);
-        // 获取Unix时间戳（以毫秒为单位）
-        const unixTime = date.getTime() / 1000;
-        // 获取当前Unix时间戳
-        const now = this.ctx.ba.getTimeOfUTC8();
-        // 计算时间差（以秒为单位）
-        const differenceInSeconds = Math.floor(now - unixTime);
-        // 获取yyyy:MM:dd HH:mm:ss
-        const days = Math.floor(differenceInSeconds / (24 * 60 * 60));
-        const hours = Math.floor((differenceInSeconds % (24 * 60 * 60)) / (60 * 60));
-        const minutes = Math.floor((differenceInSeconds % (60 * 60)) / 60);
-        const seconds = differenceInSeconds % 60;
-        // 返回格式化的字符串
-        return days
-            ? `${days}天${hours}小时${minutes.toString().padStart(2, "0")}分${seconds.toString().padStart(2, "0")}秒`
-            : `${hours}小时${minutes.toString().padStart(2, "0")}分${seconds.toString().padStart(2, "0")}秒`;
+        const apiDateTime = luxon_1.DateTime.fromFormat(dateString, "yyyy-MM-dd HH:mm:ss", {
+            zone: "UTC+8",
+        });
+        // 获取当前时间
+        const currentDateTime = luxon_1.DateTime.now();
+        // 计算时间差
+        const diff = currentDateTime.diff(apiDateTime, [
+            "years",
+            "months",
+            "days",
+            "hours",
+            "minutes",
+            "seconds",
+        ]);
+        const { years, months, days, hours, minutes, seconds } = diff.toObject();
+        // 按单位生成可读字符串（过滤零值）
+        const parts = [];
+        if (years !== 0)
+            parts.push(`${Math.abs(years)}年`);
+        if (months !== 0)
+            parts.push(`${Math.abs(months)}个月`);
+        if (days !== 0)
+            parts.push(`${Math.abs(days)}天`);
+        if (hours !== 0)
+            parts.push(`${Math.abs(hours)}小时`);
+        if (minutes !== 0)
+            parts.push(`${Math.abs(minutes)}分`);
+        if (seconds !== 0)
+            parts.push(`${Math.round(Math.abs(seconds))}秒`);
+        // 处理负值
+        const sign = diff.as("seconds") < 0 ? "-" : "";
+        // 组合结果（如果无差值返回"0秒"）
+        return parts.length > 0 ? `${sign}${parts.join("")}` : "0秒";
     }
     unixTimestampToString(timestamp) {
         const date = new Date(timestamp * 1000);

package/lib/index.d.ts

@@ -22,7 +22,6 @@ export interface Config {
     key: string;
     master: {};
     basicSettings: {};
-    unlockSubLimits: boolean;
     automaticResend: boolean;
     renderType: "render" | "page";
     userAgent: string;

package/lib/index.js

@@ -162,7 +162,6 @@ class ServerManager extends koishi_1.Service {
             const cr = this.ctx.plugin(comRegister_1.default, {
                 sub: globalConfig.sub,
                 master: globalConfig.master,
-                unlockSubLimits: globalConfig.unlockSubLimits,
                 automaticResend: globalConfig.automaticResend,
                 liveDetectMode: globalConfig.liveDetectMode,
                 restartPush: globalConfig.restartPush,
@@ -232,19 +231,13 @@ function apply(ctx, config) {
     globalConfig = config;
     // 设置提示
     ctx.notifier.create({
-        content: "从3.0.0-alpha.10以前版本更新需重新订阅",
+        type: 'danger',
+        content: "3.0.0-alpha.16 全面从指令订阅转移到配置订阅，以前使用指令的订阅需要全部重新填写到订阅配置中",
     });
     ctx.notifier.create({
+        type: 'warning',
         content: "请使用Auth插件创建超级管理员账号，没有权限将无法使用该插件提供的指令。",
     });
-    if (config.unlockSubLimits) {
-        // 用户允许订阅超过三个用户
-        // 设置警告
-        ctx.notifier.create({
-            type: "danger",
-            content: "过多的订阅可能会导致IP暂时被封禁！",
-        });
-    }
     // load database
     ctx.plugin(Database);
     // Register ServerManager
@@ -296,9 +289,6 @@ exports.Config = koishi_1.Schema.object({
         ]),
     ]),
     basicSettings: koishi_1.Schema.object({}).description("基本设置"),
-    unlockSubLimits: koishi_1.Schema.boolean()
-        .default(false)
-        .description("解锁3个直播订阅限制，默认只允许订阅3位UP主。订阅过多用户可能有导致IP暂时被封禁的风险"),
     automaticResend: koishi_1.Schema.boolean()
         .default(true)
         .description("是否开启自动重发功能，默认开启。开启后，如果推送失败，将会自动重发，尝试三次。关闭后，推送失败将不会再重发，直到下一次推送"),
@@ -309,7 +299,7 @@ exports.Config = koishi_1.Schema.object({
     userAgent: koishi_1.Schema.string()
         .required()
         .description("设置请求头User-Agen，请求出现-352时可以尝试修改，UA获取方法可参考：https://blog.csdn.net/qq_44503987/article/details/104929111"),
-    subTitle: koishi_1.Schema.object({}).description("手动订阅"),
+    subTitle: koishi_1.Schema.object({}).description("订阅配置"),
     sub: koishi_1.Schema.array(koishi_1.Schema.object({
         uid: koishi_1.Schema.string().description("订阅用户UID"),
         dynamic: koishi_1.Schema.boolean().description("是否订阅用户动态"),
@@ -321,12 +311,12 @@ exports.Config = koishi_1.Schema.object({
                 live: koishi_1.Schema.boolean().description("该频道/群组是否推送直播通知"),
                 liveGuardBuy: koishi_1.Schema.boolean().description("该频道/群组是否推送上舰消息"),
                 atAll: koishi_1.Schema.boolean().description("推送开播通知时是否艾特全体成员"),
-            })).description("频道/群组信息"),
+            })).description("需推送的频道/群组详细设置"),
             platform: koishi_1.Schema.string().description("推送平台"),
-        })).description("订阅用户需要发送的频道/群组信息"),
+        })).description("订阅用户需要发送的平台和频道/群组信息(一个平台下可以推送多个频道/群组)"),
     }))
         .role("table")
-        .description("手动输入订阅信息，方便自定义订阅内容，这里的订阅内容不会存入数据库。uid: 订阅用户UID，dynamic: 是否需要订阅动态，live: 是否需要订阅直播"),
+        .description("输入订阅信息，自定义订阅内容； uid: 订阅用户UID，dynamic: 是否需要订阅动态，live: 是否需要订阅直播"),
     dynamic: koishi_1.Schema.object({}).description("动态推送设置"),
     dynamicUrl: koishi_1.Schema.boolean()
         .default(false)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-bilibili-notify",
   "description": "Koishi bilibili notify plugin",
-  "version": "3.0.0-alpha.14",
+  "version": "3.0.0-alpha.16",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],

package/readme.md

@@ -53,43 +53,11 @@
 
 订阅UP主：订阅你想要推送的UP主
 
-- 使用指令 `bili sub <uid> [...groupId]` 订阅需要订阅的UP主
-- 参数说明：
-  - `uid` 为必填参数，为 `up主` 的  `uid` 
-  - `groupId` 为可选参数，为需要推送的群号/频道号，可输入多个群号
-- 选项说明：`bili sub <uid>` 有四个选项：-l -d -m -a
-  - `-l` 为订阅UP主直播间，包括直播开播通知，定时推送直播内容，下播通知
-  - `-d` 为订阅UP主动态推送，目前实现推送的动态类型有：普通图文动态，转发动态，直播预约动态
-  - `-m` 为多平台动态推送，格式为：群号/频道号,群号/频道号,群号/频道号.平台名;群号/频道号,群号/频道号.平台号。如果群号/频道号为 `all` 代表推送该平台下的所有群聊或/频道。在群号/频道号后加 `@` 则代表这个群聊/频道需要@全体成员。订阅TG群组时请使用 `bili sub xxx -m "xxxxxxx"` 这样的格式
-  - `-a` 为是否艾特全体成员，对 `-m` 参数不生效
-  
-  例如：
-  `-m 3247293,324389,89874324.qq;EDBWIUBIU.qqguild;79324792,3247892.onebot` 代表推送QQ下3247293,324389,89874324这三个群聊，QQ频道下EDBWIUBIU这个频道，Onebot平台下79324792,3247892这两个群聊
-  `-m 3247293,324389@,89874324.qq` 代表推送QQ下3247293,324389,89874324这三个群聊，其中群聊324389需要艾特全体成员
-  所有分隔符均为英文符号
-
-- 例如：
-  - `bili sub 1194210119 ` 订阅UID为1194210119的UP主动态推送和直播间
-  - `bili sub 1194210119 -d` 订阅UID为1194210119的UP主动态推送
-  - `bili sub 1194210119 -l` 订阅UID为1194210119的UP主直播间
-  - `bili sub 1194210119 -m 3247293,324389,89874324.qq;all.onebot;EHUIWDBUAWD.qqguild` 订阅UID为1194210119的UP主，向群号为3247293，324389，89874324的QQ群，所有onebot平台下的群聊，频道号为EHUIWDBUAWD的QQ频道平台进行推送
-  - `bili sub 1194210119 -a` 订阅UID为1194210119的UP主动态推送和直播间并艾特全体成员
-
-取消订阅UP主：取消订阅不需要推送的UP主
-
-- 使用指令 `bili unsub <uid>` 取消订阅不需要订阅的UP主
-- 参数说明：`uid` 为必填参数，为 `up主` 的 `uid`
-- 选项说明：`bili unsub <uid>` 有两个选项：-l 和 -d
-  - `-l` 为取消订阅UP主直播间
-  - `-d` 为取消订阅UP主动态
-- 例如：
-  - `bili unsub 123456` 取消订阅UID为123456的UP主动态推送和直播间
-  - `bili unsub 123456 -d` 取消订阅UID为123456的UP主动态推送
-  - `bili unsub 123456 -dl` 取消订阅UID为123456的UP主动态推送和直播间
+在插件配置中配置需要订阅的UP主
 
 查看目前已订阅的UP主：
 
-- 使用指令 `bili show`
+- 使用指令 `bili list`
 
 插件的启动、停止和重启
 
@@ -226,6 +194,8 @@
 - ver 3.0.0-alpha.12 修复：上一版本无法安装
 - ver 3.0.0-alpha.13 优化：将ESLint替换为Biome； 修复：增加弹幕词云功能产生的bug； 禁用：弹幕词云功能并不能正常运作，暂时将该功能禁用
 - ver 3.0.0-alpha.14 优化：移除不需要的服务
+- ver 3.0.0-alpha.15 修复：启动插件提示发送群组消息失败、直播推送时间显示为负数(不用再特别设置系统时区为UTC+8)
+- ver 3.0.0-alpha.16 重大更新：订阅不再依赖数据库，从指令订阅全面迁移到配置订阅； 修复：直播时长有误； 优化：`bili show` 指令更改为 `bili list`
 
 ## 交流群