mioku-service-webui 2.0.0

package/index.ts

@@ -0,0 +1,231 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logger } from "mioki";
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { createNodeWebSocket } from "@hono/node-ws";
+import type { MiokuService } from "../../core/types";
+import type { WebUISettings } from "./types";
+import { ensureAuthConfig, loginWithToken, requireAuth } from "./auth";
+import { getWebUISettings, getSystemOverview, getSaying } from "./system";
+import { CHAT_CONFIG_DIR, CHAT_DATA_DIR, LOGS_DIR, WEBUI_DIST } from "./utils";
+import { initBuiltinDatasources } from "./datasources";
+import {
+  createConfigRoutes,
+  createWebUISettingsRoutes,
+  createAIRoutes,
+  createDBRoutes,
+  createPluginConfigRoutes,
+  createMemeRoutes,
+  createManageRoutes,
+  createStoreRoutes,
+} from "./routes";
+
+export interface WebUIServiceAPI {
+  getSettings(): WebUISettings;
+}
+
+class WebUIRuntime {
+  private app = new Hono();
+  private server: ReturnType<typeof serve> | null = null;
+
+  private logAction(action: string, payload?: unknown): void {
+    const text = payload ? ` | ${JSON.stringify(payload)}` : "";
+    logger.info(`[webui-action] ${action}${text}`);
+  }
+
+  public initRoutes(): void {
+    const { upgradeWebSocket, injectWebSocket } = createNodeWebSocket({
+      app: this.app,
+    });
+
+    this.app.onError((err, c) => {
+      logger.error(`webui-service API error: ${err.message}`);
+      return c.json(
+        {
+          ok: false,
+          error: err.message || "INTERNAL_SERVER_ERROR",
+        },
+        500,
+      );
+    });
+
+    this.app.notFound((c) => {
+      if (c.req.path.startsWith("/api/")) {
+        return c.json({ ok: false, error: "API_NOT_FOUND" }, 404);
+      }
+      return c.text("Not Found", 404);
+    });
+
+    this.app.get("/api/health", (c) => c.json({ ok: true, service: "webui" }));
+
+    this.app.post("/api/auth/login", async (c) => {
+      const body = await c.req.json().catch(() => ({}));
+      this.logAction("auth.login.attempt");
+      const result = loginWithToken(String(body?.token || ""));
+      if (!result.ok) {
+        this.logAction("auth.login.failed");
+        return c.json({ ok: false, error: "TOKEN_INVALID" }, 401);
+      }
+      this.logAction("auth.login.success", { expiresAt: result.expiresAt });
+      return c.json({ ok: true, expiresAt: result.expiresAt });
+    });
+
+    this.app.use("/api/*", async (c, next) => {
+      if (c.req.path === "/api/health" || c.req.path === "/api/auth/login") {
+        return next();
+      }
+      return requireAuth(c, next);
+    });
+
+    this.app.get("/api/overview", async (c) => {
+      const data = await getSystemOverview();
+      return c.json({ ok: true, data });
+    });
+
+    this.app.get("/api/saying", async (c) => {
+      this.logAction("saying.fetch");
+      const data = await getSaying();
+      return c.json({ ok: true, data });
+    });
+
+    this.app.route("/api/config", createConfigRoutes());
+    this.app.route("/api/settings", createWebUISettingsRoutes());
+    this.app.route("/api/ai", createAIRoutes());
+    this.app.route("/api/manage", createManageRoutes());
+    this.app.route("/api/store", createStoreRoutes());
+    this.app.route("/api/db", createDBRoutes());
+    this.app.route("/api/plugin-config", createPluginConfigRoutes());
+    this.app.route("/api/meme", createMemeRoutes());
+
+    this.app.get(
+      "/api/ws/logs",
+      upgradeWebSocket((c) => {
+        let timer: NodeJS.Timeout | null = null;
+        let lastPayload = "";
+
+        return {
+          onOpen: (event, ws) => {
+            const latest = this.readLatestLogs(50);
+            lastPayload = JSON.stringify(latest);
+            ws.send(JSON.stringify({ type: "init", data: latest }));
+
+            timer = setInterval(() => {
+              const next = this.readLatestLogs(50);
+              const payload = JSON.stringify(next);
+              if (payload !== lastPayload) {
+                lastPayload = payload;
+                ws.send(JSON.stringify({ type: "update", data: next }));
+              }
+            }, 2000);
+          },
+          onMessage: (_event, ws) => {
+            ws.send(JSON.stringify({ type: "heartbeat", at: Date.now() }));
+          },
+          onClose: () => {
+            if (timer) {
+              clearInterval(timer);
+              timer = null;
+            }
+          },
+        };
+      }),
+    );
+
+    this.app.get(
+      "/meme/*",
+      serveStatic({
+        root: process.cwd(),
+        rewriteRequestPath: (p) => p.replace(/^\/meme\//, "data/chat/meme/"),
+      }),
+    );
+
+    this.app.use("/assets/*", serveStatic({ root: WEBUI_DIST }));
+    this.app.use("/favicon.ico", serveStatic({ root: WEBUI_DIST }));
+    this.app.use("/miku-logo.png", serveStatic({ root: WEBUI_DIST }));
+    this.app.use("/about-hero.jpg", serveStatic({ root: WEBUI_DIST }));
+    this.app.use("/about-hero-dark.jpg", serveStatic({ root: WEBUI_DIST }));
+    this.app.get("*", async (c) => {
+      const indexPath = path.join(WEBUI_DIST, "index.html");
+      if (!fs.existsSync(indexPath)) {
+        return c.text(
+          "WebUI frontend not built yet. Please run: npm run webui:build",
+          503,
+        );
+      }
+      const content = await fs.promises.readFile(indexPath, "utf-8");
+      return c.html(content);
+    });
+
+    const settings = getWebUISettings();
+    const server = serve({
+      fetch: this.app.fetch,
+      port: settings.port,
+      hostname: settings.host,
+    });
+    this.server = server;
+    injectWebSocket(server);
+    logger.info(
+      `webui-service 已启动: http://${settings.host}:${settings.port}`,
+    );
+  }
+
+  public readLatestLogs(count: number): string[] {
+    if (!fs.existsSync(LOGS_DIR)) {
+      return [];
+    }
+
+    const files = fs
+      .readdirSync(LOGS_DIR)
+      .map((name) => ({
+        name,
+        fullPath: path.join(LOGS_DIR, name),
+        mtimeMs: fs.statSync(path.join(LOGS_DIR, name)).mtimeMs,
+      }))
+      .sort((a, b) => b.mtimeMs - a.mtimeMs);
+
+    const file = files[0];
+    if (!file) {
+      return [];
+    }
+
+    const lines = fs
+      .readFileSync(file.fullPath, "utf-8")
+      .split(/\r?\n/)
+      .filter(Boolean);
+    return lines.slice(-count);
+  }
+
+  public stop(): void {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+  }
+}
+
+const runtime = new WebUIRuntime();
+
+const webUIService: MiokuService = {
+  name: "webui",
+  version: "2.0.0",
+  description: "Mioku WebUI 管理服务",
+  api: {
+    getSettings: () => getWebUISettings(),
+  } as WebUIServiceAPI,
+
+  async init() {
+    initBuiltinDatasources();
+    ensureAuthConfig();
+    fs.mkdirSync(CHAT_CONFIG_DIR, { recursive: true });
+    fs.mkdirSync(CHAT_DATA_DIR, { recursive: true });
+    runtime.initRoutes();
+  },
+
+  async dispose() {
+    runtime.stop();
+  },
+};
+
+export default webUIService;

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "mioku-service-webui",
+  "version": "2.0.0",
+  "description": "Mioku WebUI 服务",
+  "main": "index.ts",
+  "keywords": [
+    "mioku"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mioku-lab/mioku-service-webui.git"
+  },
+  "dependencies": {
+    "@hono/node-server": "1.19.13",
+    "@hono/node-ws": "^1.2.0",
+    "better-sqlite3": "^11.8.1",
+    "gray-matter": "^4.0.3",
+    "hono": "4.12.14"
+  }
+}

package/routes/ai.ts

@@ -0,0 +1,191 @@
+import { Hono } from "hono";
+import { logger } from "mioki";
+import { getChatConfig, updateChatConfig } from "../system";
+import aiService from "../../ai";
+
+const DEFAULT_MEMORY_GROUP_HISTORY_LIMIT = 300;
+const DEFAULT_MEMORY_USER_HISTORY_LIMIT = 100;
+const DEFAULT_TOPIC_WINDOW_HOURS = 5;
+const DEFAULT_TOPIC_HISTORY_WINDOW_COUNT = 3;
+const DEFAULT_EXPRESSION_LEARN_AFTER_MESSAGES = 100;
+const DEFAULT_EXPRESSION_SAMPLE_SIZE = 8;
+
+function normalizePersonalizationConfig(input: any): any {
+  const data =
+    input && typeof input === "object" && !Array.isArray(input)
+      ? { ...input }
+      : {};
+
+  const rawMemory =
+    data.memory && typeof data.memory === "object" && !Array.isArray(data.memory)
+      ? { ...data.memory }
+      : {};
+
+  delete rawMemory.maxIterations;
+  delete rawMemory.timeoutMs;
+
+  const groupHistoryLimit = Number(rawMemory.groupHistoryLimit);
+  const userHistoryLimit = Number(rawMemory.userHistoryLimit);
+
+  rawMemory.groupHistoryLimit =
+    Number.isFinite(groupHistoryLimit) && groupHistoryLimit > 0
+      ? Math.floor(groupHistoryLimit)
+      : DEFAULT_MEMORY_GROUP_HISTORY_LIMIT;
+  rawMemory.userHistoryLimit =
+    Number.isFinite(userHistoryLimit) && userHistoryLimit > 0
+      ? Math.floor(userHistoryLimit)
+      : DEFAULT_MEMORY_USER_HISTORY_LIMIT;
+  rawMemory.enabled =
+    typeof rawMemory.enabled === "boolean" ? rawMemory.enabled : true;
+
+  data.memory = rawMemory;
+
+  const rawTopic =
+    data.topic && typeof data.topic === "object" && !Array.isArray(data.topic)
+      ? { ...data.topic }
+      : {};
+
+  const windowHours = Number(rawTopic.windowHours);
+  const legacyTimeThresholdMs = Number(rawTopic.timeThresholdMs);
+  const historyWindowCount = Number(rawTopic.historyWindowCount);
+
+  rawTopic.enabled =
+    typeof rawTopic.enabled === "boolean" ? rawTopic.enabled : true;
+  rawTopic.windowHours =
+    Number.isFinite(windowHours) && windowHours > 0
+      ? Math.floor(windowHours)
+      : Number.isFinite(legacyTimeThresholdMs) && legacyTimeThresholdMs > 0
+        ? Math.max(1, Math.floor(legacyTimeThresholdMs / 3600_000))
+        : DEFAULT_TOPIC_WINDOW_HOURS;
+  rawTopic.historyWindowCount =
+    Number.isFinite(historyWindowCount) && historyWindowCount > 0
+      ? Math.floor(historyWindowCount)
+      : DEFAULT_TOPIC_HISTORY_WINDOW_COUNT;
+
+  delete rawTopic.messageThreshold;
+  delete rawTopic.timeThresholdMs;
+  delete rawTopic.maxTopicsPerSession;
+
+  data.topic = rawTopic;
+
+  const rawExpression =
+    data.expression &&
+    typeof data.expression === "object" &&
+    !Array.isArray(data.expression)
+      ? { ...data.expression }
+      : {};
+
+  const learnAfterMessages = Number(rawExpression.learnAfterMessages);
+  const legacyMaxExpressions = Number(rawExpression.maxExpressions);
+  const sampleSize = Number(rawExpression.sampleSize);
+
+  rawExpression.enabled =
+    typeof rawExpression.enabled === "boolean" ? rawExpression.enabled : true;
+  rawExpression.learnAfterMessages =
+    Number.isFinite(learnAfterMessages) && learnAfterMessages > 0
+      ? Math.floor(learnAfterMessages)
+      : Number.isFinite(legacyMaxExpressions) && legacyMaxExpressions > 0
+        ? Math.floor(legacyMaxExpressions)
+        : DEFAULT_EXPRESSION_LEARN_AFTER_MESSAGES;
+  rawExpression.sampleSize =
+    Number.isFinite(sampleSize) && sampleSize > 0
+      ? Math.floor(sampleSize)
+      : DEFAULT_EXPRESSION_SAMPLE_SIZE;
+  delete rawExpression.maxExpressions;
+
+  data.expression = rawExpression;
+  return data;
+}
+
+export function createAIRoutes() {
+  const app = new Hono();
+
+  app.get("/base", (c) =>
+    c.json({ ok: true, data: getChatConfig("base.json") }),
+  );
+  app.put("/base", async (c) => {
+    const body = await c.req.json();
+    logger.info(`[webui-action] ai.base.update`);
+    return c.json({ ok: true, data: updateChatConfig("base.json", body) });
+  });
+
+  app.get("/personalization", (c) => {
+    const data = normalizePersonalizationConfig(
+      getChatConfig("personalization.json"),
+    );
+    return c.json({ ok: true, data });
+  });
+  app.put("/personalization", async (c) => {
+    const body = normalizePersonalizationConfig(await c.req.json());
+    logger.info(`[webui-action] ai.personalization.update`);
+    return c.json({
+      ok: true,
+      data: updateChatConfig("personalization.json", body),
+    });
+  });
+
+  app.get("/settings", (c) =>
+    c.json({ ok: true, data: getChatConfig("settings.json") }),
+  );
+  app.put("/settings", async (c) => {
+    const body = await c.req.json();
+    logger.info(`[webui-action] ai.settings.update`);
+    return c.json({
+      ok: true,
+      data: updateChatConfig("settings.json", body),
+    });
+  });
+
+  app.get("/instances", (c) => {
+    const names = aiService?.api?.list?.() ?? [];
+    return c.json({ ok: true, data: names });
+  });
+
+  app.post("/instances", async (c) => {
+    const body = await c.req.json();
+    logger.info(`[webui-action] ai.instance.create`, {
+      name: body?.name,
+      apiUrl: body?.apiUrl,
+      modelType: body?.modelType,
+    });
+    if (!aiService?.api?.create) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+
+    await aiService.api.create({
+      name: body.name,
+      apiUrl: body.apiUrl,
+      apiKey: body.apiKey,
+      modelType: body.modelType || "text",
+    });
+    return c.json({ ok: true, data: aiService.api.list() });
+  });
+
+  app.delete("/instances/:name", (c) => {
+    const name = c.req.param("name");
+    logger.info(`[webui-action] ai.instance.remove`, { name });
+    const ok = aiService?.api?.remove?.(name);
+    return c.json({ ok: Boolean(ok) });
+  });
+
+  app.post("/default/:name", (c) => {
+    const name = c.req.param("name");
+    logger.info(`[webui-action] ai.instance.set-default`, { name });
+    const ok = aiService?.api?.setDefault?.(name);
+    return c.json({ ok: Boolean(ok) });
+  });
+
+  app.get("/skills", (c) => {
+    const skills = aiService?.api?.getAllSkills?.();
+    const tools = aiService?.api?.getAllTools?.();
+    return c.json({
+      ok: true,
+      data: {
+        skills: skills ? Array.from(skills.keys()) : [],
+        tools: tools ? Array.from(tools.keys()) : [],
+      },
+    });
+  });
+
+  return app;
+}

package/routes/config.ts

@@ -0,0 +1,52 @@
+import { Hono } from "hono";
+import { logger } from "mioki";
+import {
+  getMiokuConfig,
+  updateMiokuConfig,
+  getAvailablePlugins,
+  checkMiokuReleaseUpdate,
+  updateMiokuFromMain,
+} from "../system";
+
+export function createConfigRoutes() {
+  const app = new Hono();
+
+  app.get("/mioku", (c) => {
+    const data = getMiokuConfig();
+    return c.json({ ok: true, data });
+  });
+
+  app.put("/mioku", async (c) => {
+    const body = await c.req.json();
+    logger.info(`[webui-action] config.mioku.update`, {
+      owners: body?.owners?.length,
+      admins: body?.admins?.length,
+      napcat: body?.napcat?.length,
+      plugins: body?.plugins?.length,
+      bootConfigured: Boolean(body?.boot),
+    });
+    const data = updateMiokuConfig(body);
+    return c.json({ ok: true, data });
+  });
+
+  app.get("/mioku/update/check", async (c) => {
+    const force = c.req.query("force") === "1";
+    const data = await checkMiokuReleaseUpdate(force);
+    return c.json({ ok: true, data });
+  });
+
+  app.post("/mioku/update/apply", async (c) => {
+    logger.info(`[webui-action] config.mioku.update.apply`, {
+      targetRef: "origin/unknown",
+    });
+    const data = await updateMiokuFromMain();
+    return c.json({ ok: true, data });
+  });
+
+  app.get("/plugins/available", (c) => {
+    const data = getAvailablePlugins();
+    return c.json({ ok: true, data });
+  });
+
+  return app;
+}