koishi-plugin-kkk 3.4.2 → 3.6.0

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

@@ -147,9 +147,40 @@ function listActiveDownloads() {
     }
     return result.sort((left, right) => right.at - left.at);
 }
+/* ------------------------------------------------------------------ *
+ * 坏源判定阈值
+ * ------------------------------------------------------------------ */
+/**
+ * 换源前的热身时间：新源先给这么久证明自己。
+ *
+ * B站 playurl 经常把直链指向 `*.mcdn.bilivideo.cn` 这类 PCDN 边缘节点：
+ * TCP 连得上、响应头也回得来（content-length 都正常），就是几乎不吐数据
+ * （实测 118 KB / 60 秒 ≈ 2 KB/s）。在这种源上干等毫无意义。
+ */
+const STALL_WARMUP_MS = 20_000;
+/** 热身期过后速度仍低于这个值（byte/s）且还有备用地址时，判定为坏源并换源 */
+const STALL_MIN_SPEED = 64 * 1024;
+/**
+ * 重试同一个源之前，本轮至少要传这么多字节，才值得原地重试。
+ *
+ * 传了几 MB 再断，说明源本身是好的（只是被掐了），留着进度续传最划算；
+ * 传了几百 KB 就断，那就是坏源，直接换。
+ */
+const SWITCH_IF_UNDER_BYTES = 4 * 1024 * 1024;
+/** 单次尝试的硬上限：既没数据、又没有备用源可换的「涓流」源不能永远挂着 */
+const MAX_ATTEMPT_MS = 30 * 60_000;
+/** 打个码的地址（只留 host，别把带签名的完整直链写进日志） */
+const safeHost = (url) => {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return '(非法地址)';
+    }
+};
 /**
  * 文件下载器
- * 支持断点续传、限速下载、自动重试
+ * 支持断点续传、限速下载、自动重试，以及**坏源自动换源**
  */
 class Downloader {
     axiosInstance;
@@ -161,7 +192,20 @@ class Downloader {
     throttleConfig;
     currentSpeed;
     consecutiveResets;
-    constructor(axiosInstance, url, filepath, headers, timeout, maxRetries, throttleConfig) {
+    /** 备用直链：当前源被判定为坏源时按顺序换过去（B站 dash 的 backup_url） */
+    backupUrls;
+    /**
+     * 本次尝试「被自己掐断」的原因：
+     * - `timeout`：空闲超时（连续 timeout 毫秒没收到数据）
+     * - `slow`：坏源看门狗主动放弃
+     *
+     * 自己掐断的必须和「服务器重置」区分开 —— Node 把 abort 报成
+     * `Error: aborted`（code ECONNRESET），照抄进日志会把排查方向带偏。
+     */
+    abortReason = null;
+    /** 已经换过几次源（仅用于日志） */
+    sourceSwitches = 0;
+    constructor(axiosInstance, url, filepath, headers, timeout, maxRetries, throttleConfig, backupUrls = []) {
         this.axiosInstance = axiosInstance;
         this.url = url;
         this.filepath = filepath;
@@ -171,6 +215,7 @@ class Downloader {
         this.throttleConfig = { ...types_1.DEFAULT_THROTTLE_CONFIG, ...throttleConfig };
         this.currentSpeed = this.throttleConfig.maxSpeed;
         this.consecutiveResets = 0;
+        this.backupUrls = [...backupUrls];
     }
     /**
      * 执行下载
@@ -186,11 +231,51 @@ class Downloader {
         if (!this.filepath) {
             throw new Error('未指定文件保存路径: filepath 为空');
         }
+        // 每次尝试都从「没被掐断」开始
+        this.abortReason = null;
         const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         let intervalId = null;
         let throttleStream = null;
         let writer = null;
+        /** 本轮尝试收到的字节数（用于坏源判定，断点续传时只算这一轮新增的） */
+        let attemptBytes = 0;
+        /** 本轮尝试的开始时间 */
+        const attemptStart = Date.now();
+        let timeoutId = null;
+        let attemptCapId = null;
+        const clearTimers = () => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (attemptCapId)
+                clearTimeout(attemptCapId);
+            timeoutId = null;
+            attemptCapId = null;
+        };
+        /**
+         * 重新计时：**这是空闲超时，不是总时长超时**。
+         *
+         * 以前这里是一个从头开始算的定时器（`setTimeout(abort, 60000)` 并且全程不再重置），
+         * 于是任何需要超过 60 秒的文件（按 1.5 MB/s 算就是 90 MB 以上）都**永远下不完**：
+         * 到点就被 abort，而 Node 把「自己 abort」报成 `Error: aborted`（code ECONNRESET），
+         * 日志里就成了「下载失败: 连接被重置 (ECONNRESET): aborted」，把所有排查方向都带偏。
+         * 现在每收到一块数据就重新计时，只有**真的没数据**才超时。
+         */
+        const armIdleTimeout = () => {
+            if (this.timeout <= 0)
+                return;
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            timeoutId = setTimeout(() => {
+                this.abortReason = 'timeout';
+                controller.abort();
+            }, this.timeout);
+        };
+        armIdleTimeout();
+        // 兜底：涓流源（一直有数据但慢得离谱、又没有备用源）不能在这一次尝试里挂几个小时
+        attemptCapId = setTimeout(() => {
+            this.abortReason = 'timeout';
+            controller.abort();
+        }, MAX_ATTEMPT_MS);
         try {
             // 检查断点续传
             let startByte = 0;
@@ -234,7 +319,7 @@ class Downloader {
                 currentSpeed: this.throttleConfig.enabled ? (0, helpers_1.formatBytes)(this.currentSpeed) + '/s' : '不限速'
             });
             const response = await this.axiosInstance(requestConfig);
-            clearTimeout(timeoutId);
+            // 注意：这里**不**清除定时器 —— 传输阶段的空闲超时还得靠它（每收到数据会重新计时）
             // 检查 HTTP 状态码
             // 416 Range Not Satisfiable
             if (response.status === 416) {
@@ -328,11 +413,35 @@ class Downloader {
                 reportDownloadProgress(this.filepath, downloadedBytes, totalBytes);
             };
             const interval = totalBytes > 0 && totalBytes < 10 * 1024 * 1024 ? 1000 : 500;
-            intervalId = setInterval(printProgress, interval);
+            /**
+             * 坏源看门狗：有备用地址时，热身期过了速度还低得离谱就直接放弃这个源。
+             *
+             * 没有备用地址时不介入 —— 慢总比失败强，真正的死源交给空闲超时兜底。
+             */
+            const checkStall = () => {
+                if (this.backupUrls.length === 0)
+                    return;
+                const elapsed = Date.now() - attemptStart;
+                if (elapsed < STALL_WARMUP_MS)
+                    return;
+                const speed = attemptBytes / (elapsed / 1000);
+                if (speed >= STALL_MIN_SPEED)
+                    return;
+                node_karin_1.logger.warn(`当前下载源速度过低 (${(0, helpers_1.formatBytes)(Math.round(speed))}/s)，准备切换备用地址`);
+                this.abortReason = 'slow';
+                controller.abort();
+            };
+            intervalId = setInterval(() => {
+                printProgress();
+                checkStall();
+            }, interval);
             // 创建计数流
             const counterStream = new node_stream_1.Transform({
                 transform(chunk, encoding, callback) {
                     downloadedBytes += chunk.length;
+                    attemptBytes += chunk.length;
+                    // 还有数据在流，说明这个源活着：把空闲超时往后推
+                    armIdleTimeout();
                     callback(null, chunk);
                 }
             });
@@ -345,8 +454,6 @@ class Downloader {
             else {
                 await (0, promises_1.pipeline)(response.data, counterStream, writer);
             }
-            if (intervalId)
-                clearInterval(intervalId);
             // pipeline 已经等待所有流完成，包括 writer 的 finish 事件
             node_karin_1.logger.debug('文件下载并写入完成');
             // 验证文件大小
@@ -388,20 +495,34 @@ class Downloader {
             };
         }
         catch (error) {
-            clearTimeout(timeoutId);
+            clearTimers();
             if (intervalId)
                 clearInterval(intervalId);
             // 失败/中断也要清掉，不然「查询下载进度」会一直卡在旧任务上
             clearDownloadProgress(this.filepath);
-            const isRecoverable = (0, helpers_1.isRecoverableNetworkError)(error);
-            const isThrottling = (0, helpers_1.isThrottlingError)(error);
-            const errorDesc = (0, helpers_1.getErrorDescription)(error);
-            if (error instanceof axios_1.AxiosError) {
+            /**
+             * 自己掐断的（空闲超时 / 坏源看门狗）不能按「服务器重置」处理。
+             *
+             * Node 对 `request.abort()` 抛的是 `Error: aborted`（code ECONNRESET），
+             * 直接套 code→文案的映射就会打印成「连接被重置」，既误导排查、
+             * 又会让下面的「服务器断流自动降速」误判（把一个坏源当成风控）。
+             */
+            const idleTimeout = this.abortReason === 'timeout';
+            const slowSource = this.abortReason === 'slow';
+            const ownAbort = idleTimeout || slowSource;
+            const isRecoverable = ownAbort || (0, helpers_1.isRecoverableNetworkError)(error);
+            const isThrottling = !ownAbort && (0, helpers_1.isThrottlingError)(error);
+            const errorDesc = idleTimeout
+                ? `下载超时（${Math.round(this.timeout / 1000)} 秒内没有收到新数据）`
+                : slowSource
+                    ? '下载源速度过低，主动放弃该源'
+                    : (0, helpers_1.getErrorDescription)(error);
+            if (error instanceof axios_1.AxiosError && !ownAbort) {
                 const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
                 node_karin_1.logger.error(`请求失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`);
             }
             else {
-                node_karin_1.logger.error(`下载失败: ${errorDesc}`);
+                node_karin_1.logger.error(ownAbort ? `下载中断: ${errorDesc}` : `下载失败: ${errorDesc}`);
             }
             // 如果是断流错误，自动降速
             if (isThrottling && this.throttleConfig.enabled) {
@@ -415,6 +536,22 @@ class Downloader {
                     node_karin_1.logger.warn(`已达到最低速度限制 ${(0, helpers_1.formatBytes)(this.throttleConfig.minSpeed)}/s，无法继续降速`);
                 }
             }
+            /**
+             * 坏源优先换源。
+             *
+             * 同一份数据在别的镜像上往往能跑满带宽，而坏源上耗满 maxRetries 次
+             * （每次都要再等一个超时）纯属浪费时间；反过来，如果本轮已经传了好几 MB
+             * 只是被掐了一下，那就该留在原源续传，别把进度扔掉。
+             */
+            if ((slowSource || (idleTimeout && attemptBytes < SWITCH_IF_UNDER_BYTES)) && this.backupUrls.length > 0) {
+                const next = this.backupUrls.shift();
+                this.sourceSwitches++;
+                node_karin_1.logger.warn(`当前源不可用，换备用下载源 (${this.sourceSwitches}，剩余 ${this.backupUrls.length}): ` +
+                    `${safeHost(this.url)} -> ${safeHost(next)}`);
+                this.url = next;
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+                return this.download(progressCallback, 0);
+            }
             const nextDelay = (0, helpers_1.calculateBackoffDelay)(retryCount);
             if (retryCount < this.maxRetries) {
                 // 等待 writer 完全关闭，确保异步写入操作已完成，避免 stat 获取到不准确的文件大小
@@ -453,6 +590,9 @@ class Downloader {
                         if (isThrottling) {
                             node_karin_1.logger.warn('建议: 服务器可能有下载速度限制，请尝试在配置中降低 maxSpeed 参数');
                         }
+                        if (idleTimeout) {
+                            node_karin_1.logger.warn('提示: 这条直链所属的 CDN 节点（常见于 *.mcdn.bilivideo.cn 这类 PCDN）很可能已失效，稍后重试或换个画质通常会换到别的节点');
+                        }
                     }
                     else {
                         try {
@@ -468,6 +608,12 @@ class Downloader {
                 throw new Error(`在 ${this.maxRetries} 次尝试后下载失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`);
             }
         }
+        finally {
+            // 所有出口（成功 / 416 提前返回 / 换源 / 重试 / 抛错）都要把定时器和轮询清干净
+            clearTimers();
+            if (intervalId)
+                clearInterval(intervalId);
+        }
     }
     /**
      * 手动设置下载速度

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

@@ -54,6 +54,7 @@ class Network {
     filepath;
     maxRetries;
     throttleConfig;
+    backupUrls;
     /**
      * 创建网络请求实例
      *
@@ -79,6 +80,7 @@ class Network {
         this.filepath = data.filepath ?? '';
         this.maxRetries = data.maxRetries ?? 3;
         this.throttleConfig = data.throttle;
+        this.backupUrls = data.backupUrls ?? [];
         // 创建 axios 实例
         this.axiosInstance = axios_1.default.create({
             timeout: this.timeout,
@@ -126,7 +128,9 @@ class Network {
      * @param retryCount 重试次数（内部使用）
      */
     async downloadStream(progressCallback, retryCount = 0) {
-        const downloader = new Downloader_1.Downloader(this.axiosInstance, this.url, this.filepath, this.headers, this.timeout, this.maxRetries, this.throttleConfig);
+        const downloader = new Downloader_1.Downloader(this.axiosInstance, this.url, this.filepath, this.headers, this.timeout, this.maxRetries, this.throttleConfig, 
+        // 拷贝一份：下载器内部会 shift 掉已经试过的地址
+        [...this.backupUrls]);
         return downloader.download(progressCallback, retryCount);
     }
     async getfetch() {

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

@@ -111,6 +111,8 @@ function isParseForwardEnabled(platform) {
  *   - \`image\` 图片（信息卡、评论卡、图集、切片后的评论卡都算这一类）
  *   - \`video\` 视频（体积大的会被硬上限挡下，见 HARD_INLINE_LIMIT）
  *   - \`file\`  文件（群文件等）
+ *   - \`chart\` B站互动视频的**剧情流程图**：它本身是图片，但可以在「合并转发内容」里单独勾/不勾，
+ *     所以由发送方用 \`withForwardKind('chart', …)\` 标出来（见 compat/forward-collect）
  *
  * **没列出来的内容一律单独直发**（不进转发节点）。默认只合并文字和图片。
  *
@@ -128,7 +130,7 @@ function isParseForwardEnabled(platform) {
  * 会让整条转发被拒（\`Error with request send_group_forward_msg …\`），所以默认只合并文字和图片；
  * 想要视频也进去就勾上 \`video\` —— 真发不出去时下面的兜底会逐条直发，不会丢内容。
  */
-const FORWARD_KINDS = ['text', 'image', 'video', 'file'];
+const FORWARD_KINDS = ['text', 'image', 'video', 'file', 'chart'];
 const DEFAULT_FORWARD_CONTENT = ['text', 'image'];
 /**
  * **永远不进转发节点**的元素类型。
@@ -144,8 +146,16 @@ const NEVER_FORWARD_TYPES = /^(record|audio|markdown)$/;
  * 适配器的请求撑爆。到这一步就回退成单独直发。
  */
 const HARD_INLINE_LIMIT = 30 * 1024 * 1024;
-/** 把元素归到一个可配置的类别（\`other\` 是 at / 引用这类轻量装饰，永远跟着转发走） */
+/**
+ * 把元素归到一个可配置的类别（\`other\` 是 at / 引用这类轻量装饰，永远跟着转发走）。
+ *
+ * **发送方标的类别优先**：剧情流程图和普通图片都是 \`img\`，从段对象上看不出区别 ——
+ * 只有发送方知道它是剧情图（见 compat 的 \`withForwardKind\`）。没标的才按段类型判断。
+ */
 const kindOfElement = (element) => {
+    const tagged = (0, node_karin_1.forwardKindOf)(element);
+    if (tagged)
+        return tagged;
     const type = String(element?.type ?? '');
     if (type === 'img' || type === 'image')
         return 'image';

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

@@ -100,7 +100,7 @@ exports.ParseSteps = ParseSteps;
  * ## 注意
  *
  * - **有依赖顺序的步骤别拆开**：比如「先渲染再发送」必须在同一个任务里；
- * - 渲染内核（shotkit）是**单线程 FIFO**，两个渲染任务并发并不会更快，
+ * - 浏览器渲染是**串行**的（一个浏览器同时渲好几张只会互相拖慢），
  *   拆线只对「网络/磁盘/ffmpeg」这类真正并行的阶段有意义。
  */
 class SendTasks {

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

@@ -10,7 +10,6 @@ exports.buildPosterContext = buildPosterContext;
 exports.renderTemplateHtml = renderTemplateHtml;
 exports.downgradeNoiseLayers = downgradeNoiseLayers;
 exports.pruneMissingFontFaces = pruneMissingFontFaces;
-exports.neutralizeRemoteAssets = neutralizeRemoteAssets;
 exports.optimizeForScreenshot = optimizeForScreenshot;
 /**
  * 渲染模块（Koishi 移植版）。
@@ -19,7 +18,7 @@ exports.optimizeForScreenshot = optimizeForScreenshot;
  * Koishi 侧不引入 ktr 的构建管线（需要 vite/tailwind 打包），改为：
  *   1. 直接用 **react-dom/server** 对上游模板组件做 SSR（模板只依赖 \`{ data, ctx }\` props）；
  *   2. 内联上游构建产物 \`resources/template/style.css\`（tailwind 编译结果，省掉 tailwind 构建）；
- *   3. 优先用 koishi-plugin-puppeteer 截图（没有它才退回 koishi-plugin-shotkit 内核）。
+ *   3. 用浏览器渲染服务（koishi-plugin-puppeteer / puppeteer-without-canvas）截图；3.5.0 起不再支持 shotkit 内核。
  * 路由不在注册表里、或 SSR 失败时，回退到内置通用信息卡片，保证解析结果始终有图。
  */
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -470,36 +469,6 @@ function pruneMissingFontFaces(html, baseDir) {
         return resolvable ? block : '';
     });
 }
-/**
- * 内核（shotkit）加载不了的远程资源，交给它之前先摘掉。
- *
- * 实测：内核在 Windows 上**加载不了 https 资源**（卡片里的 https 图片一律渲染成空白框），
- * 但它照样会为这些地址发请求、并且等它们结束 —— 一张 1440x600 的小页面里只要有一个连不上的
- * https 图片，截图就从 1.5 秒变成 22 秒。React 19 的 SSR 还会给每个 `<img>` 额外补一条
- * `<link rel="preload" as="image">`（一张评论卡实测 27 条），这些 preload 同样算在页面加载里。
- *
- * 所以**只在 shotkit 这条路径**上做替换（puppeteer 那条路不动，它能正常加载远程图片）：
- *   - 删掉 `<link rel="preload">`（纯预加载提示，本地渲染没有意义）
- *   - 远程 `<img src>` 换成 1x1 透明图（反正渲染不出来），顺带删掉 srcset
- *   - 内联样式/CSS 里的 `url(http…)` 换成 none
- */
-function neutralizeRemoteAssets(html) {
-    let links = 0;
-    let images = 0;
-    let output = html.replace(/<link\b[^>]*\brel=["']?preload["']?[^>]*>/gi, () => {
-        links++;
-        return '';
-    });
-    output = output.replace(/(<img\b[^>]*?)\ssrc="https?:\/\/[^"]*"/gi, (_all, head) => {
-        images++;
-        return head + ' src="' + TRANSPARENT_PIXEL + '"';
-    });
-    output = output.replace(/(<img\b[^>]*?)\ssrcset="[^"]*"/gi, '$1');
-    output = output.replace(/url\(\s*(['"]?)https?:\/\/[^)'"]*\1\s*\)/gi, 'none');
-    return { html: output, links, images };
-}
-/** 顶掉远程图片用的 1x1 透明 gif（内联 data: 内核能正常解码） */
-const TRANSPARENT_PIXEL = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
 /** 截图前的统一降级：先剔无效字体，再降级噪点层 */
 function optimizeForScreenshot(html, baseDir) {
     const pruned = pruneMissingFontFaces(html, baseDir);
@@ -515,30 +484,20 @@ function optimizeForScreenshot(html, baseDir) {
 /**
  * 对一个 HTML 文件截图，返回 base64 和实际产出的 mime。
  *
- * 优先用 koishi-plugin-puppeteer 那条浏览器路径；没有浏览器服务时退回 shotkit 内核。
+ * **只用浏览器渲染服务**（koishi-plugin-puppeteer / puppeteer-without-canvas 之类）。
+ * 3.5.0 起不再支持 shotkit 内核：它的预编译内核在 Windows 上加载不了 https 资源
+ * （卡片里的封面、头像全是空白框），换来的那点速度不值得让卡片看起来是坏的。
  *
- * `scale` 会作为 deviceScaleFactor（配置项 `app.renderScale`，100 = 1x，200 = 2x）：
+ * scale 会作为 deviceScaleFactor（配置项 app.renderScale，100 = 1x，200 = 2x）：
  * 不设的话高分辨率卡片会被截成 1x，群里看着又小又糊。
  */
-/** 用了 shotkit 只提示一次（每张卡片都刷一行没意义） */
-let shotkitLogged = false;
-async function screenshot(htmlPath, selector, timeout, scale = 1, format = 'jpeg', htmlSource) {
+async function screenshot(htmlPath, selector, timeout, scale = 1, format = 'jpeg') {
     const koishiCtx = (0, node_karin_1.getKoishiContext)();
     /** 浏览器渲染服务（koishi-plugin-puppeteer / puppeteer-without-canvas 之类） */
     const puppeteer = koishiCtx?.get ? koishiCtx.get('puppeteer') : koishiCtx?.puppeteer;
-    /** kernel 渲染服务（koishi-plugin-shotkit） */
-    const shotkit = typeof koishiCtx?.get === 'function' ? koishiCtx.get('shotkit') : koishiCtx?.shotkit;
-    if (!puppeteer && !shotkit) {
-        throw new Error('未安装 koishi-plugin-puppeteer（或 koishi-plugin-shotkit），无法渲染图片');
+    if (!puppeteer) {
+        throw new Error('没有可用的渲染器：需要安装浏览器渲染服务（koishi-plugin-puppeteer 或同类插件）才能渲染图片');
     }
-    /**
-     * 优先渲染器（面板「通用设置 → 优先渲染器」，配置项 `app.renderer`，默认 shotkit）。
-     *
-     * 谁排前面谁先上，失败或服务没装就自动落到另一个；两个都没有才报错。
-     * 默认 shotkit 是因为它快得多也省内存；要完整还原卡片外观（尤其是 https 远程封面/头像）
-     * 就把这个开关改成 puppeteer。
-     */
-    const preferShotkit = String(Config_1.Config.app?.renderer ?? 'shotkit').toLowerCase() !== 'puppeteer';
     // 卡片是给手机看的：**低于 2x 会明显发虚**，所以下限锁 2（上限 3）。
     // 想更大更清晰就调 `app.renderScale`（100 → 2x，150 → 3x），配 100 时保持 2x 不出错。
     const requested = Number.isFinite(scale) && scale > 0 ? scale * 2 : 2;
@@ -550,59 +509,6 @@ async function screenshot(htmlPath, selector, timeout, scale = 1, format = 'jpeg
             deviceScaleFactor = Math.max(1, deviceScaleFactor - 1);
     }
     catch { /* 忽略 */ }
-    /**
-     * shotkit 内核路径。
-     *
-     * 内核一次调用出一张图、直接按 `selector` 截元素盒子，不需要 evaluate 量尺寸，
-     * 也不执行页面 JS。上面选了 shotkit 就先用它；选了 puppeteer 而没装浏览器时也走这里兜底。
-     *
-     * 注意：实测这个预编译内核在 Windows 上**加载不了 https 资源**（http / data: / file: 正常），
-     * 卡片里的远程封面、头像会缺图 —— 面板上的说明里写了，要完整外观请把优先渲染器改成 puppeteer。
-     *
-     * 格式固定 PNG：内核不支持 JPEG（支持 webp，要压体积可以把 type 改成 'webp'
-     * 并把下面的 mime 一起改掉）。
-     */
-    let shotkitFailure = null;
-    if (shotkit && typeof shotkit.renderFile === 'function' && (preferShotkit || !puppeteer)) {
-        try {
-            const started = Date.now();
-            /**
-             * 交给内核的 HTML 先摘掉它加载不了的远程资源（见 neutralizeRemoteAssets 的说明）。
-             * 走 `screenshot({ html })` 而不是 renderFile：磁盘上那份保持原样，
-             * 万一内核失败要回退到 puppeteer，那边还能正常加载远程图片。
-             */
-            const sanitized = htmlSource ? neutralizeRemoteAssets(htmlSource) : null;
-            if (sanitized && (sanitized.links > 0 || sanitized.images > 0)) {
-                node_karin_1.logger.debug('[Render] 内核用 HTML：摘掉 preload ' + sanitized.links + ' 条、远程图片 ' + sanitized.images + ' 张');
-            }
-            const buffer = sanitized && typeof shotkit.screenshot === 'function'
-                ? ((await shotkit.screenshot({
-                    html: sanitized.html,
-                    selector,
-                    timeout,
-                    deviceScaleFactor,
-                    type: 'png',
-                }))?.image)
-                : await shotkit.renderFile(htmlPath, {
-                    selector,
-                    timeout,
-                    deviceScaleFactor,
-                    type: 'png',
-                });
-            if (buffer && buffer.length) {
-                if (!shotkitLogged) {
-                    shotkitLogged = true;
-                    node_karin_1.logger.info('[Render] 使用 shotkit 内核渲染卡片（静态内核，不执行页面 JS）');
-                }
-                node_karin_1.logger.debug('[Render] shotkit 渲染 ' + htmlPath.split(/[\\/]/).pop() + ' 用时 ' + (Date.now() - started) + 'ms');
-                return { base64: Buffer.from(buffer).toString('base64'), mime: 'image/png', dsf: deviceScaleFactor };
-            }
-        }
-        catch (error) {
-            shotkitFailure = error;
-            node_karin_1.logger.warn('[Render] shotkit 渲染失败，回退到 koishi-plugin-puppeteer：' + String(error?.message ?? error));
-        }
-    }
     /**
      * 视口用卡片的**设计宽度**（模板都按 1440 排版），高度按内容量一次。
      *
@@ -711,12 +617,6 @@ async function screenshot(htmlPath, selector, timeout, scale = 1, format = 'jpeg
             catch { /* 页面可能已被插件关掉，忽略 */ }
         }
     }
-    if (!puppeteer) {
-        // 走到这里说明：优先的那条路失败了，而且另一条也没得用
-        const reason = String(shotkitFailure?.message ?? shotkitFailure ?? '');
-        throw new Error('没有可用的渲染器：未安装 koishi-plugin-puppeteer（或它的 start 失败）'
-            + (reason ? '；shotkit 内核渲染失败：' + reason : ''));
-    }
     node_karin_1.logger.debug('[Render] 插件未暴露 page/browser，退回 puppeteer.render()');
     return await puppeteer.render('', async (page) => capture(page));
 }
@@ -864,9 +764,9 @@ const Render = async (_event, route, data) => {
         // 二维码：必须像素级清晰（JPEG 压缩会影响扫码），继续用 PNG；其它卡片用 JPEG 压体积
         const isQrCode = /qrcode/i.test(route);
         const format = isQrCode ? 'png' : 'jpeg';
-        // mime 由 screenshot 返回实际产出的格式：shotkit 走 PNG，其余路径仍是传入的 format
+        // mime 由 screenshot 返回实际产出的格式（就是上面选的那个 format）
         const htmlBuiltAt = Date.now();
-        const { base64, mime, dsf } = await screenshot(htmlPath, '#container', Number(Config_1.Config.app?.RenderWaitTime ?? 10) * 1000, scale, format, html);
+        const { base64, mime, dsf } = await screenshot(htmlPath, '#container', Number(Config_1.Config.app?.RenderWaitTime ?? 10) * 1000, scale, format);
         const shotAt = Date.now();
         const buffer = Buffer.from(base64, 'base64');
         const meta = (0, exports.getImageMetadata)(buffer);

package/lib/karin/module/utils/build-metadata.js

@@ -10,41 +10,86 @@ const node_karin_1 = require("../../../compat/node-karin.js");
 const root_1 = require("../../root");
 let cachedMetadata = null;
 /**
- * 获取构建元数据
- * @returns 构建元数据对象，如果读取失败则返回 null
+ * 构建元数据的候选位置。
+ *
+ * 正常情况是 scripts/build.mjs 生成的 lib/build-metadata.json（随 lib 一起部署、也打进 npm 包）；
+ * 早期版本把文件放在插件根目录，所以两个位置都看一眼。
  */
-const getBuildMetadata = () => {
-    if (cachedMetadata) {
-        return cachedMetadata;
-    }
-    try {
-        // 使用插件路径 + lib/build-metadata.json
-        // Root.pluginPath 指向插件根目录，构建后的元数据在 lib 目录下
-        const metadataPath = (0, node_path_1.resolve)(root_1.Root.pluginPath, 'lib/build-metadata.json');
-        if (node_fs_1.default.existsSync(metadataPath)) {
-            const content = node_fs_1.default.readFileSync(metadataPath, 'utf-8');
-            cachedMetadata = JSON.parse(content);
-            return cachedMetadata;
+const candidatePaths = () => [
+    (0, node_path_1.resolve)(root_1.Root.pluginPath, 'lib/build-metadata.json'),
+    (0, node_path_1.resolve)(root_1.Root.pluginPath, 'build-metadata.json')
+];
+/** 读磁盘上的构建元数据；文件不存在返回 null，文件坏了只记一条日志 */
+const readFromDisk = () => {
+    for (const file of candidatePaths()) {
+        try {
+            if (!node_fs_1.default.existsSync(file))
+                continue;
+            const parsed = JSON.parse(node_fs_1.default.readFileSync(file, 'utf-8'));
+            if (!parsed || typeof parsed !== 'object')
+                continue;
+            return {
+                version: String(parsed.version ?? ''),
+                buildTime: String(parsed.buildTime ?? ''),
+                buildTimestamp: Number(parsed.buildTimestamp ?? 0) || 0,
+                name: String(parsed.name ?? ''),
+                description: String(parsed.description ?? ''),
+                homepage: String(parsed.homepage ?? ''),
+                commitHash: String(parsed.commitHash ?? ''),
+                shortCommitHash: String(parsed.shortCommitHash ?? '')
+            };
+        }
+        catch (error) {
+            node_karin_1.logger.error('构建元数据解析失败（' + file + '）:', error);
         }
-    }
-    catch (error) {
-        node_karin_1.logger.error('无法读取构建元数据:', error);
     }
     return null;
 };
+/**
+ * 兜底元数据：老安装包里没有 build-metadata.json，就用 package.json 拼一份。
+ *
+ * 版本号一定是准的，构建时间和 commit 留空 —— 卡片上显示「未知」也比整块信息消失要好，
+ * 而且旧版本提示里的版本比较还需要 version 字段。
+ */
+const fromPackage = () => {
+    const pkg = root_1.Root.pkg ?? {};
+    return {
+        version: String(root_1.Root.pluginVersion ?? pkg.version ?? ''),
+        buildTime: '',
+        buildTimestamp: 0,
+        name: String(root_1.Root.pluginName ?? pkg.name ?? ''),
+        description: String(pkg.description ?? ''),
+        homepage: String(pkg.homepage ?? ''),
+        commitHash: '',
+        shortCommitHash: ''
+    };
+};
+/**
+ * 获取构建元数据。
+ *
+ * 一定返回对象（读不到构建产物时退回 package.json），调用方不需要再判空。
+ */
+const getBuildMetadata = () => {
+    if (cachedMetadata)
+        return cachedMetadata;
+    cachedMetadata = readFromDisk() ?? fromPackage();
+    return cachedMetadata;
+};
 exports.getBuildMetadata = getBuildMetadata;
 /**
  * 格式化构建时间为可读格式
  * @param isoString ISO 格式的时间字符串
- * @returns 格式化后的时间字符串，格式：2025年11月02日 17:30
+ * @returns 格式化后的时间字符串，格式：2025年11月02日 17:30；无法解析时返回空串
  */
 const formatBuildTime = (isoString) => {
     const date = new Date(isoString);
+    if (!isoString || Number.isNaN(date.getTime()))
+        return '';
     const year = date.getFullYear();
     const month = String(date.getMonth() + 1).padStart(2, '0');
     const day = String(date.getDate()).padStart(2, '0');
     const hour = String(date.getHours()).padStart(2, '0');
     const minute = String(date.getMinutes()).padStart(2, '0');
-    return `${year}年${month}月${day}日 ${hour}:${minute}`;
+    return year + '年' + month + '月' + day + '日 ' + hour + ':' + minute;
 };
 exports.formatBuildTime = formatBuildTime;