koishi-plugin-kkk 1.0.0

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

@@ -0,0 +1,429 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sliceImageToMarkdown = exports.sendSlicedImage = void 0;
+/**
+ * 超长图片的「切片 + markdown 拼接」发送。
+ *
+ * 背景：评论区卡片会把「主评论 + 楼中楼」全部渲染进一张图，实测能长到 **2880×40000**
+ * （1.15 亿像素、7MB）—— QQ 直接拒收（报 `[40093011] 上传文件大小超过限制`），
+ * 表现就是「评论卡发不出来」。
+ *
+ * 解法：把长图按固定高度切成若干片，每片单独上传，再用 **一条 markdown 消息** 拼起来：
+ *
+ *   ![#2880px #6000px](url1)
+ *   ![#2880px #6000px](url2)
+ *
+ * QQ 对同一 markdown 里连续的图片是**紧贴渲染**的，所以视觉上仍然是一整张卡片（严丝合缝），
+ * 而每片都在 QQ 的预览尺寸内，不会再被拒。
+ */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_karin_1 = require("../../../compat/node-karin.js");
+const runtime_1 = require("../../../compat/runtime");
+const Render_1 = require("../../module/utils/Render");
+/**
+ * 每片的**目标**高度。
+ *
+ * 一开始用的 6000：QQ 会把这么高的图整体缩小显示，结果前几片字小到看不清；
+ * 而最后一片因为短，反而被按宽度铺满，看起来比别的「宽」。
+ * 现在改成 2000 —— 每片都在 QQ 的舒适区内，字够大；同时下面的算法保证**每片等长**。
+ */
+const SLICE_HEIGHT = 2000;
+/** 切片前先把宽度压到这个值（卡片本来 2880 宽，QQ 显示用不到，缩一半解码量降到 1/4） */
+const SLICE_WIDTH = 1440;
+/** 把 data URI 或本地路径读成 Buffer */
+const readImage = (source) => {
+    try {
+        if (source.startsWith('data:')) {
+            const comma = source.indexOf(',');
+            return Buffer.from(source.slice(comma + 1), 'base64');
+        }
+        if (node_fs_1.default.existsSync(source))
+            return node_fs_1.default.readFileSync(source);
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
+/** 用 ffmpeg 裁一段出来（项目本来就依赖 ffmpeg，不额外引图像库） */
+const cropWithFfmpeg = async (input, output, width, height, y, 
+/** 自定义 filter（给缩放步骤用）；不传就是按宽度/高度/偏移裁剪 */
+customFilter) => {
+    const filter = customFilter ?? ('crop=' + width + ':' + height + ':0:' + y);
+    const runtime = (0, runtime_1.tryGetRuntime)();
+    const ffmpeg = runtime?.ctx?.ffmpeg;
+    const args = ['-y', '-i', input, '-vf', filter, '-frames:v', '1', output];
+    /**
+     * **不要用宿主的 ffmpeg 服务** —— 实测 `ffmpeg.builder()...run()` 会**卡住不返回**
+     * （既没有 ffmpeg 进程、也没有 CPU 占用、更没有任何日志，表现就是「怎么没反应了」）。
+     * 命令行方式已经验证可用，直接用它。
+     */
+    try {
+        const { spawn } = await Promise.resolve().then(() => __importStar(require('node:child_process')));
+        const bin = process.env.FFMPEG_PATH || 'ffmpeg';
+        await new Promise((resolve, reject) => {
+            const proc = spawn(bin, args, { stdio: 'ignore' });
+            proc.on('error', reject);
+            proc.on('close', (code) => (code === 0 ? resolve() : reject(new Error('ffmpeg exit ' + code))));
+        });
+        return true;
+    }
+    catch (error) {
+        node_karin_1.logger.warn('[图片切片] ffmpeg 裁剪失败: ' + String(error?.message ?? error));
+        return false;
+    }
+};
+/** 上传到宿主 assets，拿到 QQ 能访问的 https 地址 */
+const uploadSlice = async (buffer, name, attempts = 3) => {
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        const url = await uploadSliceOnce(buffer, name);
+        if (url)
+            return url;
+        if (attempt < attempts) {
+            node_karin_1.logger.mark('[图片切片] 上传第 ' + attempt + ' 次失败，' + attempt * 1000 + 'ms 后重试');
+            await new Promise((resolve) => setTimeout(resolve, attempt * 1000));
+        }
+    }
+    return null;
+};
+/** 单次上传（重试逻辑在外面） */
+const uploadSliceOnce = async (buffer, name) => {
+    try {
+        const assets = (0, runtime_1.tryGetRuntime)()?.ctx?.assets;
+        if (!assets?.upload)
+            return null;
+        const uploaded = await assets.upload('data:image/jpeg;base64,' + buffer.toString('base64'), name);
+        const url = typeof uploaded === 'string' ? uploaded : uploaded?.url;
+        return url && /^https?:\/\//i.test(String(url)) ? String(url) : null;
+    }
+    catch (error) {
+        node_karin_1.logger.warn('[图片切片] 上传失败: ' + String(error?.message ?? error));
+        return null;
+    }
+};
+/**
+ * 发送可能超长的图片：短图直接发，长图切片后用一条 markdown 拼接。
+ *
+ * @param e 消息事件
+ * @param source data URI 或本地图片路径
+ * @returns 是否已发送
+ */
+const sendSlicedImage = async (e, input) => {
+    /**
+     * 入参形态有三种，全都要认：
+     *   1. data URI / 本地路径（字符串）
+     *   2. segment.image(...) 造出来的元素（src 在 attrs 上）
+     *   3. 上面两种的**数组** —— Render() 对多图模板返回的就是数组。
+     * 之前只处理前两种，数组进来时取不到 src 会静默失败（切片一直没生效就是这个原因）。
+     */
+    const first = Array.isArray(input) ? input[0] : input;
+    const source = typeof first === 'string'
+        ? first
+        : String(first?.attrs?.src ?? first?.data?.file ?? first?.data?.url ?? '');
+    const buffer = readImage(source);
+    if (!buffer) {
+        node_karin_1.logger.warn('[图片切片] 取不到图片内容（入参 ' + (Array.isArray(input) ? 'array' : typeof input) + '），回退原逻辑');
+        return false;
+    }
+    /**
+     * **按需切片**（默认开，配置项 sliceImageOnDemand）：
+     *   - 图片 ≤ 20MB 且不超高 → 先按普通图片发一次；
+     *   - 发出去**没有消息 ID**（QQ 拒收时就是这样，不抛异常）或抛异常 → 才切片重发；
+     *   - 图片本身就超过 20MB → 直接切片，不用白试一次。
+     * 关掉开关就一律普通发送（超高的卡会被 QQ 拒收，但这是用户的选择）。
+     */
+    const runtimeConfig = (0, runtime_1.tryGetRuntime)()?.config ?? {};
+    /**
+     * **切片只在 QQ 适配器上生效**（用户要求）。
+     *
+     * 切片是为了绕开 QQ 官方 bot 的图片上传限制（单图体积/像素上限），
+     * 其它平台没这个问题，硬切只会增加消息条数、破坏观感。
+     */
+    const platform = String(e?.bot?.bot?.platform ?? e?.platform ?? e?.bot?.platform ?? '');
+    if (platform && !/qq/i.test(platform)) {
+        node_karin_1.logger.debug('[图片切片] 当前平台 ' + platform + ' 不是 QQ，按普通图片发送');
+        await e.reply(node_karin_1.segment.image(source));
+        return true;
+    }
+    const onDemand = runtimeConfig.sliceImageOnDemand !== false;
+    const sliceHeight = Math.max(300, Number(runtimeConfig.sliceImageHeight) || SLICE_HEIGHT);
+    const IMAGE_SIZE_LIMIT = 20 * 1024 * 1024;
+    const meta = (0, Render_1.getImageMetadata)(buffer);
+    let width = Number(meta.width) || 0;
+    let height = Number(meta.height) || 0;
+    // 读不出尺寸时用 ffprobe 兜一次，绝不因为读不到尺寸就放弃切片
+    if (!width || !height) {
+        try {
+            const { spawnSync } = await Promise.resolve().then(() => __importStar(require('node:child_process')));
+            const probe = spawnSync('ffprobe', ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height', '-of', 'csv=p=0', '-'], { input: buffer });
+            const parts = String(probe.stdout ?? '').trim().split(',');
+            width = Number(parts[0]) || 0;
+            height = Number(parts[1]) || 0;
+        }
+        catch { /* 兜底失败按 0 处理 */ }
+    }
+    node_karin_1.logger.mark('[图片切片] 收到图片 ' + width + 'x' + height + '（' + (buffer.length / 1024).toFixed(0) + ' KB）');
+    /**
+     * 普通发送：**收到消息 ID 才算成功**（QQ 拒收时不抛异常、只返回空）。
+     *
+     * 另外加了超时 —— 超高图片（实测 2880×15520）上传时适配器会**长时间卡住不返回**，
+     * 不加超时整条流程就停在这里，用户看到的就是「没反应」。15 秒没结果就当作失败去切片。
+     */
+    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const tryNormalSendOnce = async () => {
+        const sendPromise = (async () => {
+            try {
+                const result = await e.reply(node_karin_1.segment.image(source));
+                /**
+                 * 失败有三种表现，缺一不可（用户提醒：**不一定只是拿不到消息 ID**，QQ 会直接返回错误信息）：
+                 *   1. 抛异常（网络/TLS 问题最常见，比如证书校验失败）
+                 *   2. 拿不到 messageId（适配器静默失败）
+                 *   3. **返回体里带错误**（result.error / message 里含 error/失败/超过限制 之类）
+                 */
+                const errorText = String(result?.error?.message ?? result?.error ?? result?.message ?? result?.data?.error ?? '');
+                if (errorText && /error|fail|失败|超过|限制|拒绝|invalid|denied/i.test(errorText)) {
+                    node_karin_1.logger.mark('[图片切片] 普通发送返回错误信息: ' + errorText.slice(0, 120));
+                    return false;
+                }
+                return Boolean(result?.messageId);
+            }
+            catch (error) {
+                node_karin_1.logger.mark('[图片切片] 普通发送抛错，改走切片: ' + String(error?.message ?? error).slice(0, 120));
+                return false;
+            }
+        })();
+        const timeoutPromise = new Promise((resolve) => {
+            const timer = setTimeout(() => resolve(false), 15000);
+            timer.unref?.();
+        });
+        return await Promise.race([sendPromise, timeoutPromise]);
+    };
+    /**
+     * 带**重试**的普通发送（用户要求）。
+     *
+     * 实测失败大多是**瞬时**的：DNS 抖动、连接被重置、TLS 证书对不上
+     * （你环境里就有把 COS 域名解析到错服务器、返回「只有 IP 的证书」的情况）。
+     * 这种一失败就切片属于过度反应，先退避重试几次，成功就不切。
+     */
+    const tryNormalSend = async (attempts = 3) => {
+        for (let attempt = 1; attempt <= attempts; attempt++) {
+            if (await tryNormalSendOnce())
+                return true;
+            if (attempt < attempts) {
+                node_karin_1.logger.mark('[图片切片] 普通发送第 ' + attempt + ' 次失败，' + attempt * 800 + 'ms 后重试');
+                await sleep(attempt * 800);
+            }
+        }
+        return false;
+    };
+    // 开关关闭 → 永远普通发送
+    if (!onDemand) {
+        await e.reply(node_karin_1.segment.image(source));
+        return true;
+    }
+    /**
+     * 顺序就是用户要的：**先按普通图片发一次**，
+     *   - 拿到消息 ID → 成功，结束（大多数卡片都走这里，不会多此一举切片）
+     *   - 拿不到消息 ID（QQ 拒收就是这样，不抛异常）/ 抛异常 → 再切片重发
+     * 只有图片本身就超过 20MB 才跳过这次尝试，直接切。
+     */
+    const oversized = buffer.length > IMAGE_SIZE_LIMIT;
+    if (oversized) {
+        node_karin_1.logger.mark('[图片切片] 图片 ' + (buffer.length / 1024 / 1024).toFixed(1) + 'MB 超过 20MB 限制，直接切片');
+    }
+    else if (await tryNormalSend()) {
+        return true;
+    }
+    else {
+        node_karin_1.logger.mark('[图片切片] 普通发送没有拿到消息 ID（多为 QQ 拒收），改走切片');
+    }
+    if (!width || !height || height <= sliceHeight) {
+        // 尺寸本身就在范围内、只是发不出去：没得切，原样再试一次
+        await e.reply(node_karin_1.segment.image(source));
+        return true;
+    }
+    const runtime = (0, runtime_1.tryGetRuntime)();
+    const tmpDir = node_path_1.default.join(node_os_1.default.tmpdir(), 'kkk-slice-' + Date.now());
+    try {
+        node_fs_1.default.mkdirSync(tmpDir, { recursive: true });
+        const original = node_path_1.default.join(tmpDir, 'full.jpg');
+        node_fs_1.default.writeFileSync(original, buffer);
+        /**
+         * **先整体缩一次再从缩略图切片** —— 这一步是性能关键。
+         *
+         * 卡片实测 2880×40000（1.15 亿像素）：直接在原图上裁 7 刀，每刀都要把整图重新解码一遍，
+         * 实测要跑好几分钟（用户会看到「怎么没反应了」）。缩到一半宽再裁，
+         * 解码量降到 1/4，7 刀总共一两秒，而且 QQ 显示尺寸本来就不需要 2880 宽。
+         */
+        const scaleWidth = Math.min(width, SLICE_WIDTH);
+        const input = node_path_1.default.join(tmpDir, 'small.jpg');
+        const scaled = scaleWidth < width
+            ? await cropWithFfmpeg(original, input, 0, 0, 0, 'scale=' + scaleWidth + ':-1')
+            : true;
+        const useInput = scaled && node_fs_1.default.existsSync(input) ? input : original;
+        const useHeight = scaled && scaleWidth < width ? Math.round((height * scaleWidth) / width) : height;
+        const useWidth = scaled && scaleWidth < width ? scaleWidth : width;
+        if (useInput !== original) {
+            node_karin_1.logger.mark('[图片切片] 已缩放到 ' + useWidth + 'x' + useHeight + ' 再切片');
+        }
+        const parts = [];
+        /**
+         * **每片等长**：先按最大高度算出片数，再把总高平均分配。
+         * 这样最后一片不会因为矮而被 QQ 按宽度铺开（用户说的「最后一张太宽」）。
+         * 除不尽时最后一片会与前一片重叠几个像素，视觉上几乎看不出来，比留白干净。
+         */
+        const total = Math.max(1, Math.ceil(useHeight / sliceHeight));
+        const each = Math.ceil(useHeight / total);
+        for (let index = 0; index < total; index++) {
+            const sliceHeight = each;
+            // 最后一片贴底裁，保证高度一致（宁可重叠几像素，也不要短一截）
+            const offset = index === total - 1 ? Math.max(0, useHeight - each) : index * each;
+            const output = node_path_1.default.join(tmpDir, 'slice-' + index + '.jpg');
+            const ok = await cropWithFfmpeg(useInput, output, useWidth, sliceHeight, offset);
+            if (!ok || !node_fs_1.default.existsSync(output))
+                break;
+            const url = await uploadSlice(node_fs_1.default.readFileSync(output), 'kkk-slice-' + index + '.jpg');
+            if (!url)
+                break;
+            // 尺寸写死成实际像素：QQ 会按这个尺寸渲染，连续图片紧贴 = 视觉上仍是一整张
+            parts.push('![#' + useWidth + 'px #' + sliceHeight + 'px](' + url + ')');
+        }
+        if (!parts.length) {
+            // 切片失败就退回原图，至少不是完全没反应
+            await e.reply(node_karin_1.segment.image(source));
+            return true;
+        }
+        node_karin_1.logger.mark('[图片切片] 长图 ' + width + 'x' + height + ' 已切成 ' + parts.length + ' 片，用 markdown 拼接发送');
+        await e.reply(node_karin_1.segment.markdown(parts.join(String.fromCharCode(10))));
+        return true;
+    }
+    finally {
+        try {
+            node_fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { /* 清理失败无所谓 */ }
+    }
+};
+exports.sendSlicedImage = sendSlicedImage;
+/**
+ * 只切片、不发送：把可能超长的图片变成**一个 markdown 元素**（调用方自己决定怎么发）。
+ *
+ * 错误卡片就用它 —— 实测错误卡片能到 2880x40000 / 45MB（堆栈越长越夸张），
+ * 直接发必然被 QQ 拒收，等于「报错本身也发不出来」。
+ */
+const sliceImageToMarkdown = async (input) => {
+    const first = Array.isArray(input) ? input[0] : input;
+    const source = typeof first === 'string'
+        ? first
+        : String(first?.attrs?.src ?? first?.data?.file ?? first?.data?.url ?? '');
+    if (!source)
+        return null;
+    const runtimeConfig = (0, runtime_1.tryGetRuntime)()?.config ?? {};
+    // 合并成一条 markdown 也是 QQ 专属优化（绕过图片上传限制）：其它平台逐张发即可
+    const platform = String(e?.bot?.bot?.platform ?? e?.platform ?? e?.bot?.platform ?? '');
+    if (platform && !/qq/i.test(platform)) {
+        for (const one of valid)
+            await e.reply(node_karin_1.segment.image(one));
+        return true;
+    }
+    const sliceHeight = Math.max(300, Number(runtimeConfig.sliceImageHeight) || SLICE_HEIGHT);
+    const tmpDir = node_path_1.default.join(node_os_1.default.tmpdir(), 'kkk-sliceonly-' + Date.now());
+    try {
+        node_fs_1.default.mkdirSync(tmpDir, { recursive: true });
+        const buffer = readImage(source);
+        if (!buffer)
+            return null;
+        const meta = (0, Render_1.getImageMetadata)(buffer);
+        let width = Number(meta.width) || 0;
+        let height = Number(meta.height) || 0;
+        if (!width || !height) {
+            try {
+                const { spawnSync } = await Promise.resolve().then(() => __importStar(require('node:child_process')));
+                const probe = spawnSync('ffprobe', ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height', '-of', 'csv=p=0', '-'], { input: buffer });
+                const ps = String(probe.stdout ?? '').trim().split(',');
+                width = Number(ps[0]) || 0;
+                height = Number(ps[1]) || 0;
+            }
+            catch { /* 忽略 */ }
+        }
+        if (!width || !height)
+            return null;
+        // 不高就直接一段
+        if (height <= sliceHeight) {
+            const url = await uploadSlice(buffer, 'kkk-one.jpg');
+            return url ? node_karin_1.segment.markdown('![#' + width + 'px #' + height + 'px](' + url + ')') : null;
+        }
+        // 超高：先缩放再等分切片
+        const original = node_path_1.default.join(tmpDir, 'full.jpg');
+        node_fs_1.default.writeFileSync(original, buffer);
+        const scaleWidth = Math.min(width, SLICE_WIDTH);
+        const small = node_path_1.default.join(tmpDir, 'small.jpg');
+        const scaled = scaleWidth < width ? await cropWithFfmpeg(original, small, 0, 0, 0, 'scale=' + scaleWidth + ':-1') : false;
+        const useInput = scaled && node_fs_1.default.existsSync(small) ? small : original;
+        const useWidth = scaled ? scaleWidth : width;
+        const useHeight = scaled ? Math.round((height * scaleWidth) / width) : height;
+        const total = Math.max(1, Math.ceil(useHeight / sliceHeight));
+        const each = Math.ceil(useHeight / total);
+        const parts = [];
+        for (let index = 0; index < total; index++) {
+            const offset = index === total - 1 ? Math.max(0, useHeight - each) : index * each;
+            const output = node_path_1.default.join(tmpDir, 'slice-' + index + '.jpg');
+            const ok = await cropWithFfmpeg(useInput, output, useWidth, each, offset);
+            if (!ok || !node_fs_1.default.existsSync(output))
+                break;
+            const url = await uploadSlice(node_fs_1.default.readFileSync(output), 'kkk-slice-' + index + '.jpg');
+            if (!url)
+                break;
+            parts.push('![#' + useWidth + 'px #' + each + 'px](' + url + ')');
+        }
+        if (!parts.length)
+            return null;
+        node_karin_1.logger.mark('[图片切片] 错误卡片等超长图已切成 ' + parts.length + ' 段（markdown）');
+        return node_karin_1.segment.markdown(parts.join(String.fromCharCode(10)));
+    }
+    finally {
+        try {
+            node_fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { /* 忽略 */ }
+    }
+};
+exports.sliceImageToMarkdown = sliceImageToMarkdown;