koishi-plugin-message-dedup 0.0.1

package/README.md

@@ -0,0 +1,30 @@
+# koishi-plugin-message-dedup
+
+Koishi 消息去重插件，检测群内重复的图片、链接、聊天记录。
+
+![](assets/dup-1.jpg)
+
+## 功能
+
+- **链接去重**：检测重复发送的网页链接
+- **转发消息去重**：检测重复的聊天记录转发
+- **图片去重**：使用 pHash 感知哈希检测相似图片（默认关闭，可能误判表情包）
+
+## 配置
+
+| 配置项 | 说明 | 默认值 |
+|--------|------|--------|
+| enableImage | 启用图片去重 | false |
+| enableLink | 启用链接去重 | true |
+| enableForward | 启用转发消息去重 | true |
+| sendMethod | 图片发送方式 (koishi/onebot) | onebot |
+
+## 安装
+
+```bash
+npm install koishi-plugin-message-dedup
+```
+
+## License
+
+MIT

package/lib/config.d.ts

@@ -0,0 +1,16 @@
+import { Schema } from 'koishi';
+export interface Config {
+    enableImage: boolean;
+    enableLink: boolean;
+    enableForward: boolean;
+    imageSimilarityThreshold: number;
+    linkExactMatch: boolean;
+    forwardContentMaxLength: number;
+    retentionDays: number;
+    stickerDir: string;
+    sendMethod: 'koishi' | 'onebot';
+    excludedGuilds: string[];
+    excludedUsers: string[];
+    debug: boolean;
+}
+export declare const Config: Schema<Config>;

package/lib/config.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const koishi_1 = require("koishi");
+exports.Config = koishi_1.Schema.object({
+    enableImage: koishi_1.Schema.boolean()
+        .default(false)
+        .description('启用图片去重（默认关闭，可能误判表情包）'),
+    enableLink: koishi_1.Schema.boolean()
+        .default(true)
+        .description('启用链接去重'),
+    enableForward: koishi_1.Schema.boolean()
+        .default(true)
+        .description('启用转发消息去重'),
+    imageSimilarityThreshold: koishi_1.Schema.number()
+        .default(10)
+        .min(0)
+        .max(32)
+        .description('图片相似度阈值'),
+    linkExactMatch: koishi_1.Schema.boolean()
+        .default(true)
+        .description('链接是否要求完全匹配'),
+    forwardContentMaxLength: koishi_1.Schema.number()
+        .default(500)
+        .min(100)
+        .max(2000)
+        .description('转发消息内容摘要最大长度'),
+    retentionDays: koishi_1.Schema.number()
+        .default(7)
+        .min(1)
+        .max(30)
+        .description('数据保留天数'),
+    stickerDir: koishi_1.Schema.string()
+        .default('data/emojiluna/dup')
+        .description('表情包目录路径'),
+    sendMethod: koishi_1.Schema.union([
+        koishi_1.Schema.const('koishi').description('Koishi通用方式'),
+        koishi_1.Schema.const('onebot').description('OneBot API直接发送')
+    ])
+        .default('onebot')
+        .description('图片发送方式'),
+    excludedGuilds: koishi_1.Schema.array(String)
+        .default([])
+        .description('排除检测的群ID列表'),
+    excludedUsers: koishi_1.Schema.array(String)
+        .default([])
+        .description('排除检测的用户ID列表'),
+    debug: koishi_1.Schema.boolean()
+        .default(false)
+        .description('调试模式')
+});

package/lib/database.d.ts

@@ -0,0 +1,22 @@
+import { Context } from 'koishi';
+declare module 'koishi' {
+    interface Tables {
+        message_dedup: DedupRecord;
+    }
+}
+export interface DedupRecord {
+    id?: number;
+    guildId: string;
+    userId: string;
+    username: string;
+    timestamp: number;
+    contentType: 'image' | 'link' | 'forward';
+    contentHash: string;
+    originalMessageId: string;
+    originalContent: string;
+    extraInfo: string;
+}
+export declare function extendDatabase(ctx: Context): void;
+export declare function findDuplicate(ctx: Context, guildId: string, contentType: 'image' | 'link' | 'forward', contentHash: string, imageThreshold?: number): Promise<DedupRecord | null>;
+export declare function saveRecord(ctx: Context, record: DedupRecord): Promise<void>;
+export declare function cleanupOldRecords(ctx: Context, retentionDays: number): Promise<void>;

package/lib/database.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendDatabase = extendDatabase;
+exports.findDuplicate = findDuplicate;
+exports.saveRecord = saveRecord;
+exports.cleanupOldRecords = cleanupOldRecords;
+const hash_1 = require("./hash");
+function extendDatabase(ctx) {
+    ctx.model.extend('message_dedup', {
+        id: 'unsigned',
+        guildId: 'string',
+        userId: 'string',
+        username: 'string',
+        timestamp: 'integer',
+        contentType: 'string',
+        contentHash: 'string',
+        originalMessageId: 'string',
+        originalContent: 'text',
+        extraInfo: 'text'
+    }, {
+        primary: 'id',
+        autoInc: true
+    });
+}
+async function findDuplicate(ctx, guildId, contentType, contentHash, imageThreshold) {
+    const records = await ctx.database.get('message_dedup', {
+        guildId,
+        contentType
+    });
+    if (contentType === 'image' && imageThreshold !== undefined) {
+        // 图片需要计算汉明距离
+        // compareHashes返回0-1，0表示相同
+        // threshold是百分比阈值（如10表示10%）
+        const thresholdRatio = imageThreshold / 100;
+        for (const record of records) {
+            try {
+                const distance = (0, hash_1.calculateHashDistance)(contentHash, record.contentHash);
+                if (distance <= thresholdRatio) {
+                    return record;
+                }
+            }
+            catch {
+                // 哈希格式不匹配时跳过
+                continue;
+            }
+        }
+    }
+    else {
+        // 链接和转发消息直接匹配哈希
+        return records.find(r => r.contentHash === contentHash) || null;
+    }
+    return null;
+}
+async function saveRecord(ctx, record) {
+    await ctx.database.create('message_dedup', record);
+}
+async function cleanupOldRecords(ctx, retentionDays) {
+    const cutoffTime = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+    await ctx.database.remove('message_dedup', {
+        timestamp: { $lt: cutoffTime }
+    });
+}

package/lib/hash.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from 'koishi';
+/**
+ * 计算图片感知哈希(pHash)
+ */
+export declare function calculateImageHash(buffer: Buffer): Promise<string>;
+/**
+ * 计算两个哈希的汉明距离（返回0-1，0表示相同）
+ */
+export declare function calculateHashDistance(hash1: string, hash2: string): number;
+/**
+ * 从URL下载图片并计算哈希
+ */
+export declare function downloadAndHashImage(imageUrl: string, ctx: Context): Promise<string | null>;
+/**
+ * 提取消息中的URL
+ */
+export declare function extractUrls(text: string): string[];
+/**
+ * 计算字符串哈希（用于链接/转发消息）
+ */
+export declare function calculateStringHash(str: string): string;
+/**
+ * 标准化URL（去除跟踪参数等）
+ */
+export declare function normalizeUrl(url: string): string;

package/lib/hash.js

@@ -0,0 +1,121 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateImageHash = calculateImageHash;
+exports.calculateHashDistance = calculateHashDistance;
+exports.downloadAndHashImage = downloadAndHashImage;
+exports.extractUrls = extractUrls;
+exports.calculateStringHash = calculateStringHash;
+exports.normalizeUrl = normalizeUrl;
+const jimp_1 = require("jimp");
+/**
+ * 计算图片感知哈希(pHash)
+ */
+async function calculateImageHash(buffer) {
+    const image = await jimp_1.Jimp.read(buffer);
+    return image.pHash();
+}
+/**
+ * 计算两个哈希的汉明距离（返回0-1，0表示相同）
+ */
+function calculateHashDistance(hash1, hash2) {
+    return (0, jimp_1.compareHashes)(hash1, hash2);
+}
+/**
+ * 从URL下载图片并计算哈希
+ */
+async function downloadAndHashImage(imageUrl, ctx) {
+    try {
+        // 检查是否是data URI
+        if (imageUrl.startsWith('data:')) {
+            // data:image/png;base64,xxxxx
+            const base64Match = imageUrl.match(/^data:image\/[^;]+;base64,(.+)$/);
+            if (base64Match) {
+                const buffer = Buffer.from(base64Match[1], 'base64');
+                return await calculateImageHash(buffer);
+            }
+            return null;
+        }
+        // 检查是否是file URI
+        if (imageUrl.startsWith('file://')) {
+            const filePath = imageUrl.slice(7);
+            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+            const buffer = fs.readFileSync(filePath);
+            return await calculateImageHash(buffer);
+        }
+        // 使用http服务下载图片
+        if (!ctx.http) {
+            return null;
+        }
+        const response = await ctx.http.get(imageUrl, { responseType: 'arraybuffer' });
+        const buffer = Buffer.from(response);
+        return await calculateImageHash(buffer);
+    }
+    catch (err) {
+        return null;
+    }
+}
+/**
+ * 提取消息中的URL
+ */
+function extractUrls(text) {
+    const urlRegex = /https?:\/\/[^\s<>"{}|\\^`\[\]]+/gi;
+    return text.match(urlRegex) || [];
+}
+/**
+ * 计算字符串哈希（用于链接/转发消息）
+ */
+function calculateStringHash(str) {
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) + hash) + str.charCodeAt(i);
+        hash = hash & 0xFFFFFFFF;
+    }
+    return hash.toString(16);
+}
+/**
+ * 标准化URL（去除跟踪参数等）
+ */
+function normalizeUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        const trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content', 'spm', 'from'];
+        trackingParams.forEach(p => urlObj.searchParams.delete(p));
+        return urlObj.toString();
+    }
+    catch {
+        return url;
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+import { Context } from 'koishi';
+import { Config } from './config';
+export declare const name = "message-dedup";
+export declare const inject: {
+    readonly required: readonly ["database"];
+    readonly optional: readonly ["http"];
+};
+export { Config };
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,345 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.inject = exports.name = void 0;
+exports.apply = apply;
+const koishi_1 = require("koishi");
+const config_1 = require("./config");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
+const hash_1 = require("./hash");
+const database_1 = require("./database");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.name = 'message-dedup';
+exports.inject = {
+    required: ['database'],
+    optional: ['http']
+};
+function apply(ctx, config) {
+    const logger = ctx.logger('message-dedup');
+    // 扩展数据库模型
+    (0, database_1.extendDatabase)(ctx);
+    // 定期清理过期数据
+    const retentionDays = config.retentionDays ?? 7;
+    if (retentionDays > 0) {
+        ctx.setInterval(() => {
+            (0, database_1.cleanupOldRecords)(ctx, retentionDays).catch(err => {
+                logger.error('清理过期数据失败:', err);
+            });
+        }, 24 * 60 * 60 * 1000);
+    }
+    // 中间件处理消息
+    ctx.middleware(async (session, next) => {
+        // 只处理群消息
+        if (!session.guildId)
+            return next();
+        // 检查是否在排除列表
+        if (config.excludedGuilds.includes(session.guildId))
+            return next();
+        if (session.userId && config.excludedUsers.includes(session.userId))
+            return next();
+        try {
+            const result = await processMessage(session, config, ctx, logger);
+            if (result) {
+                await sendDuplicateWarning(session, result, config, ctx);
+                return;
+            }
+        }
+        catch (err) {
+            if (config.debug) {
+                logger.error('处理消息失败:', err);
+            }
+        }
+        return next();
+    });
+    if (config.debug) {
+        logger.info('message-dedup 插件已加载（调试模式）');
+    }
+}
+async function processMessage(session, config, ctx, logger) {
+    const elements = session.elements;
+    if (!elements || elements.length === 0)
+        return null;
+    const username = session.author?.nickname || session.author?.username || session.username || '未知用户';
+    const originalContent = session.content || extractTextFromElements(elements) || '';
+    // 1. 检查图片
+    if (config.enableImage) {
+        for (const elem of elements) {
+            if (elem.type === 'img' && elem.attrs?.src) {
+                const duplicate = await processImage(elem.attrs.src, session, username, originalContent, config, ctx, logger);
+                if (duplicate)
+                    return duplicate;
+            }
+        }
+    }
+    // 2. 检查链接
+    if (config.enableLink) {
+        const text = extractTextFromElements(elements);
+        const urls = (0, hash_1.extractUrls)(text);
+        for (const url of urls) {
+            const duplicate = await processLink(url, session, username, originalContent, config, ctx, logger);
+            if (duplicate)
+                return duplicate;
+        }
+    }
+    // 3. 检查转发消息
+    if (config.enableForward) {
+        for (const elem of elements) {
+            if (elem.type === 'forward') {
+                const duplicate = await processForward(elem, session, username, originalContent, config, ctx, logger);
+                if (duplicate)
+                    return duplicate;
+            }
+        }
+    }
+    return null;
+}
+function extractTextFromElements(elements) {
+    return elements.map(elem => {
+        if (elem.type === 'text') {
+            return elem.attrs?.content || '';
+        }
+        if (elem.children && elem.children.length > 0) {
+            return extractTextFromElements(elem.children);
+        }
+        return '';
+    }).join('');
+}
+async function processImage(imageUrl, session, username, originalContent, config, ctx, logger) {
+    try {
+        if (config.debug) {
+            logger.info(`处理图片: ${imageUrl}`);
+        }
+        const hash = await (0, hash_1.downloadAndHashImage)(imageUrl, ctx);
+        if (!hash) {
+            if (config.debug) {
+                logger.info(`无法计算图片哈希`);
+            }
+            return null;
+        }
+        if (config.debug) {
+            logger.info(`图片哈希: ${hash}`);
+        }
+        const guildId = session.guildId;
+        const duplicate = await (0, database_1.findDuplicate)(ctx, guildId, 'image', hash, config.imageSimilarityThreshold);
+        if (duplicate) {
+            if (config.debug) {
+                logger.info(`发现重复图片`);
+            }
+            return duplicate;
+        }
+        await (0, database_1.saveRecord)(ctx, {
+            guildId: session.guildId,
+            userId: session.userId,
+            username,
+            timestamp: Date.now(),
+            contentType: 'image',
+            contentHash: hash,
+            originalMessageId: session.messageId,
+            originalContent,
+            extraInfo: JSON.stringify({ url: imageUrl })
+        });
+        return null;
+    }
+    catch (err) {
+        if (config.debug) {
+            logger.error('处理图片失败:', err);
+        }
+        return null;
+    }
+}
+async function processLink(url, session, username, originalContent, config, ctx, logger) {
+    try {
+        const normalizedUrl = config.linkExactMatch ? url : (0, hash_1.normalizeUrl)(url);
+        const hash = (0, hash_1.calculateStringHash)(normalizedUrl);
+        if (config.debug) {
+            logger.info(`链接哈希: ${hash} URL: ${url}`);
+        }
+        const guildId = session.guildId;
+        const duplicate = await (0, database_1.findDuplicate)(ctx, guildId, 'link', hash);
+        if (duplicate) {
+            if (config.debug) {
+                logger.info(`发现重复链接`);
+            }
+            return duplicate;
+        }
+        await (0, database_1.saveRecord)(ctx, {
+            guildId: session.guildId,
+            userId: session.userId,
+            username,
+            timestamp: Date.now(),
+            contentType: 'link',
+            contentHash: hash,
+            originalMessageId: session.messageId,
+            originalContent,
+            extraInfo: JSON.stringify({ url })
+        });
+        return null;
+    }
+    catch (err) {
+        if (config.debug) {
+            logger.error('处理链接失败:', err);
+        }
+        return null;
+    }
+}
+async function processForward(forwardElem, session, username, originalContent, config, ctx, logger) {
+    try {
+        const content = extractForwardContent(forwardElem);
+        if (!content || content.length < 10) {
+            return null;
+        }
+        const truncated = content.slice(0, config.forwardContentMaxLength);
+        const hash = (0, hash_1.calculateStringHash)(truncated);
+        if (config.debug) {
+            logger.info(`转发消息哈希: ${hash}, 内容长度: ${content.length}`);
+        }
+        const guildId = session.guildId;
+        const duplicate = await (0, database_1.findDuplicate)(ctx, guildId, 'forward', hash);
+        if (duplicate) {
+            if (config.debug) {
+                logger.info(`发现重复转发消息`);
+            }
+            return duplicate;
+        }
+        await (0, database_1.saveRecord)(ctx, {
+            guildId: session.guildId,
+            userId: session.userId,
+            username,
+            timestamp: Date.now(),
+            contentType: 'forward',
+            contentHash: hash,
+            originalMessageId: session.messageId,
+            originalContent: truncated.slice(0, 100),
+            extraInfo: JSON.stringify({ preview: truncated.slice(0, 100) })
+        });
+        return null;
+    }
+    catch (err) {
+        if (config.debug) {
+            logger.error('处理转发消息失败:', err);
+        }
+        return null;
+    }
+}
+function extractForwardContent(elem) {
+    let content = '';
+    if (elem.attrs?.content) {
+        content += elem.attrs.content;
+    }
+    if (elem.attrs?.text) {
+        content += elem.attrs.text;
+    }
+    if (elem.children && elem.children.length > 0) {
+        for (const child of elem.children) {
+            content += extractForwardContent(child);
+        }
+    }
+    return content;
+}
+async function sendDuplicateWarning(session, duplicate, config, ctx) {
+    const date = new Date(duplicate.timestamp);
+    const dateStr = date.toLocaleString('zh-CN', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit'
+    });
+    const message = `此条news已被其他群友发布过\n原消息：${dateStr}\n发送人：${duplicate.username}`;
+    // 随机选择表情包
+    const stickerFile = getRandomSticker(ctx.baseDir, config.stickerDir);
+    // 根据配置选择发送方式
+    if (config.sendMethod === 'onebot' && session.platform === 'onebot' && session.bot?.internal) {
+        const groupId = Number(session.guildId);
+        try {
+            // 使用 reply CQ码引用原消息
+            const originalMsgId = duplicate.originalMessageId;
+            let cqMessage = `[CQ:reply,id=${originalMsgId}]${message}`;
+            // 添加表情包
+            if (stickerFile) {
+                const imageBase64 = fs.readFileSync(stickerFile).toString('base64');
+                cqMessage += `[CQ:image,file=base64://${imageBase64}]`;
+            }
+            await session.bot.internal.sendGroupMsg(groupId, cqMessage);
+            return;
+        }
+        catch (err) {
+            // OneBot 发送失败，回退到 Koishi 方式
+        }
+    }
+    // Koishi 通用方式，使用 quote 引用
+    if (stickerFile) {
+        const imageBase64 = fs.readFileSync(stickerFile).toString('base64');
+        const ext = path.extname(stickerFile).slice(1).toLowerCase();
+        const mimeType = ext === 'jpg' ? 'jpeg' : ext;
+        await session.send([
+            koishi_1.h.quote(duplicate.originalMessageId),
+            message,
+            koishi_1.h.img(`data:image/${mimeType};base64,${imageBase64}`)
+        ]);
+    }
+    else {
+        await session.send([koishi_1.h.quote(duplicate.originalMessageId), message]);
+    }
+}
+/**
+ * 从表情包目录随机选择一张图片
+ * 如果目录不存在或为空，使用插件内置默认表情包
+ */
+function getRandomSticker(baseDir, stickerDir) {
+    const supportedExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.webp'];
+    // 尝试用户配置的目录
+    const userDir = path.resolve(baseDir, stickerDir);
+    if (fs.existsSync(userDir)) {
+        const files = fs.readdirSync(userDir)
+            .filter(f => supportedExtensions.some(ext => f.toLowerCase().endsWith(ext)));
+        if (files.length > 0) {
+            const randomFile = files[Math.floor(Math.random() * files.length)];
+            return path.join(userDir, randomFile);
+        }
+    }
+    // 尝试插件内置默认表情包目录
+    const pluginAssetsDir = path.resolve(__dirname, '../assets');
+    if (fs.existsSync(pluginAssetsDir)) {
+        const files = fs.readdirSync(pluginAssetsDir)
+            .filter(f => supportedExtensions.some(ext => f.toLowerCase().endsWith(ext)));
+        if (files.length > 0) {
+            const randomFile = files[Math.floor(Math.random() * files.length)];
+            return path.join(pluginAssetsDir, randomFile);
+        }
+    }
+    return null;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "koishi-plugin-message-dedup",
+  "version": "0.0.1",
+  "description": "消息去重插件，检测群内重复的图片、链接、聊天记录",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "assets"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "watch": "tsc -p tsconfig.json --watch"
+  },
+  "peerDependencies": {
+    "koishi": "^4.18.0"
+  },
+  "keywords": [
+    "koishi",
+    "plugin",
+    "dedup",
+    "message"
+  ],
+  "license": "MIT",
+  "author": "FHfanshu",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FHfanshu/koishi-plugin-message-dedup"
+  },
+  "koishi": {
+    "description": {
+      "zh": "消息去重插件，检测群内重复的图片、链接、聊天记录并提醒"
+    },
+    "service": {
+      "required": [
+        "database"
+      ],
+      "optional": [
+        "http"
+      ]
+    }
+  }
+}