koishi-plugin-kkk 1.0.0

package/lib/karin/module/utils/Network/constants.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_HEADERS = exports.RECOVERABLE_KEYWORDS = exports.RECOVERABLE_ERROR_CODES = exports.ERROR_CODE_MAP = void 0;
+const axios_1 = __importDefault(require("../../../../compat/axios.js"));
+/**
+ * 错误代码到中文描述的映射
+ */
+exports.ERROR_CODE_MAP = {
+    // 网络连接错误
+    ECONNRESET: '连接被重置',
+    ECONNREFUSED: '连接被拒绝',
+    ECONNABORTED: '连接中止',
+    ETIMEDOUT: '连接超时',
+    ENETUNREACH: '网络不可达',
+    EHOSTUNREACH: '主机不可达',
+    ENOTFOUND: 'DNS解析失败',
+    EPIPE: '管道破裂',
+    EAI_AGAIN: 'DNS临时失败',
+    // Axios 特定错误代码
+    ERR_BAD_OPTION_VALUE: '无效的配置选项值',
+    ERR_BAD_OPTION: '无效的配置选项',
+    ERR_NETWORK: '网络错误',
+    ERR_DEPRECATED: '使用了已弃用的功能',
+    ERR_BAD_RESPONSE: '无效的响应',
+    ERR_BAD_REQUEST: '无效的请求',
+    ERR_CANCELED: '请求被取消',
+    ERR_NOT_SUPPORT: '不支持的功能',
+    ERR_INVALID_URL: '无效的URL',
+    // HTTP 状态码相关
+    EHTTP: 'HTTP错误',
+    // 其他常见错误
+    EACCES: '权限不足',
+    ENOENT: '文件或目录不存在',
+    EMFILE: '打开的文件过多',
+    ENOSPC: '磁盘空间不足'
+};
+/**
+ * 可恢复的错误代码列表
+ */
+exports.RECOVERABLE_ERROR_CODES = [
+    'ECONNRESET', // 连接被重置（代理切换、网络切换、服务器断流）
+    'ETIMEDOUT', // 连接超时
+    'ECONNREFUSED', // 连接被拒绝
+    'ENOTFOUND', // DNS解析失败
+    'ENETUNREACH', // 网络不可达
+    'EHOSTUNREACH', // 主机不可达
+    'EPIPE', // 管道破裂
+    'EAI_AGAIN', // DNS临时失败
+    'ECONNABORTED' // 连接中止
+];
+/**
+ * 可恢复错误的关键词
+ */
+exports.RECOVERABLE_KEYWORDS = ['aborted', 'timeout', 'network', 'ECONNRESET', 'socket hang up', 'connection reset'];
+/**
+ * Chrome 版本数据地址
+ * @remarks
+ * 访问失败时将自动尝试代理站
+ */
+const CHROME_VERSIONS_URL = 'https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json';
+/**
+ * 代理前缀
+ * @remarks
+ * 直接将目标地址拼接在此域名后面即可
+ */
+const PROXY_PREFIX = 'https://jiashu.1win.eu.org/';
+/**
+ * 构建浏览器 UA 字符串
+ * @param version - Chrome 版本号，例如 `146.0.7680.76`
+ * @returns UA 字符串
+ */
+const buildUserAgent = (version) => `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${version} Safari/537.36 Edg/${version}`;
+/**
+ * 获取最新稳定版 Chrome 版本号
+ * @param url - 版本源地址
+ * @param proxyPrefix - 代理前缀地址，当直连失败时使用
+ * @returns 成功返回版本号，失败返回 null
+ */
+const fetchLatestChromeVersion = async (url, proxyPrefix) => {
+    try {
+        const resp = await axios_1.default.get(url, { timeout: 15000 });
+        const version = resp.data?.channels?.Stable?.version;
+        return typeof version === 'string' && version.length > 0 ? version : null;
+    }
+    catch {
+        try {
+            const resp = await axios_1.default.get(`${proxyPrefix}${url}`, { timeout: 15000 });
+            const version = resp.data?.channels?.Stable?.version;
+            return typeof version === 'string' && version.length > 0 ? version : null;
+        }
+        catch {
+            return null;
+        }
+    }
+};
+/**
+ * 默认 UA 字符串（降级兜底）
+ */
+const DEFAULT_UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36 Edg/137.0.0.0';
+/**
+ * 动态解析得到的 UA
+ * @remarks
+ * 优先使用「最新稳定版」Chrome 版本；失败时回退到内置 UA
+ */
+// Koishi 移植：原实现用顶层 await 拉取最新 Chrome 版本（CJS 构建不支持顶层 await），
+// 改为先用内置 UA，随后在后台异步刷新。
+const RESOLVED_UA = DEFAULT_UA;
+/**
+ * 默认请求头
+ */
+exports.BASE_HEADERS = {
+    Accept: '*/*',
+    'accept-language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',
+    'User-Agent': RESOLVED_UA
+};
+// 后台刷新 UA（失败保持内置兜底，不影响请求）
+void (async () => {
+    try {
+        const latest = await fetchLatestChromeVersion(CHROME_VERSIONS_URL, PROXY_PREFIX);
+        if (latest)
+            exports.BASE_HEADERS['User-Agent'] = buildUserAgent(latest);
+    }
+    catch {
+        // 忽略：保持 DEFAULT_UA
+    }
+})();

package/lib/karin/module/utils/Network/helpers.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeFilename = exports.extractTotalBytesFromHeaders = exports.formatBytes = exports.calculateBackoffDelay = exports.isThrottlingError = exports.isRecoverableNetworkError = exports.sanitizeHeaders = exports.sanitizeIP = exports.getErrorDescription = void 0;
+const axios_1 = require("../../../../compat/axios.js");
+const constants_1 = require("./constants");
+/**
+ * 获取错误的中英文描述
+ * @param error 错误对象
+ * @returns 格式化的错误描述
+ */
+const getErrorDescription = (error) => {
+    const code = error?.code || (error instanceof axios_1.AxiosError ? error.code : null);
+    const message = error?.message || String(error);
+    if (code && constants_1.ERROR_CODE_MAP[code]) {
+        return `${constants_1.ERROR_CODE_MAP[code]} (${code}): ${message}`;
+    }
+    else if (code) {
+        return `错误代码 ${code}: ${message}`;
+    }
+    else {
+        return message;
+    }
+};
+exports.getErrorDescription = getErrorDescription;
+/**
+ * 脱敏处理IP地址
+ * @param text 包含IP的文本
+ * @returns 脱敏后的文本
+ */
+const sanitizeIP = (text) => {
+    if (!text)
+        return text;
+    // IPv4 脱敏: 192.168.1.1 -> 192.168.*.*
+    text = text.replace(/\b(\d{1,3}\.\d{1,3})\.\d{1,3}\.\d{1,3}\b/g, '$1.*.*');
+    // IPv6 脱敏: 2001:0db8:85a3::8a2e:0370:7334 -> 2001:0db8:****
+    text = text.replace(/\b([0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}):[0-9a-fA-F:]+\b/g, '$1:****');
+    return text;
+};
+exports.sanitizeIP = sanitizeIP;
+/**
+ * 脱敏处理敏感请求头信息
+ * @param headers 原始请求头
+ * @returns 脱敏后的请求头（敏感字段直接删除）
+ */
+const sanitizeHeaders = (headers) => {
+    if (!headers)
+        return {};
+    const sanitized = {};
+    const sensitiveKeys = ['cookie', 'cookies', 'authorization', 'x-api-key', 'api-key', 'token'];
+    const ipSensitiveKeys = ['x-forwarded-for', 'x-real-ip', 'x-client-ip', 'x-originating-ip'];
+    for (const [key, value] of Object.entries(headers)) {
+        const lowerKey = key.toLowerCase();
+        // 敏感字段直接跳过，不添加到结果中
+        if (sensitiveKeys.some((sk) => lowerKey.includes(sk))) {
+            continue;
+        }
+        // IP 相关字段也直接跳过
+        if (ipSensitiveKeys.some((sk) => lowerKey.includes(sk))) {
+            continue;
+        }
+        // 其他字段保留
+        sanitized[key] = String(value);
+    }
+    return sanitized;
+};
+exports.sanitizeHeaders = sanitizeHeaders;
+/**
+ * 判断错误是否为可恢复的网络错误
+ * @param error 错误对象
+ * @returns 是否为可恢复错误
+ */
+const isRecoverableNetworkError = (error) => {
+    // 检查错误代码
+    if (error?.code && constants_1.RECOVERABLE_ERROR_CODES.includes(error.code)) {
+        return true;
+    }
+    // 检查 AxiosError
+    if (error instanceof axios_1.AxiosError) {
+        if (error.code && constants_1.RECOVERABLE_ERROR_CODES.includes(error.code)) {
+            return true;
+        }
+        const errorMessage = error.message?.toLowerCase() || '';
+        if (constants_1.RECOVERABLE_KEYWORDS.some((keyword) => errorMessage.includes(keyword.toLowerCase()))) {
+            return true;
+        }
+    }
+    // 检查普通 Error
+    if (error instanceof Error) {
+        const errorMessage = error.message?.toLowerCase() || '';
+        if (constants_1.RECOVERABLE_KEYWORDS.some((keyword) => errorMessage.includes(keyword.toLowerCase()))) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.isRecoverableNetworkError = isRecoverableNetworkError;
+/**
+ * 判断是否为服务器断流（风控）导致的错误
+ * @param error 错误对象
+ * @returns 是否为断流错误
+ */
+const isThrottlingError = (error) => {
+    const code = error?.code || (error instanceof axios_1.AxiosError ? error.code : null);
+    // ECONNRESET 是最常见的断流错误
+    if (code === 'ECONNRESET') {
+        return true;
+    }
+    // 检查错误消息
+    const message = error?.message?.toLowerCase() || '';
+    const throttlingKeywords = ['connection reset', 'socket hang up', 'econnreset'];
+    return throttlingKeywords.some((keyword) => message.includes(keyword));
+};
+exports.isThrottlingError = isThrottlingError;
+/**
+ * 计算指数退避延迟
+ * @param retryCount 当前重试次数
+ * @param baseDelay 基础延迟（毫秒）
+ * @param maxDelay 最大延迟（毫秒）
+ * @returns 延迟时间（毫秒）
+ */
+const calculateBackoffDelay = (retryCount, baseDelay = 1000, maxDelay = 8000) => {
+    return Math.min(2 ** retryCount * baseDelay, maxDelay);
+};
+exports.calculateBackoffDelay = calculateBackoffDelay;
+/**
+ * 格式化字节数为可读字符串
+ * @param bytes 字节数
+ * @returns 格式化后的字符串
+ */
+const formatBytes = (bytes) => {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+};
+exports.formatBytes = formatBytes;
+/**
+ * 从响应头中提取文件总字节数
+ * @param headers 响应头
+ * @returns 文件总大小，无法提取时返回 0
+ */
+const extractTotalBytesFromHeaders = (headers) => {
+    if (!headers)
+        return 0;
+    const contentRange = headers['content-range'];
+    const contentRangeText = Array.isArray(contentRange) ? contentRange[0] : String(contentRange ?? '');
+    const rangeMatch = contentRangeText.match(/\/(\d+)(?:\s*$)/);
+    if (rangeMatch) {
+        return Number.parseInt(rangeMatch[1], 10);
+    }
+    const contentLength = headers['content-length'];
+    const contentLengthText = Array.isArray(contentLength) ? contentLength[0] : String(contentLength ?? '');
+    const parsedLength = Number.parseInt(contentLengthText, 10);
+    return Number.isFinite(parsedLength) ? parsedLength : 0;
+};
+exports.extractTotalBytesFromHeaders = extractTotalBytesFromHeaders;
+/**
+ * 清理文件名，移除不安全字符
+ * @param filename 原始文件名
+ * @returns 安全的文件名
+ */
+const sanitizeFilename = (filename) => {
+    // 替换非法符号 + 控制字符
+    return filename
+        .replace(/[<>:"/\\|?*\p{Cc}]/gu, '_')
+        .replace(/^\.+/, '')
+        .replace(/\.+$/, '')
+        .replace(/\s+/g, '_')
+        .substring(0, 200);
+};
+exports.sanitizeFilename = sanitizeFilename;

package/lib/karin/module/utils/Network/index.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Network 模块
+ * 提供网络请求、文件下载（支持限速和断点续传）等功能
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseHeaders = exports.DEFAULT_THROTTLE_CONFIG = exports.ThrottleStream = exports.Networks = exports.Network = exports.ImageDownloader = exports.sanitizeHeaders = exports.sanitizeFilename = exports.isThrottlingError = exports.isRecoverableNetworkError = exports.getErrorDescription = exports.formatBytes = exports.extractTotalBytesFromHeaders = exports.calculateBackoffDelay = exports.Downloader = exports.BASE_HEADERS = void 0;
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "BASE_HEADERS", { enumerable: true, get: function () { return constants_1.BASE_HEADERS; } });
+var Downloader_1 = require("./Downloader");
+Object.defineProperty(exports, "Downloader", { enumerable: true, get: function () { return Downloader_1.Downloader; } });
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "calculateBackoffDelay", { enumerable: true, get: function () { return helpers_1.calculateBackoffDelay; } });
+Object.defineProperty(exports, "extractTotalBytesFromHeaders", { enumerable: true, get: function () { return helpers_1.extractTotalBytesFromHeaders; } });
+Object.defineProperty(exports, "formatBytes", { enumerable: true, get: function () { return helpers_1.formatBytes; } });
+Object.defineProperty(exports, "getErrorDescription", { enumerable: true, get: function () { return helpers_1.getErrorDescription; } });
+Object.defineProperty(exports, "isRecoverableNetworkError", { enumerable: true, get: function () { return helpers_1.isRecoverableNetworkError; } });
+Object.defineProperty(exports, "isThrottlingError", { enumerable: true, get: function () { return helpers_1.isThrottlingError; } });
+Object.defineProperty(exports, "sanitizeFilename", { enumerable: true, get: function () { return helpers_1.sanitizeFilename; } });
+Object.defineProperty(exports, "sanitizeHeaders", { enumerable: true, get: function () { return helpers_1.sanitizeHeaders; } });
+var ImageDownloader_1 = require("./ImageDownloader");
+Object.defineProperty(exports, "ImageDownloader", { enumerable: true, get: function () { return ImageDownloader_1.ImageDownloader; } });
+var Network_1 = require("./Network");
+Object.defineProperty(exports, "Network", { enumerable: true, get: function () { return Network_1.Network; } });
+// 为了向后兼容，同时导出 Networks 别名
+var Network_2 = require("./Network");
+Object.defineProperty(exports, "Networks", { enumerable: true, get: function () { return Network_2.Network; } });
+var ThrottleStream_1 = require("./ThrottleStream");
+Object.defineProperty(exports, "ThrottleStream", { enumerable: true, get: function () { return ThrottleStream_1.ThrottleStream; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "DEFAULT_THROTTLE_CONFIG", { enumerable: true, get: function () { return types_1.DEFAULT_THROTTLE_CONFIG; } });
+// 为了向后兼容，导出 baseHeaders 别名
+var constants_2 = require("./constants");
+Object.defineProperty(exports, "baseHeaders", { enumerable: true, get: function () { return constants_2.BASE_HEADERS; } });

package/lib/karin/module/utils/Network/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_THROTTLE_CONFIG = void 0;
+/**
+ * 默认限速配置
+ */
+exports.DEFAULT_THROTTLE_CONFIG = {
+    enabled: true,
+    maxSpeed: 10 * 1024 * 1024, // 10 MB/s
+    autoReduceRatio: 0.7,
+    minSpeed: 1 * 1024 * 1024 // 1 MB/s
+};

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThrottleStream = exports.sanitizeHeaders = exports.Networks = exports.Network = exports.isThrottlingError = exports.isRecoverableNetworkError = exports.getErrorDescription = exports.formatBytes = exports.extractTotalBytesFromHeaders = exports.Downloader = exports.DEFAULT_THROTTLE_CONFIG = exports.baseHeaders = exports.BASE_HEADERS = void 0;
+var Network_1 = require("./Network");
+Object.defineProperty(exports, "BASE_HEADERS", { enumerable: true, get: function () { return Network_1.BASE_HEADERS; } });
+Object.defineProperty(exports, "baseHeaders", { enumerable: true, get: function () { return Network_1.baseHeaders; } });
+Object.defineProperty(exports, "DEFAULT_THROTTLE_CONFIG", { enumerable: true, get: function () { return Network_1.DEFAULT_THROTTLE_CONFIG; } });
+Object.defineProperty(exports, "Downloader", { enumerable: true, get: function () { return Network_1.Downloader; } });
+Object.defineProperty(exports, "extractTotalBytesFromHeaders", { enumerable: true, get: function () { return Network_1.extractTotalBytesFromHeaders; } });
+Object.defineProperty(exports, "formatBytes", { enumerable: true, get: function () { return Network_1.formatBytes; } });
+Object.defineProperty(exports, "getErrorDescription", { enumerable: true, get: function () { return Network_1.getErrorDescription; } });
+Object.defineProperty(exports, "isRecoverableNetworkError", { enumerable: true, get: function () { return Network_1.isRecoverableNetworkError; } });
+Object.defineProperty(exports, "isThrottlingError", { enumerable: true, get: function () { return Network_1.isThrottlingError; } });
+Object.defineProperty(exports, "Network", { enumerable: true, get: function () { return Network_1.Network; } });
+Object.defineProperty(exports, "Networks", { enumerable: true, get: function () { return Network_1.Networks; } });
+Object.defineProperty(exports, "sanitizeHeaders", { enumerable: true, get: function () { return Network_1.sanitizeHeaders; } });
+Object.defineProperty(exports, "ThrottleStream", { enumerable: true, get: function () { return Network_1.ThrottleStream; } });

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

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * 解析去重锁。
+ *
+ * 同一次点击可能被 QQ 投递两遍（指令按钮既发消息又发交互事件、用户连点、客户端重发），
+ * 而解析本身是重活（取流 + 下载 + 发送），跑两遍的后果是：
+ * 用户看到两次「检测到链接，开始解析」，第二次还会因为缓存已被清理而失败。
+ *
+ * 这里按「会话 + 作品 + 画质 + 弹幕开关」在短时间内只放行一次；
+ * 换画质/换解析内容属于不同的键，不会被误伤。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acquireParseLock = acquireParseLock;
+/** 去重窗口（毫秒） */
+const WINDOW = 20 * 1000;
+const recent = new Map();
+/**
+ * 尝试取得一次解析许可。
+ * @param key 去重键（建议包含会话、作品 ID、画质与弹幕开关）
+ * @returns true = 可以解析；false = 刚刚已经跑过一次，忽略
+ */
+function acquireParseLock(key) {
+    const now = Date.now();
+    for (const [item, at] of recent) {
+        if (now - at > WINDOW)
+            recent.delete(item);
+    }
+    const last = recent.get(key);
+    if (last !== undefined && now - last < WINDOW)
+        return false;
+    recent.set(key, now);
+    return true;
+}
+exports.default = acquireParseLock;

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWithParseOverride = runWithParseOverride;
+exports.getParseOverride = getParseOverride;
+exports.parseParseFlags = parseParseFlags;
+/**
+ * 单条消息的解析参数覆盖（画质 / 弹幕）。
+ *
+ * ## 为什么需要它
+ * QQ 平台的交互面板（见 module/utils/QqPanel.ts）让用户点按钮选画质，
+ * 但画质是**深埋在**业务代码里的全局配置读取：\`Config.bilibili.videoQuality\` 在
+ * 取流、选流、下载各写了一次，把参数一层层传下去要改十几个函数签名。
+ *
+ * 这里用 AsyncLocalStorage 把「本次解析的选择」挂在异步上下文上，
+ * Config 的 Proxy 读取时优先取覆盖值 —— 业务代码一行都不用改，
+ * 定时推送、其它会话也不会被串味（上下文只在本条消息的处理链里生效）。
+ */
+const node_async_hooks_1 = require("node:async_hooks");
+const storage = new node_async_hooks_1.AsyncLocalStorage();
+/**
+ * 在参数覆盖的上下文里执行解析。
+ * @param override 覆盖项（空对象则直接执行）
+ * @param fn 解析逻辑
+ */
+function runWithParseOverride(override, fn) {
+    if (!override || !Object.keys(override).length)
+        return fn();
+    return storage.run(override, fn);
+}
+/** 当前上下文里的覆盖项（不在解析链路里时返回 undefined） */
+function getParseOverride() {
+    return storage.getStore();
+}
+/**
+ * 解析消息里的 \`--xxx\` 参数。
+ *
+ * 约定（按钮 action.data 与手工输入通用，所以刻意做得短、好敲）：
+ *   - \`--qn=80\`    B站画质
+ *   - \`--q=1080p\`  抖音/小红书画质
+ *   - \`--dm=1\`     烧录弹幕
+ *   - \`--panel=1\`  只重发面板（1 = 带弹幕，0 = 纯视频）
+ *   - \`--p=abc123\` 面板按钮的短令牌（真实链接存在插件内存里，见 QqPanel）
+ * @param msg 消息文本
+ * @returns 解析结果
+ */
+function parseParseFlags(msg) {
+    const text = String(msg ?? '');
+    const override = {};
+    let hasAny = false;
+    let panel;
+    let panelToken;
+    let bangumiPage;
+    const cleaned = text
+        .replace(/\s*--p=([0-9a-z]+)/i, (_all, value) => {
+        panelToken = value;
+        hasAny = true;
+        return '';
+    })
+        .replace(/\s*--qn=(\d+)/gi, (_all, value) => {
+        override.bilibiliQuality = Number(value);
+        hasAny = true;
+        return '';
+    })
+        .replace(/\s*--q=([0-9a-z]+)/gi, (_all, value) => {
+        override.douyinQuality = value;
+        override.xiaohongshuQuality = value;
+        hasAny = true;
+        return '';
+    })
+        .replace(/\s*--dm=1/gi, () => {
+        override.burnDanmaku = true;
+        hasAny = true;
+        return '';
+    })
+        .replace(/\s*--panel=([01])/gi, (_all, value) => {
+        panel = value === '1' ? 1 : 0;
+        hasAny = true;
+        return '';
+    })
+        .replace(/\s*--bgp=(\d+)/gi, (_all, value) => {
+        bangumiPage = Number(value);
+        hasAny = true;
+        return '';
+    })
+        .trim();
+    return { override, cleaned, hasAny, panel, panelToken, bangumiPage };
+}
+exports.default = parseParseFlags;

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBiliCard = resolveBiliCard;
+exports.resolveQqCardContent = resolveQqCardContent;
+/**
+ * QQ 卡片「无链接」还原。
+ *
+ * QQ 官方适配器把分享卡片整段当文本丢进来，而新版卡片**连跳转链接都没有**，
+ * 于是各平台的链接正则一条都匹配不上 —— 用户侧的表现就是「卡片发出来没反应」。
+ * 这里把卡片（详见 compat/qqcard.ts）还原成一条规范链接，追加到消息文本末尾，
+ * 让原有的解析命令照常命中：命令本身仍按前缀匹配，普通消息完全不受影响。
+ *
+ * 匹配策略（强 → 弱）：
+ *   1. 卡片自带 B 站链接（b23.tv / bilibili.com）→ 直接规范化；
+ *   2. 卡片封面哈希 == 搜索结果的 \`pic\` 哈希 → 同一张稿件封面，直接认定；
+ *   3. 标题包含/相等（打分 ≥ 60）→ 认定。
+ * 认不出来就**不还原**，宁可让下游提示「未找到链接」，也不要猜错视频解析出别人的内容。
+ */
+const node_karin_1 = require("../../../compat/node-karin.js");
+const qqcard_1 = require("../../../compat/qqcard");
+const text_1 = require("../../../compat/text");
+const search_1 = require("../../platform/bilibili/search");
+/** B 站链接特征（消息里已经有链接就不用还原了） */
+const BILI_URL = /bilibili\.com|b23\.tv|bili2233|\bBV[0-9A-Za-z]{10}\b/i;
+/** 还原结果缓存：同一条卡片消息会被匹配、命令、统计等多处读取，没必要重复搜索 */
+const cache = new Map();
+const CACHE_LIMIT = 64;
+/** 认不认这条搜索结果 */
+const isConfident = (item) => item.coverMatch || item.score >= 60;
+/** 纯平台名/占位词，拿去搜索只会搜到无关视频 */
+const GENERIC_TITLE = /^(哔哩哔哩|bilibili|视频|弹幕|分享|网页链接|抖音|快手|小红书)+$/i;
+/**
+ * 标题是否值得拿去搜索。
+ * 卡片字段缺失时标题可能是「哔哩哔哩」这类来源名，与其拿它赌一个视频，不如放弃还原。
+ * @param title 卡片标题
+ */
+const isSearchableTitle = (title) => {
+    const key = String(title ?? '').replace(/\s+/g, '');
+    return key.length >= 4 && !GENERIC_TITLE.test(key);
+};
+/**
+ * 把一张 B 站卡片还原成规范视频链接。
+ * @param card 卡片
+ * @returns 规范链接；无法确定时返回空串
+ */
+async function resolveBiliCard(card) {
+    const inline = card.urls.find((url) => BILI_URL.test(url) || /\bBV[0-9A-Za-z]{10}\b/.test(url));
+    if (inline)
+        return await (0, search_1.resolveBiliCanonicalUrl)(inline);
+    if (!isSearchableTitle(card.title)) {
+        node_karin_1.logger.debug('[QQ卡片] 标题「' + card.title + '」过于宽泛，放弃搜索还原');
+        return '';
+    }
+    const items = await (0, search_1.searchBilibiliVideos)({
+        keyword: card.title,
+        title: card.title,
+        author: card.author,
+        cover: card.cover,
+        limit: 8
+    });
+    const best = items.find(isConfident);
+    if (!best) {
+        node_karin_1.logger.debug('[QQ卡片] 标题「' + card.title + '」没有找到足够可信的B站视频，放弃还原' + (items[0] ? '（最高分 ' + items[0].score + '：' + items[0].title + '）' : ''));
+        return '';
+    }
+    node_karin_1.logger.debug('[QQ卡片] 还原B站视频: ' + best.title + ' → ' + best.bvid + '（分数 ' + best.score + (best.coverMatch ? '，封面命中' : '') + '）');
+    return 'https://www.bilibili.com/video/' + best.bvid;
+}
+/**
+ * 归一化一条消息文本：JSON 转义还原 + 已有链接提取 + 无链接卡片搜索还原。
+ *
+ * 普通消息走同步快路径（一次 \`includes('{')\` 就返回），只有疑似卡片的文本才会触发网络搜索。
+ * @param content 原始消息文本
+ * @returns 可交给解析命令的文本
+ */
+async function resolveQqCardContent(content) {
+    const raw = String(content ?? '');
+    const base = (0, text_1.normalizeMessageText)(raw);
+    if (!raw || !raw.includes('{'))
+        return base;
+    const cached = cache.get(raw);
+    if (cached !== undefined)
+        return cached;
+    const result = await resolveCards(raw, base);
+    if (cache.size >= CACHE_LIMIT)
+        cache.delete(cache.keys().next().value);
+    cache.set(raw, result);
+    return result;
+}
+/** 实际的还原逻辑（与缓存分开，便于阅读） */
+async function resolveCards(raw, base) {
+    const cards = (0, qqcard_1.parseQqCards)(raw);
+    if (!cards.length)
+        return base;
+    // 已经有 B 站链接的消息不用还原：解析命令自己就能处理短链
+    if ((0, text_1.extractUrls)(base).some((url) => BILI_URL.test(url)))
+        return base;
+    const targets = cards.filter((card) => card.platform === 'bilibili' && isSearchableTitle(card.title)).slice(0, 2);
+    if (!targets.length)
+        return base;
+    const extra = [];
+    for (const card of targets) {
+        try {
+            const url = await resolveBiliCard(card);
+            if (url && !base.includes(url) && !extra.includes(url))
+                extra.push(url);
+        }
+        catch (error) {
+            node_karin_1.logger.debug('[QQ卡片] 还原失败: ' + String(error));
+        }
+    }
+    return extra.length ? base + ' ' + extra.join(' ') : base;
+}
+exports.default = resolveQqCardContent;