koishi-plugin-memesluna 0.2.2 → 0.2.4

package/lib/index.js

@@ -5,8 +5,8 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -16,7 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -26,18 +25,518 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Config: () => Config,
+  MemesLunaService: () => MemesLunaService,
   apply: () => apply,
-  inject: () => inject
+  inject: () => inject,
+  name: () => name
 });
 module.exports = __toCommonJS(index_exports);
+var import_promises2 = __toESM(require("fs/promises"));
+var import_path2 = __toESM(require("path"));
+
+// src/service.ts
+var import_crypto = require("crypto");
 var import_promises = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
-var import_service = require("./service");
-__reExport(index_exports, require("./config"), module.exports);
-__reExport(index_exports, require("./service"), module.exports);
-const RESERVED_PATHS = /* @__PURE__ */ new Set([
+var import_koishi = require("koishi");
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".gif",
+  ".bmp",
+  ".webp",
+  ".svg",
+  ".tif",
+  ".tiff",
+  ".avif",
+  ".psd"
+]);
+var COLLECTION_NAME_REGEXP = /^[a-zA-Z0-9_-]+$/;
+var ENDPOINT_NAME_REGEXP = /^[a-zA-Z0-9_-]+$/;
+var MemesLunaService = class extends import_koishi.Service {
+  constructor(ctx, config) {
+    super(ctx, "memesluna", true);
+    this.config = config;
+    this.defineDatabase();
+    this._readyPromise = new Promise((resolve) => {
+      this._readyResolve = resolve;
+    });
+    ctx.on("ready", async () => {
+      await this.ensureStorage();
+      this._readyResolve();
+    });
+  }
+  _readyPromise;
+  _readyResolve;
+  static inject = ["database"];
+  get ready() {
+    return this._readyPromise;
+  }
+  defineDatabase() {
+    this.ctx.database.extend(
+      "memesluna_endpoints",
+      {
+        id: "string",
+        name: "string",
+        group: "string",
+        description: "string",
+        url: "string",
+        method: "string",
+        url_construction: "string",
+        model_name: "string",
+        query_params: "string",
+        proxy_settings: "string",
+        created_at: "timestamp",
+        updated_at: "timestamp"
+      },
+      {
+        primary: "id",
+        unique: ["name"]
+      }
+    );
+  }
+  getStorageRoot() {
+    return import_path.default.resolve(this.ctx.baseDir, this.config.storagePath);
+  }
+  async ensureStorage() {
+    await import_promises.default.mkdir(this.getStorageRoot(), { recursive: true });
+  }
+  ensureCollectionName(name2) {
+    if (!name2 || !COLLECTION_NAME_REGEXP.test(name2)) {
+      throw new Error("Invalid collection name: only letters, numbers, _ and - are allowed.");
+    }
+  }
+  ensureEndpointName(name2) {
+    if (!name2 || !ENDPOINT_NAME_REGEXP.test(name2)) {
+      throw new Error("Invalid endpoint name: only letters, numbers, _ and - are allowed.");
+    }
+  }
+  getCollectionDir(collectionName) {
+    return import_path.default.join(this.getStorageRoot(), collectionName);
+  }
+  getCollectionLinksFile(collectionName) {
+    return import_path.default.join(this.getCollectionDir(collectionName), `${collectionName}.txt`);
+  }
+  getCollectionDescriptionFile(collectionName) {
+    return import_path.default.join(this.getCollectionDir(collectionName), ".description");
+  }
+  async getCollectionDescription(collectionName) {
+    try {
+      return (await import_promises.default.readFile(this.getCollectionDescriptionFile(collectionName), "utf8")).trim();
+    } catch {
+      return "";
+    }
+  }
+  async setCollectionDescription(collectionName, description) {
+    if (!await this.collectionExists(collectionName)) {
+      return false;
+    }
+    await import_promises.default.writeFile(this.getCollectionDescriptionFile(collectionName), description.trim(), "utf8");
+    return true;
+  }
+  async collectionExists(collectionName) {
+    const dir = this.getCollectionDir(collectionName);
+    try {
+      const stat = await import_promises.default.stat(dir);
+      return stat.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  async getCollections() {
+    const root = this.getStorageRoot();
+    try {
+      const entries = await import_promises.default.readdir(root, { withFileTypes: true });
+      return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    } catch {
+      return [];
+    }
+  }
+  async createCollection(collectionName) {
+    this.ensureCollectionName(collectionName);
+    const dir = this.getCollectionDir(collectionName);
+    try {
+      await import_promises.default.mkdir(dir);
+      return true;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async deleteCollection(collectionName) {
+    this.ensureCollectionName(collectionName);
+    const dir = this.getCollectionDir(collectionName);
+    try {
+      await import_promises.default.rm(dir, { recursive: true, force: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  isImageFile(filename) {
+    const ext = import_path.default.extname(filename).toLowerCase();
+    return IMAGE_EXTENSIONS.has(ext);
+  }
+  ensureSafeImageFilename(filename) {
+    const normalized = import_path.default.basename(filename || "");
+    if (!filename || normalized !== filename || filename.includes("/") || filename.includes("\\")) {
+      throw new Error("Invalid image filename");
+    }
+    if (!this.isImageFile(normalized)) {
+      throw new Error("Invalid image filename");
+    }
+    return normalized;
+  }
+  getMimeByFilename(filename) {
+    const ext = import_path.default.extname(filename).toLowerCase();
+    if (ext === ".png") return "image/png";
+    if (ext === ".gif") return "image/gif";
+    if (ext === ".webp") return "image/webp";
+    if (ext === ".bmp") return "image/bmp";
+    if (ext === ".svg") return "image/svg+xml";
+    if (ext === ".avif") return "image/avif";
+    if (ext === ".tif" || ext === ".tiff") return "image/tiff";
+    return "image/jpeg";
+  }
+  resolveLocalImagePath(collectionName, filename) {
+    const safeName = this.ensureSafeImageFilename(filename);
+    return import_path.default.join(this.getCollectionDir(collectionName), safeName);
+  }
+  async getLocalImageBuffer(collectionName, filename) {
+    if (!await this.collectionExists(collectionName)) {
+      return null;
+    }
+    let fullPath;
+    try {
+      fullPath = this.resolveLocalImagePath(collectionName, filename);
+    } catch {
+      return null;
+    }
+    try {
+      const buffer = await import_promises.default.readFile(fullPath);
+      return {
+        buffer,
+        mime: this.getMimeByFilename(fullPath)
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getCollectionImages(collectionName) {
+    if (!await this.collectionExists(collectionName)) {
+      return [];
+    }
+    const dir = this.getCollectionDir(collectionName);
+    const entries = await import_promises.default.readdir(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile() && this.isImageFile(entry.name)).map((entry) => entry.name).sort();
+  }
+  async getCollectionLinks(collectionName) {
+    if (!await this.collectionExists(collectionName)) {
+      return [];
+    }
+    const linksPath = this.getCollectionLinksFile(collectionName);
+    try {
+      const text = await import_promises.default.readFile(linksPath, "utf8");
+      return text.split(/\r?\n/g).map((line) => line.trim()).filter((line) => line.startsWith("http://") || line.startsWith("https://"));
+    } catch {
+      return [];
+    }
+  }
+  async addLinksToCollection(collectionName, links) {
+    if (!await this.collectionExists(collectionName)) {
+      throw new Error(`Collection not found: ${collectionName}`);
+    }
+    const normalized = links.map((link) => link.trim()).filter((link) => link.startsWith("http://") || link.startsWith("https://"));
+    if (!normalized.length) {
+      return 0;
+    }
+    const current = await this.getCollectionLinks(collectionName);
+    const merged = [...current];
+    for (const link of normalized) {
+      if (!merged.includes(link)) {
+        merged.push(link);
+      }
+    }
+    const linksPath = this.getCollectionLinksFile(collectionName);
+    await import_promises.default.writeFile(linksPath, `${merged.join("\n")}${merged.length ? "\n" : ""}`, "utf8");
+    return merged.length - current.length;
+  }
+  async removeLinkFromCollection(collectionName, link) {
+    if (!await this.collectionExists(collectionName)) {
+      return false;
+    }
+    const current = await this.getCollectionLinks(collectionName);
+    const next = current.filter((item) => item !== link);
+    if (next.length === current.length) {
+      return false;
+    }
+    const linksPath = this.getCollectionLinksFile(collectionName);
+    await import_promises.default.writeFile(linksPath, `${next.join("\n")}${next.length ? "\n" : ""}`, "utf8");
+    return true;
+  }
+  detectExtFromDataUrl(dataUrl) {
+    const matched = /^data:image\/([a-zA-Z0-9+.-]+);base64,/i.exec(dataUrl);
+    const ext = matched?.[1]?.toLowerCase();
+    if (!ext) return "png";
+    if (ext === "jpeg") return "jpg";
+    return ext;
+  }
+  normalizeBase64(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith("data:")) {
+      const extHint = this.detectExtFromDataUrl(trimmed);
+      const index = trimmed.indexOf(",");
+      return {
+        base64: index >= 0 ? trimmed.slice(index + 1) : trimmed,
+        extHint
+      };
+    }
+    return { base64: trimmed };
+  }
+  buildSafeFilename(originalName, extHint) {
+    const fallbackName = `${Date.now()}-${Math.floor(Math.random() * 1e4)}`;
+    const src = (originalName ?? fallbackName).trim();
+    const parsed = import_path.default.parse(src);
+    const sanitizedBase = (parsed.name || fallbackName).replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+    const rawExt = (parsed.ext || (extHint ? `.${extHint}` : "") || ".png").toLowerCase();
+    const normalizedExt = rawExt === ".jpeg" ? ".jpg" : rawExt;
+    const finalExt = IMAGE_EXTENSIONS.has(normalizedExt) ? normalizedExt : ".png";
+    return `${sanitizedBase}${finalExt}`;
+  }
+  async deduplicateFilename(collectionDir, filename) {
+    const parsed = import_path.default.parse(filename);
+    let counter = 1;
+    let candidate = filename;
+    while (true) {
+      try {
+        await import_promises.default.access(import_path.default.join(collectionDir, candidate));
+        candidate = `${parsed.name}_${counter}${parsed.ext}`;
+        counter++;
+      } catch {
+        return candidate;
+      }
+    }
+  }
+  async addLocalImageBase64(collectionName, base64Data, originalName) {
+    if (!await this.collectionExists(collectionName)) {
+      throw new Error(`Collection not found: ${collectionName}`);
+    }
+    const { base64, extHint } = this.normalizeBase64(base64Data);
+    const buffer = Buffer.from(base64, "base64");
+    if (!buffer.length) {
+      throw new Error("Invalid image base64 payload");
+    }
+    const dir = this.getCollectionDir(collectionName);
+    const initialName = this.buildSafeFilename(originalName, extHint);
+    const finalName = await this.deduplicateFilename(dir, initialName);
+    await import_promises.default.writeFile(import_path.default.join(dir, finalName), buffer);
+    return finalName;
+  }
+  async deleteImageFromCollection(collectionName, filename) {
+    if (!await this.collectionExists(collectionName)) {
+      return false;
+    }
+    let safeName;
+    try {
+      safeName = this.ensureSafeImageFilename(filename);
+    } catch {
+      return false;
+    }
+    const fullPath = import_path.default.join(this.getCollectionDir(collectionName), safeName);
+    try {
+      await import_promises.default.unlink(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async moveImageToCollection(sourceCollection, targetCollection, filename) {
+    if (!await this.collectionExists(sourceCollection) || !await this.collectionExists(targetCollection)) {
+      return null;
+    }
+    let safeName;
+    try {
+      safeName = this.ensureSafeImageFilename(filename);
+    } catch {
+      return null;
+    }
+    const sourcePath = import_path.default.join(this.getCollectionDir(sourceCollection), safeName);
+    const targetDir = this.getCollectionDir(targetCollection);
+    const targetName = await this.deduplicateFilename(targetDir, safeName);
+    const targetPath = import_path.default.join(targetDir, targetName);
+    try {
+      await import_promises.default.rename(sourcePath, targetPath);
+      return targetName;
+    } catch {
+      return null;
+    }
+  }
+  async getCollectionInfo(collectionName) {
+    if (!await this.collectionExists(collectionName)) {
+      return null;
+    }
+    const localImages = await this.getCollectionImages(collectionName);
+    const links = await this.getCollectionLinks(collectionName);
+    const description = await this.getCollectionDescription(collectionName);
+    return {
+      name: collectionName,
+      description,
+      localCount: localImages.length,
+      linkCount: links.length,
+      totalCount: localImages.length + links.length,
+      hasContent: localImages.length > 0 || links.length > 0,
+      cover: localImages[0]
+    };
+  }
+  async getRandomResource(collectionName) {
+    if (!await this.collectionExists(collectionName)) {
+      return null;
+    }
+    const localImages = await this.getCollectionImages(collectionName);
+    const links = await this.getCollectionLinks(collectionName);
+    const pool = [
+      ...localImages.map((name2) => ({
+        type: "local",
+        value: import_path.default.join(this.getCollectionDir(collectionName), name2)
+      })),
+      ...links.map((link) => ({ type: "external", value: link }))
+    ];
+    if (!pool.length) {
+      return null;
+    }
+    return pool[Math.floor(Math.random() * pool.length)];
+  }
+  parseJsonField(value, fallback) {
+    if (!value) return fallback;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return fallback;
+    }
+  }
+  mapEndpoint(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      group: row.group || "\u9ED8\u8BA4\u5206\u7EC4",
+      description: row.description || "",
+      url: row.url,
+      method: row.method || "redirect",
+      urlConstruction: row.url_construction || "normal",
+      modelName: row.model_name || "",
+      queryParams: this.parseJsonField(row.query_params, []),
+      proxySettings: this.parseJsonField(row.proxy_settings, {
+        fallbackAction: "returnJson"
+      }),
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  async getEndpoints() {
+    const rows = await this.ctx.database.get("memesluna_endpoints", {});
+    return rows.map((row) => this.mapEndpoint(row)).sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async getEndpointByName(name2) {
+    const rows = await this.ctx.database.get("memesluna_endpoints", { name: name2 });
+    if (!rows.length) return null;
+    return this.mapEndpoint(rows[0]);
+  }
+  async addEndpoint(input) {
+    this.ensureEndpointName(input.name);
+    if (!input.url) {
+      throw new Error("Endpoint URL is required.");
+    }
+    const id = (0, import_crypto.randomUUID)();
+    const now = /* @__PURE__ */ new Date();
+    await this.ctx.database.create("memesluna_endpoints", {
+      id,
+      name: input.name,
+      group: input.group || "\u9ED8\u8BA4\u5206\u7EC4",
+      description: input.description || "",
+      url: input.url,
+      method: input.method || "redirect",
+      url_construction: input.urlConstruction || "normal",
+      model_name: input.modelName || "",
+      query_params: JSON.stringify(input.queryParams || []),
+      proxy_settings: JSON.stringify({
+        fallbackAction: "returnJson",
+        ...input.proxySettings || {}
+      }),
+      created_at: now,
+      updated_at: now
+    });
+    return id;
+  }
+  async updateEndpoint(name2, input) {
+    const current = await this.getEndpointByName(name2);
+    if (!current) {
+      return false;
+    }
+    const payload = {
+      updated_at: /* @__PURE__ */ new Date()
+    };
+    if (input.group !== void 0) payload.group = input.group || "\u9ED8\u8BA4\u5206\u7EC4";
+    if (input.description !== void 0) payload.description = input.description || "";
+    if (input.url !== void 0) payload.url = input.url;
+    if (input.method !== void 0) payload.method = input.method;
+    if (input.urlConstruction !== void 0) payload.url_construction = input.urlConstruction;
+    if (input.modelName !== void 0) payload.model_name = input.modelName;
+    if (input.queryParams !== void 0) payload.query_params = JSON.stringify(input.queryParams);
+    if (input.proxySettings !== void 0) payload.proxy_settings = JSON.stringify(input.proxySettings);
+    await this.ctx.database.set("memesluna_endpoints", { name: name2 }, payload);
+    return true;
+  }
+  async deleteEndpoint(name2) {
+    const before = await this.ctx.database.get("memesluna_endpoints", { name: name2 });
+    if (!before.length) {
+      return false;
+    }
+    await this.ctx.database.remove("memesluna_endpoints", { name: name2 });
+    return true;
+  }
+  async buildRouteInventory(backendPath) {
+    const endpoints = await this.getEndpoints();
+    const collections = await this.getCollections();
+    const lines = [];
+    for (const endpoint of endpoints) {
+      const queryPart = endpoint.queryParams.filter((param) => param.required).map((param) => `${param.name}=<${param.name}>`).join("&");
+      const suffix = queryPart ? `?${queryPart}` : "";
+      const desc = endpoint.description || endpoint.name;
+      lines.push(`- ${endpoint.name} ${desc} ${backendPath}/${endpoint.name}${suffix}`);
+    }
+    for (const collection of collections) {
+      const info = await this.getCollectionInfo(collection);
+      if (info?.hasContent) {
+        const desc = info.description || collection;
+        lines.push(`- ${collection} ${desc} ${backendPath}/${collection}`);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/config.ts
+var import_koishi2 = require("koishi");
+var Config = import_koishi2.Schema.object({
+  backendPath: import_koishi2.Schema.string().default("/memesluna").description("\u540E\u7AEF\u670D\u52A1\u8DEF\u5F84\u524D\u7F00"),
+  storagePath: import_koishi2.Schema.string().default("data/memesluna").description("\u672C\u5730\u5408\u96C6\u5B58\u50A8\u76EE\u5F55"),
+  selfUrl: import_koishi2.Schema.string().default("").description("\u670D\u52A1\u516C\u5F00\u5730\u5740\uFF0C\u4E0D\u586B\u5219\u4F18\u5148\u4F7F\u7528 server.selfUrl"),
+  injectVariables: import_koishi2.Schema.boolean().default(true).description("\u662F\u5426\u5411 ChatLuna \u6CE8\u5165 {{endpoint}} \u548C {{memesluna}} \u53D8\u91CF"),
+  variableRefreshIntervalMs: import_koishi2.Schema.number().min(30 * 1e3).max(60 * 60 * 1e3).default(5 * 60 * 1e3).description("\u53D8\u91CF\u5237\u65B0\u95F4\u9694\uFF08\u6BEB\u79D2\uFF09"),
+  injectVariablesPrompt: import_koishi2.Schema.string().role("textarea").default(`\u4F60\u53EF\u4EE5\u4F7F\u7528\u8868\u60C5\u5305\u6765\u4E30\u5BCC\u4F60\u7684\u56DE\u590D\u3002\u8868\u60C5\u5305\u5217\u8868\u662F{endpoint}\uFF0C\u57FA\u7840URL\u662F{base_url}\uFF0C\u4F60\u8981\u628A\u57FA\u7840URL\u62FC\u63A5\u5230\u8DEF\u5F84\u524D\u9762,\u4E0D\u8981\u52A0\u6587\u4EF6\u540D,\u53EA\u52A0\u8DEF\u5F84,\u7528\u53D1\u9001\u56FE\u7247\u7684\u65B9\u5F0F\u53D1\u9001\u3002`).description("\u6CE8\u5165\u5230 ChatLuna {{memesluna}} \u53D8\u91CF\u7684\u63D0\u793A\u8BCD\u6A21\u677F\uFF0C\u652F\u6301 {endpoint} \u548C {base_url} \u5360\u4F4D\u7B26")
+});
+var name = "memesluna";
+
+// src/index.ts
+var RESERVED_PATHS = /* @__PURE__ */ new Set([
   "config",
   "admin",
   "admin-login",
@@ -51,9 +550,9 @@ const RESERVED_PATHS = /* @__PURE__ */ new Set([
   "static",
   "favicon.ico"
 ]);
-const IMAGE_URL_REGEXP = /\.(jpeg|jpg|gif|png|webp|bmp|svg)(\?.*)?$/i;
-function isReservedPath(name) {
-  return RESERVED_PATHS.has(name) || name.includes(".");
+var IMAGE_URL_REGEXP = /\.(jpeg|jpg|gif|png|webp|bmp|svg)(\?.*)?$/i;
+function isReservedPath(name2) {
+  return RESERVED_PATHS.has(name2) || name2.includes(".");
 }
 function getValueByDotNotation(obj, dotPath) {
   if (!dotPath) return void 0;
@@ -73,7 +572,7 @@ function normalizeContentType(contentType) {
   return contentType.toLowerCase().split(";")[0].trim();
 }
 function guessMimeByExt(filePath) {
-  const ext = import_path.default.extname(filePath).toLowerCase();
+  const ext = import_path2.default.extname(filePath).toLowerCase();
   switch (ext) {
     case ".png":
       return "image/png";
@@ -229,23 +728,23 @@ async function applyDynamicForward(ctx, config, service, routeName, query) {
     const validated = new URLSearchParams();
     const errors = [];
     for (const param of endpoint.queryParams) {
-      const name = param.name;
-      const raw = query[name];
+      const name2 = param.name;
+      const raw = query[name2];
       const value = Array.isArray(raw) ? raw[0] : raw;
       if (typeof value === "string") {
         if (param.validValues && param.validValues.length > 0 && !param.validValues.includes(value)) {
-          errors.push(`Invalid value for '${name}'`);
+          errors.push(`Invalid value for '${name2}'`);
         } else {
-          validated.set(name, value);
+          validated.set(name2, value);
         }
         continue;
       }
       if (param.required) {
-        errors.push(`Missing required parameter: ${name}`);
+        errors.push(`Missing required parameter: ${name2}`);
         continue;
       }
       if (param.defaultValue !== void 0) {
-        validated.set(name, param.defaultValue);
+        validated.set(name2, param.defaultValue);
       }
     }
     if (errors.length > 0) {
@@ -278,7 +777,7 @@ async function applyDynamicForward(ctx, config, service, routeName, query) {
   if (resource.type === "external") {
     return { redirectTo: resource.value };
   }
-  const fileBuffer = await import_promises.default.readFile(resource.value);
+  const fileBuffer = await import_promises2.default.readFile(resource.value);
   return {
     status: 200,
     body: fileBuffer,
@@ -352,7 +851,7 @@ function normalizeUrlConstruction(value) {
 async function buildAdminState(service) {
   const endpoints = await service.getEndpoints();
   const collectionNames = await service.getCollections();
-  const collections = await Promise.all(collectionNames.map((name) => service.getCollectionInfo(name)));
+  const collections = await Promise.all(collectionNames.map((name2) => service.getCollectionInfo(name2)));
   return {
     endpoints,
     collectionNames,
@@ -588,6 +1087,9 @@ function buildHomepageHtml(basePath) {
           <li class="nav-item">
             <a class="nav-link" href="${basePath}/admin">\u7BA1\u7406</a>
           </li>
+          <li class="nav-item">
+            <a class="nav-link" href="${basePath}/admin/endpoint">\u7AEF\u70B9</a>
+          </li>
         </ul>
       </div>
     </div>
@@ -1798,7 +2300,7 @@ async function updateMemesVariable(ctx, config, service) {
 function applyConsole(ctx, config, service) {
   if (!ctx.console) return;
   const consoleService = ctx.console;
-  const packageBase = import_path.default.resolve(ctx.baseDir, "node_modules/koishi-plugin-memesluna");
+  const packageBase = import_path2.default.resolve(ctx.baseDir, "node_modules/koishi-plugin-memesluna");
   const withReady = (handler) => {
     return async (...args) => {
       await service.ready;
@@ -1806,8 +2308,8 @@ function applyConsole(ctx, config, service) {
     };
   };
   consoleService.addEntry({
-    dev: import_path.default.resolve(packageBase, "client/index.ts"),
-    prod: import_path.default.resolve(packageBase, "dist")
+    dev: import_path2.default.resolve(packageBase, "client/index.ts"),
+    prod: import_path2.default.resolve(packageBase, "dist")
   });
   consoleService.addListener(
     "memesluna/getState",
@@ -1815,7 +2317,7 @@ function applyConsole(ctx, config, service) {
       const endpoints = await service.getEndpoints();
       const collections = await service.getCollections();
       const detailedCollections = await Promise.all(
-        collections.map(async (name) => service.getCollectionInfo(name))
+        collections.map(async (name2) => service.getCollectionInfo(name2))
       );
       return {
         backendPath: config.backendPath,
@@ -1826,20 +2328,20 @@ function applyConsole(ctx, config, service) {
   );
   consoleService.addListener(
     "memesluna/createCollection",
-    withReady(async (name) => {
-      return await service.createCollection(name);
+    withReady(async (name2) => {
+      return await service.createCollection(name2);
     })
   );
   consoleService.addListener(
     "memesluna/deleteCollection",
-    withReady(async (name) => {
-      return await service.deleteCollection(name);
+    withReady(async (name2) => {
+      return await service.deleteCollection(name2);
     })
   );
   consoleService.addListener(
     "memesluna/setCollectionDescription",
-    withReady(async (name, description) => {
-      return await service.setCollectionDescription(name, description);
+    withReady(async (name2, description) => {
+      return await service.setCollectionDescription(name2, description);
     })
   );
   consoleService.addListener(
@@ -1881,14 +2383,14 @@ function applyConsole(ctx, config, service) {
   );
   consoleService.addListener(
     "memesluna/updateEndpoint",
-    withReady(async (name, payload) => {
-      return await service.updateEndpoint(name, payload);
+    withReady(async (name2, payload) => {
+      return await service.updateEndpoint(name2, payload);
     })
   );
   consoleService.addListener(
     "memesluna/deleteEndpoint",
-    withReady(async (name) => {
-      return await service.deleteEndpoint(name);
+    withReady(async (name2) => {
+      return await service.deleteEndpoint(name2);
     })
   );
   consoleService.addListener("memesluna/getBaseUrl", async () => {
@@ -1902,7 +2404,7 @@ function applyServer(ctx, config, service) {
     const baseUrl = toAbsoluteBaseUrl(ctx, config);
     const endpoints = await service.getEndpoints();
     const collections = await service.getCollections();
-    const collectionInfos = await Promise.all(collections.map((name) => service.getCollectionInfo(name)));
+    const collectionInfos = await Promise.all(collections.map((name2) => service.getCollectionInfo(name2)));
     const inventory = await service.buildRouteInventory(basePath);
     const llmPrompt = config.injectVariablesPrompt.replace("{endpoint}", inventory || "- \u6682\u65E0\u53EF\u7528\u8DEF\u7531").replace("{base_url}", baseUrl);
     koa.body = {
@@ -1917,14 +2419,14 @@ function applyServer(ctx, config, service) {
   });
   ctx.server.post(`${basePath}/api/admin/collections`, async (koa) => {
     const body = getRequestBody(koa);
-    const name = toTrimmedString(body.name);
-    if (!name) {
+    const name2 = toTrimmedString(body.name);
+    if (!name2) {
       koa.status = 400;
       koa.body = { error: "Collection name is required" };
       return;
     }
     try {
-      const created = await service.createCollection(name);
+      const created = await service.createCollection(name2);
       if (!created) {
         koa.status = 409;
         koa.body = { error: "Collection already exists" };
@@ -1937,13 +2439,13 @@ function applyServer(ctx, config, service) {
     }
   });
   ctx.server.delete(`${basePath}/api/admin/collections/:name`, async (koa) => {
-    const name = toTrimmedString(koa.params.name);
-    if (!name) {
+    const name2 = toTrimmedString(koa.params.name);
+    if (!name2) {
       koa.status = 400;
       koa.body = { error: "Collection name is required" };
       return;
     }
-    const deleted = await service.deleteCollection(name);
+    const deleted = await service.deleteCollection(name2);
     if (!deleted) {
       koa.status = 404;
       koa.body = { error: "Collection not found" };
@@ -1952,10 +2454,10 @@ function applyServer(ctx, config, service) {
     koa.body = { ok: true };
   });
   ctx.server.patch(`${basePath}/api/admin/collections/:name/description`, async (koa) => {
-    const name = toTrimmedString(koa.params.name);
+    const name2 = toTrimmedString(koa.params.name);
     const body = getRequestBody(koa);
     const description = toTrimmedString(body.description);
-    const updated = await service.setCollectionDescription(name, description);
+    const updated = await service.setCollectionDescription(name2, description);
     if (!updated) {
       koa.status = 404;
       koa.body = { error: "Collection not found" };
@@ -2066,15 +2568,15 @@ function applyServer(ctx, config, service) {
   });
   ctx.server.post(`${basePath}/api/admin/endpoints`, async (koa) => {
     const body = getRequestBody(koa);
-    const name = toTrimmedString(body.name);
+    const name2 = toTrimmedString(body.name);
     const url = toTrimmedString(body.url);
-    if (!name || !url) {
+    if (!name2 || !url) {
       koa.status = 400;
       koa.body = { error: "name and url are required" };
       return;
     }
     const payload = {
-      name,
+      name: name2,
       group: toTrimmedString(body.group) || "\u9ED8\u8BA4\u5206\u7EC4",
       description: toTrimmedString(body.description),
       url,
@@ -2116,8 +2618,8 @@ function applyServer(ctx, config, service) {
     koa.body = { ok: true };
   });
   ctx.server.delete(`${basePath}/api/admin/endpoints/:name`, async (koa) => {
-    const name = toTrimmedString(koa.params.name);
-    const deleted = await service.deleteEndpoint(name);
+    const name2 = toTrimmedString(koa.params.name);
+    const deleted = await service.deleteEndpoint(name2);
     if (!deleted) {
       koa.status = 404;
       koa.body = { error: "Endpoint not found" };
@@ -2126,10 +2628,14 @@ function applyServer(ctx, config, service) {
     koa.body = { ok: true };
   });
   ctx.server.get(`${basePath}/admin`, async (koa) => {
-    koa.redirect(`${basePath}/#admin`);
+    koa.status = 200;
+    koa.set("Content-Type", "text/html; charset=utf-8");
+    koa.body = buildAdminHtml(basePath);
   });
   ctx.server.get(`${basePath}/admin/endpoint`, async (koa) => {
-    koa.redirect(`${basePath}/#endpoint`);
+    koa.status = 200;
+    koa.set("Content-Type", "text/html; charset=utf-8");
+    koa.body = buildAdminEndpointHtml(basePath);
   });
   ctx.server.get(`${basePath}/api/collections/:name/resources`, async (koa) => {
     const collectionName = koa.params.name;
@@ -2164,7 +2670,7 @@ function applyServer(ctx, config, service) {
   });
 }
 function apply(ctx, config) {
-  ctx.plugin(import_service.MemesLunaService, config);
+  ctx.plugin(MemesLunaService, config);
   ctx.inject(["memesluna", "server"], async (ctx2) => {
     const service = ctx2.memesluna;
     await service.ready;
@@ -2216,11 +2722,12 @@ function apply(ctx, config) {
     });
   }
 }
-const inject = ["database", "chatluna", "server"];
+var inject = ["database", "chatluna", "server"];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Config,
+  MemesLunaService,
   apply,
   inject,
-  ...require("./config"),
-  ...require("./service")
+  name
 });