koishi-plugin-kkk 1.0.0

package/lib/karin/module/utils/Common.js

@@ -0,0 +1,418 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Common = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_karin_1 = require("../../../compat/node-karin.js");
+const axios_1 = __importDefault(require("../../../compat/axios.js"));
+const root_1 = require("../../../compat/root.js");
+const esm_1 = require("../../../compat/esm");
+const QqCardResolve_1 = require("./QqCardResolve");
+const Config_1 = require("../../module/utils/Config");
+const __1 = require("..");
+const root_2 = require("../../root");
+/** 常用工具合集 */
+class Tools {
+    static VIDEO_PREVIEW_REMOVED_RETENTION_MS = 5 * 60 * 1000;
+    static VIDEO_PREVIEW_SWEEP_INTERVAL_MS = 10 * 60 * 1000;
+    /**
+     * 插件缓存目录
+     */
+    tempDri;
+    videoPreviewState;
+    /**
+     * 初始化工具实例并启动预览状态的后台清理任务。
+     */
+    constructor() {
+        this.tempDri = {
+            /** 插件缓存目录 */
+            default: `${root_1.karinPathTemp}/${root_2.Root.pluginName}/`.replace(/\\/g, '/'),
+            /** 视频缓存文件 */
+            video: `${root_1.karinPathTemp}/${root_2.Root.pluginName}/kkkdownload/video/`.replace(/\\/g, '/'),
+            /** 图片缓存文件 */
+            images: `${root_1.karinPathTemp}/${root_2.Root.pluginName}/kkkdownload/images/`.replace(/\\/g, '/')
+        };
+        this.videoPreviewState = new Map();
+        const cleanupTimer = setInterval(() => {
+            this.pruneVideoPreviewState();
+        }, Tools.VIDEO_PREVIEW_SWEEP_INTERVAL_MS);
+        cleanupTimer.unref?.();
+    }
+    /**
+     * 获取引用消息
+     * @param e event 消息事件
+     * @returns 被引用的消息
+     */
+    /**
+     * 尝试从图片 URL 识别二维码并返回支持的平台链接
+     * @param imageUrl 图片 URL
+     * @param source 来源描述（用于日志）
+     * @returns 识别到的平台链接，或 null
+     */
+    async tryScanImageQrCode(imageUrl, source) {
+        try {
+            node_karin_1.logger.debug(`检测到${source}为图片，尝试识别二维码...`);
+            const response = await axios_1.default.get(imageUrl, { responseType: 'arraybuffer' });
+            const buffer = Buffer.from(response.data);
+            // Koishi 移植：@ikenxuan/qrcode 是 ESM-only 包（exports 没有 require 条件），
+            // 且 tsc 会把 import() 降级成 require()，所以用 importEsm 走真正的 ESM 加载。
+            const { scanSync } = await (0, esm_1.importEsm)('@ikenxuan/qrcode');
+            const qrContent = scanSync(buffer);
+            const patterns = [
+                /(https?:\/\/)?(www|v|jx|m|jingxuan)\.(douyin|iesdouyin)\.com/i, // 抖音分享链接
+                /https:\/\/aweme\.snssdk\.com\/aweme\/v1\/play/i, // 抖音 CDN 下载链接
+                /(bilibili\.com|b23\.tv|t\.bilibili\.com|bili2233\.cn|\bBV[1-9a-zA-Z]{10}\b|\bav\d+\b)/i, // B站
+                /(快手.*快手|v\.kuaishou\.com|kuaishou\.com)/, // 快手
+                /(xiaohongshu\.com|xhslink\.(?:com|cn))/ // 小红书
+            ];
+            if (qrContent && patterns.some((pattern) => pattern.test(qrContent))) {
+                node_karin_1.logger.debug(`从${source}二维码中识别到支持的平台链接: ${qrContent}`);
+                return qrContent;
+            }
+            else if (qrContent) {
+                node_karin_1.logger.debug(`识别到二维码内容但不是支持的平台: ${qrContent}`);
+            }
+        }
+        catch (error) {
+            node_karin_1.logger.error(`识别${source}二维码时发生错误:`, error);
+        }
+        return null;
+    }
+    async getReplyMessage(e) {
+        const result = await this.readReplyMessage(e);
+        // Koishi 移植：QQ 分享卡片在适配器里是「带 JSON 转义的一整段文本」，
+        // 引用解析时同样要还原转义 + 补上挖出来的链接，否则平台的链接正则匹配不到；
+        // 新版卡片可能完全不带链接，这里再走一次「卡片 → B站搜索还原」。
+        return await (0, QqCardResolve_1.resolveQqCardContent)(result);
+    }
+    async readReplyMessage(e) {
+        if (e.replyId) {
+            const reply = await e.bot.getMsg(e.contact, e.replyId);
+            for (const v of reply.elements) {
+                if (v.type === 'text') {
+                    try {
+                        const parsed = JSON.parse(v.text);
+                        if (parsed.type === 'markdown' && parsed.data?.content) {
+                            const content = parsed.data.content;
+                            // 尝试从 markdown 中提取图片链接并识别二维码
+                            const imageRegex = /!\[.*?\]\((.*?)\)/g;
+                            let match;
+                            while ((match = imageRegex.exec(content)) !== null) {
+                                const qrResult = await this.tryScanImageQrCode(match[1], '引用消息中的 markdown 图片');
+                                if (qrResult)
+                                    return qrResult;
+                            }
+                            return content;
+                        }
+                    }
+                    catch {
+                        // 不是 JSON 格式，按普通文本处理
+                    }
+                    return v.text;
+                }
+                else if (v.type === 'json') {
+                    return v.data;
+                }
+                else if (v.type === 'image') {
+                    const qrResult = await this.tryScanImageQrCode(v.file, '引用消息');
+                    if (qrResult)
+                        return qrResult;
+                }
+            }
+        }
+        return '';
+    }
+    /**
+     * 将中文数字转换为阿拉伯数字的函数
+     * @param chineseNumber 数字的中文
+     * @returns 中文数字对应的阿拉伯数字映射
+     */
+    chineseToArabic(chineseNumber) {
+        // 映射表，定义基础的中文数字
+        const chineseToArabicMap = {
+            零: 0,
+            一: 1,
+            二: 2,
+            三: 3,
+            四: 4,
+            五: 5,
+            六: 6,
+            七: 7,
+            八: 8,
+            九: 9
+        };
+        // 对应中文单位映射
+        const units = {
+            十: 10,
+            百: 100,
+            千: 1000,
+            万: 10000,
+            亿: 100000000
+        };
+        let result = 0;
+        let temp = 0; // 存储每一段的临时结果
+        let unit = 1; // 当前处理的单位，初始为1
+        for (let i = chineseNumber.length - 1; i >= 0; i--) {
+            const char = chineseNumber[i];
+            // 如果是单位字符
+            if (units[char] !== undefined) {
+                unit = units[char];
+                if (unit === 10000 || unit === 100000000) {
+                    result += temp * unit;
+                    temp = 0;
+                }
+            }
+            else {
+                // 如果是数字字符
+                const num = chineseToArabicMap[char];
+                if (unit > 1) {
+                    temp += num * unit;
+                }
+                else {
+                    temp += num;
+                }
+                unit = 1; // 重置单位
+            }
+        }
+        return result + temp;
+    }
+    /**
+     * 格式化cookie字符串
+     * @param cookies cookie数组
+     * @returns 格式化后的cookie字符串
+     */
+    formatCookies(cookies) {
+        return cookies
+            .map((cookie) => {
+            // 分割每个cookie字符串以获取名称和值
+            const [nameValue] = cookie.split(';').map((part) => part.trim());
+            const [name, value] = nameValue.split('=');
+            // 重新组合名称和值，忽略其他属性
+            return `${name}=${value}`;
+        })
+            .join('; ');
+    }
+    /**
+     * 计算目标视频平均码率（单位：Kbps）
+     * @param targetSizeMB 目标视频大小（MB）
+     * @param duration 视频时长（秒）
+     * @returns
+     */
+    calculateBitrate(targetSizeMB, duration) {
+        // 将目标大小转换为字节
+        const targetSizeBytes = targetSizeMB * 1024 * 1024; // 转换为字节
+        // 计算比特率并返回单位 Mbps
+        return (targetSizeBytes * 8) / duration / 1024; // Kbps
+    }
+    /**
+     * 获取视频文件大小（单位MB）
+     * @param filePath 视频文件绝对路径
+     * @returns
+     */
+    async getVideoFileSize(filePath) {
+        try {
+            const stats = await node_fs_1.default.promises.stat(filePath); // 获取文件信息
+            const fileSizeInBytes = stats.size; // 文件大小（字节）
+            const fileSizeInMB = fileSizeInBytes / (1024 * 1024); // 转换为MB
+            return fileSizeInMB;
+        }
+        catch (error) {
+            console.error('获取文件大小时发生错误:', error);
+            throw error;
+        }
+    }
+    /**
+     * 根据配置文件的配置项，删除缓存文件
+     * @param path 文件的绝对路径
+     * @param force 是否强制删除，默认 `false`
+     * @returns
+     */
+    async removeFile(path, force = false) {
+        path = path.replace(/\\/g, '/');
+        if (Config_1.Config.app.removeCache) {
+            try {
+                await node_fs_1.default.promises.unlink(path);
+                node_karin_1.logger.mark('缓存文件: ', path + ' 删除成功！');
+                return true;
+            }
+            catch (err) {
+                node_karin_1.logger.error('缓存文件: ', path + ' 删除失败！', err);
+                return false;
+            }
+        }
+        else if (force) {
+            try {
+                await node_fs_1.default.promises.unlink(path);
+                node_karin_1.logger.mark('缓存文件: ', path + ' 删除成功！');
+                return true;
+            }
+            catch (err) {
+                node_karin_1.logger.error('缓存文件: ', path + ' 删除失败！', err);
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * 注册一个视频预览状态，供预览页面和 SSE 状态流读取。
+     * @param filePath 视频文件绝对路径。
+     * @param removeCache 预览文件是否会在 TTL 到期后自动删除。
+     * @param ttlMs 预览状态的生存时间，单位为毫秒。
+     * @returns 当前注册后的预览状态对象。
+     */
+    registerVideoPreview(filePath, removeCache, ttlMs) {
+        this.pruneVideoPreviewState();
+        const filename = node_path_1.default.basename(filePath);
+        const createdAt = Date.now();
+        const expireAt = removeCache ? createdAt + ttlMs : undefined;
+        const info = {
+            filename,
+            filePath,
+            createdAt,
+            expireAt,
+            removeCache
+        };
+        this.videoPreviewState.set(filename, info);
+        return info;
+    }
+    /**
+     * 按文件名获取视频预览状态。
+     * @param filename 预览文件名。
+     * @returns 命中的预览状态；未命中时返回 `null`。
+     */
+    getVideoPreview(filename) {
+        this.pruneVideoPreviewState();
+        return this.videoPreviewState.get(filename) ?? null;
+    }
+    /**
+     * 将视频预览状态标记为已移除，并安排延迟回收。
+     * @param filePathOrFilename 视频绝对路径或文件名。
+     * @returns 更新后的预览状态；若不存在则返回 `null`。
+     */
+    markVideoPreviewRemoved(filePathOrFilename) {
+        this.pruneVideoPreviewState();
+        const filename = filePathOrFilename.includes('/') || filePathOrFilename.includes('\\') ? node_path_1.default.basename(filePathOrFilename) : filePathOrFilename;
+        const info = this.videoPreviewState.get(filename);
+        if (!info) {
+            return null;
+        }
+        const updated = {
+            ...info,
+            removedAt: Date.now(),
+            cleanupAt: Date.now() + Tools.VIDEO_PREVIEW_REMOVED_RETENTION_MS
+        };
+        this.videoPreviewState.set(filename, updated);
+        return updated;
+    }
+    /**
+     * 清理过期或已删除的视频预览状态，避免全局缓存持续增长。
+     * @param now 当前时间戳，默认使用 `Date.now()`。
+     */
+    pruneVideoPreviewState(now = Date.now()) {
+        for (const [filename, info] of this.videoPreviewState) {
+            const fileMissing = !node_fs_1.default.existsSync(info.filePath);
+            const shouldMarkRemoved = !info.removedAt &&
+                ((info.removeCache && typeof info.expireAt === 'number' && now >= info.expireAt && fileMissing) ||
+                    (!info.removeCache && fileMissing));
+            if (shouldMarkRemoved) {
+                const removedAt = now;
+                this.videoPreviewState.set(filename, {
+                    ...info,
+                    removedAt,
+                    cleanupAt: removedAt + Tools.VIDEO_PREVIEW_REMOVED_RETENTION_MS
+                });
+                continue;
+            }
+            if (info.cleanupAt && now >= info.cleanupAt) {
+                this.videoPreviewState.delete(filename);
+            }
+        }
+    }
+    /**
+     * 评论图、推送图是否使用深色模式
+     * @returns
+     */
+    useDarkTheme() {
+        let dark = true;
+        const configTheme = Config_1.Config.app.Theme;
+        if (configTheme === 0 || configTheme === 3) {
+            // 自动 / 智能场景的兜底自动
+            const currentHour = new Date().getHours();
+            if (currentHour >= 6 && currentHour < 18) {
+                dark = false;
+            }
+        }
+        else if (configTheme === 1) {
+            dark = false;
+        }
+        else if (configTheme === 2) {
+            dark = true;
+        }
+        return dark;
+    }
+    /**
+     * 验证视频请求
+     * @param filename 文件名
+     * @param res 响应对象
+     * @returns 返回安全解析后的路径
+     */
+    validateVideoRequest(filename, res) {
+        // 1. 基础校验
+        if (!filename) {
+            (0, node_karin_1.createNotFoundResponse)(res, '无效的文件名');
+            return null;
+        }
+        // 2. 规范化并解析路径
+        const intendedBaseDir = node_path_1.default.resolve(exports.Common.tempDri.video);
+        const requestedPath = node_path_1.default.join(intendedBaseDir, filename); // 先拼接
+        const resolvedPath = node_path_1.default.normalize(requestedPath); // 规范化
+        // 3. 安全性检查：防止路径穿越
+        if (!resolvedPath.startsWith(intendedBaseDir + node_path_1.default.sep) || filename.includes('/') || filename.includes('\\')) {
+            node_karin_1.logger.warn(`潜在的路径穿越尝试或无效文件名: ${filename}, 解析路径: ${resolvedPath}`);
+            (0, node_karin_1.createNotFoundResponse)(res, '无效的文件名或路径');
+            return null;
+        }
+        // 确保文件名本身不包含路径分隔符
+        if (node_path_1.default.basename(filename) !== filename) {
+            node_karin_1.logger.warn(`文件名包含路径分隔符: ${filename}`);
+            (0, node_karin_1.createNotFoundResponse)(res, '无效的文件名');
+            return null;
+        }
+        // 检查文件是否存在
+        if (!node_fs_1.default.existsSync(resolvedPath)) {
+            (0, node_karin_1.createNotFoundResponse)(res, '视频文件未找到');
+            return null;
+        }
+        return resolvedPath; // 返回安全解析后的路径
+    }
+    /**
+     * 格式化数字
+     * @param num 数字
+     * @returns 格式化后的字符串
+     */
+    count(num) {
+        return (0, __1.Count)(num);
+    }
+    /**
+     * 格式化文件大小
+     * @param sizeInMB 文件大小（MB）
+     * @returns 格式化后的文件大小字符串（带单位）
+     */
+    formatFileSize(sizeInMB) {
+        const size = typeof sizeInMB === 'string' ? parseFloat(sizeInMB) : sizeInMB;
+        if (size < 1024) {
+            return `${size.toFixed(2)}MB`;
+        }
+        else if (size < 1024 * 1024) {
+            return `${(size / 1024).toFixed(2)}GB`;
+        }
+        else {
+            return `${(size / (1024 * 1024)).toFixed(2)}TB`;
+        }
+    }
+}
+/** 常用工具合集 */
+exports.Common = new Tools();