koishi-plugin-memesluna 0.5.1 → 0.5.2

package/lib/index.js

@@ -293,7 +293,6 @@ var MemesLunaService = class extends import_koishi.Service {
         }
         if (!existingFilenames.has(currentName)) {
           const index = ++maxIndex;
-          const fullPath = import_path.default.join(colDir, currentName);
           try {
             await this.ctx.database.create("memesluna_images", {
               id: (0, import_crypto.randomUUID)(),
@@ -303,7 +302,8 @@ var MemesLunaService = class extends import_koishi.Service {
               type: "local",
               value: currentName,
               mime: this.getMimeByFilename(currentName),
-              ...await this.getImageFingerprints(await import_promises.default.readFile(fullPath)),
+              hash: "",
+              perceptual_hash: "",
               created_at: /* @__PURE__ */ new Date()
             });
             existingFilenames.add(currentName);
@@ -343,7 +343,9 @@ var MemesLunaService = class extends import_koishi.Service {
     await import_promises.default.mkdir(this.getStorageRoot(), { recursive: true });
     await import_promises.default.mkdir(this.getStagingDir(), { recursive: true });
     await this.syncExistingFilesToDatabase();
-    await this.backfillImageFingerprints();
+    this.backfillImageFingerprints().catch((err) => {
+      this.ctx.logger("memesluna").warn("Failed to backfill image fingerprints in background:", err);
+    });
   }
   async getImagePerceptualHash(buffer) {
     const photon = loadPhoton();
@@ -911,6 +913,78 @@ var MemesLunaService = class extends import_koishi.Service {
     const buffer = Buffer.from(base64, "base64");
     return this.addLocalImageBuffer(collectionName, buffer, originalName, extHint);
   }
+  async addLocalImagesBase64(collectionName, images) {
+    this.ensureCollectionName(collectionName);
+    if (!await this.collectionExists(collectionName)) {
+      throw new Error(`Collection not found: ${collectionName}`);
+    }
+    const maxImg = await this.ctx.database.get("memesluna_images", { collection: collectionName }, { limit: 1, sort: { index: "desc" } });
+    let nextIndex = maxImg.length ? maxImg[0].index + 1 : 1;
+    const backend = this.getStorageBackend();
+    const results = [];
+    const processPromises = images.map(async (img) => {
+      const { base64, extHint } = this.normalizeBase64(img.base64Data);
+      const buffer = Buffer.from(base64, "base64");
+      if (!buffer.length) {
+        throw new Error("Invalid image payload");
+      }
+      const fingerprints = await this.getImageFingerprints(buffer);
+      const duplicate = await this.getDuplicateImageByHash(fingerprints.hash, { includeStaged: false, includeImages: true });
+      if (duplicate) {
+        throw new Error("Duplicate image already exists: " + duplicate);
+      }
+      const rawExt = (import_path.default.parse(img.originalName ?? "").ext || (extHint ? `.${extHint}` : "") || ".png").toLowerCase();
+      const finalExt = rawExt === ".jpeg" ? ".jpg" : rawExt;
+      if (!IMAGE_EXTENSIONS.has(finalExt)) {
+        throw new Error("Unsupported image format");
+      }
+      const baseName = img.originalName ? import_path.default.basename(img.originalName, import_path.default.extname(img.originalName)) : `image-${Date.now()}`;
+      const safeBase = sanitizeFilename(`${baseName}${finalExt}`);
+      return {
+        buffer,
+        fingerprints,
+        safeBase
+      };
+    });
+    const processed = await Promise.all(processPromises);
+    const databaseRows = [];
+    for (const p of processed) {
+      const index = nextIndex++;
+      const finalName = await this.deduplicateDatabaseFilename(collectionName, p.safeBase);
+      if (backend) {
+        const result = await backend.upload(p.buffer, finalName);
+        databaseRows.push({
+          id: (0, import_crypto.randomUUID)(),
+          collection: collectionName,
+          index,
+          filename: finalName,
+          type: "storage",
+          value: result.key,
+          public_url: result.publicUrl || "",
+          mime: this.getMimeByFilename(finalName),
+          ...p.fingerprints,
+          created_at: /* @__PURE__ */ new Date()
+        });
+      } else {
+        const dir = this.getCollectionDir(collectionName);
+        await import_promises.default.writeFile(import_path.default.join(dir, finalName), p.buffer);
+        databaseRows.push({
+          id: (0, import_crypto.randomUUID)(),
+          collection: collectionName,
+          index,
+          filename: finalName,
+          type: "local",
+          value: finalName,
+          mime: this.getMimeByFilename(finalName),
+          ...p.fingerprints,
+          created_at: /* @__PURE__ */ new Date()
+        });
+      }
+      results.push(finalName);
+    }
+    await Promise.all(databaseRows.map((row) => this.ctx.database.create("memesluna_images", row)));
+    return results;
+  }
   async addStagedImageBuffer(buffer, originalName, source = "filter", reason = "") {
     if (!buffer.length) {
       throw new Error("Invalid image payload");
@@ -1450,6 +1524,13 @@ function hitDailyAutoCollectLimit(groupId, limit) {
   return false;
 }
 __name(hitDailyAutoCollectLimit, "hitDailyAutoCollectLimit");
+function isDailyAutoCollectLimitReached(groupId, limit) {
+  const day = getDailyKey();
+  const current = autoCollectDailyLimits.get(groupId);
+  if (!current || current.day !== day) return false;
+  return current.count >= limit;
+}
+__name(isDailyAutoCollectLimitReached, "isDailyAutoCollectLimitReached");
 function trackImageFrequency(hash, groupId, windowMs) {
   const now = Date.now();
   const key = `${groupId}:${hash}`;
@@ -1652,6 +1733,7 @@ function applyAutoCollect(ctx, config) {
     const groupId = getSessionGroupId(session);
     if (!groupId) return;
     if (whitelist.size && !whitelist.has(groupId)) return;
+    if (isDailyAutoCollectLimitReached(groupId, dailyLimit)) return;
     const imageUrls = getMessageImages(session);
     if (!imageUrls.length) return;
     const service = ctx.memesluna;
@@ -1834,18 +1916,20 @@ function applyServer(ctx, config, service) {
       koa.body = { error: "No images provided" };
       return;
     }
-    const uploaded = [];
-    for (const item of items) {
-      const base64 = toTrimmedString(item.base64);
-      const originalName = toTrimmedString(item.originalName);
-      if (!base64) continue;
-      const saved = await service.addLocalImageBase64(collectionName, base64, originalName || void 0);
-      uploaded.push(saved);
+    try {
+      const imagesToUpload = items.map((item) => ({
+        base64Data: toTrimmedString(item.base64),
+        originalName: toTrimmedString(item.originalName) || void 0
+      })).filter((img) => img.base64Data);
+      const uploaded = await service.addLocalImagesBase64(collectionName, imagesToUpload);
+      koa.body = {
+        ok: true,
+        uploaded
+      };
+    } catch (error) {
+      koa.status = 400;
+      koa.body = { error: error.message || "Failed to upload images" };
     }
-    koa.body = {
-      ok: true,
-      uploaded
-    };
   });
   ctx.server.delete(`${basePath}/api/admin/collections/:name/images/:filename`, async (koa) => {
     const collectionName = toTrimmedString(koa.params.name);
@@ -2119,8 +2203,7 @@ function apply(ctx, config) {
         if (!ext) {
           return "图片格式不兼容，仅支持 JPG/PNG/GIF/WEBP/BMP 格式图片（已拒绝 AVIF，且不会放入暂缓区）";
         }
-        const base64 = buffer.toString("base64");
-        const filename = await service.addLocalImageBase64(name2, base64, `stole${ext}`);
+        const filename = await service.addLocalImageBuffer(name2, buffer, `stole${ext}`);
         savedFilenames.push(filename);
         successCount++;
       } catch (err) {

package/lib/service.d.ts

@@ -121,6 +121,10 @@ export declare class MemesLunaService extends Service {
     private deduplicateDatabaseFilename;
     addLocalImageBuffer(collectionName: string, buffer: Buffer, originalName?: string, extHint?: string): Promise<string>;
     addLocalImageBase64(collectionName: string, base64Data: string, originalName?: string): Promise<string>;
+    addLocalImagesBase64(collectionName: string, images: Array<{
+        base64Data: string;
+        originalName?: string;
+    }>): Promise<string[]>;
     addStagedImageBuffer(buffer: Buffer, originalName?: string, source?: string, reason?: string): Promise<StagedImageInfo>;
     addStagedImageBase64(base64Data: string, originalName?: string, source?: string, reason?: string): Promise<StagedImageInfo>;
     getStagedImages(): Promise<StagedImageInfo[]>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-memesluna",
   "description": "Image Forward service for Koishi with ChatLuna integration",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "types": "lib/index.d.ts",