koishi-plugin-rocom 1.0.18 → 1.0.19

package/lib/render.js

@@ -36,13 +36,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Renderer = void 0;
+exports.Renderer = exports.lowBandwidthRenderOptions = void 0;
 const koishi_1 = require("koishi");
 const template = __importStar(require("art-template"));
 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_url_1 = require("node:url");
+const async_control_1 = require("./async-control");
 const logger = new koishi_1.Logger('rocom-render');
 const TEMPLATE_CAPTURE_PADDING = {
     package: { left: 0, right: 0, top: 0, bottom: 0 },
@@ -59,6 +60,15 @@ const DEFAULT_SCREENSHOT_OPTIONS = {
     type: 'jpeg',
     quality: 82,
 };
+// 家园详情低带宽建议初值，需用真实截图校准。
+exports.lowBandwidthRenderOptions = {
+    timeoutMs: 30000,
+    imageWaitMs: 3000,
+    fontWaitMs: 1500,
+    deviceScaleFactor: 1,
+    jpegQuality: 65,
+    maxPageHeight: 12000,
+};
 function toDirectoryFileUrl(dirPath) {
     const href = (0, node_url_1.pathToFileURL)(dirPath).href;
     return href.endsWith('/') ? href : `${href}/`;
@@ -68,8 +78,10 @@ function normalizeTemplateResourcePaths(content) {
 }
 class Renderer {
     resPath;
-    constructor(resPath) {
+    defaults;
+    constructor(resPath, defaults = {}) {
         this.resPath = resPath;
+        this.defaults = defaults;
     }
     resourceUrl(relativePath) {
         return (0, node_url_1.pathToFileURL)(node_path_1.default.join(this.getPreferredResourceRoot(), relativePath)).href;
@@ -107,7 +119,58 @@ class Renderer {
             return '';
         return node_path_1.default.join(resolved.resourceRoot, 'render-templates', templateName, 'style.css');
     }
-    async renderHtml(ctx, templateName, data) {
+    async renderHtml(ctx, templateName, data, options = {}) {
+        const pages = await this.renderPages(ctx, templateName, data, { ...options, maxPageHeight: 0 });
+        return pages?.[0] ?? null;
+    }
+    async renderPages(ctx, templateName, data, options = {}) {
+        options = { maxPageHeight: 6000, ...this.defaults, ...options };
+        let page;
+        let tempDir = '';
+        let stopped = false;
+        let closing;
+        const close = () => {
+            if (page && !closing)
+                closing = Promise.resolve().then(() => page.close()).catch(() => { });
+            return closing;
+        };
+        try {
+            return await (0, async_control_1.withDeadline)(options.timeoutMs || 30000, options.signal, async (signal) => {
+                const acquire = async () => {
+                    page = await ctx.puppeteer.page();
+                    if (stopped || signal.aborted) {
+                        await close();
+                        signal.throwIfAborted();
+                    }
+                    return page;
+                };
+                return this.capture(ctx, templateName, data, { ...options, signal }, acquire, dir => { tempDir = dir; });
+            }, () => { stopped = true; void close(); });
+        }
+        catch (error) {
+            logger.warn('render interrupted for ' + templateName + ': ' + error);
+            return null;
+        }
+        finally {
+            stopped = true;
+            // A stalled browser must not block the request's deadline indefinitely.
+            void close();
+            if (tempDir) {
+                try {
+                    node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                }
+                catch { }
+            }
+        }
+    }
+    async capture(ctx, templateName, data, options, acquire, rememberDirectory) {
+        const timeoutMs = options.timeoutMs && options.timeoutMs > 0 ? options.timeoutMs : 30000;
+        const deadline = Date.now() + timeoutMs;
+        const imageWaitMs = options.imageWaitMs && options.imageWaitMs > 0 ? options.imageWaitMs : 10000;
+        const fontWaitMs = options.fontWaitMs && options.fontWaitMs > 0 ? options.fontWaitMs : 3000;
+        const jpegQuality = options.jpegQuality && options.jpegQuality > 0 ? options.jpegQuality : DEFAULT_SCREENSHOT_OPTIONS.quality;
+        const screenshotOptions = { type: 'jpeg', quality: jpegQuality };
+        const remainingMs = () => { options.signal?.throwIfAborted(); return Math.max(1, deadline - Date.now()); };
         try {
             const resolvedTemplate = this.resolveTemplatePath(templateName);
             if (!resolvedTemplate) {
@@ -125,25 +188,33 @@ class Renderer {
                 logger.error('puppeteer service is unavailable');
                 return null;
             }
-            const page = await ctx.puppeteer.page();
-            const tempDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'rocom-render-'));
-            const tempHtmlPath = node_path_1.default.join(tempDir, `${templateName.replace(/[\\/]/g, '_')}.html`);
+            // Puppeteer 服务由 Koishi 共享，只能关闭本次 page，不能关闭共享 browser。
+            const page = await acquire();
+            let tempDir = '';
             try {
+                options.signal?.throwIfAborted();
+                tempDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'rocom-render-'));
+                rememberDirectory(tempDir);
+                const tempHtmlPath = node_path_1.default.join(tempDir, `${templateName.replace(/[\\/]/g, '_')}.html`);
                 await page.setCacheEnabled(false);
                 node_fs_1.default.writeFileSync(tempHtmlPath, html, 'utf-8');
-                const initialViewport = TEMPLATE_VIEWPORTS[templateName] || { width: 1280, height: 768, deviceScaleFactor: 2 };
+                const templateViewport = TEMPLATE_VIEWPORTS[templateName] || { width: 1280, height: 768, deviceScaleFactor: 2 };
+                const initialViewport = {
+                    ...templateViewport,
+                    deviceScaleFactor: options.deviceScaleFactor ?? templateViewport.deviceScaleFactor,
+                };
                 await page.setViewport(initialViewport);
                 try {
                     await page.goto((0, node_url_1.pathToFileURL)(tempHtmlPath).href, {
                         waitUntil: 'networkidle0',
-                        timeout: 15000,
+                        timeout: Math.min(15000, remainingMs()),
                     });
                 }
                 catch (err) {
                     logger.warn(`page.goto failed for ${templateName}: ${err}`);
                 }
                 try {
-                    await page.evaluate(async () => {
+                    await page.evaluate(async (waitImageMs, waitFontMs) => {
                         const images = Array.from(document.images);
                         // 限制远程图片等待时间，避免慢速资源拖垮整次渲染（对应上游 v3.7.1）。
                         await Promise.race([
@@ -155,18 +226,22 @@ class Renderer {
                                     img.onerror = () => resolve();
                                 });
                             })),
-                            new Promise(resolve => setTimeout(resolve, 10000)),
+                            new Promise(resolve => setTimeout(resolve, waitImageMs)),
                         ]);
                         const fonts = document.fonts;
                         if (fonts?.ready) {
-                            await fonts.ready;
+                            // 字体等待单独设上限，避免字体服务异常时无限等待。
+                            await Promise.race([
+                                fonts.ready,
+                                new Promise(resolve => setTimeout(resolve, waitFontMs)),
+                            ]);
                         }
-                    });
+                    }, Math.min(imageWaitMs, remainingMs()), Math.min(fontWaitMs, remainingMs()));
                 }
                 catch (err) {
                     logger.warn(`asset wait failed for ${templateName}: ${err}`);
                 }
-                await new Promise(resolve => setTimeout(resolve, 300));
+                await (0, async_control_1.delay)(300, options.signal);
                 const selectors = [
                     '.exchange-page',
                     '.record-page',
@@ -193,6 +268,10 @@ class Renderer {
                     '.pet-panel-page',
                     '.pet-detail-page',
                     '.activity-calendar-page',
+                    '.pet-ranking-page',
+                    '.share-code-page',
+                    '.announcement-list-page',
+                    '.announcement-detail-page',
                 ];
                 let target = null;
                 for (const selector of selectors) {
@@ -220,10 +299,10 @@ class Renderer {
                         const capturePadding = TEMPLATE_CAPTURE_PADDING[templateName] || { left: 0, right: 0, top: 0, bottom: 0 };
                         await page.setViewport({
                             width: Math.max(Math.ceil(elementMetrics.x + elementMetrics.width + capturePadding.right) + 8, 200),
-                            height: Math.max(Math.ceil(elementMetrics.y + elementMetrics.height + capturePadding.bottom) + 8, 200),
+                            height: Math.min(6000, Math.max(Math.ceil(elementMetrics.y + elementMetrics.height + capturePadding.bottom) + 8, 200)),
                             deviceScaleFactor: initialViewport.deviceScaleFactor,
                         });
-                        await new Promise(resolve => setTimeout(resolve, 100));
+                        await (0, async_control_1.delay)(100, options.signal);
                         // 居中（margin auto）模板在视口调整后 x/y 会变化，截图前需要重新测量，
                         // 否则 clip 会带着旧偏移导致画面左侧被截断（对应上游 v3.7.5 修复）。
                         try {
@@ -247,30 +326,27 @@ class Renderer {
                         catch (err) {
                             logger.warn(`element remeasure failed for ${templateName}: ${err}`);
                         }
-                        const hasOverflow = elementMetrics.width > box.width + 0.5 ||
-                            elementMetrics.height > box.height + 0.5;
-                        if (capturePadding.left || capturePadding.right || capturePadding.top || capturePadding.bottom || hasOverflow) {
-                            const clipX = Math.max(0, elementMetrics.x - capturePadding.left);
-                            const clipY = Math.max(0, elementMetrics.y - capturePadding.top);
-                            const clipWidth = elementMetrics.width + capturePadding.left + capturePadding.right;
-                            const clipHeight = elementMetrics.height + capturePadding.top + capturePadding.bottom;
-                            const screenshot = await page.screenshot({
-                                ...DEFAULT_SCREENSHOT_OPTIONS,
-                                clip: {
-                                    x: clipX,
-                                    y: clipY,
-                                    width: clipWidth,
-                                    height: clipHeight,
-                                },
-                            });
-                            return Buffer.isBuffer(screenshot) ? screenshot : Buffer.from(screenshot);
+                        const clipX = Math.max(0, elementMetrics.x - capturePadding.left);
+                        const clipY = Math.max(0, elementMetrics.y - capturePadding.top);
+                        const width = elementMetrics.width + capturePadding.left + capturePadding.right;
+                        const height = elementMetrics.height + capturePadding.top + capturePadding.bottom;
+                        const maxHeight = Math.max(1, options.maxPageHeight || height);
+                        // Evenly distribute the last few pixels instead of emitting a tiny blank final page.
+                        const step = Math.ceil(height / Math.ceil(height / maxHeight));
+                        const pages = [];
+                        for (let offset = 0; offset < height; offset += step) {
+                            options.signal?.throwIfAborted();
+                            const screenshot = await page.screenshot({ ...screenshotOptions, captureBeyondViewport: true,
+                                clip: { x: clipX, y: clipY + offset, width, height: Math.min(step, height - offset) } });
+                            pages.push(Buffer.from(screenshot));
                         }
+                        return pages;
                     }
-                    const screenshot = await target.screenshot(DEFAULT_SCREENSHOT_OPTIONS);
-                    return Buffer.isBuffer(screenshot) ? screenshot : Buffer.from(screenshot);
+                    const screenshot = await target.screenshot(screenshotOptions);
+                    return [Buffer.from(screenshot)];
                 }
-                const screenshot = await page.screenshot({ ...DEFAULT_SCREENSHOT_OPTIONS, fullPage: true });
-                return Buffer.isBuffer(screenshot) ? screenshot : Buffer.from(screenshot);
+                const screenshot = await page.screenshot({ ...screenshotOptions, fullPage: true });
+                return [Buffer.from(screenshot)];
             }
             finally {
                 try {
@@ -279,7 +355,14 @@ class Renderer {
                 catch {
                     // ignore
                 }
-                node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                if (tempDir) {
+                    try {
+                        node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
             }
         }
         catch (e) {

package/lib/send-image.d.ts

@@ -1,4 +1,4 @@
 import { PluginConfig } from './types';
 export declare function detectImageMime(image: Buffer): string;
 export declare function compressPngImage(image: Buffer, config: Pick<PluginConfig, 'imageCompressionEnabled' | 'imageCompressionMinBytes' | 'imageCompressionLevel'>): Buffer;
-export declare function sendImageWithFallback(session: any, image: Buffer | null, fallbackText: string, scene: string, compressionConfig?: Pick<PluginConfig, 'imageCompressionEnabled' | 'imageCompressionMinBytes' | 'imageCompressionLevel'>): Promise<void>;
+export declare function sendImageWithFallback(session: any, image: Buffer | Buffer[] | null, fallbackText: string, scene: string, compressionConfig?: Pick<PluginConfig, 'imageCompressionEnabled' | 'imageCompressionMinBytes' | 'imageCompressionLevel'>): Promise<boolean>;

package/lib/send-image.js

@@ -114,6 +114,16 @@ function compressPngImage(image, config) {
     return image;
 }
 async function sendImageWithFallback(session, image, fallbackText, scene, compressionConfig) {
+    if (Array.isArray(image)) {
+        if (!image.length)
+            return sendImageWithFallback(session, null, fallbackText, scene, compressionConfig);
+        for (const page of image) {
+            const ok = await sendImageWithFallback(session, page, fallbackText, scene, compressionConfig);
+            if (!ok)
+                return false;
+        }
+        return true;
+    }
     const ctxInfo = formatSessionContext(session);
     if (!image) {
         logger.warn(`[${scene}] render returned empty image, fallback to text | ${ctxInfo}`);
@@ -132,8 +142,9 @@ async function sendImageWithFallback(session, image, fallbackText, scene, compre
     try {
         const result = await session.send(koishi_1.h.image(outputImage, detectImageMime(outputImage)));
         if (!hasSendResult(result)) {
-            logger.warn(`[${scene}] image send returned empty result | size=${outputImage.length}B | ${ctxInfo}`);
+            throw new Error('图片发送未返回消息 ID');
         }
+        return true;
     }
     catch (e) {
         logger.error(`[${scene}] image send failed | size=${outputImage.length}B | ${ctxInfo} | ${e}`);

package/lib/share-code-service.d.ts

@@ -0,0 +1,32 @@
+export declare const SHARE_CODE_MAX_LENGTH: number;
+export type ShareCodeSource = 'parse' | 'record';
+export declare function extractShareCode(input: string): string;
+export declare function parsedRecord(record: any): any | null;
+export declare function buildShareCodeView(payload: any, source: ShareCodeSource, record?: any, baseUrl?: string): {
+    source: ShareCodeSource;
+    sourceLabel: string;
+    shareCode: string;
+    shareCodePreview: string;
+    version: number;
+    spriteCount: number;
+    mode: {
+        id: number;
+        name: string;
+        icon: string;
+        configured: boolean;
+    };
+    magic: {
+        id: number;
+        name: string;
+        icon: string;
+        configured: boolean;
+    };
+    teams: any;
+    parseCount: number;
+    firstSeen: string;
+    lastSeen: string;
+    shareCodeHash: string;
+    commandHint: string;
+    copyright: string;
+};
+export declare function buildShareCodeText(data: any): string;

package/lib/share-code-service.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHARE_CODE_MAX_LENGTH = void 0;
+exports.extractShareCode = extractShareCode;
+exports.parsedRecord = parsedRecord;
+exports.buildShareCodeView = buildShareCodeView;
+exports.buildShareCodeText = buildShareCodeText;
+const client_1 = require("./client");
+const player_service_1 = require("./player-service");
+exports.SHARE_CODE_MAX_LENGTH = 16 * 1024;
+function extractShareCode(input) {
+    const raw = String(input ?? '').trim().replace(/^[`"']+|[`"']+$/g, '');
+    if (!raw)
+        return '';
+    if (raw.length > exports.SHARE_CODE_MAX_LENGTH)
+        throw new Error('分享码内容过长');
+    const match = /(?:[?&#]|^)share(?:Data|_data|_code)=([^&#\s]+)/i.exec(raw);
+    if (!match) {
+        if (/^https?:\/\//i.test(raw))
+            throw new Error('链接中没有分享码参数');
+        return raw;
+    }
+    let value = match[1];
+    for (let i = 0; i < 2; i++) {
+        let decoded;
+        try {
+            decoded = decodeURIComponent(value);
+        }
+        catch {
+            throw new Error('分享码链接的编码不完整');
+        }
+        if (decoded === value)
+            break;
+        value = decoded;
+    }
+    return value.trim().replace(/^[`"']+|[`"']+$/g, '');
+}
+// 避免对已存解析对象重复发 POST。
+function parsedRecord(record) {
+    for (const candidate of [record?.share_code, record?.parsed, record]) {
+        if (candidate && typeof candidate === 'object' && Array.isArray(candidate.teams)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function toInt(value, fallback = 0) {
+    const n = Number(value);
+    return Number.isFinite(n) ? Math.trunc(n) : fallback;
+}
+function text(value, fallback = '') {
+    if (value === null || value === undefined)
+        return fallback;
+    const s = String(value).trim();
+    return s || fallback;
+}
+function formatTime(value) {
+    const raw = text(value);
+    if (!raw)
+        return '';
+    const normalized = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}/.test(raw) && !/(Z|[+-]\d{2}:?\d{2})$/.test(raw)
+        ? `${raw.replace(' ', 'T')}+08:00`
+        : raw.replace('Z', '+00:00');
+    const date = new Date(normalized);
+    if (Number.isNaN(date.getTime()))
+        return raw;
+    const shifted = new Date(date.getTime() + 8 * 3600_000);
+    const pad = (v) => String(v).padStart(2, '0');
+    return `${shifted.getUTCFullYear()}-${pad(shifted.getUTCMonth() + 1)}-${pad(shifted.getUTCDate())} ${pad(shifted.getUTCHours())}:${pad(shifted.getUTCMinutes())}`;
+}
+function normalizeUrl(value, baseUrl) {
+    return (0, player_service_1.resourceUrl)(value, baseUrl);
+}
+function wikiAssetUrl(baseUrl, path) {
+    if (!baseUrl)
+        return path;
+    return `${String(baseUrl).replace(/\/$/, '')}${path}`;
+}
+function normalizeNamedIcon(value, emptyName, baseUrl) {
+    const item = (0, client_1.isObject)(value) ? value : {};
+    const id = toInt(item.id);
+    return {
+        id,
+        name: text(item.name, emptyName),
+        icon: normalizeUrl(item.icon, baseUrl),
+        configured: Boolean(id || text(item.name) || text(item.icon)),
+    };
+}
+function normalizeTeam(value, index, baseUrl) {
+    const team = (0, client_1.isObject)(value) ? value : {};
+    const pet = normalizeNamedIcon(team.pet, '未配置精灵', baseUrl);
+    if (pet.id)
+        pet.icon = wikiAssetUrl(baseUrl, `/api/v1/resources/wiki/assets/pets/${pet.id}/icon.png`);
+    const bloodline = normalizeNamedIcon(team.bloodline, '未配置血脉', baseUrl);
+    const personality = normalizeNamedIcon(team.personality, '未配置性格', baseUrl);
+    const ivs = [];
+    for (const raw of Array.isArray(team.ivs_detail) ? team.ivs_detail : []) {
+        ivs.push(normalizeNamedIcon(raw, '未配置', baseUrl));
+    }
+    while (ivs.length < 3)
+        ivs.push(normalizeNamedIcon(null, '未配置', baseUrl));
+    const skills = [];
+    for (const raw of Array.isArray(team.skills) ? team.skills : []) {
+        const skill = normalizeNamedIcon(raw, '未配置技能', baseUrl);
+        if (skill.id)
+            skill.icon = wikiAssetUrl(baseUrl, `/api/v1/resources/wiki/assets/skills/${skill.id}.png`);
+        skills.push(skill);
+    }
+    while (skills.length < 4)
+        skills.push(normalizeNamedIcon(null, '未配置技能', baseUrl));
+    return {
+        slot: toInt(team.slot, index + 1),
+        pet,
+        bloodline,
+        personality,
+        ivs: ivs.slice(0, 3),
+        skills: skills.slice(0, 4),
+        empty: !pet.configured,
+    };
+}
+function unwrapRecord(record) {
+    if (!(0, client_1.isObject)(record))
+        return { payload: {}, meta: {} };
+    if ((0, client_1.isObject)(record.share_code))
+        return { payload: record.share_code, meta: record };
+    if ((0, client_1.isObject)(record.parsed))
+        return { payload: record.parsed, meta: record };
+    return { payload: record, meta: {} };
+}
+function shareCodePreview(code) {
+    if (code.length <= 36)
+        return code;
+    return `${code.slice(0, 20)}...${code.slice(-12)}`;
+}
+function buildShareCodeView(payload, source, record, baseUrl = '') {
+    let data = (0, client_1.isObject)(payload) ? payload : {};
+    let recordMeta = {};
+    if (record) {
+        const unwrapped = unwrapRecord(record);
+        if (!data.teams)
+            data = unwrapped.payload;
+        recordMeta = unwrapped.meta;
+    }
+    const teams = (Array.isArray(data.teams) ? data.teams : [])
+        .map((item, index) => normalizeTeam(item, index, baseUrl))
+        .sort((a, b) => a.slot - b.slot);
+    const shareCode = text(data.share_code);
+    const mode = normalizeNamedIcon(data.mode, '未知编队模式', baseUrl);
+    const magic = normalizeNamedIcon(data.magic, '未配置魔法', baseUrl);
+    if (magic.configured && magic.name === '未配置魔法')
+        magic.name = `魔法 ${magic.id}`;
+    const spriteCount = toInt(data.sprite_count, teams.length);
+    return {
+        source,
+        sourceLabel: source === 'record' ? '历史记录' : '即时解析',
+        shareCode,
+        shareCodePreview: shareCodePreview(shareCode),
+        version: toInt(data.version, 1),
+        spriteCount,
+        mode,
+        magic,
+        teams,
+        parseCount: toInt(recordMeta.parse_count),
+        firstSeen: formatTime(recordMeta.first_seen_at),
+        lastSeen: formatTime(recordMeta.last_seen_at),
+        shareCodeHash: text(recordMeta.share_code_hash),
+        commandHint: '阵容码 解析 <分享码或链接> · 阵容码 查询 <分享码>',
+        copyright: 'Koishi & WeGame 洛克王国插件',
+    };
+}
+function buildShareCodeText(data) {
+    const lines = [
+        `阵容码${data.sourceLabel || '解析'}：${data.mode?.name || '未知模式'}，共 ${data.spriteCount || 0} 只精灵`,
+    ];
+    for (const team of data.teams || []) {
+        const talents = (team.ivs || []).filter((item) => item.configured).map((item) => item.name);
+        const skillNames = (team.skills || []).filter((item) => item.configured).map((item) => item.name);
+        lines.push(`${team.slot}. ${team.pet.name} | ${team.bloodline.name} | ${team.personality.name} | 天赋：${talents.join('、') || '未配置'} | 技能：${skillNames.join('、') || '未配置'}`);
+    }
+    if (data.parseCount) {
+        lines.push(`解析次数：${data.parseCount}，最近记录：${data.lastSeen || '未知'}`);
+    }
+    return lines.join('\n');
+}

package/lib/subscription-runner.d.ts

@@ -0,0 +1,6 @@
+import { Context } from 'koishi';
+export interface Runner {
+    <T>(job: (signal: AbortSignal) => Promise<T>): Promise<T | undefined>;
+    aborted: () => boolean;
+}
+export declare function createRunner(ctx: Context): Runner;

package/lib/subscription-runner.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunner = createRunner;
+// 每个插件实例的互斥与停止标记：取消在途任务、阻止重叠检查。
+function createRunner(ctx) {
+    const controller = new AbortController();
+    let running = false;
+    ctx.on('dispose', () => controller.abort());
+    const runner = Object.assign(async (job) => {
+        if (running || controller.signal.aborted)
+            return;
+        running = true;
+        try {
+            return await job(controller.signal);
+        }
+        finally {
+            running = false;
+        }
+    }, { aborted: () => controller.signal.aborted });
+    return runner;
+}

package/lib/subscription-send.d.ts

@@ -4,6 +4,8 @@ export interface SubscriptionTarget {
     channelId?: string;
     guildId?: string;
     userId?: string;
+    selfId?: string;
 }
-export declare function sendScheduledMessage(ctx: Context, target: SubscriptionTarget, message: any): Promise<boolean>;
-export declare function sendScheduledImageWithFallback(ctx: Context, target: SubscriptionTarget, image: Buffer | null, fallbackText: string, mentionAll?: boolean): Promise<boolean>;
+export declare function sentMessageIds(value: unknown): boolean;
+export declare function sendScheduledMessage(ctx: Context, target: SubscriptionTarget, message: any, signal?: AbortSignal): Promise<boolean>;
+export declare function sendScheduledImageWithFallback(ctx: Context, target: SubscriptionTarget, image: Buffer | Buffer[] | null, fallbackText: string, mentionAll?: boolean, signal?: AbortSignal): Promise<boolean>;

package/lib/subscription-send.js

@@ -1,22 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sentMessageIds = sentMessageIds;
 exports.sendScheduledMessage = sendScheduledMessage;
 exports.sendScheduledImageWithFallback = sendScheduledImageWithFallback;
 const koishi_1 = require("koishi");
 const send_image_1 = require("./send-image");
 const logger = new koishi_1.Logger('rocom-subscription-send');
-function findBot(ctx, platform = '') {
+function findBot(ctx, platform = '', selfId = '') {
     if (!ctx.bots?.length)
         return null;
-    if (!platform)
-        return ctx.bots[0];
-    return ctx.bots.find((bot) => bot.platform === platform) || ctx.bots[0];
+    if (selfId) {
+        const exact = ctx.bots.find((bot) => String(bot.selfId) === String(selfId)
+            && (!platform || bot.platform === platform));
+        return exact || null;
+    }
+    const candidates = platform ? ctx.bots.filter((bot) => bot.platform === platform) : ctx.bots;
+    if (!candidates.length)
+        return null;
+    // 缺少 self_id 的旧订阅只在对应平台恰有一个 Bot 时兼容，避免误发其他 Bot。
+    if (candidates.length > 1) {
+        logger.warn(`平台 ${platform || '(unknown)'} 存在多个 Bot 且订阅缺少 self_id，跳过发送`);
+        return null;
+    }
+    return candidates[0];
+}
+function sentMessageIds(value) {
+    return Array.isArray(value) && value.some(id => typeof id === 'string' && id.trim().length > 0);
 }
-async function sendScheduledMessage(ctx, target, message) {
+async function sendScheduledMessage(ctx, target, message, signal) {
+    if (signal?.aborted)
+        return false;
     const platform = target.platform || '';
     const channelId = target.channelId || target.guildId || '';
     const userId = target.userId || '';
-    const bot = findBot(ctx, platform);
+    const bot = findBot(ctx, platform, target.selfId);
     if (!bot) {
         logger.warn('no available bot, skip scheduled push');
         return false;
@@ -24,21 +41,14 @@ async function sendScheduledMessage(ctx, target, message) {
     try {
         if (userId && !target.guildId) {
             if (typeof bot.sendPrivateMessage === 'function') {
-                await bot.sendPrivateMessage(userId, message);
-                return true;
+                return sentMessageIds(await bot.sendPrivateMessage(userId, message)) && !signal?.aborted;
             }
             if (typeof bot.sendMessage === 'function') {
-                await bot.sendMessage(userId, message);
-                return true;
+                return sentMessageIds(await bot.sendMessage(userId, message)) && !signal?.aborted;
             }
         }
-        if (platform && channelId) {
-            await ctx.broadcast([`${platform}:${channelId}`], message);
-            return true;
-        }
         if (channelId && typeof bot.sendMessage === 'function') {
-            await bot.sendMessage(channelId, message, target.guildId);
-            return true;
+            return sentMessageIds(await bot.sendMessage(channelId, message, target.guildId || undefined)) && !signal?.aborted;
         }
     }
     catch (err) {
@@ -48,14 +58,29 @@ async function sendScheduledMessage(ctx, target, message) {
     logger.warn(`scheduled push target is incomplete: ${JSON.stringify(target)}`);
     return false;
 }
-async function sendScheduledImageWithFallback(ctx, target, image, fallbackText, mentionAll = false) {
+async function sendScheduledImageWithFallback(ctx, target, image, fallbackText, mentionAll = false, signal) {
+    if (signal?.aborted)
+        return false;
+    if (Array.isArray(image)) {
+        if (!image.length)
+            return sendScheduledImageWithFallback(ctx, target, null, fallbackText, mentionAll, signal);
+        for (let i = 0; i < image.length; i++) {
+            const segment = koishi_1.h.image(image[i], (0, send_image_1.detectImageMime)(image[i]));
+            const content = mentionAll && i === 0 ? (0, koishi_1.h)('message', {}, (0, koishi_1.h)('at', { type: 'all' }), segment) : segment;
+            if (!await sendScheduledMessage(ctx, target, content, signal)) {
+                // One complete text fallback replaces the remaining image pages.
+                return sendScheduledMessage(ctx, target, koishi_1.h.text(fallbackText), signal);
+            }
+        }
+        return true;
+    }
     const buildContent = (body) => mentionAll ? (0, koishi_1.h)('message', {}, (0, koishi_1.h)('at', { type: 'all' }), koishi_1.h.text('\n'), body) : body;
     if (!image) {
-        return sendScheduledMessage(ctx, target, buildContent(koishi_1.h.text(fallbackText)));
+        return sendScheduledMessage(ctx, target, buildContent(koishi_1.h.text(fallbackText)), signal);
     }
     const imageSegment = koishi_1.h.image(image, (0, send_image_1.detectImageMime)(image));
-    const sent = await sendScheduledMessage(ctx, target, buildContent(imageSegment));
+    const sent = await sendScheduledMessage(ctx, target, buildContent(imageSegment), signal);
     if (sent)
         return true;
-    return sendScheduledMessage(ctx, target, buildContent(koishi_1.h.text(fallbackText)));
+    return sendScheduledMessage(ctx, target, buildContent(koishi_1.h.text(fallbackText)), signal);
 }