koishi-plugin-rocom 1.0.18 → 1.0.24

package/lib/render.d.ts

@@ -1,11 +1,27 @@
 import { Context } from 'koishi';
+export type ImageFormat = 'jpeg' | 'png' | 'webp';
+export declare function normalizeImageFormat(format: unknown): ImageFormat;
+export interface RenderOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    imageWaitMs?: number;
+    fontWaitMs?: number;
+    deviceScaleFactor?: number;
+    imageFormat?: ImageFormat;
+    jpegQuality?: number;
+    maxPageHeight?: number;
+}
+export declare const lowBandwidthRenderOptions: RenderOptions;
 export declare class Renderer {
     private resPath;
-    constructor(resPath: string);
+    private defaults;
+    constructor(resPath: string, defaults?: RenderOptions);
     resourceUrl(relativePath: string): string;
     private getPreferredResourceRoot;
     private getTemplateCandidateRoots;
     private resolveTemplatePath;
     private getStylePath;
-    renderHtml(ctx: Context, templateName: string, data: any): Promise<Buffer | null>;
+    renderHtml(ctx: Context, templateName: string, data: any, options?: RenderOptions): Promise<Buffer | null>;
+    renderPages(ctx: Context, templateName: string, data: any, options?: RenderOptions): Promise<Buffer[] | null>;
+    private capture;
 }

package/lib/render.js

@@ -36,22 +36,28 @@ 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;
+exports.normalizeImageFormat = normalizeImageFormat;
 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 },
 };
 const TEMPLATE_VIEWPORTS = {
     activities: { width: 1600, height: 1200, deviceScaleFactor: 2 },
+    // 商人卡片模板按原生尺寸渲染：视口 960 + deviceScaleFactor 4 → 3840 物理像素输出
+    'yuanxing-shangren/merchant': { width: 960, height: 1600, deviceScaleFactor: 4 },
+    'yuanxing-shangren/today': { width: 960, height: 1600, deviceScaleFactor: 4 },
 };
 const VISUAL_BOUNDS_TEMPLATES = new Set([
     'home',
+    'home-pets',
     'yuanxing-shangren/merchant',
     'yuanxing-shangren/today',
 ]);
@@ -59,6 +65,19 @@ const DEFAULT_SCREENSHOT_OPTIONS = {
     type: 'jpeg',
     quality: 82,
 };
+const IMAGE_FORMATS = new Set(['jpeg', 'png', 'webp']);
+function normalizeImageFormat(format) {
+    return typeof format === 'string' && IMAGE_FORMATS.has(format) ? format : 'jpeg';
+}
+// 家园详情低带宽建议初值，需用真实截图校准。
+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 +87,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 +128,62 @@ 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 imageFormat = normalizeImageFormat(options.imageFormat ?? DEFAULT_SCREENSHOT_OPTIONS.type);
+        // quality 仅对有损格式（jpeg/webp）有意义，png 截图忽略该参数
+        const screenshotOptions = imageFormat === 'png'
+            ? { type: imageFormat }
+            : { type: imageFormat, quality: jpegQuality };
+        const remainingMs = () => { options.signal?.throwIfAborted(); return Math.max(1, deadline - Date.now()); };
         try {
             const resolvedTemplate = this.resolveTemplatePath(templateName);
             if (!resolvedTemplate) {
@@ -125,27 +201,35 @@ 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([
                             Promise.all(images.map((img) => {
                                 if (img.complete)
@@ -155,18 +239,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',
@@ -190,9 +278,16 @@ class Renderer {
                     '.merchant-page',
                     '.page',
                     '.home-page',
+                    '.home-pets-page',
                     '.pet-panel-page',
                     '.pet-detail-page',
                     '.activity-calendar-page',
+                    '.pet-ranking-page',
+                    '.share-code-page',
+                    '.share-page',
+                    '.pet-page',
+                    '.announcement-list-page',
+                    '.announcement-detail-page',
                 ];
                 let target = null;
                 for (const selector of selectors) {
@@ -220,12 +315,12 @@ 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 修复）。
+                        // 否则 clip 会带着旧偏移导致画面左侧被截断。
                         try {
                             const remeasured = await page.evaluate((el, visualBounds) => {
                                 const rect = el.getBoundingClientRect();
@@ -247,30 +342,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 +371,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

@@ -11,6 +11,8 @@ const node_zlib_1 = __importDefault(require("node:zlib"));
 const logger = new koishi_1.Logger('rocom-send');
 const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
 const JPEG_SIGNATURE = Buffer.from([0xff, 0xd8, 0xff]);
+const WEBP_RIFF_SIGNATURE = Buffer.from('RIFF', 'ascii');
+const WEBP_MARK = Buffer.from('WEBP', 'ascii');
 function formatSessionContext(session) {
     if (!session)
         return 'session=<null>';
@@ -53,11 +55,19 @@ function isPng(buffer) {
 function isJpeg(buffer) {
     return buffer.length > JPEG_SIGNATURE.length && buffer.subarray(0, JPEG_SIGNATURE.length).equals(JPEG_SIGNATURE);
 }
+function isWebp(buffer) {
+    // WebP: "RIFF"<4 字节长度>"WEBP"
+    return buffer.length >= 12
+        && buffer.subarray(0, 4).equals(WEBP_RIFF_SIGNATURE)
+        && buffer.subarray(8, 12).equals(WEBP_MARK);
+}
 function detectImageMime(image) {
     if (isPng(image))
         return 'image/png';
     if (isJpeg(image))
         return 'image/jpeg';
+    if (isWebp(image))
+        return 'image/webp';
     return 'image/png';
 }
 function compressPngImage(image, config) {
@@ -114,6 +124,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 +152,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,68 @@
+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;
+export interface ShareCodeClassicAssets {
+    frame: string;
+    logo: string;
+    rocoIcon: string;
+    star: string;
+    wax: string;
+    typeIcon: (name: string) => string;
+    bloodIcon: (element: string) => string;
+}
+export interface ClassicNatureInfo {
+    name?: string;
+    up?: string;
+    down?: string;
+    summary?: string;
+}
+export declare function parseNaturePair(summary: unknown): {
+    up: string;
+    down: string;
+};
+export declare function buildShareCodeClassicView(view: any, assets: ShareCodeClassicAssets, natureLookup?: (id: string) => ClassicNatureInfo): {
+    team: {
+        mode_name: any;
+        share_code: any;
+        sprite_count: any;
+        count_label: string;
+        magic_icon: any;
+        teams: any;
+    };
+    shareAssets: {
+        frame: string;
+        logo: string;
+        rocoIcon: string;
+        star: string;
+        wax: string;
+    };
+};