koishi-plugin-bilibili-notify 0.0.1

package/lib/biliAPI.d.ts

@@ -0,0 +1,29 @@
+import { Context, Service } from "koishi";
+import { CookieJar } from 'tough-cookie';
+declare module 'koishi' {
+    interface Context {
+        biliAPI: BiliAPI;
+    }
+}
+declare class BiliAPI extends Service {
+    static inject: string[];
+    jar: CookieJar;
+    client: any;
+    loginData: any;
+    constructor(ctx: Context);
+    protected start(): void | Promise<void>;
+    getTimeNow(): Promise<any>;
+    getUserSpaceDynamic(mid: string): Promise<any>;
+    getCookieInfo(refreshToken: string): Promise<any>;
+    getUserInfo(mid: string): Promise<any>;
+    getMyselfInfo(): Promise<any>;
+    getLoginQRCode(): Promise<any>;
+    getLoginStatus(qrcodeKey: string): Promise<any>;
+    getLiveRoomInfo(roomId: string): Promise<any>;
+    getMasterInfo(mid: string): Promise<any>;
+    createNewClient(): void;
+    getCookies(): Promise<string>;
+    loadCookiesFromDatabase(): Promise<void>;
+    checkIfTokenNeedRefresh(refreshToken: string, csrf: string): Promise<void>;
+}
+export default BiliAPI;

package/lib/biliAPI.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const koishi_1 = require("koishi");
+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 GET_DYNAMIC_LIST = 'https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/all';
+const GET_USER_SPACE_DYNAMIC_LIST = 'https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/space';
+const GET_COOKIES_INFO = 'https://passport.bilibili.com/x/passport-login/web/cookie/info';
+const GET_USER_INFO = 'https://api.bilibili.com/x/space/wbi/acc/info';
+const GET_MYSELF_INFO = 'https://api.bilibili.com/x/member/web/account';
+const GET_LOGIN_QRCODE = 'https://passport.bilibili.com/x/passport-login/web/qrcode/generate';
+const GET_LOGIN_STATUS = 'https://passport.bilibili.com/x/passport-login/web/qrcode/poll';
+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';
+class BiliAPI extends koishi_1.Service {
+    static inject = ['database', 'wbi'];
+    jar;
+    client;
+    loginData;
+    constructor(ctx) {
+        super(ctx, 'biliAPI');
+    }
+    start() {
+        /* this.client = this.ctx.http.extend({
+            endpoint: 'https://api.live.bilibili.com',
+        }) */
+        this.createNewClient();
+        this.loadCookiesFromDatabase();
+        this.logger.info('BiliAPI已被注册到Context中');
+    }
+    async getTimeNow() {
+        const { data } = await this.client.get(GET_TIME_NOW);
+        return data;
+    }
+    async getUserSpaceDynamic(mid) {
+        const { data } = await this.client.get(`${GET_USER_SPACE_DYNAMIC_LIST}?host_mid=${mid}`);
+        return data;
+    }
+    // Check if Token need refresh
+    async getCookieInfo(refreshToken) {
+        const { data } = await this.client.get(`${GET_COOKIES_INFO}?csrf=${refreshToken}`);
+        return data;
+    }
+    async getUserInfo(mid) {
+        const wbi = await this.ctx.wbi.getWbi({ mid });
+        const { data } = await this.client.get(`${GET_USER_INFO}?${wbi}`);
+        return data;
+    }
+    async getMyselfInfo() {
+        const { data } = await this.client.get(GET_MYSELF_INFO);
+        return data;
+    }
+    async getLoginQRCode() {
+        const { data } = await this.client.get(GET_LOGIN_QRCODE);
+        return data;
+    }
+    async getLoginStatus(qrcodeKey) {
+        const { data } = await this.client.get(`${GET_LOGIN_STATUS}?qrcode_key=${qrcodeKey}`);
+        return data;
+    }
+    async getLiveRoomInfo(roomId) {
+        const { data } = await this.client.get(`${GET_LIVE_ROOM_INFO}?room_id=${roomId}`);
+        return data;
+    }
+    async getMasterInfo(mid) {
+        const { data } = await this.client.get(`${GET_MASTER_INFO}?uid=${mid}`);
+        return data;
+    }
+    createNewClient() {
+        this.jar = new tough_cookie_1.CookieJar();
+        this.client = (0, axios_cookiejar_support_1.wrapper)(axios_1.default.create({ jar: this.jar, headers: { 'Content-Type': 'application/json' } }));
+    }
+    async getCookies() {
+        let cookies;
+        this.jar.store.getAllCookies((err, c) => {
+            if (err)
+                throw err;
+            cookies = JSON.stringify(c, null, 2);
+        });
+        return cookies;
+    }
+    async loadCookiesFromDatabase() {
+        // 读取数据库获取cookies
+        const data = (await this.ctx.database.get('loginBili', 1))[0];
+        // 没有数据则直接返回
+        if (data === undefined)
+            return;
+        // 解密数据
+        const decryptedCookies = this.ctx.wbi.decrypt(data.bili_cookies);
+        // 解析从数据库读到的cookies
+        const cookies = JSON.parse(decryptedCookies);
+        // 定义CSRF Token
+        let csrf;
+        cookies.forEach(cookieData => {
+            // console.log(cookieData);
+            // 获取key为bili_jct的值
+            if (cookieData.key === 'bili_jct')
+                csrf = cookieData.value;
+            // 创建一个完整的 Cookie 实例
+            const cookie = new tough_cookie_1.Cookie({
+                key: cookieData.key,
+                value: cookieData.value,
+                expires: new Date(cookieData.expires),
+                domain: cookieData.domain,
+                path: cookieData.path,
+                secure: cookieData.secure,
+                httpOnly: cookieData.httpOnly,
+                sameSite: cookieData.sameSite
+            });
+            this.jar.setCookieSync(cookie, `http${cookie.secure ? 's' : ''}://${cookie.domain}${cookie.path}`, {});
+        });
+        // 解密refresh_token
+        const decryptedRefreshToken = this.ctx.wbi.decrypt(data.bili_refresh_token);
+        // Check if token need refresh
+        this.checkIfTokenNeedRefresh(decryptedRefreshToken, csrf);
+    }
+    async checkIfTokenNeedRefresh(refreshToken, csrf) {
+        const { data } = await this.getCookieInfo(refreshToken);
+        // 不需要刷新，直接返回
+        if (!data.refresh)
+            return;
+        const publicKey = await crypto.subtle.importKey("jwk", {
+            kty: "RSA",
+            n: "y4HdjgJHBlbaBN04VERG4qNBIFHP6a3GozCl75AihQloSWCXC5HDNgyinEnhaQ_4-gaMud_GF50elYXLlCToR9se9Z8z433U3KjM-3Yx7ptKkmQNAMggQwAVKgq3zYAoidNEWuxpkY_mAitTSRLnsJW-NCTa0bqBFF6Wm1MxgfE",
+            e: "AQAB",
+        }, { name: "RSA-OAEP", hash: "SHA-256" }, true, ["encrypt"]);
+        async function getCorrespondPath(timestamp) {
+            const data = new TextEncoder().encode(`refresh_${timestamp}`);
+            const encrypted = new Uint8Array(await crypto.subtle.encrypt({ name: "RSA-OAEP" }, publicKey, data));
+            return encrypted.reduce((str, c) => str + c.toString(16).padStart(2, "0"), "");
+        }
+        const correspondPath = await getCorrespondPath(Date.now());
+        const { data: refreshCsrfHtml } = await this.client.get(`https://www.bilibili.com/correspond/1/${correspondPath}`);
+        // 创建一个虚拟的DOM元素
+        const { document } = new jsdom_1.JSDOM(refreshCsrfHtml).window;
+        // 提取标签name为1-name的内容
+        const targetElement = document.getElementById('1-name');
+        const refresh_csrf = targetElement ? targetElement.textContent : null;
+        // 发送刷新请求
+        const { data: refreshData } = await this.client.post('https://passport.bilibili.com/x/passport-login/web/cookie/refresh', {
+            csrf,
+            refresh_csrf,
+            source: 'main_web',
+            refresh_token: refreshToken
+        });
+        // 检查是否有其他问题
+        switch (refreshData.code) {
+            // 账号未登录
+            case -101: return this.createNewClient();
+            case -111: throw new Error('csrf 校验失败');
+            case 86095: throw new Error('refresh_csrf 错误或 refresh_token 与 cookie 不匹配');
+        }
+        // 更新refresh_token
+        await this.ctx.database.upsert('loginBili', [{
+                id: 1,
+                bili_refresh_token: refreshData.data.refresh_token
+            }]);
+        // Get new csrf from cookies
+        let newCsrf;
+        this.jar.store.getAllCookies((err, c) => {
+            if (err)
+                throw err;
+            c.forEach(cookie => {
+                if (cookie.key === 'bili_jct')
+                    newCsrf = cookie.value;
+            });
+        });
+        // Accept update
+        const { data: aceeptData } = await this.client.post('https://passport.bilibili.com/x/passport-login/web/confirm/refresh', {
+            csrf: newCsrf,
+            refresh_token: refreshToken
+        });
+        // 检查是否有其他问题
+        switch (aceeptData.code) {
+            case -111: throw new Error('csrf 校验失败');
+            case -400: throw new Error('请求错误');
+        }
+        // 没有问题，cookies已更新完成
+    }
+}
+/* namespace LiveAPI {
+    export interface Config {
+        roomId: string
+    }
+
+    export const Config: Schema<Config> = Schema.object({
+        roomId: Schema.string().required()
+    })
+} */
+exports.default = BiliAPI;

package/lib/comRegister.d.ts

@@ -0,0 +1,17 @@
+import { Context, Logger, Schema, Session } from "koishi";
+declare class ComRegister {
+    static inject: string[];
+    logger: Logger;
+    config: ComRegister.Config;
+    constructor(ctx: Context, config: ComRegister.Config);
+    dynamicDetect(ctx: Context, session: Session, uid: string, dispose: Function): () => Promise<"账号未登录" | "未知错误">;
+    liveDetect(ctx: Context, session: Session, roomId: string, dispose: Function): () => Promise<void>;
+    checkIfNeedSub(comNeed: boolean, subType: string, session: Session, data?: any): Promise<boolean>;
+}
+declare namespace ComRegister {
+    interface Config {
+        pushTime: number;
+    }
+    const Config: Schema<Config>;
+}
+export default ComRegister;

package/lib/comRegister.js

@@ -0,0 +1,402 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const koishi_1 = require("koishi");
+// 导入qrcode
+const qrcode_1 = __importDefault(require("qrcode"));
+var LiveType;
+(function (LiveType) {
+    LiveType[LiveType["NotLiveBroadcast"] = 0] = "NotLiveBroadcast";
+    LiveType[LiveType["StartBroadcasting"] = 1] = "StartBroadcasting";
+    LiveType[LiveType["LiveBroadcast"] = 2] = "LiveBroadcast";
+})(LiveType || (LiveType = {}));
+class ComRegister {
+    static inject = ['biliAPI', 'gimg', 'wbi'];
+    logger;
+    config;
+    constructor(ctx, config) {
+        this.logger = ctx.logger('commandRegister');
+        this.config = config;
+        ctx.command('test')
+            .subcommand('.cookies')
+            .usage('测试指令，用于测试从数据库读取cookies')
+            .action(async () => {
+            await ctx.biliAPI.loadCookiesFromDatabase();
+        });
+        ctx.command('test')
+            .subcommand('.my')
+            .usage('测试指令，用于测试获取自己信息')
+            .example('test.my')
+            .action(async () => {
+            const content = await ctx.biliAPI.getMyselfInfo();
+            console.log(content);
+        });
+        ctx.command('test')
+            .subcommand('.user <mid:string>')
+            .usage('测试指令，用于测试获取用户信息')
+            .example('test.user 用户UID')
+            .action(async (_, mid) => {
+            const content = await ctx.biliAPI.getUserInfo(mid);
+            console.log(content);
+        });
+        ctx.command('test')
+            .subcommand('.time')
+            .usage('测试时间接口')
+            .example('test.time')
+            .action(async () => {
+            const content = await ctx.biliAPI.getTimeNow();
+            console.log(content);
+        });
+        ctx.command('test')
+            .subcommand('.exist')
+            .usage('测试写法')
+            .example('test.exist')
+            .action(async () => {
+            let num = 1;
+            console.log(num && `Hello World`);
+        });
+        ctx.command('test')
+            .subcommand('.gimg <uid:string> <index:number>')
+            .usage('测试图片生成')
+            .example('test.gimg')
+            .action(async (_, uid, index) => {
+            // 获取用户空间动态数据
+            const { data } = await ctx.biliAPI.getUserSpaceDynamic(uid);
+            const [pic] = await ctx.gimg.generateDynamicImg(data.items[index]);
+            return pic;
+        });
+        ctx.command('bili', 'bili-notify插件相关指令')
+            .subcommand('.login', '登录B站之后才可以进行之后的操作')
+            .usage('使用二维码登录，登录B站之后才可以进行之后的操作')
+            .example('bili login')
+            .action(async ({ session }) => {
+            this.logger.info('调用bili login指令');
+            // 获取二维码
+            const content = await ctx.biliAPI.getLoginQRCode();
+            // 判断是否出问题
+            if (content.code !== 0)
+                return await session.send('出问题咯，请联系管理员解决！');
+            // 设置二维码参数
+            let options = {
+                errorCorrectionLevel: 'H', // 错误更正水平
+                type: 'image/png', // 输出类型
+                quality: 0.92, // 图像质量（仅适用于'image/jpeg'）
+                margin: 1, // 边距大小
+                color: {
+                    dark: '#000000', // 二维码颜色
+                    light: '#FFFFFF' // 背景颜色
+                }
+            };
+            // 生成二维码
+            qrcode_1.default.toBuffer(content.data.url, options, async (err, buffer) => {
+                if (err)
+                    return await session.send('二维码生成出错，请联系管理员解决！');
+                await session.send(koishi_1.h.image(buffer, 'image/png'));
+            });
+            // 定义定时器
+            let dispose;
+            // 发起登录请求检查登录状态
+            dispose = ctx.setInterval(async () => {
+                const loginContent = await ctx.biliAPI.getLoginStatus(content.data.qrcode_key);
+                if (loginContent.code !== 0) {
+                    dispose();
+                    return await session.send('登录失败！请联系管理员解决！');
+                }
+                if (loginContent.data.code === 86038) {
+                    dispose();
+                    return await session.send('二维码已失效，请重新登录！');
+                }
+                if (loginContent.data.code === 0) { // 登录成功
+                    const encryptedCookies = ctx.wbi.encrypt(await ctx.biliAPI.getCookies());
+                    const encryptedRefreshToken = ctx.wbi.encrypt(loginContent.data.refresh_token);
+                    await ctx.database.upsert('loginBili', [{
+                            id: 1,
+                            bili_cookies: encryptedCookies,
+                            bili_refresh_token: encryptedRefreshToken
+                        }]);
+                    dispose();
+                    return await session.send('登录成功！');
+                }
+            }, 1000);
+        });
+        ctx.command('bili')
+            .subcommand('.sub <mid:string> [groupid:string]')
+            .option('live', '-l')
+            .option('dynamic', '-d')
+            .usage('订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d。若没有加任何参数，之后会向你单独询问，<>中为必选参数，[]中为可选参数，目标群号若不填，则默认为当前群聊')
+            .example('bili sub 用户uid 目标QQ群号(可选) -l -d')
+            .action(async ({ session, options }, mid, groupid) => {
+            this.logger.info('调用bili.sub指令');
+            // 检查必选参数是否有值
+            if (mid === undefined) {
+                return '请输入用户uid';
+            }
+            // 定义是否需要直播通知，动态订阅，视频推送
+            let liveMsg, dynamicMsg;
+            // 获取用户信息
+            const content = await ctx.biliAPI.getUserInfo(mid);
+            // 判断是否有其他问题
+            if (content.code !== 0) {
+                let msg;
+                switch (content.code) {
+                    case -400:
+                        msg = '请求错误';
+                        break;
+                    case -403:
+                        msg = '访问权限不足，尝试重新登录，如果不行请联系管理员';
+                        break;
+                    case -404:
+                        msg = '用户不存在';
+                        break;
+                    case -352:
+                        msg = '请登录后再尝试订阅';
+                        break;
+                    default: msg = '未知错误，请联系管理员';
+                }
+                return msg;
+            }
+            // 获取data
+            const { data } = content;
+            // 判断是否需要订阅直播
+            liveMsg = await this.checkIfNeedSub(options.live, '直播', session, data);
+            // 判断是否需要订阅动态
+            dynamicMsg = await this.checkIfNeedSub(options.dynamic, '动态', session);
+            // console.log(liveMsg, dynamicMsg, videoMsg);
+        });
+        ctx.command('bili')
+            .subcommand('.dynamic <uid:string>')
+            .usage('订阅用户动态推送')
+            .example('bili dynamic 1')
+            .action(async ({ session }, uid) => {
+            this.logger.info('调用bili.dynamic指令');
+            let dispose;
+            // 开始循环检测
+            dispose = ctx.setInterval(this.dynamicDetect(ctx, session, uid, dispose), 60000);
+        });
+        ctx.command('bili')
+            .subcommand('.live <roomId:string>')
+            .usage('订阅主播开播通知')
+            .example('bili live 732')
+            .action(async ({ session }, roomId) => {
+            if (!roomId) {
+                await session.send('请输入需要订阅主播的房间号');
+                return;
+            }
+            this.logger.info('调用bili.live指令');
+            let dispose;
+            // 开始循环检测
+            dispose = ctx.setInterval(this.liveDetect(ctx, session, roomId, dispose), 5000);
+        });
+        ctx.command('bili')
+            .subcommand('.status <roomId:string>')
+            .usage('查询主播当前直播状态')
+            .example('bili status 732')
+            .action(async ({ session }, roomId) => {
+            this.logger.info('调用bili.status指令');
+            if (!roomId)
+                return session.send('请输入房间号!');
+            const content = await ctx.biliAPI.getLiveRoomInfo(roomId);
+            const { data } = content;
+            const { data: userData } = await ctx.biliAPI.getMasterInfo(data.uid);
+            // B站出问题了
+            if (content.code !== 0) {
+                if (content.msg === '未找到该房间') {
+                    session.send('未找到该房间！');
+                }
+                else {
+                    console.log(content);
+                    session.send('未知错误，请呼叫管理员检查问题！');
+                }
+                return;
+            }
+            const string = await ctx.gimg.generateLiveImg(data, userData, data.live_status === 1 ?
+                LiveType.StartBroadcasting :
+                LiveType.NotLiveBroadcast);
+            session.send(string);
+        });
+    }
+    dynamicDetect(ctx, session, uid, dispose) {
+        let firstSubscription = true;
+        let timePoint;
+        return async () => {
+            // 第一次的判断
+            if (firstSubscription) {
+                // 获取用户信息
+                const { data: userData } = await ctx.biliAPI.getMasterInfo(uid);
+                // 发送订阅消息通知
+                session.send(`订阅${userData.info.uname}动态通知!`);
+                // 设置第一次的时间点
+                timePoint = (await ctx.biliAPI.getTimeNow()).data.now;
+                console.log(timePoint);
+                // 设置第一次为false
+                firstSubscription = false;
+                return;
+            }
+            // 获取用户空间动态数据
+            const content = await ctx.biliAPI.getUserSpaceDynamic(uid);
+            // 判断是否出现其他问题
+            if (content.code !== 0) {
+                switch (content.code) {
+                    case -101: { // 账号未登录
+                        return '账号未登录';
+                    }
+                    default: { // 未知错误
+                        return '未知错误';
+                    }
+                }
+            }
+            // 获取数据内容
+            const items = content.data.items;
+            // 发送请求 只查看前五条数据
+            for (let num = 4; num >= 0; num--) {
+                // 没有动态内容则直接跳过
+                if (!items[num])
+                    continue;
+                // 寻找发布时间比时间点时间更晚的动态
+                if (items[num].modules.module_author.pub_ts > timePoint) {
+                    // 将时间点设置为这条动态的发布时间
+                    timePoint = items[num].modules.module_author.pub_ts;
+                    // 推送该条动态
+                    const [pic, _] = await ctx.gimg.generateDynamicImg(items[num]);
+                    session.send(pic);
+                }
+            }
+        };
+    }
+    liveDetect(ctx, session, roomId, dispose) {
+        let firstSubscription = true;
+        let timer = 0;
+        let open = false;
+        let liveTime;
+        let uData;
+        return async () => {
+            // Test code
+            /* console.log('===========================>');
+            console.log(timer);
+            console.log(open);
+            console.log('===========================>'); */
+            // 发送请求检测直播状态
+            const content = await ctx.biliAPI.getLiveRoomInfo(roomId);
+            const { data } = content;
+            // B站出问题了
+            if (content.code !== 0) {
+                if (content.msg === '未找到该房间') {
+                    session.send('未找到该房间！');
+                }
+                else {
+                    console.log(content);
+                    session.send('未知错误，请呼叫管理员检查问题！');
+                }
+                dispose();
+                return;
+            }
+            if (firstSubscription) {
+                firstSubscription = false;
+                // 获取主播信息
+                const { data: userData } = await ctx.biliAPI.getMasterInfo(data.uid);
+                // 主播信息不会变，请求一次即可
+                uData = userData;
+                // 发送订阅消息通知
+                session.send(`订阅${userData.info.uname}直播通知`);
+                if (data.live_status === 1) { // 当前正在直播
+                    // 改变开播状态
+                    open = true;
+                    // 推送直播信息
+                    await session.send(await ctx
+                        .gimg
+                        .generateLiveImg(data, uData, LiveType.LiveBroadcast));
+                } // 未开播，直接返回
+                return;
+            }
+            // 检查直播状态
+            switch (data.live_status) {
+                case 0:
+                case 2: { // 状态 0 和 2 说明未开播
+                    if (open) { // 之前开播，现在下播了
+                        // 更改直播状态
+                        open = false;
+                        // 下播了将定时器清零
+                        timer = 0;
+                        // 发送下播通知
+                        session.send(`${uData.info.uname}下播啦，本次直播了${ctx.gimg.getTimeDifference(liveTime)}`);
+                    }
+                    // 未进循环，还未开播，继续循环
+                    break;
+                }
+                case 1: {
+                    if (!open) { // 之前未开播，现在开播了
+                        // 更改直播状态
+                        open = true;
+                        // 设置开播时间
+                        liveTime = data.live_time;
+                        // 获取主播信息
+                        const { data: userData } = await ctx.biliAPI.getMasterInfo(data.uid);
+                        // 主播信息不会变，开播时刷新一次即可
+                        uData = userData;
+                        // 发送直播通知
+                        await session.send(await ctx.gimg.generateLiveImg(data, uData, LiveType.StartBroadcasting));
+                        await session.send(`https://live.bilibili.com/${roomId}`);
+                    }
+                    else { // 还在直播
+                        if (this.config.pushTime > 0) {
+                            timer++;
+                            // 开始记录时间
+                            if (timer >= (12 * 30 * this.config.pushTime)) { // 到时间推送直播消息
+                                // 到时间重新计时
+                                timer = 0;
+                                // 发送状态信息
+                                session.send(await ctx
+                                    .gimg
+                                    .generateLiveImg(data, uData, LiveType.LiveBroadcast));
+                                await session.send(`https://live.bilibili.com/${roomId}`);
+                            }
+                        }
+                        // 否则继续循环
+                    }
+                }
+            }
+        };
+    }
+    async checkIfNeedSub(comNeed, subType, session, data) {
+        if (comNeed) {
+            if (subType === '直播' && data.live_room.roomStatus === 0) {
+                return false;
+            }
+            return true;
+        }
+        let input; // 用户输入
+        // 询问用户是否需要订阅直播
+        while (1) {
+            session.send(`是否需要订阅${subType}？需要输入 y 不需要输入 n `);
+            input = await session.prompt();
+            if (!input) {
+                await session.send('输入超时！请重新订阅');
+                continue;
+            }
+            switch (input) {
+                case 'y': { // 需要订阅直播
+                    // 如果用户没有开通直播间则无法订阅
+                    if (subType === '直播' && data.live_room.roomStatus === 0) {
+                        await session.send('该用户没有开通直播间，无法订阅直播');
+                        return false;
+                    }
+                    // 开启直播订阅
+                    return true;
+                }
+                // 不需要
+                case 'n': return false;
+                default: { // 输入了其他的内容
+                    session.send('输入有误，请输入 y 或 n');
+                }
+            }
+        }
+    }
+}
+(function (ComRegister) {
+    ComRegister.Config = koishi_1.Schema.object({
+        pushTime: koishi_1.Schema.number().required()
+    });
+})(ComRegister || (ComRegister = {}));
+exports.default = ComRegister;

package/lib/database.d.ts

@@ -0,0 +1,23 @@
+import { Context } from "koishi";
+declare module 'koishi' {
+    interface Tables {
+        bilibili: Bilibili;
+        loginBili: LoginBili;
+    }
+}
+export interface Bilibili {
+    id: number;
+    uid: string;
+    room_id: string;
+    dynamic: number;
+    video: number;
+    live: number;
+    time: Date;
+}
+export interface LoginBili {
+    id: number;
+    bili_cookies: string;
+    bili_refresh_token: string;
+}
+export declare const name = "Database";
+export declare function apply(ctx: Context): void;