mioku-service-webui 2.0.0

package/routes/db.ts

@@ -0,0 +1,218 @@
+import { Hono } from "hono";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  deleteMessagesByRange,
+  exportData,
+  getPluginConfigs,
+  getStats,
+  importDataFromJson,
+  listMemeTree,
+  listTables,
+  queryMessages,
+  savePluginConfig,
+  updateMessage,
+} from "../database";
+import { CHAT_DATA_DIR } from "../utils";
+import { loadPluginConfigPage } from "../config-page-loader";
+import { getDatasource } from "../datasources";
+
+export function createDBRoutes() {
+  const app = new Hono();
+
+  app.get("/tables", (c) =>
+    c.json({ ok: true, data: listTables() }),
+  );
+
+  app.get("/messages", (c) => {
+    const q = c.req.query();
+    const data = queryMessages({
+      table: q.table,
+      keyword: q.keyword,
+      userId: q.userId,
+      sessionId: q.sessionId,
+      startTime: q.startTime ? Number(q.startTime) : undefined,
+      endTime: q.endTime ? Number(q.endTime) : undefined,
+      page: q.page ? Number(q.page) : 1,
+      pageSize: q.pageSize ? Number(q.pageSize) : 20,
+    });
+    return c.json({ ok: true, data });
+  });
+
+  app.get("/stats", (c) =>
+    c.json({ ok: true, data: getStats() }),
+  );
+
+  app.put("/message", async (c) => {
+    const body = await c.req.json();
+    return c.json({ ok: true, data: updateMessage(body) });
+  });
+
+  app.post("/cleanup", async (c) => {
+    const body = await c.req.json();
+    return c.json({ ok: true, data: deleteMessagesByRange(body) });
+  });
+
+  app.get("/export", (c) => {
+    const format = (c.req.query("format") === "csv" ? "csv" : "json") as
+      | "json"
+      | "csv";
+    const result = exportData(format);
+    return c.json({ ok: true, data: result });
+  });
+
+  app.post("/import", async (c) => {
+    const form = await c.req.formData();
+    const file = form.get("file") as File | null;
+    if (!file) {
+      return c.json({ ok: false, error: "FILE_REQUIRED" }, 400);
+    }
+    const result = importDataFromJson(file as any);
+    return c.json({ ok: true, data: result });
+  });
+
+  return app;
+}
+
+export function createPluginConfigRoutes() {
+  const app = new Hono();
+
+  app.get("/overview", (c) => {
+    const pluginDir = path.join(process.cwd(), "plugins");
+    if (!fs.existsSync(pluginDir)) {
+      return c.json({ ok: true, data: [] });
+    }
+
+    const plugins = fs.readdirSync(pluginDir).filter((name) => {
+      const pluginPath = path.join(pluginDir, name);
+      return fs.statSync(pluginPath).isDirectory();
+    });
+
+    const overview = plugins
+      .map((name) => {
+        const configDir = path.join(process.cwd(), "config", name);
+        const manifest = loadPluginConfigPage(name);
+        const existingConfigFiles =
+          fs.existsSync(configDir)
+            ? fs
+                .readdirSync(configDir)
+                .filter((f) => f.endsWith(".json"))
+                .map((f) => f.replace(".json", ""))
+            : [];
+        const declaredConfigFiles = manifest
+          ? Array.from(
+              new Set(
+                (manifest.fields || [])
+                  .map((field) => String(field.key || ""))
+                  .filter((key) => key.includes("."))
+                  .map((key) => key.split(".")[0]),
+              ),
+            )
+          : [];
+        const configFiles = Array.from(
+          new Set([...existingConfigFiles, ...declaredConfigFiles]),
+        );
+
+        return {
+          name,
+          title: manifest?.title || name,
+          description: manifest?.description,
+          hasPage: manifest?.hasCustomPage || false,
+          configFiles,
+        };
+      })
+      .filter((p) => p.hasPage);
+
+    return c.json({ ok: true, data: overview });
+  });
+
+  app.get("/:name/page", (c) => {
+    const name = c.req.param("name");
+    const manifest = loadPluginConfigPage(name);
+    const configs = getPluginConfigs(name);
+
+    if (!manifest) {
+      return c.json({ ok: true, data: null });
+    }
+
+    return c.json({
+      ok: true,
+      data: {
+        plugin: manifest.plugin,
+        title: manifest.title,
+        description: manifest.description,
+        markdown: manifest.markdown,
+        fields: manifest.fields,
+        hasCustomPage: manifest.hasCustomPage,
+        configs,
+      },
+    });
+  });
+
+  app.get("/datasources/:source", async (c) => {
+    const source = c.req.param("source");
+    const q = c.req.query("q") || undefined;
+    const limitText = c.req.query("limit");
+    const limit = limitText ? Number(limitText) : undefined;
+    const options = await getDatasource(source, {
+      q,
+      limit: Number.isFinite(limit) ? limit : undefined,
+    });
+    return c.json({ ok: true, data: options });
+  });
+
+  app.get("/:name", (c) => {
+    const name = c.req.param("name");
+    return c.json({ ok: true, data: getPluginConfigs(name) });
+  });
+
+  app.put("/:name/:config", async (c) => {
+    const pluginName = c.req.param("name");
+    const configName = c.req.param("config");
+    const body = await c.req.json();
+    savePluginConfig(pluginName, configName, body);
+    return c.json({ ok: true });
+  });
+
+  return app;
+}
+
+export function createMemeRoutes() {
+  const app = new Hono();
+
+  app.get("/tree", (c) =>
+    c.json({ ok: true, data: listMemeTree() }),
+  );
+
+  app.post("/upload", async (c) => {
+    const form = await c.req.formData();
+    const character = String(form.get("character") || "unknown");
+    const emotion = String(form.get("emotion") || "default");
+    const file = form.get("file") as File | null;
+    if (!file) {
+      return c.json({ ok: false, error: "FILE_REQUIRED" }, 400);
+    }
+
+    const dir = path.join(CHAT_DATA_DIR, "meme", character, emotion);
+    fs.mkdirSync(dir, { recursive: true });
+
+    const fileName = file.name || `upload-${Date.now()}.png`;
+    const filePath = path.join(dir, fileName);
+    const buffer = Buffer.from(await file.arrayBuffer());
+    fs.writeFileSync(filePath, buffer);
+
+    return c.json({ ok: true, path: path.relative(process.cwd(), filePath) });
+  });
+
+  app.delete("/", async (c) => {
+    const body = await c.req.json();
+    const filePath = path.join(process.cwd(), String(body.path || ""));
+    if (!fs.existsSync(filePath)) {
+      return c.json({ ok: false, error: "NOT_FOUND" }, 404);
+    }
+    fs.unlinkSync(filePath);
+    return c.json({ ok: true });
+  });
+
+  return app;
+}

package/routes/index.ts

@@ -0,0 +1,6 @@
+export { createConfigRoutes } from "./config";
+export { createWebUISettingsRoutes } from "./webui";
+export { createAIRoutes } from "./ai";
+export { createDBRoutes, createPluginConfigRoutes, createMemeRoutes } from "./db";
+export { createManageRoutes } from "./manage";
+export { createStoreRoutes } from "./store";

package/routes/manage.ts

@@ -0,0 +1,92 @@
+import { Hono } from "hono";
+import type {
+  ChangeRepoRequest,
+  InstallRequest,
+  RemoveRequest,
+  UpdateAllRequest,
+  UpdateRequest,
+} from "../types";
+import {
+  changeManagedPackageRepo,
+  getManagedPackageDetail,
+  installManagedPackage,
+  listManagedPackages,
+  listManagedPackagesWithUpdates,
+  updateManagedPackage,
+  updateAllManagedPackages,
+  checkUpdate,
+  removeManagedPackage,
+} from "../system";
+
+export function createManageRoutes() {
+  const app = new Hono();
+
+  app.get("/plugins", (c) =>
+    c.json({ ok: true, data: listManagedPackages("plugin") }),
+  );
+  app.get("/services", (c) =>
+    c.json({ ok: true, data: listManagedPackages("service") }),
+  );
+  app.get("/plugins/overview", async (c) =>
+    c.json({ ok: true, data: await listManagedPackagesWithUpdates("plugin") }),
+  );
+  app.get("/plugins/:name", async (c) => {
+    const name = c.req.param("name");
+    const result = await getManagedPackageDetail(name, "plugin");
+    return c.json(result);
+  });
+  app.get("/services/overview", async (c) =>
+    c.json({ ok: true, data: await listManagedPackagesWithUpdates("service") }),
+  );
+  app.get("/services/:name", async (c) => {
+    const name = c.req.param("name");
+    const result = await getManagedPackageDetail(name, "service");
+    return c.json(result);
+  });
+
+  app.post("/install", async (c) => {
+    const body = (await c.req.json()) as InstallRequest;
+    const result = await installManagedPackage(body);
+    return c.json(result);
+  });
+
+  app.post("/check-update", async (c) => {
+    const body = (await c.req.json()) as {
+      name: string;
+      target: "plugin" | "service";
+    };
+    const result = await checkUpdate(body.name, body.target);
+    return c.json(result);
+  });
+
+  app.post("/update", async (c) => {
+    const body = (await c.req.json()) as UpdateRequest;
+    const result = await updateManagedPackage(body);
+    return c.json(result);
+  });
+  app.post("/update-all", async (c) => {
+    const body = (await c.req.json().catch(() => ({}))) as Partial<UpdateAllRequest>;
+    const result = await updateAllManagedPackages({
+      target: body.target || "plugin",
+      packageManager: body.packageManager,
+    });
+    return c.json(result);
+  });
+
+  app.post("/remove", async (c) => {
+    const body = (await c.req.json()) as RemoveRequest;
+    const result = await removeManagedPackage(body);
+    return c.json(result);
+  });
+  app.post("/change-repo", async (c) => {
+    const body = (await c.req.json()) as Partial<ChangeRepoRequest>;
+    const result = await changeManagedPackageRepo(
+      String(body.name || ""),
+      (body.target || "plugin") as "plugin" | "service",
+      String(body.repoUrl || ""),
+    );
+    return c.json(result);
+  });
+
+  return app;
+}