koishi-plugin-emojiluna-plus 0.0.1

package/lib/adapters/consoleListeners.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyConsoleListeners = applyConsoleListeners;
+const path_1 = __importDefault(require("path"));
+const DIRECT_EVENTS = {
+    'emojiluna/getEmojiList': 'getEmojiList',
+    'emojiluna/getEmojiPage': 'getEmojiPage',
+    'emojiluna/searchEmoji': 'searchEmoji',
+    'emojiluna/getCategories': 'getCategories',
+    'emojiluna/getCategoriesPage': 'getCategoriesPage',
+    'emojiluna/getAllTags': 'getAllTags',
+    'emojiluna/getTagsPage': 'getTagsPage',
+    'emojiluna/updateEmojiName': 'updateEmojiName',
+    'emojiluna/updateEmojiTags': 'updateEmojiTags',
+    'emojiluna/updateEmojiCategory': 'updateEmojiCategory',
+    'emojiluna/deleteEmoji': 'deleteEmoji',
+    'emojiluna/addCategory': 'addCategory',
+    'emojiluna/deleteCategory': 'deleteCategory',
+    'emojiluna/cleanupEmptyCategories': 'cleanupEmptyCategories',
+    'emojiluna/cleanupEmptyTags': 'cleanupEmptyTags',
+    'emojiluna/getAiTaskStats': 'getAiTaskStats',
+    'emojiluna/getFailedAiEmojiIds': 'getFailedAiEmojiIds',
+    'emojiluna/retryFailedTasks': 'retryFailedTasks',
+    'emojiluna/getAiTasksAll': 'getAiTasksAll',
+    'emojiluna/setAiPaused': 'setAiPaused',
+    'emojiluna/reanalyzeBatch': 'reanalyzeBatch',
+    'emojiluna/deleteAiTask': 'deleteAiTask',
+    'emojiluna/retryAiTask': 'retryAiTask',
+};
+const MAX_REQUESTED_EMOJI_NAME = 64;
+function applyConsoleListeners(ctx, config) {
+    ctx.inject(['console', 'emojiluna'], (ctx) => {
+        void registerListeners(ctx, config);
+    });
+}
+async function registerListeners(ctx, config) {
+    const emojiluna = ctx.emojiluna;
+    const invoke = emojiluna;
+    await emojiluna.ready;
+    ctx.console.addEntry({
+        dev: path_1.default.resolve(__dirname, '../../client/index.ts'),
+        prod: path_1.default.resolve(__dirname, '../dist'),
+    });
+    for (const [event, method] of Object.entries(DIRECT_EVENTS)) {
+        ctx.console.addListener(event, invoke[method]);
+    }
+    ctx.console.addListener('emojiluna/getBaseUrl', async () => {
+        const selfUrl = config.selfUrl || ctx.server?.selfUrl || '';
+        return selfUrl ? `${selfUrl.replace(/\/+$/, '')}${config.backendPath}` : '';
+    });
+    ctx.console.addListener('emojiluna/getUploadToken', async () => {
+        return emojiluna.uploadToken;
+    });
+    ctx.console.addListener('emojiluna/getEmojiCount', async (options) => {
+        const list = await emojiluna.getEmojiList(options ?? {});
+        return list.length;
+    });
+    ctx.console.addListener('emojiluna/addEmoji', async (emojiData) => {
+        const buffer = decodeImagePayload(emojiData);
+        return await emojiluna.addEmoji({
+            name: normalizeName(emojiData.name),
+            category: emojiData.category || config.autoCollectCategory,
+            tags: emojiData.tags ?? [],
+        }, buffer);
+    });
+    ctx.console.addListener('emojiluna/addEmojis', async (emojis, aiAnalysis) => {
+        if (!Array.isArray(emojis) || !emojis.length) {
+            throw new Error('表情包数据数组为必填项');
+        }
+        const payloads = emojis.map((item) => ({
+            options: {
+                name: normalizeName(item.name),
+                category: item.category || config.autoCollectCategory,
+                tags: item.tags ?? [],
+            },
+            buffer: decodeImagePayload(item),
+        }));
+        return await emojiluna.addEmojis(payloads, aiAnalysis);
+    });
+    ctx.console.addListener('emojiluna/analyzeEmoji', async (id) => {
+        const emoji = await emojiluna.getEmojiById(id);
+        if (!emoji)
+            throw new Error('表情包不存在');
+        const imageBuffer = await emojiluna.readEmojiBuffer(emoji);
+        if (!imageBuffer)
+            throw new Error('表情包文件读取失败');
+        const result = await emojiluna.analyzeEmoji(imageBuffer.toString('base64'));
+        if (!result)
+            return { success: false, message: 'AI分析未返回结果，请检查模型或开启 debug' };
+        const oldData = {
+            name: emoji.name,
+            category: emoji.category,
+            tags: [...emoji.tags],
+        };
+        const updates = [];
+        const nextTags = normalizeTags(result.tags, emoji.tags);
+        if (result.category && result.category !== emoji.category) {
+            await emojiluna.updateEmojiCategory(id, result.category);
+            updates.push(`分类: ${emoji.category} → ${result.category}`);
+        }
+        if (nextTags.join(',') !== oldData.tags.join(',')) {
+            await emojiluna.updateEmojiTags(id, nextTags);
+            updates.push(`标签: [${oldData.tags.join(', ')}] → [${nextTags.join(', ')}]`);
+        }
+        emojiluna.debug.log('ai', `手动分析 ${id} 完成`, { updates, result });
+        return {
+            success: true,
+            updates,
+            result,
+            oldData,
+            newData: {
+                name: result.name,
+                category: result.category,
+                tags: nextTags,
+                description: result.description,
+            },
+        };
+    });
+    ctx.console.addListener('emojiluna/scanFolder', async (folderPath) => {
+        assertFolderAllowed(ctx, config, folderPath);
+        return await emojiluna.scanFolder(folderPath);
+    });
+    ctx.console.addListener('emojiluna/importFromFolder', async (options) => {
+        assertFolderAllowed(ctx, config, options?.folderPath);
+        emojiluna.debug.log('service', `控制台导入目录 ${options?.folderPath}`, options);
+        return await emojiluna.importFromFolder(options);
+    });
+}
+function normalizeName(name) {
+    const value = (name ?? '').trim();
+    if (!value)
+        throw new Error('表情包名称为必填项');
+    return value.slice(0, MAX_REQUESTED_EMOJI_NAME);
+}
+function normalizeTags(next, current) {
+    const merged = [...new Set([...(current ?? []), ...(next ?? [])])];
+    return merged.map((tag) => tag.trim()).filter(Boolean);
+}
+function decodeImagePayload(emojiData) {
+    if (!emojiData?.imageData) {
+        throw new Error('图片数据为必填项');
+    }
+    const buffer = Buffer.from(emojiData.imageData, 'base64');
+    if (!buffer.length)
+        throw new Error('图片数据为空或不是合法的 base64');
+    return buffer;
+}
+function assertFolderAllowed(ctx, config, folderPath) {
+    if (!folderPath?.trim())
+        throw new Error('文件夹路径不能为空');
+    const roots = config.folderImportRoots ?? [];
+    if (!roots.length)
+        return;
+    const resolved = path_1.default.resolve(folderPath).toLowerCase();
+    const allowed = roots.some((root) => {
+        if (!root?.trim())
+            return false;
+        const prefix = path_1.default.resolve(root).toLowerCase().replace(/[\\/]+$/, '');
+        return resolved === prefix || resolved.startsWith(prefix + path_1.default.sep);
+    });
+    if (!allowed) {
+        ctx.emojiluna.debug.log('service', `拒绝访问目录 ${folderPath}（不在允许列表内）`);
+        throw new Error('该目录不在 folderImportRoots 允许范围内');
+    }
+}

package/lib/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export { applyBackend } from './backend';
+export { applyCommands } from './commands';

package/lib/adapters/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCommands = exports.applyBackend = void 0;
+var backend_1 = require("./backend");
+Object.defineProperty(exports, "applyBackend", { enumerable: true, get: function () { return backend_1.applyBackend; } });
+var commands_1 = require("./commands");
+Object.defineProperty(exports, "applyCommands", { enumerable: true, get: function () { return commands_1.applyCommands; } });

package/lib/adapters/render.d.ts

@@ -0,0 +1,7 @@
+import { Context, h } from 'koishi';
+import { Config } from '../config';
+import { EmojiItem } from '../types';
+export declare function truncate(text: string, max?: number): string;
+export declare function emojiUrl(ctx: Context, config: Config, emoji: EmojiItem): string | null;
+export declare function emojiText(emoji: EmojiItem): string;
+export declare function emojiMessage(ctx: Context, config: Config, emoji: EmojiItem): Promise<h>;

package/lib/adapters/render.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncate = truncate;
+exports.emojiUrl = emojiUrl;
+exports.emojiText = emojiText;
+exports.emojiMessage = emojiMessage;
+const koishi_1 = require("koishi");
+const DEFAULT_TRUNCATE = 200;
+function truncate(text, max = DEFAULT_TRUNCATE) {
+    if (!text)
+        return '';
+    return text.length <= max ? text : text.slice(0, max - 1) + '…';
+}
+function emojiUrl(ctx, config, emoji) {
+    if (!config.backendServer)
+        return null;
+    const selfUrl = config.selfUrl || ctx.server?.selfUrl || '';
+    if (!selfUrl)
+        return null;
+    return `${selfUrl.replace(/\/+$/, '')}${config.backendPath}/get/${encodeURIComponent(emoji.id)}`;
+}
+function emojiText(emoji) {
+    const tags = emoji.tags.length ? ` #${emoji.tags.join(' #')}` : '';
+    return truncate(`${emoji.name} [${emoji.category}]${tags}`, 120);
+}
+async function emojiMessage(ctx, config, emoji) {
+    const url = emojiUrl(ctx, config, emoji);
+    if (url)
+        return koishi_1.h.image(url);
+    const buffer = await ctx.emojiluna.readEmojiBuffer(emoji);
+    if (!buffer) {
+        return koishi_1.h.text(`表情包文件不可读: ${emoji.name} (${emoji.id})`);
+    }
+    return koishi_1.h.image(`data:${emoji.mimeType};base64,${buffer.toString('base64')}`);
+}

package/lib/adapters/restApi.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'koishi';
+import { Config } from '../config';
+export declare function applyRestApi(ctx: Context, config: Config): void;

package/lib/adapters/restApi.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyRestApi = applyRestApi;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../utils");
+const formidable_1 = __importDefault(require("formidable"));
+const UPLOAD_DIR_NAME = 'uploads';
+const MAX_QUERY_LIMIT = 200;
+const DEFAULT_SEARCH_LIMIT = 50;
+function getSingleQuery(value) {
+    if (Array.isArray(value))
+        return value[0];
+    if (typeof value === 'string')
+        return value;
+    return undefined;
+}
+function toFiniteNumber(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function getPaginationParams(query) {
+    const limit = toFiniteNumber(getSingleQuery(query.limit));
+    const offset = toFiniteNumber(getSingleQuery(query.offset));
+    return {
+        limit: limit === undefined
+            ? undefined
+            : Math.max(1, Math.min(MAX_QUERY_LIMIT, limit)),
+        offset: offset === undefined ? undefined : Math.max(0, offset),
+    };
+}
+function firstField(fields, key) {
+    return getSingleQuery(fields[key]);
+}
+function parseTagsField(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            return parsed.filter((tag) => typeof tag === 'string');
+        }
+    }
+    catch {
+        return raw
+            .split(',')
+            .map((tag) => tag.trim())
+            .filter(Boolean);
+    }
+    return [];
+}
+function readUploadToken(koa) {
+    const header = (koa.get('x-upload-token') || koa.get('authorization') || '').toString();
+    return header.startsWith('Bearer ') ? header.slice(7).trim() : header.trim();
+}
+function json(koa, body, status = 200) {
+    koa.status = status;
+    koa.set('Content-Type', 'application/json');
+    koa.body = JSON.stringify(body);
+}
+async function serveImage(ctx, koa, emoji) {
+    if (!emoji) {
+        koa.status = 404;
+        koa.body = 'Emoji not found';
+        return;
+    }
+    const buffer = await ctx.emojiluna.readEmojiBuffer(emoji);
+    if (!buffer) {
+        koa.status = 404;
+        koa.body = 'Emoji file unreadable';
+        return;
+    }
+    koa.status = 200;
+    koa.set('Content-Type', emoji.mimeType || (0, utils_1.getImageType)(buffer));
+    koa.set('Content-Length', buffer.length.toString());
+    koa.body = buffer;
+}
+async function serveRandom(ctx, koa, emojis) {
+    if (!emojis.length) {
+        koa.status = 404;
+        koa.body = 'No emojis available';
+        return;
+    }
+    const picked = emojis[Math.floor(Math.random() * emojis.length)];
+    await serveImage(ctx, koa, picked);
+}
+function uploadFailureStatus(message) {
+    if (/已达上限/.test(message))
+        return 409;
+    if (/already exists|已存在/.test(message))
+        return 409;
+    if (/图片过大|too large|maxFileSize|File size/.test(message))
+        return 413;
+    if (/无法识别的图片格式|Invalid image/.test(message))
+        return 415;
+    return 500;
+}
+function applyRestApi(ctx, config) {
+    if (!config.backendServer)
+        return;
+    const debug = ctx.emojiluna.debug;
+    ctx.inject(['server', 'emojiluna'], async (ctx) => {
+        await ctx.emojiluna.ready;
+        const base = config.backendPath;
+        ctx.server.get(`${base}/list`, async (koa) => {
+            const { limit, offset } = getPaginationParams(koa.request.query);
+            const tag = getSingleQuery(koa.request.query.tag);
+            const emojis = await ctx.emojiluna.getEmojiList({
+                keyword: getSingleQuery(koa.request.query.keyword),
+                category: getSingleQuery(koa.request.query.category),
+                tags: tag ? [tag] : undefined,
+                limit,
+                offset,
+            });
+            debug.log('http', `GET ${base}/list -> ${emojis.length}`);
+            json(koa, emojis);
+        });
+        ctx.server.get(`${base}/search`, async (koa) => {
+            const keyword = getSingleQuery(koa.request.query.keyword) ?? '';
+            const { limit, offset } = getPaginationParams(koa.request.query);
+            const matched = await ctx.emojiluna.searchEmoji(keyword);
+            const from = offset ?? 0;
+            const emojis = matched.slice(from, limit ?? DEFAULT_SEARCH_LIMIT);
+            debug.log('http', `GET ${base}/search ${keyword} -> ${emojis.length}/${matched.length}`);
+            json(koa, emojis);
+        });
+        ctx.server.get(`${base}/categories`, async (koa) => {
+            const { limit, offset } = getPaginationParams(koa.request.query);
+            const page = await ctx.emojiluna.getCategoriesPage({
+                keyword: getSingleQuery(koa.request.query.keyword),
+                limit,
+                offset,
+            });
+            debug.log('http', `GET ${base}/categories -> ${page.items.length}/${page.total}`);
+            json(koa, page.items);
+        });
+        ctx.server.get(`${base}/categories/:category`, async (koa) => {
+            const { category } = koa.params;
+            const emojis = await ctx.emojiluna.getEmojiList({ category });
+            debug.log('http', `GET ${base}/categories/${category} -> ${emojis.length}`);
+            await serveRandom(ctx, koa, emojis);
+        });
+        ctx.server.get(`${base}/tags`, async (koa) => {
+            const tags = await ctx.emojiluna.getAllTags();
+            debug.log('http', `GET ${base}/tags -> ${tags.length}`);
+            json(koa, tags);
+        });
+        ctx.server.get(`${base}/tags/:tag`, async (koa) => {
+            const { tag } = koa.params;
+            const emojis = await ctx.emojiluna.getEmojiList({ tags: [tag] });
+            debug.log('http', `GET ${base}/tags/${tag} -> ${emojis.length}`);
+            await serveRandom(ctx, koa, emojis);
+        });
+        ctx.server.get(`${base}/random`, async (koa) => {
+            const emojis = await ctx.emojiluna.getEmojiList();
+            debug.log('http', `GET ${base}/random from ${emojis.length} emojis`);
+            await serveRandom(ctx, koa, emojis);
+        });
+        ctx.server.get(`${base}/get/:id`, async (koa) => {
+            const { id } = koa.params;
+            const emoji = (await ctx.emojiluna.getEmojiById(id)) ??
+                (await ctx.emojiluna.getEmojiByName(id));
+            debug.log('http', `GET ${base}/get/${id} -> ${emoji ? emoji.id : 'miss'}`);
+            await serveImage(ctx, koa, emoji);
+        });
+        ctx.server.post(`${base}/upload`, async (koa) => {
+            if (readUploadToken(koa) !== ctx.emojiluna.uploadToken) {
+                debug.log('http', 'POST upload 被拒绝：token 不匹配');
+                return json(koa, { success: false, message: 'Unauthorized' }, 401);
+            }
+            try {
+                const { fields, file } = await readUploadPayload(ctx, koa);
+                if (!file?.filepath) {
+                    return json(koa, { success: false, message: 'No file uploaded' }, 400);
+                }
+                const emoji = await ctx.emojiluna.addEmoji({
+                    name: firstField(fields, 'name') ||
+                        file.originalFilename?.replace(/\.[^/.]+$/, '') ||
+                        'uploaded',
+                    category: firstField(fields, 'category'),
+                    tags: parseTagsField(firstField(fields, 'tags')),
+                }, { path: file.filepath }, firstField(fields, 'aiAnalysis') === 'true');
+                debug.log('http', `POST upload -> ${emoji.id}`);
+                return json(koa, { success: true, emoji });
+            }
+            catch (error) {
+                const message = error.message ?? String(error);
+                ctx.logger.error(`Upload endpoint error: ${message}`);
+                debug.log('http', `POST upload 失败: ${message}`);
+                return json(koa, { success: false, message }, uploadFailureStatus(message));
+            }
+        });
+    });
+}
+async function readUploadPayload(ctx, koa) {
+    const request = koa.request;
+    if (request.files) {
+        const file = request.files.file;
+        return {
+            fields: request.body ?? {},
+            file: Array.isArray(file) ? file[0] : file,
+        };
+    }
+    const uploadDir = path_1.default.join(ctx.emojiluna.storageDir, UPLOAD_DIR_NAME);
+    await promises_1.default.mkdir(uploadDir, { recursive: true });
+    const form = (0, formidable_1.default)({
+        uploadDir,
+        keepExtensions: true,
+        maxFileSize: (ctx.emojiluna.config.maxFileSize || ctx.emojiluna.config.maxEmojiSize) *
+            1024 * 1024,
+        multiples: false,
+    });
+    const [fields, files] = await new Promise((settle, fail) => {
+        form.parse(koa.req, (error, parsedFields, parsedFiles) => {
+            if (error)
+                return fail(error);
+            settle([parsedFields, parsedFiles]);
+        });
+    });
+    const file = files.file;
+    return { fields, file: (Array.isArray(file) ? file[0] : file) };
+}

package/lib/collectors/autoCollector.d.ts

@@ -0,0 +1,75 @@
+import { Context, h, Session } from 'koishi';
+import { Config } from '../config';
+import { DebugLogger } from '../debug';
+export interface CollectTrace {
+    gate: string;
+    ok: boolean;
+    detail: string;
+}
+export interface CollectStats {
+    enabled: boolean;
+    configured: boolean;
+    mode: 'instant' | 'frequency';
+    seen: number;
+    collected: number;
+    rejected: Record<string, number>;
+    queue: number;
+    active: number;
+    signatures: number;
+    preloaded: boolean;
+    recent: string[];
+}
+export declare class AutoCollector {
+    private ctx;
+    private config;
+    private debug;
+    private signatures;
+    private frequency;
+    private counters;
+    private globalDay;
+    private pendingRefs;
+    private inFlight;
+    private rejectedHashes;
+    private aiVerdicts;
+    private queue;
+    private active;
+    private nameSeq;
+    private manualEnabled;
+    private signaturesReady;
+    private stopped;
+    private metrics;
+    private recent;
+    constructor(ctx: Context, config: Config, debug: DebugLogger);
+    private get luna();
+    get isEnabled(): boolean;
+    start(): void;
+    observe(session: Session): number;
+    probe(session: Session, dryRun?: boolean, elements?: h[]): Promise<CollectTrace[]>;
+    stats(): CollectStats;
+    setEnabled(enabled: boolean | null): void;
+    resetCounters(): void;
+    dispose(): void;
+    private pump;
+    private processJob;
+    private save;
+    private evaluateScope;
+    private evaluateSize;
+    private evaluateResolution;
+    private evaluateKnownHash;
+    private evaluateSimilarity;
+    private evaluateFrequency;
+    private evaluateLimit;
+    private evaluateLibrary;
+    private evaluateAiFilter;
+    private buildSignature;
+    private preloadSignatures;
+    private rememberSignature;
+    private windowCounter;
+    private consumeQuota;
+    private pruneCaches;
+    private chatKey;
+    private buildName;
+    private buildTags;
+    private reject;
+    private record;
+}