koishi-plugin-emojiluna-plus 0.0.1

package/lib/services/emojiluna.js

@@ -0,0 +1,910 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmojiLunaService = void 0;
+const koishi_1 = require("koishi");
+const storage_1 = require("../storage");
+const aiAnalyzer_1 = require("./aiAnalyzer");
+const utils_1 = require("../utils");
+const image_1 = require("../image");
+const debug_1 = require("../debug");
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const crypto_1 = require("crypto");
+class EmojiLunaService extends koishi_1.Service {
+    config;
+    _emojiStorage = {};
+    _categories = {};
+    _isInitialized = false;
+    _readyPromise;
+    _readyResolve;
+    _isDisposed = false;
+    _uploadManager;
+    _aiAnalyzer;
+    _byName = new Map();
+    _byTag = new Map();
+    _byCategory = new Map();
+    _storageDir;
+    _uploadToken;
+    debug;
+    autoCollector = null;
+    constructor(ctx, config) {
+        super(ctx, 'emojiluna', true);
+        this.config = config;
+        defineDatabase(ctx);
+        this.debug = new debug_1.DebugLogger(ctx, config);
+        this._storageDir = path_1.default.resolve(ctx.baseDir, config.storagePath);
+        this._uploadToken = config.uploadToken || (0, crypto_1.randomUUID)().replace(/-/g, '');
+        this._uploadManager = new storage_1.UploadManager(ctx, config, this.debug);
+        this._aiAnalyzer = new aiAnalyzer_1.AIAnalyzer(ctx, config, this.debug);
+        this._uploadManager.setTaskProcessor({
+            analyzeEmoji: (base64) => this.analyzeEmoji(base64),
+            updateEmojiInfo: (id, updates) => this.updateEmojiInfo(id, updates),
+            getEmojiById: async (id) => {
+                const emoji = this._emojiStorage[id];
+                if (!emoji)
+                    return null;
+                return {
+                    id: emoji.id,
+                    name: emoji.name,
+                    category: emoji.category,
+                    tags: emoji.tags,
+                    path: emoji.path
+                };
+            }
+        });
+        this._readyPromise = new Promise((resolve) => {
+            this._readyResolve = resolve;
+        });
+        ctx.on('ready', async () => {
+            try {
+                await this.initializeStorage();
+                await this._aiAnalyzer.initialize();
+                this._isInitialized = true;
+            }
+            catch (error) {
+                this.ctx.logger.error(`EmojiLuna initialization failed: ${error.message}`, error);
+            }
+            finally {
+                this._readyResolve();
+            }
+            this._uploadManager.startAITaskProcessor();
+        });
+    }
+    get ready() {
+        return this._readyPromise;
+    }
+    get uploadManager() {
+        return this._uploadManager;
+    }
+    get storageDir() {
+        return this._storageDir;
+    }
+    get aiAnalyzer() {
+        return this._aiAnalyzer;
+    }
+    get uploadToken() {
+        return this._uploadToken;
+    }
+    async initializeStorage() {
+        await promises_1.default.mkdir(this._storageDir, { recursive: true });
+        await this.loadEmojis();
+        await this.loadCategories();
+        await this._uploadManager.loadExistingHashes();
+        this.debug.log('service', `初始化完成：${this.getEmojiCount()} 个表情包，${this.getCategoryCount()} 个分类，存储目录 ${this._storageDir}`);
+        this.debug.log('service', `HTTP 上传 token 来源：${this.config.uploadToken ? '配置项' : '随机生成（仅控制台可用）'}`);
+        this.ctx.on('dispose', () => {
+            this._isDisposed = true;
+            this._emojiStorage = {};
+            this._categories = {};
+            this._byName.clear();
+            this._byTag.clear();
+            this._byCategory.clear();
+        });
+    }
+    get isInitialized() {
+        return this._isInitialized;
+    }
+    async readEmojiBuffer(emoji) {
+        try {
+            return await promises_1.default.readFile(emoji.path);
+        }
+        catch (error) {
+            this.ctx.logger.warn(`Emoji file unreadable ${emoji.id}: ${emoji.path} (${error.message})`);
+            return null;
+        }
+    }
+    indexEmoji(emoji) {
+        this._byName.set(emoji.name, emoji.id);
+        for (const tag of emoji.tags) {
+            const set = this._byTag.get(tag) ?? new Set();
+            set.add(emoji.id);
+            this._byTag.set(tag, set);
+        }
+        const category = emoji.category.trim();
+        const categorySet = this._byCategory.get(category) ?? new Set();
+        categorySet.add(emoji.id);
+        this._byCategory.set(category, categorySet);
+    }
+    unindexEmoji(emoji) {
+        if (this._byName.get(emoji.name) === emoji.id)
+            this._byName.delete(emoji.name);
+        for (const tag of emoji.tags)
+            this._byTag.get(tag)?.delete(emoji.id);
+        this._byCategory.get(emoji.category.trim())?.delete(emoji.id);
+    }
+    reindexEmoji(before, after) {
+        this.unindexEmoji(before);
+        this.indexEmoji(after);
+    }
+    async categorizeEmoji(imageBase64) {
+        const result = await this._aiAnalyzer.categorize(imageBase64);
+        if (result?.newCategory) {
+            const exists = await this.getCategoryByName(result.newCategory);
+            if (!exists) {
+                await this.addCategory(result.newCategory, 'AI建议的新分类');
+            }
+            result.category = result.newCategory;
+        }
+        return result;
+    }
+    async analyzeEmoji(imageBase64) {
+        const result = await this._aiAnalyzer.analyze(imageBase64);
+        if (result?.newCategory) {
+            const exists = await this.getCategoryByName(result.newCategory);
+            if (!exists) {
+                await this.addCategory(result.newCategory, 'AI建议的新分类');
+            }
+            result.category = result.newCategory;
+        }
+        return result;
+    }
+    async filterImageByType(imageBase64) {
+        return this._aiAnalyzer.filterImageType(imageBase64);
+    }
+    assertActive() {
+        if (this._isDisposed)
+            throw new Error('EmojiLuna 服务已卸载，请重新启用插件后再试');
+    }
+    async addEmoji(options, source, aiAnalysis = this.config.autoAnalyze) {
+        this.assertActive();
+        const sourcePath = 'path' in source ? source.path : null;
+        const imageBuffer = sourcePath
+            ? await promises_1.default.readFile(sourcePath)
+            : source;
+        const format = (0, image_1.detectImageFormat)(imageBuffer);
+        const mimeType = `image/${format === 'unknown' ? 'jpeg' : format}`;
+        const imageHash = (0, utils_1.hashBuffer)(imageBuffer);
+        const validationError = await this._uploadManager.validateNewEmoji(imageBuffer, imageHash);
+        if (validationError) {
+            await this._uploadManager.cleanupTempFile(sourcePath);
+            throw new Error(validationError);
+        }
+        const limit = this.config.maxEmojiCount;
+        if (limit > 0 && this.getEmojiCount() >= limit) {
+            await this._uploadManager.cleanupTempFile(sourcePath);
+            throw new Error(`表情包数量已达上限 ${limit}，请先清理或提高 maxEmojiCount`);
+        }
+        const id = (0, crypto_1.randomUUID)();
+        const destPath = path_1.default.join(this._storageDir, `${id}.${format === 'unknown' ? 'jpg' : format}`);
+        await promises_1.default.mkdir(this._storageDir, { recursive: true });
+        if (sourcePath) {
+            await this._uploadManager.finalizeFile(sourcePath, destPath);
+        }
+        else {
+            await promises_1.default.writeFile(destPath, imageBuffer);
+        }
+        try {
+            const emoji = await this.buildEmojiRecord(id, destPath, imageBuffer, mimeType, imageHash, options, aiAnalysis);
+            await this.persistEmoji(emoji, imageHash);
+            this._uploadManager.registerEmoji(id, imageHash);
+            return emoji;
+        }
+        catch (error) {
+            await promises_1.default.rm(destPath, { force: true }).catch(() => undefined);
+            this._uploadManager.forgetEmoji(id, imageHash);
+            throw error;
+        }
+    }
+    async buildEmojiRecord(id, destPath, imageBuffer, mimeType, imageHash, options, aiAnalysis) {
+        let finalOptions = { ...options };
+        if (aiAnalysis) {
+            const cachedResult = this._uploadManager.getCachedAIResult(imageHash);
+            if (cachedResult) {
+                finalOptions = {
+                    name: cachedResult.name || options.name,
+                    category: cachedResult.category || options.category,
+                    tags: [
+                        ...new Set([
+                            ...(options.tags || []),
+                            ...(cachedResult.tags || []),
+                        ]),
+                    ],
+                    description: cachedResult.description,
+                };
+                this.debug.log('ai', `复用缓存分析结果 ${imageHash.slice(0, 8)}: ${cachedResult.name}`, { description: cachedResult.description });
+            }
+            else {
+                this._uploadManager.queueAIAnalysis(id, destPath, imageHash);
+            }
+        }
+        else if (this.config.autoCategorize && !options.category) {
+            const categorizeResult = await this.categorizeEmoji(imageBuffer.toString('base64'));
+            if (!categorizeResult) {
+                throw new Error('AI 分类失败，未能确定分类');
+            }
+            finalOptions.category = categorizeResult.category;
+        }
+        return {
+            id,
+            name: finalOptions.name,
+            category: (finalOptions.category || this.config.autoCollectCategory).trim(),
+            path: destPath,
+            size: imageBuffer.length,
+            mimeType,
+            createdAt: new Date(),
+            tags: finalOptions.tags || [],
+            description: finalOptions.description,
+        };
+    }
+    async persistEmoji(emoji, imageHash) {
+        await this.ctx.database.upsert('emojiluna_emojis', [
+            {
+                id: emoji.id,
+                name: emoji.name,
+                category: emoji.category,
+                path: emoji.path,
+                size: emoji.size,
+                mime_type: emoji.mimeType,
+                created_at: emoji.createdAt,
+                tags: JSON.stringify(emoji.tags),
+                image_hash: imageHash,
+                description: emoji.description ?? '',
+            },
+        ]);
+        this._emojiStorage[emoji.id] = emoji;
+        this.indexEmoji(emoji);
+        await this.updateCategoryEmojiCount(emoji.category);
+        this.ctx.logger.success(`Emoji added: ${emoji.name} (${emoji.id})`);
+        this.ctx.emit('emojiluna/emoji-added', emoji);
+    }
+    async addEmojis(emojis, aiAnalysis) {
+        const createdEmojis = [];
+        const batchSize = Math.max(1, this.config.batchSize);
+        for (let i = 0; i < emojis.length; i += batchSize) {
+            const batch = emojis.slice(i, i + batchSize);
+            const results = await Promise.all(batch.map(async ({ options, buffer }) => {
+                try {
+                    return await this.addEmoji(options, buffer, aiAnalysis);
+                }
+                catch (error) {
+                    this.ctx.logger.error(`Failed to add emoji ${options.name}:`, error);
+                    return null;
+                }
+            }));
+            for (const emoji of results) {
+                if (emoji)
+                    createdEmojis.push(emoji);
+            }
+        }
+        return createdEmojis;
+    }
+    async getEmojiByName(name) {
+        const byId = this._emojiStorage[name];
+        if (byId)
+            return byId;
+        const byName = this._byName.get(name);
+        if (byName)
+            return this._emojiStorage[byName] ?? null;
+        const byTag = this._byTag.get(name)?.values().next().value;
+        if (byTag)
+            return this._emojiStorage[byTag] ?? null;
+        const byCategory = this._byCategory.get(name)?.values().next().value;
+        return byCategory ? this._emojiStorage[byCategory] ?? null : null;
+    }
+    async getEmojisByName(name) {
+        const ids = new Set([
+            ...(this._byName.get(name) ? [this._byName.get(name)] : []),
+            ...(this._byTag.get(name) ?? []),
+            ...(this._byCategory.get(name) ?? []),
+        ]);
+        return [...ids]
+            .map((id) => this._emojiStorage[id])
+            .filter((emoji) => Boolean(emoji));
+    }
+    async getEmojiById(id) {
+        return this._emojiStorage[id] || null;
+    }
+    filterEmojis(options = {}) {
+        const { keyword, tags } = options;
+        const category = options.category?.trim();
+        let emojis = category && !keyword?.trim() && !tags?.length
+            ? [...(this._byCategory.get(category) ?? [])]
+                .map((id) => this._emojiStorage[id])
+                .filter((emoji) => Boolean(emoji))
+            : Object.values(this._emojiStorage);
+        if (keyword?.trim()) {
+            const normalizedKeyword = keyword.trim();
+            emojis = emojis.filter((emoji) => emoji.name.includes(normalizedKeyword) ||
+                emoji.tags.some((tag) => tag.includes(normalizedKeyword)));
+        }
+        if (category) {
+            emojis = emojis.filter((emoji) => emoji.category.trim() === category);
+        }
+        if (tags?.length) {
+            emojis = emojis.filter((emoji) => tags.some((tag) => emoji.tags.includes(tag)));
+        }
+        return emojis;
+    }
+    async getEmojiList(options = {}) {
+        const { limit = undefined, offset = 0 } = options;
+        const emojis = this.filterEmojis(options);
+        if (!limit) {
+            return emojis;
+        }
+        return emojis.slice(offset, offset + limit);
+    }
+    async getEmojiPage(options = {}) {
+        const limit = Math.max(1, options.limit ?? 50);
+        const offset = Math.max(0, options.offset ?? 0);
+        const filtered = this.filterEmojis(options);
+        return {
+            items: filtered.slice(offset, offset + limit),
+            total: filtered.length,
+            limit,
+            offset
+        };
+    }
+    async searchEmoji(keyword) {
+        return this.filterEmojis({ keyword });
+    }
+    async deleteEmoji(id) {
+        this.assertActive();
+        const emoji = this._emojiStorage[id];
+        if (!emoji)
+            return false;
+        try {
+            await promises_1.default.unlink(emoji.path);
+            delete this._emojiStorage[id];
+            this.unindexEmoji(emoji);
+            this._uploadManager.forgetEmoji(id);
+            await this.ctx.database.remove('emojiluna_emojis', { id });
+            await this.updateCategoryEmojiCount(emoji.category);
+            this.ctx.emit('emojiluna/emoji-deleted', id);
+            return true;
+        }
+        catch (error) {
+            this.ctx.logger.error(`Failed to delete emoji ${id}:`, error);
+            return false;
+        }
+    }
+    async deleteAllEmojis() {
+        try {
+            const emojis = Object.values(this._emojiStorage);
+            const concurrency = 4;
+            for (let i = 0; i < emojis.length; i += concurrency) {
+                const batch = emojis.slice(i, i + concurrency);
+                await Promise.all(batch.map((emoji) => this.deleteEmoji(emoji.id)));
+            }
+        }
+        catch (error) {
+            this.ctx.logger.error('Failed to delete all emojis:', error);
+            return false;
+        }
+        return true;
+    }
+    async updateEmojiInfo(id, updates) {
+        this.assertActive();
+        const emoji = this._emojiStorage[id];
+        if (!emoji)
+            return false;
+        const oldCategory = emoji.category;
+        const next = {
+            ...emoji,
+            name: updates.name ?? emoji.name,
+            category: updates.category ?? emoji.category,
+            tags: updates.tags ? [...new Set(updates.tags.map((t) => t.trim()).filter(Boolean))] : emoji.tags,
+            description: updates.description ?? emoji.description,
+        };
+        const changed = next.name !== emoji.name ||
+            next.category !== emoji.category ||
+            next.description !== emoji.description ||
+            JSON.stringify(next.tags) !== JSON.stringify(emoji.tags);
+        if (!changed)
+            return true;
+        this._emojiStorage[id] = next;
+        this.reindexEmoji(emoji, next);
+        await this.ctx.database.upsert('emojiluna_emojis', [
+            {
+                id: next.id,
+                name: next.name,
+                category: next.category,
+                tags: JSON.stringify(next.tags),
+                description: next.description ?? '',
+            }
+        ]);
+        if (updates.category !== undefined &&
+            updates.category !== oldCategory) {
+            await this.updateCategoryEmojiCount(oldCategory);
+            await this.updateCategoryEmojiCount(next.category);
+        }
+        this.debug.log('service', `更新表情包 ${id}`, {
+            name: next.name,
+            category: next.category,
+            tags: next.tags,
+        });
+        this.ctx.emit('emojiluna/emoji-updated', next);
+        return true;
+    }
+    async updateEmojiName(id, name) {
+        const nextName = name.trim();
+        if (!nextName)
+            return false;
+        const emoji = this._emojiStorage[id];
+        if (!emoji)
+            return false;
+        if (emoji.name === nextName)
+            return true;
+        const duplicated = this._byName.has(nextName);
+        if (duplicated)
+            return false;
+        return this.updateEmojiInfo(id, { name: nextName });
+    }
+    async updateEmojiTags(id, tags) {
+        return this.updateEmojiInfo(id, { tags });
+    }
+    async updateEmojiCategory(id, category) {
+        const nextCategory = category.trim();
+        if (!nextCategory)
+            return false;
+        const emoji = this._emojiStorage[id];
+        if (!emoji)
+            return false;
+        if (emoji.category === nextCategory)
+            return true;
+        return this.updateEmojiInfo(id, { category: nextCategory });
+    }
+    async addCategory(name, description) {
+        const categoryName = name.trim();
+        if (!categoryName) {
+            throw new Error('分类名称不能为空');
+        }
+        const existingCategory = await this.getCategoryByName(categoryName);
+        if (existingCategory) {
+            if (description !== undefined &&
+                description !== existingCategory.description) {
+                existingCategory.description = description;
+                await this.ctx.database.upsert('emojiluna_categories', [
+                    {
+                        id: existingCategory.id,
+                        name: existingCategory.name,
+                        description: existingCategory.description
+                    }
+                ]);
+            }
+            return existingCategory;
+        }
+        const id = (0, crypto_1.randomUUID)();
+        const category = {
+            id,
+            name: categoryName,
+            description,
+            emojiCount: 0,
+            createdAt: new Date()
+        };
+        this._categories[id] = category;
+        await this.ctx.database.upsert('emojiluna_categories', [
+            {
+                id: category.id,
+                name: category.name,
+                description: category.description,
+                emoji_count: category.emojiCount,
+                created_at: category.createdAt
+            }
+        ]);
+        this.ctx.emit('emojiluna/category-added', category);
+        return category;
+    }
+    async getCategories() {
+        return Object.values(this._categories);
+    }
+    async getCategoriesPage(options = {}) {
+        const limit = Math.max(1, options.limit ?? 24);
+        const offset = Math.max(0, options.offset ?? 0);
+        const keyword = options.keyword?.trim().toLowerCase();
+        const categories = Object.values(this._categories).filter((cat) => {
+            if (!keyword)
+                return true;
+            return (cat.name.toLowerCase().includes(keyword) ||
+                (cat.description || '').toLowerCase().includes(keyword));
+        });
+        return {
+            items: categories.slice(offset, offset + limit),
+            total: categories.length,
+            limit,
+            offset
+        };
+    }
+    async getCategoryByName(name) {
+        return (Object.values(this._categories).find((cat) => cat.name === name) ||
+            null);
+    }
+    async deleteCategory(id, deleteEmojis = false) {
+        const category = this._categories[id];
+        if (!category)
+            return false;
+        const emojisInCategory = Object.values(this._emojiStorage).filter((emoji) => emoji.category === category.name);
+        if (emojisInCategory.length > 0) {
+            if (!deleteEmojis) {
+                throw new Error(`分类 ${category.name} 中还有表情包，无法删除`);
+            }
+            const results = await Promise.all(emojisInCategory.map((emoji) => this.deleteEmoji(emoji.id)));
+            if (results.some((success) => !success)) {
+                throw new Error(`分类 ${category.name} 下部分表情包删除失败`);
+            }
+        }
+        delete this._categories[id];
+        await this.ctx.database.remove('emojiluna_categories', { id });
+        this.ctx.emit('emojiluna/category-deleted', id);
+        return true;
+    }
+    async cleanupEmptyCategories() {
+        const emptyCategories = Object.values(this._categories).filter((category) => category.emojiCount <= 0);
+        for (const category of emptyCategories) {
+            delete this._categories[category.id];
+            await this.ctx.database.remove('emojiluna_categories', {
+                id: category.id
+            });
+            this.ctx.emit('emojiluna/category-deleted', category.id);
+        }
+        return emptyCategories.length;
+    }
+    buildTagUsageMap() {
+        const tagUsageMap = new Map();
+        Object.values(this._emojiStorage).forEach((emoji) => {
+            emoji.tags.forEach((tag) => {
+                const normalizedTag = tag.trim();
+                if (!normalizedTag)
+                    return;
+                tagUsageMap.set(normalizedTag, (tagUsageMap.get(normalizedTag) || 0) + 1);
+            });
+        });
+        return tagUsageMap;
+    }
+    async getAllTags() {
+        const tags = new Set();
+        Object.values(this._emojiStorage).forEach((emoji) => {
+            emoji.tags.forEach((tag) => tags.add(tag));
+        });
+        return Array.from(tags);
+    }
+    async getTagsPage(options = {}) {
+        const limit = Math.max(1, options.limit ?? 24);
+        const offset = Math.max(0, options.offset ?? 0);
+        const keyword = options.keyword?.trim().toLowerCase();
+        const tagUsageMap = this.buildTagUsageMap();
+        const tags = Array.from(tagUsageMap.entries())
+            .map(([name, usage]) => ({ name, usage }))
+            .filter((tag) => {
+            if (!keyword)
+                return true;
+            return tag.name.toLowerCase().includes(keyword);
+        })
+            .sort((a, b) => b.usage - a.usage);
+        return {
+            items: tags.slice(offset, offset + limit),
+            total: tags.length,
+            limit,
+            offset
+        };
+    }
+    async cleanupEmptyTags() {
+        let removedCount = 0;
+        for (const emoji of Object.values(this._emojiStorage)) {
+            const rawTags = emoji.tags ?? [];
+            const cleanedTags = [
+                ...new Set(rawTags.map((tag) => tag.trim()).filter(Boolean)),
+            ];
+            const unchanged = cleanedTags.length === rawTags.length &&
+                cleanedTags.every((tag, index) => tag === rawTags[index]);
+            if (unchanged)
+                continue;
+            removedCount += Math.max(0, rawTags.length - cleanedTags.length);
+            await this.updateEmojiTags(emoji.id, cleanedTags);
+        }
+        return removedCount;
+    }
+    async categorizeExistingEmojis() {
+        if (!this._aiAnalyzer.model || !this.config.autoCategorize) {
+            return { success: 0, failed: 0 };
+        }
+        let success = 0, failed = 0;
+        for (const emoji of Object.values(this._emojiStorage)) {
+            try {
+                const imageBuffer = await promises_1.default.readFile(emoji.path);
+                const imageBase64 = imageBuffer.toString('base64');
+                const result = await this.categorizeEmoji(imageBase64);
+                if (result && result.category !== emoji.category) {
+                    await this.updateEmojiCategory(emoji.id, result.category);
+                    success++;
+                }
+            }
+            catch (error) {
+                this.ctx.logger.error(`分类表情包 ${emoji.id} 失败:`, error);
+                failed++;
+            }
+        }
+        return { success, failed };
+    }
+    static SUPPORTED_EXTENSIONS = [
+        '.png',
+        '.jpg',
+        '.jpeg',
+        '.gif',
+        '.webp'
+    ];
+    async scanFolder(folderPath) {
+        const files = [];
+        const subfolders = [];
+        try {
+            await promises_1.default.access(folderPath);
+        }
+        catch {
+            throw new Error(`文件夹不存在或无法访问: ${folderPath}`);
+        }
+        const entries = await promises_1.default.readdir(folderPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path_1.default.join(folderPath, entry.name);
+            if (entry.isDirectory()) {
+                subfolders.push(entry.name);
+            }
+            else if (entry.isFile()) {
+                const ext = path_1.default.extname(entry.name).toLowerCase();
+                if (EmojiLunaService.SUPPORTED_EXTENSIONS.includes(ext)) {
+                    const stat = await promises_1.default.stat(entryPath);
+                    files.push({
+                        path: entryPath,
+                        name: path_1.default.basename(entry.name, ext),
+                        category: path_1.default.basename(folderPath),
+                        size: stat.size
+                    });
+                }
+            }
+        }
+        return {
+            folderPath,
+            files,
+            subfolders,
+            totalFiles: files.length
+        };
+    }
+    async scanFolderRecursive(folderPath, useSubfoldersAsCategories, defaultCategory, basePath) {
+        const files = [];
+        const actualBasePath = basePath || folderPath;
+        try {
+            await promises_1.default.access(folderPath);
+        }
+        catch {
+            this.ctx.logger.warn(`文件夹不存在或无法访问: ${folderPath}`);
+            return files;
+        }
+        const entries = await promises_1.default.readdir(folderPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path_1.default.join(folderPath, entry.name);
+            if (entry.isDirectory()) {
+                const subfolderCategory = useSubfoldersAsCategories
+                    ? entry.name
+                    : defaultCategory;
+                const subFiles = await this.scanFolderRecursive(entryPath, false, subfolderCategory, actualBasePath);
+                files.push(...subFiles);
+            }
+            else if (entry.isFile()) {
+                const ext = path_1.default.extname(entry.name).toLowerCase();
+                if (EmojiLunaService.SUPPORTED_EXTENSIONS.includes(ext)) {
+                    const stat = await promises_1.default.stat(entryPath);
+                    let category = defaultCategory;
+                    if (useSubfoldersAsCategories &&
+                        folderPath !== actualBasePath) {
+                        category = path_1.default.basename(folderPath);
+                    }
+                    files.push({
+                        path: entryPath,
+                        name: path_1.default.basename(entry.name, ext),
+                        category,
+                        size: stat.size
+                    });
+                }
+            }
+        }
+        return files;
+    }
+    emojiNameExists(name) {
+        return Object.values(this._emojiStorage).some((emoji) => emoji.name === name);
+    }
+    async importFromFolder(options) {
+        const { folderPath, useSubfoldersAsCategories, defaultCategory = 'Other', recursive, aiAnalysis, skipExisting } = options;
+        const result = {
+            success: true,
+            imported: 0,
+            skipped: 0,
+            failed: 0,
+            errors: [],
+            importedEmojis: []
+        };
+        try {
+            let files;
+            if (recursive) {
+                files = await this.scanFolderRecursive(folderPath, useSubfoldersAsCategories, defaultCategory);
+            }
+            else {
+                const scanResult = await this.scanFolder(folderPath);
+                files = scanResult.files.map((f) => ({
+                    ...f,
+                    category: useSubfoldersAsCategories
+                        ? f.category
+                        : defaultCategory
+                }));
+            }
+            if (files.length === 0) {
+                result.errors.push('未找到支持的图片文件');
+                return result;
+            }
+            this.ctx.logger.info(`开始导入 ${files.length} 个表情包从 ${folderPath}`);
+            const categoryNames = [...new Set(files.map((f) => f.category))];
+            for (const categoryName of categoryNames) {
+                const exists = await this.getCategoryByName(categoryName);
+                if (!exists) {
+                    await this.addCategory(categoryName, `从文件夹导入: ${folderPath}`);
+                }
+            }
+            for (const file of files) {
+                try {
+                    if (skipExisting && this.emojiNameExists(file.name)) {
+                        result.skipped++;
+                        continue;
+                    }
+                    const imageBuffer = await promises_1.default.readFile(file.path);
+                    const emoji = await this.addEmoji({
+                        name: file.name,
+                        category: file.category,
+                        tags: []
+                    }, imageBuffer, aiAnalysis);
+                    result.imported++;
+                    result.importedEmojis.push(emoji);
+                }
+                catch (error) {
+                    result.failed++;
+                    result.errors.push(`导入 ${file.name} 失败: ${error.message}`);
+                    this.ctx.logger.error(`导入失败 ${file.path}:`, error);
+                }
+            }
+            this.ctx.logger.success(`文件夹导入完成: 成功 ${result.imported}, 跳过 ${result.skipped}, 失败 ${result.failed}`);
+        }
+        catch (error) {
+            result.success = false;
+            result.errors.push(`导入失败: ${error.message}`);
+            this.ctx.logger.error('文件夹导入失败:', error);
+        }
+        return result;
+    }
+    async updateCategoryEmojiCount(categoryName) {
+        const normalizedCategoryName = categoryName.trim();
+        if (!normalizedCategoryName)
+            return;
+        const count = this._byCategory.get(normalizedCategoryName)?.size ?? 0;
+        let category = Object.values(this._categories).find((cat) => cat.name.trim() === normalizedCategoryName);
+        if (!category && count > 0) {
+            category = await this.addCategory(normalizedCategoryName);
+        }
+        if (!category || category.emojiCount === count)
+            return;
+        category.emojiCount = count;
+        await this.ctx.database.upsert('emojiluna_categories', [
+            {
+                id: category.id,
+                emoji_count: count,
+            },
+        ]);
+    }
+    async loadEmojis() {
+        const emojis = await this.ctx.database
+            .select('emojiluna_emojis')
+            .execute();
+        for (const emojiData of emojis) {
+            const emoji = {
+                id: emojiData.id,
+                name: emojiData.name,
+                category: (emojiData.category ?? '').trim(),
+                path: emojiData.path,
+                size: emojiData.size,
+                mimeType: emojiData.mime_type || 'image/png',
+                createdAt: new Date(emojiData.created_at),
+                tags: (0, utils_1.parseTags)(emojiData.tags),
+                description: emojiData.description || undefined,
+            };
+            this._emojiStorage[emoji.id] = emoji;
+            this.indexEmoji(emoji);
+        }
+    }
+    async loadCategories() {
+        const categories = await this.ctx.database
+            .select('emojiluna_categories')
+            .execute();
+        for (const categoryData of categories) {
+            this._categories[categoryData.id] = {
+                id: categoryData.id,
+                name: categoryData.name,
+                description: categoryData.description,
+                emojiCount: categoryData.emoji_count,
+                createdAt: new Date(categoryData.created_at)
+            };
+        }
+        for (const category of this.config.categories) {
+            const exists = Object.values(this._categories).find((cat) => cat.name === category);
+            if (!exists) {
+                await this.addCategory(category);
+            }
+        }
+    }
+    getEmojiCount() {
+        return Object.keys(this._emojiStorage).length;
+    }
+    getCategoryCount() {
+        return Object.keys(this._categories).length;
+    }
+    async getAiTaskStats() {
+        return this._uploadManager.getAITaskStats();
+    }
+    async getFailedAiEmojiIds() {
+        return this._uploadManager.getFailedAIEmojiIds();
+    }
+    setAiPaused(paused) {
+        this._uploadManager.setAIPaused(paused);
+    }
+    async retryFailedTasks() {
+        return this._uploadManager.retryFailedTasks();
+    }
+    async reanalyzeBatch(ids) {
+        return this._uploadManager.reanalyzeBatch(ids);
+    }
+    async getAiTasksAll() {
+        return this._uploadManager.getAiTasksAll();
+    }
+    async deleteAiTask(emojiId) {
+        this._uploadManager.deleteAiTask(emojiId);
+    }
+    async retryAiTask(emojiId) {
+        await this._uploadManager.retryAiTask(emojiId);
+    }
+    static inject = ['database', 'chatluna'];
+}
+exports.EmojiLunaService = EmojiLunaService;
+function defineDatabase(ctx) {
+    ctx.database.extend('emojiluna_emojis', {
+        id: { type: 'string', length: 36 },
+        name: { type: 'string', length: 255 },
+        category: { type: 'string', length: 255 },
+        path: { type: 'string', length: 1024 },
+        size: { type: 'unsigned' },
+        mime_type: { type: 'string', length: 50 },
+        created_at: { type: 'timestamp' },
+        tags: { type: 'string' },
+        image_hash: { type: 'string', length: 64 },
+        description: { type: 'string', length: 1024, initial: '' },
+    }, {
+        autoInc: false,
+        primary: 'id'
+    });
+    ctx.database.extend('emojiluna_categories', {
+        id: { type: 'string', length: 36 },
+        name: { type: 'string', length: 255 },
+        description: { type: 'string', length: 500 },
+        emoji_count: { type: 'unsigned' },
+        created_at: { type: 'timestamp' }
+    }, {
+        autoInc: false,
+        primary: 'id'
+    });
+}