koishi-plugin-memesluna 0.4.6 → 0.4.7

package/lib/index.js

@@ -36,7 +36,8 @@ __export(index_exports, {
   hashImageBuffer: () => hashImageBuffer,
   inject: () => inject,
   isReservedPath: () => isReservedPath,
-  name: () => name
+  name: () => name,
+  sanitizeFilename: () => sanitizeFilename
 });
 module.exports = __toCommonJS(index_exports);
 var import_fs = require("fs");
@@ -48,6 +49,13 @@ var import_crypto = require("crypto");
 var import_promises = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
 var import_koishi = require("koishi");
+function sanitizeFilename(filename) {
+  const ext = import_path.default.extname(filename).toLowerCase();
+  const base = import_path.default.basename(filename, ext);
+  const safeBase = base.replace(/[\s/\\?%*:|"<>,;=@]/g, "_");
+  return `${safeBase}${ext}`;
+}
+__name(sanitizeFilename, "sanitizeFilename");
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".jpg",
   ".jpeg",
@@ -265,55 +273,42 @@ var MemesLunaService = class extends import_koishi.Service {
         return;
       }
       const existingImages = await this.ctx.database.get("memesluna_images", { collection: colName });
-      const existingIndices = new Set(existingImages.map((img) => img.index));
+      const existingFilenames = new Set(existingImages.map((img) => img.filename));
       const existingExternalValues = new Set(
         existingImages.filter((img) => img.type === "external").map((img) => img.value)
       );
+      const existingIndices = new Set(existingImages.map((img) => img.index));
       let maxIndex = existingImages.reduce((max, img) => Math.max(max, img.index), 0);
       for (const filename of files) {
-        const ext = import_path.default.extname(filename).toLowerCase();
-        const basename = import_path.default.basename(filename, ext);
-        let index = parseInt(basename, 10);
-        if (isNaN(index) || String(index) !== basename || index < 1 || index > 99999) {
-          index = ++maxIndex;
-          const newFilename = `${index}${ext}`;
+        const safeName = sanitizeFilename(filename);
+        let currentName = filename;
+        if (safeName !== filename) {
           const oldPath = import_path.default.join(colDir, filename);
-          const newPath = import_path.default.join(colDir, newFilename);
+          const newPath = import_path.default.join(colDir, safeName);
           try {
             await import_promises.default.rename(oldPath, newPath);
+            currentName = safeName;
+          } catch {
+          }
+        }
+        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)(),
               collection: colName,
               index,
-              filename: newFilename,
+              filename: currentName,
               type: "local",
-              value: newFilename,
-              mime: this.getMimeByFilename(newFilename),
-              ...await this.getImageFingerprints(await import_promises.default.readFile(newPath)),
+              value: currentName,
+              mime: this.getMimeByFilename(currentName),
+              ...await this.getImageFingerprints(await import_promises.default.readFile(fullPath)),
               created_at: /* @__PURE__ */ new Date()
             });
-            existingIndices.add(index);
+            existingFilenames.add(currentName);
           } catch {
           }
-        } else {
-          if (!existingIndices.has(index)) {
-            try {
-              await this.ctx.database.create("memesluna_images", {
-                id: (0, import_crypto.randomUUID)(),
-                collection: colName,
-                index,
-                filename,
-                type: "local",
-                value: filename,
-                mime: this.getMimeByFilename(filename),
-                ...await this.getImageFingerprints(await import_promises.default.readFile(import_path.default.join(colDir, filename))),
-                created_at: /* @__PURE__ */ new Date()
-              });
-              existingIndices.add(index);
-              maxIndex = Math.max(maxIndex, index);
-            } catch {
-            }
-          }
         }
       }
       const linksFile = this.getCollectionLinksFile(colName);
@@ -843,6 +838,19 @@ var MemesLunaService = class extends import_koishi.Service {
       }
     }
   }
+  async deduplicateDatabaseFilename(collectionName, filename) {
+    const parsed = import_path.default.parse(filename);
+    let counter = 1;
+    let candidate = filename;
+    while (true) {
+      const rows = await this.ctx.database.get("memesluna_images", { collection: collectionName, filename: candidate });
+      if (!rows.length) {
+        return candidate;
+      }
+      candidate = `${parsed.name}_${counter}${parsed.ext}`;
+      counter++;
+    }
+  }
   async addLocalImageBuffer(collectionName, buffer, originalName, extHint) {
     this.ensureCollectionName(collectionName);
     if (!await this.collectionExists(collectionName)) {
@@ -863,7 +871,9 @@ var MemesLunaService = class extends import_koishi.Service {
     if (!IMAGE_EXTENSIONS.has(finalExt)) {
       throw new Error("Unsupported image format");
     }
-    const finalName = `${index}${finalExt}`;
+    const baseName = originalName ? import_path.default.basename(originalName, import_path.default.extname(originalName)) : `image-${Date.now()}`;
+    const safeBase = sanitizeFilename(`${baseName}${finalExt}`);
+    const finalName = await this.deduplicateDatabaseFilename(collectionName, safeBase);
     const backend = this.getStorageBackend();
     if (backend) {
       const result = await backend.upload(buffer, finalName);
@@ -1948,6 +1958,24 @@ function applyServer(ctx, config, service) {
     );
     setKoaResponse(koa, result);
   });
+  ctx.server.get(`${basePath}/:name/:filename`, async (koa) => {
+    const collectionName = toTrimmedString(koa.params.name);
+    const filename = toTrimmedString(koa.params.filename);
+    if (isReservedPath(collectionName)) {
+      koa.status = 404;
+      koa.body = { error: "Not Found" };
+      return;
+    }
+    const image = await service.getLocalImageBuffer(collectionName, filename);
+    if (!image) {
+      koa.status = 404;
+      koa.body = { error: "Image not found" };
+      return;
+    }
+    koa.status = 200;
+    koa.set("Content-Type", image.mime);
+    koa.body = image.buffer;
+  });
 }
 __name(applyServer, "applyServer");
 function apply(ctx, config) {
@@ -2082,5 +2110,6 @@ var inject = {
   hashImageBuffer,
   inject,
   isReservedPath,
-  name
+  name,
+  sanitizeFilename
 });

package/lib/service.d.ts

@@ -1,5 +1,6 @@
 import { Context, Service } from 'koishi';
 import type { Config } from './config';
+export declare function sanitizeFilename(filename: string): string;
 export declare function hashImageBuffer(buffer: Buffer): string;
 export declare function isReservedPath(name: string): boolean;
 export interface ApiEndpoint {
@@ -117,6 +118,7 @@ export declare class MemesLunaService extends Service {
     private buildStagedFilename;
     private resolveStagedImagePath;
     private deduplicateFilename;
+    private deduplicateDatabaseFilename;
     addLocalImageBuffer(collectionName: string, buffer: Buffer, originalName?: string, extHint?: string): Promise<string>;
     addLocalImageBase64(collectionName: string, base64Data: string, originalName?: string): Promise<string>;
     addStagedImageBuffer(buffer: Buffer, originalName?: string, source?: string, reason?: string): Promise<StagedImageInfo>;

package/package.json

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