koishi-plugin-rocom 1.0.1

package/lib/render.d.ts

@@ -0,0 +1,11 @@
+import { Context } from 'koishi';
+export declare class Renderer {
+    private resPath;
+    constructor(resPath: string);
+    resourceUrl(relativePath: string): string;
+    private getResourceRoot;
+    private getTemplateRoot;
+    private getTemplatePath;
+    private getStylePath;
+    renderHtml(ctx: Context, templateName: string, data: any): Promise<Buffer | null>;
+}

package/lib/render.js

@@ -0,0 +1,226 @@
+"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.Renderer = 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 logger = new koishi_1.Logger('rocom-render');
+const TEMPLATE_CAPTURE_PADDING = {
+    package: { left: 0, right: 0, top: 0, bottom: 0 },
+};
+function toDirectoryFileUrl(dirPath) {
+    const href = (0, node_url_1.pathToFileURL)(dirPath).href;
+    return href.endsWith('/') ? href : `${href}/`;
+}
+function normalizeTemplateResourcePaths(content) {
+    return content.replace(/\{\{(_res_path|pluResPath)\}\}render\//g, '{{$1}}render-templates/');
+}
+class Renderer {
+    resPath;
+    constructor(resPath) {
+        this.resPath = resPath;
+    }
+    resourceUrl(relativePath) {
+        return (0, node_url_1.pathToFileURL)(node_path_1.default.join(this.getResourceRoot(), relativePath)).href;
+    }
+    getResourceRoot() {
+        const builtRoot = node_path_1.default.join(this.resPath, 'lib');
+        if (node_fs_1.default.existsSync(node_path_1.default.join(builtRoot, 'render-templates')))
+            return builtRoot;
+        return node_path_1.default.join(this.resPath, 'src');
+    }
+    getTemplateRoot() {
+        return node_path_1.default.join(this.getResourceRoot(), 'render-templates');
+    }
+    getTemplatePath(templateName) {
+        const directHtmlPath = node_path_1.default.join(this.getTemplateRoot(), `${templateName}.html`);
+        if (node_fs_1.default.existsSync(directHtmlPath))
+            return directHtmlPath;
+        return node_path_1.default.join(this.getTemplateRoot(), templateName, 'index.html');
+    }
+    getStylePath(templateName) {
+        return node_path_1.default.join(this.getTemplateRoot(), templateName, 'style.css');
+    }
+    async renderHtml(ctx, templateName, data) {
+        try {
+            const templatePath = this.getTemplatePath(templateName);
+            if (!node_fs_1.default.existsSync(templatePath)) {
+                logger.error(`template file missing: ${templatePath}`);
+                return null;
+            }
+            const templateContent = node_fs_1.default.readFileSync(templatePath, 'utf-8');
+            const normalizedTemplateContent = normalizeTemplateResourcePaths(templateContent);
+            const resPathUrl = toDirectoryFileUrl(this.getResourceRoot());
+            const renderData = { ...data, _res_path: resPathUrl, pluResPath: resPathUrl };
+            const html = template.render(normalizedTemplateContent, renderData);
+            if (!ctx.puppeteer?.page) {
+                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`);
+            try {
+                await page.setCacheEnabled(false);
+                node_fs_1.default.writeFileSync(tempHtmlPath, html, 'utf-8');
+                await page.setViewport({ width: 1280, height: 768, deviceScaleFactor: 2 });
+                try {
+                    await page.goto((0, node_url_1.pathToFileURL)(tempHtmlPath).href, {
+                        waitUntil: 'networkidle0',
+                        timeout: 15000,
+                    });
+                }
+                catch (err) {
+                    logger.warn(`page.goto failed for ${templateName}: ${err}`);
+                }
+                try {
+                    await page.evaluate(async () => {
+                        const images = Array.from(document.images);
+                        await Promise.all(images.map((img) => {
+                            if (img.complete)
+                                return Promise.resolve();
+                            return new Promise((resolve) => {
+                                img.onload = () => resolve();
+                                img.onerror = () => resolve();
+                            });
+                        }));
+                        const fonts = document.fonts;
+                        if (fonts?.ready) {
+                            await fonts.ready;
+                        }
+                    });
+                }
+                catch (err) {
+                    logger.warn(`asset wait failed for ${templateName}: ${err}`);
+                }
+                await new Promise(resolve => setTimeout(resolve, 300));
+                const selectors = [
+                    '.exchange-page',
+                    '.record-page',
+                    '.package-cont',
+                    '.searcheggs-cont',
+                    '.bwiki-shell',
+                    '.skill-shell',
+                    '.lineup-page',
+                    '.lineup-detail-page',
+                    '.page-section-main',
+                    '.stats-cont',
+                    '.inspect-page',
+                    '.player-search-page',
+                    '.ingame-shop-page',
+                    '.friendship-page',
+                    '.student-state-page',
+                    '.student-perks-page',
+                    '.student-page',
+                    '.home-page',
+                ];
+                let target = null;
+                for (const selector of selectors) {
+                    target = await page.$(selector);
+                    if (target)
+                        break;
+                }
+                if (!target) {
+                    target = await page.$('body');
+                }
+                if (target) {
+                    const box = await target.boundingBox();
+                    if (box && box.width > 0 && box.height > 0) {
+                        const elementMetrics = await page.evaluate((el) => {
+                            const rect = el.getBoundingClientRect();
+                            const element = el;
+                            return {
+                                x: rect.left + window.scrollX,
+                                y: rect.top + window.scrollY,
+                                width: Math.max(rect.width, element.scrollWidth, element.offsetWidth),
+                                height: Math.max(rect.height, element.scrollHeight, element.offsetHeight),
+                            };
+                        }, target);
+                        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),
+                            deviceScaleFactor: 2,
+                        });
+                        await new Promise(resolve => setTimeout(resolve, 100));
+                        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({
+                                type: 'png',
+                                clip: {
+                                    x: clipX,
+                                    y: clipY,
+                                    width: clipWidth,
+                                    height: clipHeight,
+                                },
+                            });
+                            return Buffer.isBuffer(screenshot) ? screenshot : Buffer.from(screenshot);
+                        }
+                    }
+                    const screenshot = await target.screenshot({ type: 'png' });
+                    return Buffer.isBuffer(screenshot) ? screenshot : Buffer.from(screenshot);
+                }
+                const screenshot = await page.screenshot({ fullPage: true });
+                return Buffer.isBuffer(screenshot) ? screenshot : Buffer.from(screenshot);
+            }
+            finally {
+                try {
+                    await page.close();
+                }
+                catch {
+                    // ignore
+                }
+                node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+            }
+        }
+        catch (e) {
+            logger.error(`render failed: ${e}`);
+            return null;
+        }
+    }
+}
+exports.Renderer = Renderer;

package/lib/role-token.d.ts

@@ -0,0 +1,27 @@
+import { Context } from 'koishi';
+import { UserManager } from './user';
+export interface RoleToken {
+    UserId: string;
+    fwt: string;
+    bindingId: string;
+    roleId: string;
+    loginType: string;
+    updatedAt: Date;
+}
+declare module 'koishi' {
+    interface Tables {
+        roleToken: RoleToken;
+    }
+}
+export declare function setupRoleTokenModel(ctx: Context): void;
+export declare function upsertRoleToken(ctx: Context, payload: {
+    userId: string;
+    fwt: string;
+    bindingId?: string;
+    roleId?: string;
+    loginType?: string;
+}): Promise<void>;
+export declare function getRoleToken(ctx: Context, userId: string): Promise<RoleToken | null>;
+export declare function removeRoleToken(ctx: Context, userId: string): Promise<void>;
+export declare function migrateRoleTokensToUserId(ctx: Context): Promise<number>;
+export declare function migrateLegacyFrameworkTokens(ctx: Context, userMgr: UserManager): Promise<number>;

package/lib/role-token.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupRoleTokenModel = setupRoleTokenModel;
+exports.upsertRoleToken = upsertRoleToken;
+exports.getRoleToken = getRoleToken;
+exports.removeRoleToken = removeRoleToken;
+exports.migrateRoleTokensToUserId = migrateRoleTokensToUserId;
+exports.migrateLegacyFrameworkTokens = migrateLegacyFrameworkTokens;
+function normalize(value) {
+    return String(value ?? '').trim();
+}
+function pickLatest(rows) {
+    if (!rows.length)
+        return null;
+    return [...rows].sort((a, b) => {
+        const aTime = new Date(a.updatedAt).getTime() || 0;
+        const bTime = new Date(b.updatedAt).getTime() || 0;
+        return bTime - aTime;
+    })[0] ?? null;
+}
+function pickLegacyToken(binding) {
+    return normalize(binding.framework_token);
+}
+function setupRoleTokenModel(ctx) {
+    ;
+    ctx.model.extend('roleToken', {
+        UserId: 'string',
+        fwt: 'string',
+        bindingId: 'string',
+        roleId: 'string',
+        loginType: 'string',
+        updatedAt: 'timestamp',
+    }, {
+        primary: 'UserId',
+        indexes: ['bindingId'],
+    });
+}
+async function upsertRoleToken(ctx, payload) {
+    const userId = normalize(payload.userId);
+    const fwt = normalize(payload.fwt);
+    if (!userId || !fwt)
+        return;
+    await ctx.database.remove('roleToken', { UserId: userId });
+    await ctx.database.upsert('roleToken', () => [{
+            UserId: userId,
+            fwt,
+            bindingId: normalize(payload.bindingId),
+            roleId: normalize(payload.roleId),
+            loginType: normalize(payload.loginType),
+            updatedAt: new Date(),
+        }], 'UserId');
+}
+async function getRoleToken(ctx, userId) {
+    const normalizedUserId = normalize(userId);
+    if (!normalizedUserId)
+        return null;
+    const rows = await ctx.database.get('roleToken', { UserId: normalizedUserId });
+    if (!Array.isArray(rows) || !rows.length)
+        return null;
+    return pickLatest(rows);
+}
+async function removeRoleToken(ctx, userId) {
+    const normalizedUserId = normalize(userId);
+    if (!normalizedUserId)
+        return;
+    await ctx.database.remove('roleToken', { UserId: normalizedUserId });
+}
+async function migrateRoleTokensToUserId(ctx) {
+    const rows = await ctx.database.get('roleToken', {});
+    if (!Array.isArray(rows) || !rows.length)
+        return 0;
+    const groups = new Map();
+    for (const row of rows) {
+        const userId = normalize(row?.UserId);
+        if (!userId)
+            continue;
+        const bucket = groups.get(userId) || [];
+        bucket.push(row);
+        groups.set(userId, bucket);
+    }
+    let migrated = 0;
+    for (const [userId, items] of groups) {
+        if (items.length <= 1)
+            continue;
+        const latest = pickLatest(items);
+        if (!latest?.fwt)
+            continue;
+        await removeRoleToken(ctx, userId);
+        await upsertRoleToken(ctx, {
+            userId,
+            fwt: latest.fwt,
+            bindingId: latest.bindingId,
+            roleId: latest.roleId,
+            loginType: latest.loginType,
+        });
+        migrated++;
+    }
+    return migrated;
+}
+async function migrateLegacyFrameworkTokens(ctx, userMgr) {
+    const allUsers = userMgr.getAllUsersBindings();
+    let migrated = 0;
+    for (const [userId, bindings] of Object.entries(allUsers)) {
+        const normalizedUserId = normalize(userId);
+        if (!normalizedUserId)
+            continue;
+        const existing = await getRoleToken(ctx, normalizedUserId);
+        const bindingsWithToken = bindings.filter(binding => pickLegacyToken(binding));
+        const chosen = bindingsWithToken.find(binding => binding.is_primary) || bindingsWithToken[0];
+        if (!existing?.fwt && chosen) {
+            const legacyToken = pickLegacyToken(chosen);
+            if (legacyToken) {
+                await upsertRoleToken(ctx, {
+                    userId: normalizedUserId,
+                    fwt: legacyToken,
+                    bindingId: chosen.binding_id,
+                    roleId: chosen.role_id,
+                    loginType: chosen.login_type,
+                });
+                migrated++;
+            }
+        }
+        if (bindingsWithToken.length > 0) {
+            let needsSave = false;
+            for (const binding of bindings) {
+                if (!binding.framework_token)
+                    continue;
+                delete binding.framework_token;
+                needsSave = true;
+            }
+            if (needsSave) {
+                userMgr.saveUserBindings(normalizedUserId, bindings);
+            }
+        }
+    }
+    return migrated;
+}

package/lib/send-image.d.ts

@@ -0,0 +1,3 @@
+import { PluginConfig } from './types';
+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>;

package/lib/send-image.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressPngImage = compressPngImage;
+exports.sendImageWithFallback = sendImageWithFallback;
+const koishi_1 = require("koishi");
+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]);
+function formatSessionContext(session) {
+    if (!session)
+        return 'session=<null>';
+    const platform = session.platform ?? 'unknown';
+    const userId = session.userId ?? 'unknown';
+    const guildId = session.guildId ?? 'private';
+    const channelId = session.channelId ?? 'unknown';
+    return `platform=${platform} user=${userId} guild=${guildId} channel=${channelId}`;
+}
+function hasSendResult(result) {
+    if (result == null)
+        return false;
+    if (typeof result === 'string')
+        return result.length > 0;
+    if (Array.isArray(result))
+        return result.length > 0;
+    return true;
+}
+function crc32(buffer) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < buffer.length; i++) {
+        crc ^= buffer[i];
+        for (let bit = 0; bit < 8; bit++) {
+            crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function pngChunk(type, data) {
+    const typeBuffer = Buffer.from(type, 'ascii');
+    const lengthBuffer = Buffer.allocUnsafe(4);
+    lengthBuffer.writeUInt32BE(data.length, 0);
+    const crcBuffer = Buffer.allocUnsafe(4);
+    crcBuffer.writeUInt32BE(crc32(Buffer.concat([typeBuffer, data])), 0);
+    return Buffer.concat([lengthBuffer, typeBuffer, data, crcBuffer]);
+}
+function isPng(buffer) {
+    return buffer.length > PNG_SIGNATURE.length && buffer.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE);
+}
+function compressPngImage(image, config) {
+    if (!config.imageCompressionEnabled)
+        return image;
+    if (!isPng(image))
+        return image;
+    if (image.length < Math.max(0, config.imageCompressionMinBytes || 0))
+        return image;
+    try {
+        const chunks = [];
+        const idatChunks = [];
+        let offset = PNG_SIGNATURE.length;
+        while (offset + 12 <= image.length) {
+            const length = image.readUInt32BE(offset);
+            const type = image.subarray(offset + 4, offset + 8).toString('ascii');
+            const dataStart = offset + 8;
+            const dataEnd = dataStart + length;
+            const nextOffset = dataEnd + 4;
+            if (dataEnd > image.length || nextOffset > image.length)
+                return image;
+            const data = image.subarray(dataStart, dataEnd);
+            chunks.push({ type, data });
+            if (type === 'IDAT')
+                idatChunks.push(data);
+            offset = nextOffset;
+            if (type === 'IEND')
+                break;
+        }
+        if (!idatChunks.length)
+            return image;
+        const rawImageData = node_zlib_1.default.inflateSync(Buffer.concat(idatChunks));
+        const level = Math.max(0, Math.min(9, Math.floor(config.imageCompressionLevel ?? 9)));
+        const compressedIdat = node_zlib_1.default.deflateSync(rawImageData, { level });
+        const rebuiltChunks = [];
+        let wroteIdat = false;
+        for (const chunk of chunks) {
+            if (chunk.type === 'IDAT') {
+                if (!wroteIdat) {
+                    rebuiltChunks.push(pngChunk('IDAT', compressedIdat));
+                    wroteIdat = true;
+                }
+                continue;
+            }
+            rebuiltChunks.push(pngChunk(chunk.type, chunk.data));
+        }
+        const compressed = Buffer.concat([PNG_SIGNATURE, ...rebuiltChunks]);
+        if (compressed.length < image.length)
+            return compressed;
+    }
+    catch (err) {
+        logger.warn(`PNG compression failed, sending original image: ${err}`);
+    }
+    return image;
+}
+async function sendImageWithFallback(session, image, fallbackText, scene, compressionConfig) {
+    const ctxInfo = formatSessionContext(session);
+    if (!image) {
+        logger.warn(`[${scene}] render returned empty image, fallback to text | ${ctxInfo}`);
+        try {
+            await session.send(fallbackText);
+        }
+        catch (e) {
+            logger.error(`[${scene}] text fallback send failed | ${ctxInfo} | ${e}`);
+        }
+        return;
+    }
+    const outputImage = compressionConfig ? compressPngImage(image, compressionConfig) : image;
+    if (outputImage.length < image.length) {
+        logger.info(`[${scene}] compressed image ${image.length}B -> ${outputImage.length}B | ${ctxInfo}`);
+    }
+    try {
+        const result = await session.send(koishi_1.h.image(outputImage, 'image/png'));
+        if (!hasSendResult(result)) {
+            logger.warn(`[${scene}] image send returned empty result | size=${outputImage.length}B | ${ctxInfo}`);
+        }
+    }
+    catch (e) {
+        logger.error(`[${scene}] image send failed | size=${outputImage.length}B | ${ctxInfo} | ${e}`);
+        try {
+            await session.send(fallbackText);
+        }
+        catch (fallbackErr) {
+            logger.error(`[${scene}] text fallback send failed after image send error | ${ctxInfo} | ${fallbackErr}`);
+        }
+    }
+}

package/lib/subscription-send.d.ts

@@ -0,0 +1,8 @@
+import { Context } from 'koishi';
+export interface SubscriptionTarget {
+    platform?: string;
+    channelId?: string;
+    guildId?: string;
+    userId?: string;
+}
+export declare function sendScheduledMessage(ctx: Context, target: SubscriptionTarget, message: string): Promise<boolean>;

package/lib/subscription-send.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendScheduledMessage = sendScheduledMessage;
+const koishi_1 = require("koishi");
+const logger = new koishi_1.Logger('rocom-subscription-send');
+function findBot(ctx, platform = '') {
+    if (!ctx.bots?.length)
+        return null;
+    if (!platform)
+        return ctx.bots[0];
+    return ctx.bots.find((bot) => bot.platform === platform) || ctx.bots[0];
+}
+async function sendScheduledMessage(ctx, target, message) {
+    const platform = target.platform || '';
+    const channelId = target.channelId || target.guildId || '';
+    const userId = target.userId || '';
+    const bot = findBot(ctx, platform);
+    if (!bot) {
+        logger.warn('no available bot, skip scheduled push');
+        return false;
+    }
+    try {
+        if (userId && !target.guildId) {
+            if (typeof bot.sendPrivateMessage === 'function') {
+                await bot.sendPrivateMessage(userId, message);
+                return true;
+            }
+            if (typeof bot.sendMessage === 'function') {
+                await bot.sendMessage(userId, message);
+                return true;
+            }
+        }
+        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;
+        }
+    }
+    catch (err) {
+        logger.warn(`scheduled push failed: ${err}`);
+        return false;
+    }
+    logger.warn(`scheduled push target is incomplete: ${JSON.stringify(target)}`);
+    return false;
+}

package/lib/types.d.ts

@@ -0,0 +1,32 @@
+import { Context } from 'koishi';
+import { RocomClient } from './client';
+import { UserManager, MerchantSubscriptionManager, HomeSubscriptionManager } from './user';
+import { EggService } from './egg-service';
+import { Renderer } from './render';
+export interface PluginConfig {
+    apiBaseUrl: string;
+    wegameApiKey: string;
+    qqLoginDebugMode: boolean;
+    adminUserIds: string[];
+    autoRefreshEnabled: boolean;
+    autoRefreshTime: string[];
+    merchantSubscriptionEnabled: boolean;
+    merchantSubscriptionItems: string[];
+    merchantPrivateSubscriptionEnabled: boolean;
+    merchantCheckInterval: number;
+    homeSubscriptionEnabled: boolean;
+    homeSubscriptionIntervalMinutes: number;
+    imageCompressionEnabled: boolean;
+    imageCompressionMinBytes: number;
+    imageCompressionLevel: number;
+}
+export interface PluginDeps {
+    ctx: Context;
+    config: PluginConfig;
+    client: RocomClient;
+    userMgr: UserManager;
+    merchantSubMgr: MerchantSubscriptionManager;
+    homeSubMgr: HomeSubscriptionManager;
+    eggService: EggService;
+    renderer: Renderer;
+}

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });