koishi-plugin-kkk 3.4.2 → 3.6.0

package/config/default_config/config.json

@@ -26,7 +26,6 @@
     "videoTool": true,
     "priority": 800,
     "removeCache": true,
-    "renderer": "shotkit",
     "renderScale": 100,
     "noiseOverlay": "off",
     "forwardContent": [
@@ -114,7 +113,8 @@
     "sendContent": [
       "info",
       "video",
-      "comment"
+      "comment",
+      "chart"
     ],
     "numcomment": 5,
     "realCommentCount": false,

package/lib/build-metadata.json

@@ -0,0 +1,10 @@
+{
+  "version": "3.6.0",
+  "buildTime": "2026-09-25T02:51:07.813Z",
+  "buildTimestamp": 1790304667814,
+  "name": "koishi-plugin-kkk",
+  "description": "抖音 / B站 / 快手 / 小红书 视频解析与动态推送，带 QQ 交互面板与弹幕烧录（karin-plugin-kkk 的 Koishi 移植版）",
+  "homepage": "https://github.com/maimai993/koishi-plugin-kkk#readme",
+  "commitHash": "",
+  "shortCommitHash": ""
+}

package/lib/compat/adapter-info.js

@@ -0,0 +1,333 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAdapterInfo = exports.queryAdapterImplementation = exports.cachedAdapterImplementation = void 0;
+/**
+ * 适配器信息（错误卡片与「#kkk版本」海报上的「适配器」一栏）。
+ *
+ * Koishi 的 Bot 只暴露 platform / adapterName，**没有版本号字段** —— 早期实现直接读
+ * bot.adapter.version，结果卡片上永远是一个空的「v」，也看不出到底用的哪个适配器。
+ * 这里分三步把真实信息挖出来：
+ *
+ *   1. 精准：bot.adapter 是 Adapter 实例，它的构造函数就定义在适配器插件模块里，
+ *      拿构造函数去 require.cache 里反查模块路径，再读那个包的 package.json 版本；
+ *   2. 兜底：按「平台名 + 常见包名前缀」在宿主 node_modules 里找适配器包
+ *      （社区版 koishi-plugin-adapter-x，官方版 @koishijs/plugin-adapter-x）；
+ *   3. 可选异步：OneBot 适配器可以问一句 get_version_info，拿到 NapCat / Lagrange
+ *      这类**实现端**的名字和版本号 —— 那才是用户真正装的软件版本。
+ *
+ * 全部结果都缓存，卡片渲染路径上不会重复扫目录、也不会发网络请求。
+ */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/** 平台名 → 展示名 / 协议。表里没有的平台就把平台名原样当展示名 */
+const PLATFORM_META = {
+    onebot: { name: 'OneBot', protocol: 'OneBot 11' },
+    qq: { name: 'QQ 机器人', protocol: 'QQ 开放平台' },
+    qqguild: { name: 'QQ 频道', protocol: 'QQ 频道' },
+    qqbot: { name: 'QQ 机器人', protocol: 'QQ 开放平台' },
+    bilibili: { name: '哔哩哔哩私信', protocol: 'Bilibili 私信' },
+    discord: { name: 'Discord', protocol: 'Discord' },
+    telegram: { name: 'Telegram', protocol: 'Telegram' },
+    kook: { name: 'KOOK', protocol: 'KOOK' },
+    lark: { name: '飞书', protocol: 'Lark' },
+    satori: { name: 'Satori', protocol: 'Satori' },
+    milky: { name: 'Milky', protocol: 'Milky' },
+    nextchat: { name: 'NextChat', protocol: 'NextChat' },
+    github: { name: 'GitHub', protocol: 'GitHub' }
+};
+/** 包名里出现这些关键字时，展示名以包名为准（同一个 qq 平台有好几个适配器） */
+const PACKAGE_NAME_HINTS = [
+    { key: 'adapter-qq-crack', name: 'QQ（Crack）' },
+    { key: 'adapter-onebot', name: 'OneBot' },
+    { key: 'adapter-bilibili-dm', name: '哔哩哔哩私信' },
+    { key: 'adapter-qq', name: 'QQ 机器人' },
+    { key: 'adapter-satori', name: 'Satori' }
+];
+const PACKAGE_PREFIXES = [
+    'koishi-plugin-adapter-',
+    '@koishijs/plugin-adapter-',
+    'koishi-plugin-',
+    '@koishijs/plugin-'
+];
+const COMMUNICATION_NAMES = {
+    ws: 'WebSocket',
+    websocket: 'WebSocket',
+    'ws-reverse': 'WebSocket 反向',
+    wsreverse: 'WebSocket 反向',
+    http: 'HTTP',
+    'http-reverse': 'HTTP 反向',
+    httpreverse: 'HTTP 反向',
+    sse: 'SSE',
+    webhook: 'Webhook'
+};
+/** 包版本缓存：key 是平台名 + adapterName */
+const PACKAGE_CACHE = new Map();
+/** 实现端版本缓存：key 是平台名 + selfId，值是 null 表示问过了但没问到 */
+const IMPLEMENTATION_CACHE = new Map();
+/** 机器人上线时间：Koishi 没有这个字段，第一次看到它在线时记一笔 */
+const ONLINE_SINCE = new Map();
+const botKey = (bot) => String(bot?.platform ?? bot?.adapterName ?? '') + ':' + String(bot?.selfId ?? '');
+const readPackage = (dir) => {
+    try {
+        const file = node_path_1.default.join(dir, 'package.json');
+        if (!node_fs_1.default.existsSync(file))
+            return null;
+        return JSON.parse(node_fs_1.default.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+};
+/** 从模块文件往上找最近的 package.json 目录，且必须在 node_modules 里（别爬到宿主项目自己的包） */
+const packageDirOf = (file) => {
+    try {
+        let dir = node_path_1.default.dirname(file);
+        for (let i = 0; i < 8; i++) {
+            const isModule = dir.split(/[\\/]/).includes('node_modules');
+            if (isModule && node_fs_1.default.existsSync(node_path_1.default.join(dir, 'package.json')))
+                return dir;
+            const parent = node_path_1.default.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch { /* 取不到就算了 */ }
+    return null;
+};
+/**
+ * 用 Adapter 构造函数反查适配器插件模块。
+ *
+ * 先只扫路径里带 adapter 的模块（覆盖 99% 的情况），扫不到再退化成全表扫描。
+ */
+const findAdapterModule = (ctor) => {
+    if (typeof ctor !== 'function')
+        return null;
+    let ids = [];
+    try {
+        ids = Object.keys(require.cache);
+    }
+    catch {
+        return null;
+    }
+    for (const pass of [0, 1]) {
+        for (const id of ids) {
+            if (pass === 0 && !/adapter/i.test(id))
+                continue;
+            let exportsOf;
+            try {
+                exportsOf = require.cache[id]?.exports;
+            }
+            catch {
+                continue;
+            }
+            if (!exportsOf)
+                continue;
+            if (exportsOf === ctor)
+                return id;
+            let values = [];
+            try {
+                values = Object.values(exportsOf);
+            }
+            catch {
+                continue;
+            }
+            if (values.length > 200)
+                continue;
+            if (values.includes(ctor))
+                return id;
+        }
+    }
+    return null;
+};
+/**
+ * 收集可能装着适配器插件的 node_modules 目录。
+ *
+ * 三个来源：插件自己往上找的各级 node_modules、require.cache 里真实加载过的
+ * node_modules（pnpm / 全局安装也逃不掉）、以及进程工作目录。
+ */
+const moduleRoots = () => {
+    const roots = [];
+    try {
+        let dir = __dirname;
+        for (let i = 0; i < 8; i++) {
+            roots.push(node_path_1.default.join(dir, 'node_modules'));
+            const parent = node_path_1.default.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch { /* 忽略 */ }
+    try {
+        for (const id of Object.keys(require.cache)) {
+            const marker = id.toLowerCase().lastIndexOf('node_modules');
+            if (marker < 0)
+                continue;
+            roots.push(id.slice(0, marker + 'node_modules'.length));
+        }
+    }
+    catch { /* 忽略 */ }
+    try {
+        roots.push(node_path_1.default.join(process.cwd(), 'node_modules'));
+    }
+    catch { /* 忽略 */ }
+    const unique = [];
+    for (const root of roots)
+        if (!unique.includes(root))
+            unique.push(root);
+    return unique;
+};
+/** 平台名 / adapterName → 候选包名 */
+const packageCandidates = (tokens) => {
+    const out = [];
+    for (const token of tokens) {
+        const name = String(token ?? '').trim();
+        if (!name)
+            continue;
+        if (name.startsWith('@') || name.includes('koishi-'))
+            out.push(name);
+        const bare = name.replace(/^@[^/]+\//, '');
+        for (const prefix of PACKAGE_PREFIXES)
+            out.push(prefix + bare);
+    }
+    return Array.from(new Set(out));
+};
+/** 按候选包名去 node_modules 里翻版本号 */
+const lookupPackage = (tokens) => {
+    const key = tokens.join('|');
+    const cached = PACKAGE_CACHE.get(key);
+    if (cached)
+        return cached;
+    const empty = { packageName: '', version: '' };
+    const roots = moduleRoots();
+    for (const candidate of packageCandidates(tokens)) {
+        for (const root of roots) {
+            const pkg = readPackage(node_path_1.default.join(root, ...candidate.split('/')));
+            const version = String(pkg?.version ?? '');
+            if (!version)
+                continue;
+            const hit = { packageName: String(pkg.name ?? candidate), version };
+            PACKAGE_CACHE.set(key, hit);
+            return hit;
+        }
+    }
+    PACKAGE_CACHE.set(key, empty);
+    return empty;
+};
+/** 适配器插件包名与版本（缓存，扫不到就返回空） */
+const resolvePackage = (bot) => {
+    const key = botKey(bot);
+    const cached = PACKAGE_CACHE.get(key);
+    if (cached)
+        return cached;
+    const file = findAdapterModule(bot?.adapter?.constructor);
+    const dir = file ? packageDirOf(file) : null;
+    const pkg = dir ? readPackage(dir) : null;
+    if (pkg?.version) {
+        const hit = { packageName: String(pkg.name ?? ''), version: String(pkg.version) };
+        PACKAGE_CACHE.set(key, hit);
+        return hit;
+    }
+    const fallback = lookupPackage([bot?.platform, bot?.adapterName]);
+    PACKAGE_CACHE.set(key, fallback);
+    return fallback;
+};
+/** 通信方式：读适配器配置里的 protocol，翻成好认的名字 */
+const communicationOf = (bot) => {
+    const config = bot?.config ?? {};
+    const raw = String(config.protocol ?? config.connection ?? config.mode ?? '').toLowerCase();
+    if (!raw)
+        return '未知';
+    return COMMUNICATION_NAMES[raw] ?? raw;
+};
+/** 上线时间：Koishi 不提供，第一次读到「在线」时记一笔，之后一直用它 */
+const onlineSince = (bot, force = false) => {
+    const key = botKey(bot);
+    const known = ONLINE_SINCE.get(key);
+    if (known && !force)
+        return known;
+    const status = bot?.status;
+    const online = status === 1 || status === 2 || status === 'online' || status === 'connect';
+    if (online && !known) {
+        const now = Date.now();
+        ONLINE_SINCE.set(key, now);
+        return now;
+    }
+    return known ?? 0;
+};
+const displayNameOf = (platform, packageName) => {
+    const lower = packageName.toLowerCase();
+    for (const hint of PACKAGE_NAME_HINTS) {
+        if (lower.includes(hint.key))
+            return hint.name;
+    }
+    return PLATFORM_META[platform]?.name ?? (platform || '未知');
+};
+/** 已经问到的实现端信息（没问过就是 undefined，卡片渲染路径不会触发网络请求） */
+const cachedAdapterImplementation = (bot) => IMPLEMENTATION_CACHE.get(botKey(bot)) ?? undefined;
+exports.cachedAdapterImplementation = cachedAdapterImplementation;
+/**
+ * 问适配器要实现端名字与版本（只有 OneBot 一整类支持 get_version_info）。
+ *
+ * 带 1.5 秒超时：适配器没实现这个接口、或者对面不回，都直接放弃，绝不让海报卡住。
+ */
+const queryAdapterImplementation = async (bot) => {
+    const key = botKey(bot);
+    if (IMPLEMENTATION_CACHE.has(key))
+        return IMPLEMENTATION_CACHE.get(key) ?? null;
+    const result = await (async () => {
+        const internal = bot?.internal;
+        if (!internal || typeof internal.get_version_info !== 'function')
+            return null;
+        try {
+            const timeout = new Promise((resolve) => {
+                const timer = setTimeout(() => resolve(null), 1500);
+                timer.unref?.();
+            });
+            const raw = await Promise.race([internal.get_version_info(), timeout]);
+            if (!raw || typeof raw !== 'object')
+                return null;
+            const name = String(raw.app_name ?? raw.appName ?? '').trim();
+            const version = String(raw.app_version ?? raw.appVersion ?? '').trim();
+            const protocol = String(raw.protocol_version ?? raw.protocolVersion ?? '').trim();
+            if (!name && !version)
+                return null;
+            return { name, version, protocol };
+        }
+        catch {
+            return null;
+        }
+    })();
+    IMPLEMENTATION_CACHE.set(key, result);
+    return result;
+};
+exports.queryAdapterImplementation = queryAdapterImplementation;
+/**
+ * 同步采集适配器信息（错误卡片、上报用的都是这一份）。
+ *
+ * @param bot Koishi 的原生 Bot（不是兼容层的包装）
+ */
+const resolveAdapterInfo = (bot) => {
+    const platform = String(bot?.platform ?? bot?.adapterName ?? '').trim();
+    const pkg = resolvePackage(bot);
+    const implementation = (0, exports.cachedAdapterImplementation)(bot);
+    const version = implementation?.version || pkg.version || '未知';
+    return {
+        // 前四个字段是「身份」，一律保持 Koishi 的原值；只有下面这些是这次修好的展示信息
+        name: platform || '未知',
+        displayName: implementation?.name || displayNameOf(platform, pkg.packageName),
+        version,
+        platform: platform || '未知',
+        protocol: platform,
+        standard: platform,
+        communication: communicationOf(bot),
+        connectTime: onlineSince(bot),
+        packageName: pkg.packageName,
+        raw: bot?.adapter
+    };
+};
+exports.resolveAdapterInfo = resolveAdapterInfo;

package/lib/compat/forward-collect.js

@@ -5,6 +5,8 @@ exports.runWithForwardBag = runWithForwardBag;
 exports.currentForwardBag = currentForwardBag;
 exports.isForwardCollecting = isForwardCollecting;
 exports.withoutForwardCollect = withoutForwardCollect;
+exports.withForwardKind = withForwardKind;
+exports.forwardKindOf = forwardKindOf;
 exports.collectForward = collectForward;
 exports.drainForward = drainForward;
 exports.drainForwardGroups = drainForwardGroups;
@@ -23,18 +25,26 @@ exports.drainForwardGroups = drainForwardGroups;
  *   - **只收发往本次解析那个频道的消息**：错误日志要发给主人（另一个频道/另一个 bot），
  *     那种不能被吞进触发者的转发里；
  *   - **过程提示不收**（用户要求：转发里不包含过程提示）：调 `withoutForwardCollect()`
- *     包一下那次发送即可，例如「收到请求，开始下载」「发送中…」「加载中…」。
+ *     包一下那次发送即可，例如「收到请求，开始下载」「发送中…」「加载中…」；
+ *   - **看不清类别的特殊内容**（互动视频的剧情流程图）用 `withForwardKind('chart', …)` 包一下，
+ *     它照常被收集，只是带着类别标签，交给 ParseForward 按「合并转发内容」里勾没勾来分流。
  *
  * 收集用的 `AsyncLocalStorage` 是**按解析链路**隔离的：定时推送、其它会话同时解析
  * 都不会串味。
  */
 const node_async_hooks_1 = require("node:async_hooks");
 const storage = new node_async_hooks_1.AsyncLocalStorage();
+/**
+ * 「这个元素属于哪一类内容」的标记表（见 {@link withForwardKind}）。
+ *
+ * 用 WeakMap 挂在**原对象**上：元素还要原样交给适配器发送，不能往段对象上加字段。
+ */
+const KIND_TAGS = new WeakMap();
 /** 被收集时给调用方回的假消息 ID：调用方普遍只判断「有没有拿到 ID」 */
 exports.COLLECTED_MESSAGE_ID = 'forward-collected';
 /** 在收集上下文里执行（peer 为空则不收任何东西） */
 function runWithForwardBag(peer, fn) {
-    return storage.run({ peer: String(peer ?? ''), elements: [], groups: [], bypass: 0 }, fn);
+    return storage.run({ peer: String(peer ?? ''), elements: [], groups: [], bypass: 0, kind: null, closed: false }, fn);
 }
 /** 当前收集袋（不在解析链路里时是 undefined） */
 function currentForwardBag() {
@@ -51,7 +61,7 @@ function currentForwardBag() {
  */
 function isForwardCollecting() {
     const bag = storage.getStore();
-    return !!bag && bag.bypass === 0;
+    return !!bag && !bag.closed && bag.bypass === 0;
 }
 /**
  * 这段代码里的发送都不进转发（过程提示 / 兜底文本用）。
@@ -69,6 +79,38 @@ async function withoutForwardCollect(fn) {
         bag.bypass -= 1;
     }
 }
+/**
+ * 这一段发出去的东西标一个**内容类别**（例如互动视频的 `chart` 剧情流程图）。
+ *
+ * 为什么需要它：ParseForward 是按**段类型**判断内容的（img→图片、video→视频…），
+ * 而剧情流程图和普通图片都是 `img`，用户却想在「合并转发内容」里分别控制 ——
+ * 只好由发送方自己说清楚「这条是流程图」。
+ *
+ * 不在收集上下文里（或者袋子已经冲刷过了）时原样执行，
+ * 于是**不会影响**「合并转发关着」这条常见路径：那些场景下它就是个普通的发送。
+ *
+ * @param kind 内容类别（`chart`）
+ * @param fn 这一段里发出的内容都按这个类别记账
+ */
+async function withForwardKind(kind, fn) {
+    const bag = storage.getStore();
+    if (!bag || bag.closed || bag.bypass > 0)
+        return await fn();
+    const previous = bag.kind;
+    bag.kind = kind;
+    try {
+        return await fn();
+    }
+    finally {
+        bag.kind = previous;
+    }
+}
+/** 取某个元素被标记的内容类别（没标记就是 undefined，由 ParseForward 按段类型判断） */
+function forwardKindOf(element) {
+    if (!element || typeof element !== 'object')
+        return undefined;
+    return KIND_TAGS.get(element);
+}
 /**
  * 发送漏斗。
  * @param peer 这条消息要发到哪个频道
@@ -77,7 +119,7 @@ async function withoutForwardCollect(fn) {
  */
 function collectForward(peer, content) {
     const bag = storage.getStore();
-    if (!bag || bag.bypass > 0)
+    if (!bag || bag.bypass > 0 || bag.closed)
         return false;
     const target = String(peer ?? '');
     if (!bag.peer || !target || target !== bag.peer)
@@ -88,6 +130,9 @@ function collectForward(peer, content) {
     for (const element of list) {
         if (element === undefined || element === null || element === '')
             continue;
+        /** 这一段带类别标记（见 withForwardKind）时记在元素上，供 ParseForward 分流 */
+        if (bag.kind && element && typeof element === 'object')
+            KIND_TAGS.set(element, bag.kind);
         bag.elements.push(element);
         group.push(element);
     }
@@ -103,6 +148,8 @@ function drainForward() {
     const elements = bag.elements;
     bag.elements = [];
     bag.groups = [];
+    /** 取走 = 这次解析结束了：之后再发的东西一律直发，不许再进这个袋子 */
+    bag.closed = true;
     return elements;
 }
 /**
@@ -117,5 +164,11 @@ function drainForwardGroups() {
     const groups = bag.groups;
     bag.groups = [];
     bag.elements = [];
+    /**
+     * **取走就关袋子**：解析到这里已经结束，转发马上要发出去了。
+     * 剧情图这类后台任务还在跑，之后发出来的内容必须直发 ——
+     * 否则会被收进一个再也没人 drain 的袋子，用户什么都收不到（静默丢内容）。
+     */
+    bag.closed = true;
     return groups;
 }

package/lib/compat/node-karin.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncUpstreamToKoishi = exports.segment = exports.logger = exports.withoutForwardCollect = exports.runWithForwardBag = exports.isForwardCollecting = exports.drainForwardGroups = exports.drainForward = exports.currentForwardBag = exports.collectForward = exports.COLLECTED_MESSAGE_ID = exports.karin = exports.app = exports.isFfmpegAvailable = exports.ffprobe = exports.ffmpeg = exports.createServerErrorResponse = exports.createNotFoundResponse = exports.createBadRequestResponse = exports.createSuccessResponse = exports.authMiddleware = exports.defineConfig = exports.checkPort = exports.isDocker = exports.mkdirSync = exports.updatePkg = exports.checkPkgUpdate = exports.restart = exports.watch = exports.hooks = exports.config = exports.common = exports.render = exports.db = exports.contactFriend = exports.contactGroup = exports.ForwardPayload = exports.Message = exports.KkkBot = exports.NEXT = exports.BOT_READY = exports.BOT_DISCONNECT = exports.BOT_CONNECT = exports.getKoishiContext = void 0;
+exports.syncUpstreamToKoishi = exports.segment = exports.logger = exports.withoutForwardCollect = exports.withForwardKind = exports.runWithForwardBag = exports.isForwardCollecting = exports.forwardKindOf = exports.drainForwardGroups = exports.drainForward = exports.currentForwardBag = exports.collectForward = exports.COLLECTED_MESSAGE_ID = exports.karin = exports.app = exports.isFfmpegAvailable = exports.ffprobe = exports.ffmpeg = exports.createServerErrorResponse = exports.createNotFoundResponse = exports.createBadRequestResponse = exports.createSuccessResponse = exports.authMiddleware = exports.defineConfig = exports.checkPort = exports.isDocker = exports.mkdirSync = exports.updatePkg = exports.checkPkgUpdate = exports.restart = exports.watch = exports.hooks = exports.config = exports.common = exports.render = exports.db = exports.contactFriend = exports.contactGroup = exports.ForwardPayload = exports.Message = exports.KkkBot = exports.NEXT = exports.BOT_READY = exports.BOT_DISCONNECT = exports.BOT_CONNECT = exports.getKoishiContext = void 0;
 exports.makeForward = makeForward;
 exports.isForwardSupported = isForwardSupported;
 exports.logs = logs;
@@ -30,6 +30,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const koishi_1 = require("koishi");
 // 版本比较复用注入器那边的实现（它处理了 -beta.1 这类预发布号的先后）
 const semver_1 = require("../karin/module/utils/semver");
+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");
@@ -85,20 +86,15 @@ class KkkBot {
             avatar: this.bot.user?.avatar
         };
     }
+    /**
+     * 适配器信息（卡片上那一栏）。
+     *
+     * 以前这里直接读 `bot.adapter.version` —— 但 Koishi 的 Adapter 实例上根本没有版本号，
+     * 于是错误卡片和「#kkk版本」海报上永远是一个空的「v」。现在交给 compat/adapter-info：
+     * 按 Adapter 构造函数反查适配器插件、读它的 package.json，必要时再问一次实现端版本。
+     */
     get adapter() {
-        const platform = String(this.bot.platform ?? '');
-        const raw = this.bot.adapter || {};
-        const cfg = raw.config ?? {};
-        return {
-            name: platform,
-            protocol: platform,
-            standard: platform,
-            // 错误卡片模板还会读这三项，之前没给 → 卡片上显示 undefined 和一个空的「v」
-            platform: String(raw.platform ?? cfg.platform ?? (platform || '未知')),
-            communication: String(raw.communication ?? cfg.communication ?? cfg.protocol ?? '未知'),
-            version: String(raw.version ?? cfg.version ?? ''),
-            raw: this.bot.adapter
-        };
+        return (0, adapter_info_1.resolveAdapterInfo)(this.bot);
     }
     get ctx() {
         return this.bot.ctx;
@@ -551,8 +547,9 @@ class Message {
             const failure = (0, sendError_1.classifySendFailure)(error);
             // 只有「被动回复额度/时间窗超了」才值得换通道重发；体积超限、被禁言、无权限这类
             // 换通道也一样失败，直接抛给调用方（它拿到错误码会去切片 / 降级 / 报错）
+            // 空 message 的异常（qq-chat 编码器那种）在这里补一段可读说明，别让错误卡片上一片空白
             if (!(0, sendError_1.isPassiveLimitFailure)(failure))
-                throw error;
+                throw (0, sendError_1.decorateSendError)(error, failure);
             // 用 mark 级别：这是「视频明明下好了却发不出去」的关键兜底，日志里要看得见
             logger_1.logger.mark('[compat] 被动回复受限，改用主动消息发送: ' + (0, sendError_1.describeSendFailure)(failure));
             return await sendActive();
@@ -825,52 +822,20 @@ exports.db = {
 exports.render = {
     /**
      * karin 的 render.render：给 HTML 文件截图。
-     * 优先用 koishi-plugin-puppeteer，没有浏览器服务时才退回 koishi-plugin-shotkit 内核。
+     *
+     * **只用浏览器渲染服务**（koishi-plugin-puppeteer / puppeteer-without-canvas 之类）。
+     * 3.5.0 起不再支持 shotkit 内核：它在 Windows 上加载不了 https 资源，卡片里的远程封面、
+     * 头像一律是空白框 —— 用户看到的是「卡片坏了」，快那一点不值得。
      */
     async render(options) {
         const runtime = (0, runtime_1.getRuntime)();
         const puppeteer = runtime.ctx.puppeteer;
         /**
-         * 优先渲染器（面板「通用设置 → 优先渲染器」，配置项 `app.renderer`，默认 shotkit）。
-         *
-         * 和卡片主渲染走同一个开关：选了谁谁先上，没装或渲染失败就落到另一个。
-         * 这里用延迟 require 读配置：Config 依赖本文件（node-karin 兼容层），
-         * 顶部 import 会和本文件形成循环依赖，放到调用时读最稳。
+         * 渲染只走浏览器这一条路（3.5.0 起不再支持 shotkit 内核，见 Render/index.ts 的说明）。
+         * 以前这里会按配置项 app.renderer 在「内核 / 浏览器」之间挑一个，现在没得挑了。
          */
-        let preferShotkit = true;
-        try {
-            const { Config } = require('../karin/module/utils/Config');
-            preferShotkit = String(Config?.app?.renderer ?? 'shotkit').toLowerCase() !== 'puppeteer';
-        }
-        catch { /* 读不到配置就按默认值 shotkit */ }
-        const useShotkit = preferShotkit || !puppeteer;
-        const shotkit = useShotkit
-            ? (typeof runtime.ctx.get === 'function'
-                ? runtime.ctx.get('shotkit')
-                : runtime.ctx.shotkit)
-            : undefined;
-        if (shotkit && typeof shotkit.renderFile === 'function') {
-            try {
-                const request = {
-                    // fullPage 和 selector 互斥：要整页就别给选择器
-                    fullPage: options.fullPage ?? false,
-                    omitBackground: options.omitBackground ?? true,
-                    type: options.type ?? 'png',
-                    scale: 2,
-                    pageGotoParams: options.pageGotoParams
-                };
-                if (!request.fullPage)
-                    request.selector = options.selector ?? '#container';
-                const buffer = await shotkit.renderFile(options.file, request);
-                if (buffer && buffer.length)
-                    return buffer.toString('base64');
-            }
-            catch (error) {
-                logger_1.logger.debug('[kkk] shotkit 渲染失败，回退到 puppeteer：' + String(error?.message ?? error));
-            }
-        }
         if (!puppeteer)
-            throw new Error('[kkk] 渲染失败：未安装 koishi-plugin-puppeteer（或 koishi-plugin-shotkit）');
+            throw new Error('[kkk] 渲染失败：没有可用的浏览器渲染服务（需要 koishi-plugin-puppeteer 或同类插件）');
         const screenshotOptions = {
             file: options.file,
             selector: options.selector ?? '#container',
@@ -1645,8 +1610,10 @@ exports.karin = {
 /**
  * 解析结果合并转发用的收集器（见 compat/forward-collect）。
  *
- * 业务侧一般只用得到 `withoutForwardCollect`：把「过程提示」那次发送包起来，
- * 让它不要被收进最终那条转发里。
+ * 业务侧一般只用得到两个：
+ *   - `withoutForwardCollect`：把「过程提示」那次发送包起来，让它不要被收进最终那条转发里；
+ *   - `withForwardKind`：段类型看不出类别的内容（互动视频剧情流程图）标一个类别，
+ *     交给 ParseForward 按「合并转发内容」分流。
  */
 var forward_collect_2 = require("./forward-collect");
 Object.defineProperty(exports, "COLLECTED_MESSAGE_ID", { enumerable: true, get: function () { return forward_collect_2.COLLECTED_MESSAGE_ID; } });
@@ -1654,7 +1621,9 @@ Object.defineProperty(exports, "collectForward", { enumerable: true, get: functi
 Object.defineProperty(exports, "currentForwardBag", { enumerable: true, get: function () { return forward_collect_2.currentForwardBag; } });
 Object.defineProperty(exports, "drainForward", { enumerable: true, get: function () { return forward_collect_2.drainForward; } });
 Object.defineProperty(exports, "drainForwardGroups", { enumerable: true, get: function () { return forward_collect_2.drainForwardGroups; } });
+Object.defineProperty(exports, "forwardKindOf", { enumerable: true, get: function () { return forward_collect_2.forwardKindOf; } });
 Object.defineProperty(exports, "isForwardCollecting", { enumerable: true, get: function () { return forward_collect_2.isForwardCollecting; } });
 Object.defineProperty(exports, "runWithForwardBag", { enumerable: true, get: function () { return forward_collect_2.runWithForwardBag; } });
+Object.defineProperty(exports, "withForwardKind", { enumerable: true, get: function () { return forward_collect_2.withForwardKind; } });
 Object.defineProperty(exports, "withoutForwardCollect", { enumerable: true, get: function () { return forward_collect_2.withoutForwardCollect; } });
 exports.default = exports.karin;

package/lib/compat/sendError.js

@@ -30,6 +30,7 @@ exports.UnconfirmedSendError = void 0;
 exports.classifySendFailure = classifySendFailure;
 exports.failureFromReplyResult = failureFromReplyResult;
 exports.describeSendFailure = describeSendFailure;
+exports.decorateSendError = decorateSendError;
 exports.isPassiveLimitFailure = isPassiveLimitFailure;
 /**
  * 错误码表。
@@ -200,6 +201,32 @@ function describeSendFailure(failure) {
     const code = failure.code !== undefined && !hasCode ? '[' + failure.code + '] ' : '';
     return code + (text || failure.kind);
 }
+/**
+ * 给「完全没有说明」的发送异常补一段人话。
+ *
+ * qq-chat 的编码器有时抛一个 message 为空的 Error（栈里只有 `_QQMessageEncoder.send`），
+ * 这种异常一路冒到错误卡片上就是一片空白 —— 用户看不出发生了什么，我们也无从排查。
+ * 有 message 的错误原样返回（错误码就在里面，调用方还要用）；空 message 的才包一层，
+ * 把异常类型、判错结论和栈顶帧拼进 message，原异常挂在 cause 上（判错逻辑会继续往里挖）。
+ *
+ * @param error 适配器抛出的原始异常
+ * @param failure 已经判好的失败分类
+ */
+function decorateSendError(error, failure) {
+    if (String(error?.message ?? '').trim())
+        return error;
+    const name = String(error?.name || error?.constructor?.name || 'Error');
+    const frame = String(error?.stack ?? '').split('\n').slice(1, 3).join(' ').trim();
+    const reason = describeSendFailure(failure);
+    const message = '消息发送失败（' + name + '）：'
+        + (reason && reason !== failure.kind ? reason : '适配器没有给出原因')
+        + (frame ? '｜' + frame.slice(0, 200) : '');
+    const wrapped = new Error(message);
+    wrapped.name = 'SendFailedError';
+    wrapped.cause = error;
+    wrapped.sendFailureKind = failure.kind;
+    return wrapped;
+}
 /** 是不是「换主动消息通道就能救」的那种失败（只有被动回复超限算） */
 function isPassiveLimitFailure(failure) {
     return failure.kind === 'passive-limit';