koishi-plugin-memesluna 0.4.5 → 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",
@@ -213,17 +221,6 @@ var MemesLunaService = class extends import_koishi.Service {
         indexes: ["hash"]
       }
     );
-    this.ctx.database.extend(
-      "memesluna_collection_stats",
-      {
-        collection: "string",
-        api_call_count: "integer",
-        updated_at: "timestamp"
-      },
-      {
-        primary: "collection"
-      }
-    );
     this.ctx.database.extend(
       "memesluna_staged_images",
       {
@@ -276,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);
@@ -854,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)) {
@@ -874,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);
@@ -1107,7 +1106,6 @@ var MemesLunaService = class extends import_koishi.Service {
     }
     const createdAt = dates.length ? new Date(Math.min(...dates.map((date) => date.getTime()), statCreatedAt?.getTime() || Infinity)) : statCreatedAt;
     const updatedAt = dates.length ? new Date(Math.max(...dates.map((date) => date.getTime()), statUpdatedAt?.getTime() || 0)) : statUpdatedAt;
-    const apiCallCount = await this.getCollectionApiCallCount(collectionName);
     return {
       name: collectionName,
       description,
@@ -1117,36 +1115,9 @@ var MemesLunaService = class extends import_koishi.Service {
       hasContent: localImages.length > 0 || links.length > 0,
       createdAt,
       updatedAt,
-      apiCallCount,
       cover: localImages[0]
     };
   }
-  async getCollectionApiCallCount(collectionName) {
-    if (!this.isValidCollectionName(collectionName)) {
-      return 0;
-    }
-    const rows = await this.ctx.database.get("memesluna_collection_stats", { collection: collectionName });
-    return rows[0]?.api_call_count || 0;
-  }
-  async incrementCollectionApiCallCount(collectionName) {
-    if (!this.isValidCollectionName(collectionName)) {
-      return;
-    }
-    const rows = await this.ctx.database.get("memesluna_collection_stats", { collection: collectionName });
-    const now = /* @__PURE__ */ new Date();
-    if (rows.length) {
-      await this.ctx.database.set("memesluna_collection_stats", { collection: collectionName }, {
-        api_call_count: (rows[0].api_call_count || 0) + 1,
-        updated_at: now
-      });
-      return;
-    }
-    await this.ctx.database.create("memesluna_collection_stats", {
-      collection: collectionName,
-      api_call_count: 1,
-      updated_at: now
-    });
-  }
   async getRandomResource(collectionName) {
     if (!this.isValidCollectionName(collectionName)) {
       return null;
@@ -1366,7 +1337,6 @@ async function applyDynamicForward(ctx, config, service, routeName, _query, requ
   if (!resource) {
     return { notFound: true };
   }
-  await service.incrementCollectionApiCallCount(routeName);
   if (resource.type === "external") {
     return { redirectTo: resource.value };
   }
@@ -1988,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) {
@@ -2122,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 {
@@ -28,7 +29,6 @@ export interface CollectionInfo {
     hasContent: boolean;
     createdAt?: Date;
     updatedAt?: Date;
-    apiCallCount: number;
     cover?: string;
 }
 export interface CollectionResource {
@@ -118,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>;
@@ -133,8 +134,6 @@ export declare class MemesLunaService extends Service {
     deleteImageFromCollection(collectionName: string, filename: string): Promise<boolean>;
     moveImageToCollection(sourceCollection: string, targetCollection: string, filename: string): Promise<string | null>;
     getCollectionInfo(collectionName: string): Promise<CollectionInfo | null>;
-    getCollectionApiCallCount(collectionName: string): Promise<number>;
-    incrementCollectionApiCallCount(collectionName: string): Promise<void>;
     getRandomResource(collectionName: string): Promise<CollectionResource | null>;
     private mapEndpoint;
     getEndpoints(): Promise<ApiEndpoint[]>;
@@ -177,11 +176,6 @@ declare module 'koishi' {
             perceptual_hash: string;
             created_at: Date;
         };
-        memesluna_collection_stats: {
-            collection: string;
-            api_call_count: number;
-            updated_at: Date;
-        };
         memesluna_staged_images: {
             id: string;
             filename: string;

package/package.json

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