koishi-plugin-kkk 3.7.0 → 3.7.2

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # 更新日志
 
+## 3.7.2
+
+> 群里发的图片**统一改走 markdown** 了 —— 普通图片消息会被 QQ 压得发糊，markdown 图片不会；
+> 顺手把互动视频那张**剧情图的字放大**了。
+
+### 图片不再被压糊
+
+- 卡片、评论图、图集、推送里的图……以前都是当「普通图片」发出去的，QQ 会二次压缩，
+  卡片上的小字糊成一团。现在**图片一律按 markdown 图片发**：先传到机器人自己的图床，
+  再用带尺寸的图片写法发出去，字是清楚的。
+- markdown 图片**必须写死尺寸**（`![#宽px #高px](地址)`）—— 不写尺寸的话手机端根本不显示这张图，
+  所以每一张都会先把真实的宽高读出来（JPEG / PNG / GIF / WebP 都认）。
+- **平台不一样，处理不一样**（客户端能力决定的，不是选择）：
+  - QQ 官方机器人：走 markdown 图片；
+  - OneBot 系（NapCat、Lagrange、go-cqhttp、Chronocat 等）：客户端不认 markdown，
+    收到只会显示成一串网址、图片全丢，所以这条链路**照旧发普通图片**；
+  - QQ 频道（qqguild）同理，也不改写。
+- 一条消息里**同时有视频 / 语音 / 文件**时不改写：那种消息会按媒体发出去，markdown 内容会被丢掉。
+- 转发里的图、合并转发收集中的图也不改写，保持原样。
+- 传图床失败（或者宿主没装 assets 服务）时**照旧发普通图片**，不会因为改写不了就把图弄丢。
+- 同一张图反复发（推送封面、面板卡片）不会再反复上传。
+
+### 互动视频：剧情图的字大了
+
+- 剧情图里每个选项 / 结局的**字号调大**了（大约 1/3），手机上看得清多了。
+- 长文字不再按「14 个字」硬切，改成**按这一列还能放多少像素**来截断，
+  字大了也不会压到下一列的圆圈上；最后一列右边本来空着，会多显示几个字。
+- 「已选」「图例」「提示」这些说明文字也跟着放大了一点。
+
+## 3.7.1
+
+> 修一个 3.7.0 改过头的地方：**视频直接发到群里的那种互动视频，照旧要在群里发带按钮的选择面板**；
+> 而且点完选项之后，**上一段视频会撤回**，群里只留当前这一段。
+
+### 互动视频：两种玩法各归各位
+
+- **选了在线播放**（或者视频太大、自动转成在线播放）：选项在网页播放器里贴出来，群里不再问一遍。
+- **视频直接发到群里**（没有播放页）：照旧在群里发**带按钮的选择面板** ——
+  QQ 官方机器人是按钮，其它平台是一行一个选项的文字，点一下接着播下一段。
+- **点完选项会撤回上一段视频**：不然玩几段之后，群里会躺着一串视频。
+  顺序是先发新的、再撤旧的，中间不会出现「一段视频都没有」的空档；
+  选择面板照旧是发新的时候撤掉旧的。
+- 剧情图（勾了「流程图」时）照常：第一段出一张，走到结局再出一张。
+
 ## 3.7.0
 
 > 互动视频这一版基本重做了：**选剧情搬到了网页播放器里**（选项就贴在画面上、点完能看到下载进度），

package/lib/build-metadata.json

@@ -1,10 +1,10 @@
 {
-  "version": "3.7.0",
-  "buildTime": "2026-09-25T18:12:21.026Z",
-  "buildTimestamp": 1790359941027,
+  "version": "3.7.2",
+  "buildTime": "2026-09-26T02:01:03.950Z",
+  "buildTimestamp": 1790388063951,
   "name": "koishi-plugin-kkk",
   "description": "抖音 / B站 / 快手 / 小红书 视频解析与动态推送，带 QQ 交互面板与弹幕烧录（karin-plugin-kkk 的 Koishi 移植版）",
   "homepage": "https://github.com/maimai993/koishi-plugin-kkk#readme",
-  "commitHash": "80c363bd36af99ed42afc894ead313a883b8b44a",
-  "shortCommitHash": "80c363b"
+  "commitHash": "41e817b5ec90f1b56475866f553b33c15a0b4e94",
+  "shortCommitHash": "41e817b"
 }

package/lib/compat/imageMarkdown.js

@@ -0,0 +1,280 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imagesToMarkdown = exports.clearMarkdownImageCache = exports.markdownImageOf = void 0;
+/**
+ * 图片段 → markdown 图片（`![#宽px #高px](url)`）。
+ *
+ * 用户反馈两条，这里一起解决：
+ *   1. **「所有的图片发送都要走 md，不然太模糊了」** —— QQ 的普通图片消息（image 段 → 适配器按
+ *      MEDIA 上传）会被客户端二次压缩，卡片上的小字糊成一团；markdown 里的图片不会被压，字是清楚的。
+ *   2. **「![#px大小#px大小]() 必须要 #px，不然手机不会显示」** —— md 图片必须写死尺寸，
+ *      不写尺寸手机端干脆不显示这张图。
+ *
+ * 所以这里在**发送出口**统一改写：compat/node-karin 的 reply / sendMsg / sendMaster 四条路径都过一遍，
+ * 业务代码照旧 e.reply(segment.image(...))，不用一处处改。
+ *
+ * 只在「认 markdown 的平台」上生效（官方 QQ：`qq`）：
+ *   - OneBot 系（NapCat / Lagrange / go-cqhttp / Chronocat…）收到 markdown 只显示成一串文字、
+ *     图片全丢（用户实测），所以那条链路继续发图片段；
+ *   - QQ 频道（`qqguild`）的适配器没有 markdown 分支，md 元素会被当纯文本渲染 → 也排除。
+ *
+ * 另外三种情况**不动**（动了只会更糟）：
+ *   - 消息里还有视频 / 语音 / 文件：适配器遇到附件会把整条消息转成 MEDIA，markdown 内容会被丢掉；
+ *   - 合并转发收集中的消息：转发节点里塞 markdown 客户端不认；
+ *   - 上传拿不到公网地址（没装 assets 服务等）、或者**读不出图片尺寸**：保持原来的图片段。
+ *     读不出尺寸是可以退回普通图片的，但**绝不能发一张不带尺寸的 markdown 图片** ——
+ *     用户实测「必须要 #px，不然手机不会显示」，那种图上手机就是一片空白。
+ */
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_url_1 = require("node:url");
+const logger_1 = require("./logger");
+const runtime_1 = require("./runtime");
+const segment_1 = require("./segment");
+/** OneBot 系：不渲染 markdown（见文件头） */
+const ONEBOT_LIKE = /onebot|napcat|lagrange|go-?cqhttp|chronocat|mirai/i;
+/**
+ * 会渲染 markdown 图片的平台。
+ *
+ * 只认 `qq` 这一个平台名 —— QQ 的 markdown 是**官方机器人**能力，
+ * `qqguild`（频道）走的是另一套编码器，md 元素在那里会被当成纯文本原样发出去。
+ */
+const canUseMarkdownImage = (platform) => {
+    const name = String(platform || '').toLowerCase();
+    if (!name)
+        return false;
+    if (ONEBOT_LIKE.test(name))
+        return false;
+    if (name.startsWith('qqguild'))
+        return false;
+    return name === 'qq' || name.startsWith('qq-') || name.startsWith('qqbot');
+};
+/** 媒体段：md 和附件不能塞进同一条消息（会被适配器吃掉），所以要跳过整条改写 */
+const ATTACHMENT_TYPES = new Set(['video', 'audio', 'record', 'file']);
+const isImageElement = (element) => !!element && typeof element === 'object' && (element.type === 'img' || element.type === 'image');
+const srcOf = (element) => {
+    const attrs = element?.attrs ?? {};
+    const src = attrs.src ?? attrs.url ?? element?.data?.file ?? element?.data?.url;
+    return typeof src === 'string' ? src : '';
+};
+/** 按二进制头认 mime（发给 assets 用；标错会让适配器按错格式处理） */
+const mimeOfBuffer = (buffer) => {
+    if (buffer.length >= 8 && buffer[0] === 0x89 && buffer.toString('latin1', 1, 4) === 'PNG')
+        return 'image/png';
+    if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8)
+        return 'image/jpeg';
+    if (buffer.length >= 6 && buffer.toString('latin1', 0, 3) === 'GIF')
+        return 'image/gif';
+    if (buffer.length >= 12 && buffer.toString('latin1', 0, 4) === 'RIFF' && buffer.toString('latin1', 8, 12) === 'WEBP')
+        return 'image/webp';
+    return 'image/jpeg';
+};
+/**
+ * 读出图片的**真实像素尺寸** —— md 里的 `#宽px #高px` 就靠它。
+ *
+ * 不引第三方库：卡片是 JPEG、图集是 JPEG、二维码是 PNG、实况图封面是 WebP，四种头都自己认，
+ * 免得又出现「取不到尺寸 → 正方形拉伸」或「没写尺寸 → 手机不显示」。
+ */
+const readImageSize = (buffer) => {
+    // PNG：IHDR 就在固定偏移
+    if (buffer.length >= 24 && buffer[0] === 0x89 && buffer.toString('latin1', 1, 4) === 'PNG') {
+        return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
+    }
+    // GIF：逻辑屏幕描述符，小端
+    if (buffer.length >= 10 && buffer.toString('latin1', 0, 3) === 'GIF') {
+        return { width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8) };
+    }
+    // JPEG：扫到 SOF 段（SOF0..SOF15，跳过 DHT/DAC 这些非 SOF 标记）
+    if (buffer.length > 4 && buffer[0] === 0xff && buffer[1] === 0xd8) {
+        let offset = 2;
+        while (offset + 9 < buffer.length) {
+            if (buffer[offset] !== 0xff) {
+                offset++;
+                continue;
+            }
+            const marker = buffer[offset + 1];
+            if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+                return { height: buffer.readUInt16BE(offset + 5), width: buffer.readUInt16BE(offset + 7) };
+            }
+            const length = buffer.readUInt16BE(offset + 2);
+            if (length <= 0)
+                break;
+            offset += 2 + length;
+        }
+    }
+    // WebP：VP8X（扩展）/ VP8L（无损）/ VP8（有损）三种头的写法都不一样
+    if (buffer.length >= 30 && buffer.toString('latin1', 0, 4) === 'RIFF' && buffer.toString('latin1', 8, 12) === 'WEBP') {
+        const format = buffer.toString('latin1', 12, 16);
+        if (format === 'VP8X') {
+            return { width: 1 + buffer.readUIntLE(24, 3), height: 1 + buffer.readUIntLE(27, 3) };
+        }
+        if (format === 'VP8L') {
+            const bits = buffer.readUInt32LE(21);
+            return { width: 1 + (bits & 0x3fff), height: 1 + ((bits >> 14) & 0x3fff) };
+        }
+        if (format === 'VP8 ') {
+            return { width: buffer.readUInt16LE(26) & 0x3fff, height: buffer.readUInt16LE(28) & 0x3fff };
+        }
+    }
+    return { width: 0, height: 0 };
+};
+/** 把各种写法读成 Buffer：data URI / base64:// / file:// / 本地路径 / http(s) */
+const loadImageBuffer = async (src) => {
+    try {
+        if (src.startsWith('base64://'))
+            return Buffer.from(src.slice('base64://'.length), 'base64');
+        if (src.startsWith('data:')) {
+            const comma = src.indexOf(',');
+            if (comma < 0)
+                return null;
+            return Buffer.from(src.slice(comma + 1), 'base64');
+        }
+        const localPath = src.startsWith('file://') ? (0, node_url_1.fileURLToPath)(src) : src;
+        if (!/^https?:\/\//i.test(src)) {
+            if (node_fs_1.default.existsSync(localPath))
+                return node_fs_1.default.readFileSync(localPath);
+            return null;
+        }
+        const response = await fetch(src);
+        if (!response.ok) {
+            logger_1.logger.mark('[图片md] 下载失败 HTTP ' + response.status + ': ' + src.slice(0, 80));
+            return null;
+        }
+        return Buffer.from(await response.arrayBuffer());
+    }
+    catch (error) {
+        logger_1.logger.mark('[图片md] 读取图片失败: ' + String(error?.message ?? error).slice(0, 120));
+        return null;
+    }
+};
+/**
+ * 上传到宿主的 assets，拿到 QQ 能直接取的 https 地址。
+ *
+ * md 里的图片地址**必须是公网 http(s)**：适配器只对 data: 图片做特殊处理
+ * （见 qq-crack 的 renderMarkdownDataImages —— data 图片会被它转回 MEDIA 上传，等于白改），
+ * 相对路径/本地路径手机端也取不到。
+ */
+let warnedNoAssets = false;
+const uploadImage = async (buffer) => {
+    const assets = (0, runtime_1.tryGetRuntime)()?.ctx?.assets;
+    if (!assets?.upload) {
+        /** 没装 assets 服务就整条链路都用不了，提示一次就够，别每张图刷一遍日志 */
+        if (!warnedNoAssets) {
+            warnedNoAssets = true;
+            logger_1.logger.mark('[图片md] 宿主没有 assets 服务（拿不到公网图片地址），图片继续按普通图片段发送');
+        }
+        return null;
+    }
+    const mime = mimeOfBuffer(buffer);
+    const ext = mime === 'image/png' ? '.png' : mime === 'image/gif' ? '.gif' : mime === 'image/webp' ? '.webp' : '.jpg';
+    try {
+        const uploaded = await assets.upload('data:' + mime + ';base64,' + buffer.toString('base64'), 'kkk-md' + ext);
+        const url = typeof uploaded === 'string' ? uploaded : uploaded?.url;
+        return url && /^https?:\/\//i.test(String(url)) ? String(url) : null;
+    }
+    catch (error) {
+        logger_1.logger.mark('[图片md] 上传失败: ' + String(error?.message ?? error).slice(0, 120));
+        return null;
+    }
+};
+/**
+ * 同一张图反复发（推送里的封面、面板卡片…）不用反复上传：
+ * 按图片内容摘要缓存结果，顺带省掉重复的下载与解码。
+ */
+const imageCache = new Map();
+const IMAGE_CACHE_MAX = 200;
+/** 图片段 → md 图片字符串；拿不到尺寸/地址就返回 null（调用方保持原样，别把图弄丢） */
+const markdownImageOf = async (src) => {
+    if (!src)
+        return null;
+    const key = node_crypto_1.default.createHash('md5').update(src).digest('hex');
+    const cached = imageCache.get(key);
+    if (cached)
+        return cached;
+    const buffer = await loadImageBuffer(src);
+    let result = null;
+    if (buffer && buffer.length) {
+        const { width, height } = readImageSize(buffer);
+        /**
+         * **读不出尺寸就不换成 markdown**（退回普通图片段）。
+         *
+         * 用户实测：「必须要 #px，不然手机不会显示」—— 不带尺寸的 md 图片在手机端干脆是空白，
+         * 比糊更糟。所以这里宁可发一张（会被压糊但看得见的）普通图片，
+         * 也不发一张手机上什么都不显示的 markdown 图片。
+         */
+        if (width > 0 && height > 0) {
+            const url = await uploadImage(buffer);
+            if (url)
+                result = '![#' + width + 'px #' + height + 'px](' + url + ')';
+        }
+    }
+    /**
+     * **只缓存成功的结果**：网络 / 图床抖动导致的失败要是也缓存下来，
+     * 这张图之后就一直按普通图片发（糊），得等重启才能恢复。
+     */
+    if (result) {
+        if (imageCache.size >= IMAGE_CACHE_MAX)
+            imageCache.delete(imageCache.keys().next().value);
+        imageCache.set(key, result);
+    }
+    else {
+        logger_1.logger.debug('[图片md] 这张图这次没转成 markdown，按普通图片发送: ' + src.slice(0, 60));
+    }
+    return result;
+};
+exports.markdownImageOf = markdownImageOf;
+/** 清空缓存（测试用） */
+const clearMarkdownImageCache = () => { imageCache.clear(); };
+exports.clearMarkdownImageCache = clearMarkdownImageCache;
+/**
+ * 把一条消息里的图片段改写成 markdown 图片（其它段原样保留、顺序不变）。
+ *
+ * 连续的图片合成**一个** markdown 元素（换行分隔）—— 和官方 QQ 的渲染习惯一致：
+ * 连续图片紧贴显示，视觉上仍是一整张卡片，而不是一张一张孤立的图。
+ *
+ * @param elements 已归一化的消息元素数组
+ * @param platform 适配器平台名（kompat 层从 bot.platform / session.platform 取）
+ * @returns 改写后的数组；不该改或改不动时**原样返回**，绝不让消息发不出去
+ */
+const imagesToMarkdown = async (elements, platform) => {
+    const list = Array.isArray(elements) ? elements : [];
+    if (!list.length)
+        return list;
+    if (!canUseMarkdownImage(platform))
+        return list;
+    if (!list.some(isImageElement))
+        return list;
+    if (list.some((element) => ATTACHMENT_TYPES.has(String(element?.type ?? ''))))
+        return list;
+    const out = [];
+    /** 攒着的连续图片（遇到非图片段就冲出去） */
+    let run = [];
+    const flushRun = () => {
+        // 有图转不动（上传失败等）时 run 里会是空串占位，这里只冲有内容的
+        if (run.length)
+            out.push(segment_1.segment.markdown(run.join(String.fromCharCode(10))));
+        run = [];
+    };
+    for (const element of list) {
+        if (!isImageElement(element)) {
+            flushRun();
+            out.push(element);
+            continue;
+        }
+        const markdown = await (0, exports.markdownImageOf)(srcOf(element));
+        if (markdown) {
+            run.push(markdown);
+        }
+        else {
+            // 转不了就把它自己按图片段发出去，别丢
+            flushRun();
+            out.push(element);
+        }
+    }
+    flushRun();
+    return out;
+};
+exports.imagesToMarkdown = imagesToMarkdown;

package/lib/compat/node-karin.js

@@ -34,6 +34,7 @@ const adapter_info_1 = require("./adapter-info");
 const logger_1 = require("./logger");
 Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
 const forward_collect_1 = require("./forward-collect");
+const imageMarkdown_1 = require("./imageMarkdown");
 const sendError_1 = require("./sendError");
 const runtime_1 = require("./runtime");
 const segment_1 = require("./segment");
@@ -240,14 +241,16 @@ class KkkBot {
             logger_1.logger.debug('当前适配器（' + this.bot.platform + '）不支持合并转发，改为直接发送内容');
         }
         // 退化路径：整条发一次；失败再逐个元素发，尽量把内容送出去
+        /** 退化发送 = 直接发消息，所以图片同样要改走 markdown（见 compat/imageMarkdown） */
+        const fallback = await (0, imageMarkdown_1.imagesToMarkdown)(payload.elements, platformOfBot(this.bot));
         try {
-            const ids = await this.bot.sendMessage(channelId, payload.elements);
+            const ids = await this.bot.sendMessage(channelId, fallback);
             return { messageId: ids[ids.length - 1] ?? '' };
         }
         catch (error) {
             logger_1.logger.warn('整条发送失败，改为逐个元素发送: ' + String(error?.message ?? error));
             let lastId = '';
-            for (const item of payload.elements) {
+            for (const item of fallback) {
                 const ids = await this.bot.sendMessage(channelId, [item]);
                 lastId = ids[ids.length - 1] ?? lastId;
             }
@@ -346,11 +349,14 @@ class KkkBot {
     }
     /** 发送消息（karin 的 bot.sendMsg） */
     async sendMsg(contact, content, _options) {
+        const elements = normalizeContent(content);
         /** 解析结果合并转发：正在收集就攒起来（见 compat/forward-collect） */
-        if ((0, forward_collect_1.collectForward)(peerOf(contact), content))
+        if ((0, forward_collect_1.collectForward)(peerOf(contact), elements))
             return { messageId: forward_collect_1.COLLECTED_MESSAGE_ID };
         const channelId = typeof contact === 'string' ? contact : contact.peer;
-        const ids = await this.bot.sendMessage(channelId, normalizeContent(content));
+        /** 图片统一改走 markdown（见 compat/imageMarkdown） */
+        const outgoing = await (0, imageMarkdown_1.imagesToMarkdown)(elements, platformOfBot(this.bot));
+        const ids = await this.bot.sendMessage(channelId, outgoing);
         // 同 reply/uploadFile：**没拿到消息 ID 就是没发出去**，别当成功返回
         const id = ids?.[ids.length - 1] ?? '';
         if (!id) {
@@ -471,13 +477,21 @@ class Message {
      * 这时自动改用**主动消息**（不带引用，直接往频道里发），失败才把原错误抛出去。
      */
     async reply(content, _options) {
-        const elements = normalizeContent(content);
+        const raw = normalizeContent(content);
         /**
          * 解析结果合并转发：正在收集就攒起来，等解析结束发一条转发（见 compat/forward-collect）。
          * 回一个假的消息 ID：调用方普遍只看「有没有拿到 ID」（例如 uploadFile 判断发送成没成功）。
          */
-        if ((0, forward_collect_1.collectForward)(this.contact?.peer ?? '', elements))
+        if ((0, forward_collect_1.collectForward)(this.contact?.peer ?? '', raw))
             return { messageId: forward_collect_1.COLLECTED_MESSAGE_ID };
+        /**
+         * **图片统一改走 markdown**（上传拿公网地址 + 写死 `#宽px #高px`），见 compat/imageMarkdown。
+         *
+         * 放在这里是因为它是**所有回复的唯一出口** —— 业务代码一律 `e.reply(...)`，
+         * 不用一处处改业务代码。转换不成功会退回原来的图片段（绝不把图弄丢）。
+         * 上面的合并转发分支已经返回了，所以转发节点里仍然是普通图片段。
+         */
+        const elements = await (0, imageMarkdown_1.imagesToMarkdown)(raw, platformOfMessage(this));
         /**
          * 没拿到消息 ID 就是**没发出去**（对齐 qq-chat 的判法）。
          *
@@ -570,6 +584,19 @@ function normalizeContent(content) {
 function peerOf(contact) {
     return typeof contact === 'string' ? contact : String(contact?.peer ?? '');
 }
+/**
+ * 适配器平台名。
+ *
+ * 发送出口要用它判断「这个平台认不认 markdown 图片」（见 compat/imageMarkdown）：
+ * KkkBot 包装上直接转发真实 Bot 的 platform，传 KkkBot 或裸 Bot 都能取到。
+ */
+function platformOfBot(bot) {
+    return String(bot?.platform ?? bot?.bot?.platform ?? '');
+}
+/** 同上，从消息事件取（会话上就带 platform，拿不到再问 bot） */
+function platformOfMessage(message) {
+    return String(message.session?.platform ?? platformOfBot(message.bot));
+}
 /**
  * 合并转发的载荷。
  *
@@ -707,18 +734,22 @@ async function sendMsg(selfId, contact, content, _options) {
             + '），这条消息发不出去。等它重新上线后下次推送会正常发出；如果是长期不在线，检查一下适配器连接');
     }
     const channelId = peerOf(contact);
+    const elements = normalizeContent(content);
     /** 解析结果合并转发：这条也走漏斗（karin.sendMsg 是业务代码另一条常用出口） */
-    if ((0, forward_collect_1.collectForward)(channelId, normalizeContent(content))) {
+    if ((0, forward_collect_1.collectForward)(channelId, elements)) {
         return { messageId: forward_collect_1.COLLECTED_MESSAGE_ID, rawData: [] };
     }
-    const ids = await bot.bot.sendMessage(channelId, normalizeContent(content));
+    /** 图片统一改走 markdown（见 compat/imageMarkdown） */
+    const outgoing = await (0, imageMarkdown_1.imagesToMarkdown)(elements, platformOfBot(bot.bot));
+    const ids = await bot.bot.sendMessage(channelId, outgoing);
     return { messageId: ids[ids.length - 1] ?? '', rawData: ids };
 }
 async function sendMaster(botId, master, content, _options) {
     const bot = resolveBot(botId);
     if (!bot)
         throw new Error('[kkk] 没有可用的机器人实例，无法发送消息');
-    const elements = normalizeContent(content);
+    // 图片统一改走 markdown（见 compat/imageMarkdown）：私聊和群里一样，md 图片才不会被压糊
+    const elements = await (0, imageMarkdown_1.imagesToMarkdown)(normalizeContent(content), platformOfBot(bot.bot));
     const target = bot.bot;
     // Satori 的 Bot 有 sendPrivateMessage；个别适配器没有，退化成私聊频道 id
     const ids = typeof target.sendPrivateMessage === 'function'

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

@@ -51,6 +51,19 @@ const runtime_1 = require("../../../compat/runtime");
 const player_1 = require("../../../player");
 // 解析阶段（「下载进度」指令读的就是这里登记的状态）
 const Downloader_1 = require("./Network/Downloader");
+/** 发送结果里把消息 ID 抠出来（不同适配器返回的形状不一样：对象带 messageId、或者就是字符串数组） */
+const reportSent = (options, sent) => {
+    if (!options?.onSent)
+        return;
+    try {
+        const id = typeof sent === 'string'
+            ? sent
+            : (sent?.messageId ?? (Array.isArray(sent) ? sent[0] : ''));
+        if (id)
+            options.onSent(String(id));
+    }
+    catch { /* 拿不到 ID 不影响发送本身 */ }
+};
 /**
  * 基础基类
  * @remarks 提供事件上下文与通用请求头，继承自 `AmagiBase` 以复用 Amagi 客户端。
@@ -259,13 +272,15 @@ const uploadFile = async (event, file, videoUrl, options) => {
                 // 是群文件
                 const bot = node_karin_1.default.getBot(String(options.activeOption?.uin));
                 node_karin_1.logger.mark(`${node_karin_1.logger.blue('主动消息:')} 视频大小: ${newFileSize.toFixed(1)}MB 正在通过${node_karin_1.logger.yellow('bot.uploadFile')}回复...`);
-                await bot.uploadFile(contact, File, file.originTitle ? `${file.originTitle}.mp4` : `${File.split('/').pop()}`);
+                const sent = await bot.uploadFile(contact, File, file.originTitle ? `${file.originTitle}.mp4` : `${File.split('/').pop()}`);
+                reportSent(options, sent);
             }
             else {
                 // 不是群文件
                 node_karin_1.logger.mark(`${node_karin_1.logger.blue('主动消息:')} 视频大小: ${newFileSize.toFixed(1)}MB 正在通过${node_karin_1.logger.yellow('karin.sendMsg')}回复...`);
                 // 兼容层已经把「没拿到消息 ID」当成失败抛出（见 compat/sendError），所以这里没有异常就是发出去了
-                await node_karin_1.default.sendMsg(selfId, contact, [node_karin_1.segment.video(File)], { retryCount: 0 });
+                const sent = await node_karin_1.default.sendMsg(selfId, contact, [node_karin_1.segment.video(File)], { retryCount: 0 });
+                reportSent(options, sent);
                 sendStatus = true;
             }
         }
@@ -274,13 +289,15 @@ const uploadFile = async (event, file, videoUrl, options) => {
             if (useGroupFile) {
                 // 是文件
                 node_karin_1.logger.mark(`${node_karin_1.logger.blue('被动消息:')} 视频大小: ${newFileSize.toFixed(1)}MB 正在通过${node_karin_1.logger.yellow('e.bot.uploadFile')}回复...`);
-                await event.bot.uploadFile(event.contact, File, file.originTitle ? `${file.originTitle}.mp4` : `${File.split('/').pop()}`);
+                const sent = await event.bot.uploadFile(event.contact, File, file.originTitle ? `${file.originTitle}.mp4` : `${File.split('/').pop()}`);
+                reportSent(options, sent);
             }
             else {
                 // 不是文件
                 node_karin_1.logger.mark(`${node_karin_1.logger.blue('被动消息:')} 视频大小: ${newFileSize.toFixed(1)}MB 正在通过${node_karin_1.logger.yellow('e.reply')}回复...`);
                 // 同上：异常才是失败（没拿到消息 ID 已经由兼容层抛出来了）
-                await event.reply(node_karin_1.segment.video(File) || videoUrl);
+                const sent = await event.reply(node_karin_1.segment.video(File) || videoUrl);
+                reportSent(options, sent);
                 sendStatus = true;
             }
         }

package/lib/karin/platform/bilibili/bilibili.js

@@ -588,15 +588,14 @@ class Bilibili extends utils_1.Base {
                             await downloadTask;
                             await this.sendPreparedVideo();
                             /**
-                             * 互动视频：**群里不再发「选择按钮」了**（用户要求）。
-                             *
-                             * 剧情选择整个搬到播放页上（选项贴在视频上、点完显示加载进度）；
-                             * 群里如果还同步问一遍，用户会被两处剧情各问一次。
-                             * 只有「视频直接发到群里、没走播放页」时，顺手补一张**剧情图**（图片，不是按钮）——
-                             * 用户至少能看到这张图里有几条分支。
+                             * 互动视频的剧情怎么走，看这次的视频发到哪儿：
+                             *   · **走在线播放**（视频没发进群里，用户在看播放页）→ 选项在播放页上贴出来，
+                             *     群里不再问一遍，免得两处各问一次（见 sendPreparedVideo 里的 story）；
+                             *   · **直接发到群里**（没有播放页）→ 照旧在群里发**带按钮的选择面板**，
+                             *     用户点一下播下一段，并撤回上一段视频（用户要求）。
                              */
                             if (this.interactive && !this.publishedStory)
-                                void this.sendInteractiveChartOnly();
+                                void this.startInteractiveStory();
                         });
                     }
                 }
@@ -1720,38 +1719,6 @@ class Bilibili extends utils_1.Base {
         }
         return this.preparedVideo !== null;
     }
-    /**
-     * 互动视频发到群里时：只补一张**剧情图**，不问选项（用户要求：群里不要选择按钮）。
-     *
-     * 选项流程在播放页里（见 sendPreparedVideo 的 story）；这里只把「有几条分支」画出来。
-     * 失败只记日志 —— 出不了图不影响视频已经发出去这件事。
-     */
-    async sendInteractiveChartOnly() {
-        const interactive = this.interactive;
-        if (!interactive)
-            return;
-        /** 没勾「流程图」就什么都不做（配置说了算） */
-        if (!Config_1.Config.bilibili.sendContent.some((item) => item === 'chart'))
-            return;
-        try {
-            const info = await (0, InteractiveVideo_1.fetchInteractiveInfo)({ bvid: interactive.bvid, cid: interactive.cid, headers: this.headers });
-            if (!info)
-                return;
-            await (0, interactive_story_1.renderInteractiveChart)({
-                e: this.e,
-                bvid: interactive.bvid,
-                graphVersion: info.graphVersion,
-                cid: interactive.cid,
-                title: this.workInfo?.title ?? '互动视频',
-                notice: info.notice,
-                headers: this.headers,
-                full: true
-            });
-        }
-        catch (error) {
-            node_karin_1.logger.debug('[互动视频] 群里补剧情图失败（不影响视频）: ' + String(error?.message ?? error));
-        }
-    }
     /**
      * 起一次互动剧情（后台长跑，不阻塞解析主流程）。
      *
@@ -1923,11 +1890,18 @@ class Bilibili extends utils_1.Base {
             }
             node_karin_1.logger.warn('[在线播放] 播放会话登记失败，退回直接发送视频文件');
         }
+        /**
+         * 互动视频（发到群里的那种）：把这条视频的消息 ID 记下来 ——
+         * 用户点了下一个选项之后，这条要撤回，群里只留当前这一段。
+         */
+        const sentOptions = this.interactive
+            ? { onSent: (messageId) => (0, interactive_story_1.rememberStoryVideo)(this.e, messageId) }
+            : undefined;
         if (totalBytes > Config_1.Config.app.groupfilevalue) {
-            await (0, utils_1.uploadFile)(this.e, { filepath, totalBytes, originTitle }, videoUrl ?? '', { useGroupFile: true });
+            await (0, utils_1.uploadFile)(this.e, { filepath, totalBytes, originTitle }, videoUrl ?? '', { useGroupFile: true, ...sentOptions });
         }
         else {
-            await (0, utils_1.uploadFile)(this.e, { filepath, totalBytes, originTitle }, videoUrl ?? '');
+            await (0, utils_1.uploadFile)(this.e, { filepath, totalBytes, originTitle }, videoUrl ?? '', sentOptions);
         }
         return true;
     }