mioku-service-webui 4.14.0 → 4.15.0

package/config-page-loader.ts

@@ -51,7 +51,7 @@ export function loadAdapterConfigPage(adapterName: string): ConfigPageManifest |
 }
 
 /** 从机器人根目录按 node_modules 依赖解析包真实目录（pnpm / 提升安装等布局） */
-function resolvePackageDir(root: string, packageName: string): string | null {
+export function resolvePackageDir(root: string, packageName: string): string | null {
   const require = createRequire(path.join(root, "package.json"));
   try {
     return path.dirname(require.resolve(`${packageName}/package.json`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-service-webui",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "description": "Mioku WebUI 服务",
   "main": "index.ts",
   "type": "module",

package/routes/ai.ts

@@ -2,6 +2,11 @@ import { Hono } from "hono";
 import { logger } from "mioku";
 import { getChatConfig, updateChatConfig } from "../system";
 import { listStickerCatalog } from "../database";
+import {
+  readThemeCatalog,
+  updateThemeSelection,
+  writeCustomThemes,
+} from "../theme-packs";
 import aiService from "mioku-service-ai";
 import type { AIModelRole, AIProtocol, AIUsageRange } from "mioku";
 
@@ -113,6 +118,23 @@ export function createAIRoutes() {
     return c.json({ ok: true, data: updateChatConfig("base.json", body) });
   });
 
+  app.get("/themes", (c) => {
+    return c.json({ ok: true, data: readThemeCatalog() });
+  });
+
+  app.put("/themes", async (c) => {
+    logger.info(`[webui-action] ai.themes.update`);
+    return c.json({ ok: true, data: writeCustomThemes(await c.req.json()) });
+  });
+
+  app.put("/themes/selection", async (c) => {
+    logger.info(`[webui-action] ai.themes.select`);
+    return c.json({
+      ok: true,
+      data: updateThemeSelection(await c.req.json()),
+    });
+  });
+
   app.get("/personalization", (c) => {
     const data = stripDeadPersonalizationKeys(
       getChatConfig("personalization.json"),

package/theme-packs.ts

@@ -0,0 +1,311 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolvePackageDir } from "./config-page-loader";
+import { getChatConfig, updateChatConfig } from "./system";
+import { projectRoot } from "./utils";
+
+const BUILTIN_PREFIX = "builtin:";
+const CUSTOM_PREFIX = "custom:";
+const MAX_THEMES_PER_KIND = 100;
+const MAX_NAME = 40;
+const MAX_TEXT = 20_000;
+const MAX_STYLES = 40;
+const MAX_EXAMPLES = 200;
+const MAX_EXAMPLE = 500;
+
+export interface ReplyStyleTheme {
+  id: string;
+  name: string;
+  persona: string;
+  baseStyle: string;
+  multipleStyles: string[];
+  multipleProbability: number;
+  builtin: boolean;
+}
+
+export interface EmotionTheme {
+  id: string;
+  name: string;
+  defaultEmotion: string;
+  updateIntervalMs: number;
+  emotions: Record<string, { examples: string[] }>;
+  builtin: boolean;
+}
+
+export interface ThemeCatalog {
+  reply: ReplyStyleTheme[];
+  emotion: EmotionTheme[];
+}
+
+export interface ThemeSelection {
+  replyStyleTheme: string;
+  emotionTheme: string;
+}
+
+interface RawReplyTheme {
+  id: string;
+  name: string;
+  persona: string;
+  baseStyle: string;
+  multipleStyles: string[];
+  multipleProbability: number;
+}
+
+interface RawEmotionTheme {
+  id: string;
+  name: string;
+  defaultEmotion: string;
+  updateIntervalMs: number;
+  emotions: Record<string, { examples: string[] }>;
+}
+
+function resolveChatPluginDir(): string | null {
+  const root = projectRoot();
+  const local = path.join(root, "plugins", "chat");
+  if (fs.existsSync(path.join(local, "themes", "builtin.json"))) return local;
+  return resolvePackageDir(root, "mioku-plugin-chat");
+}
+
+let builtinCache: {
+  key: string;
+  reply: RawReplyTheme[];
+  emotion: RawEmotionTheme[];
+} | null = null;
+
+function emptyBuiltin(): {
+  reply: RawReplyTheme[];
+  emotion: RawEmotionTheme[];
+} {
+  return { reply: [], emotion: [] };
+}
+
+function readBuiltinPacks(): {
+  reply: RawReplyTheme[];
+  emotion: RawEmotionTheme[];
+} {
+  const dir = resolveChatPluginDir();
+  if (!dir) return emptyBuiltin();
+  const file = path.join(dir, "themes", "builtin.json");
+  if (!fs.existsSync(file)) return emptyBuiltin();
+
+  try {
+    const stat = fs.statSync(file);
+    const key = `${file}:${stat.mtimeMs}:${stat.size}`;
+    if (builtinCache?.key === key) {
+      return builtinCache;
+    }
+    const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
+    const stats = {
+      key,
+      reply: normalizeReplyList(parsed?.reply, { allowBuiltin: true }),
+      emotion: normalizeEmotionList(parsed?.emotion, { allowBuiltin: true }),
+    };
+    builtinCache = stats;
+    return stats;
+  } catch {
+    return emptyBuiltin();
+  }
+}
+
+export function readThemeCatalog(): ThemeCatalog {
+  const builtin = readBuiltinPacks();
+  const custom = getChatConfig("themes.json") || {};
+  return {
+    reply: [
+      ...builtin.reply.map((theme) => ({ ...theme, builtin: true })),
+      ...normalizeReplyList(custom.reply, { allowBuiltin: false }).map(
+        (theme) => ({ ...theme, builtin: false }),
+      ),
+    ],
+    emotion: [
+      ...builtin.emotion.map((theme) => ({ ...theme, builtin: true })),
+      ...normalizeEmotionList(custom.emotion, { allowBuiltin: false }).map(
+        (theme) => ({ ...theme, builtin: false }),
+      ),
+    ],
+  };
+}
+
+/** 只写用户主题包；内置主题永远来自插件代码 */
+export function writeCustomThemes(body: unknown): ThemeCatalog {
+  const source = isRecord(body) ? body : {};
+  const next = {
+    reply: normalizeReplyList(source.reply, { allowBuiltin: false }),
+    emotion: normalizeEmotionList(source.emotion, { allowBuiltin: false }),
+  };
+  updateChatConfig("themes.json", next);
+  return readThemeCatalog();
+}
+
+export function updateThemeSelection(body: unknown): ThemeSelection {
+  const source = isRecord(body) ? body : {};
+  const catalog = readThemeCatalog();
+  const current = getChatConfig("personalization.json") || {};
+
+  const next: Record<string, unknown> = { ...current };
+  if ("replyStyleTheme" in source) {
+    next.replyStyleTheme = resolveSelection(
+      source.replyStyleTheme,
+      catalog.reply,
+    );
+  }
+  if ("emotionTheme" in source) {
+    next.emotionTheme = resolveSelection(source.emotionTheme, catalog.emotion);
+  }
+  updateChatConfig("personalization.json", next);
+
+  return {
+    replyStyleTheme: normalizeId(next.replyStyleTheme),
+    emotionTheme: normalizeId(next.emotionTheme),
+  };
+}
+
+function resolveSelection(
+  value: unknown,
+  themes: Array<{ id: string }>,
+): string {
+  const id = normalizeId(value);
+  if (!id) return "";
+  return themes.some((theme) => theme.id === id) ? id : "";
+}
+
+function normalizeId(value: unknown): string {
+  if (typeof value !== "string") return "";
+  const id = value.trim();
+  if (!id || id.length > 100) return "";
+  if (!id.startsWith(BUILTIN_PREFIX) && !id.startsWith(CUSTOM_PREFIX))
+    return "";
+  return id;
+}
+
+function normalizeReplyList(
+  raw: unknown,
+  options: { allowBuiltin: boolean },
+): RawReplyTheme[] {
+  if (!Array.isArray(raw)) return [];
+  const result: RawReplyTheme[] = [];
+  const seen = new Set<string>();
+  for (const item of raw) {
+    if (!isRecord(item)) continue;
+    const id = normalizeId(item.id);
+    if (!isThemeIdAllowed(id, options.allowBuiltin) || seen.has(id)) continue;
+    const name = readText(item.name, MAX_NAME);
+    if (!name) continue;
+    seen.add(id);
+    result.push({
+      id,
+      name,
+      persona: readText(item.persona, MAX_TEXT),
+      baseStyle: readText(item.baseStyle, MAX_TEXT),
+      multipleStyles: readTextList(item.multipleStyles, MAX_STYLES, MAX_TEXT),
+      multipleProbability: readProbability(item.multipleProbability),
+    });
+    if (result.length >= MAX_THEMES_PER_KIND) break;
+  }
+  return result;
+}
+
+function normalizeEmotionList(
+  raw: unknown,
+  options: { allowBuiltin: boolean },
+): RawEmotionTheme[] {
+  if (!Array.isArray(raw)) return [];
+  const result: RawEmotionTheme[] = [];
+  const seen = new Set<string>();
+  for (const item of raw) {
+    if (!isRecord(item)) continue;
+    const id = normalizeId(item.id);
+    if (!isThemeIdAllowed(id, options.allowBuiltin) || seen.has(id)) continue;
+    const name = readText(item.name, MAX_NAME);
+    if (!name) continue;
+    const emotions = normalizeEmotions(item.emotions);
+    seen.add(id);
+    result.push({
+      id,
+      name,
+      emotions,
+      defaultEmotion: pickDefaultEmotion(item.defaultEmotion, emotions),
+      updateIntervalMs: readInterval(item.updateIntervalMs),
+    });
+    if (result.length >= MAX_THEMES_PER_KIND) break;
+  }
+  return result;
+}
+
+function isThemeIdAllowed(id: string, allowBuiltin: boolean): boolean {
+  if (!id) return false;
+  return allowBuiltin || !id.startsWith(BUILTIN_PREFIX);
+}
+
+function normalizeEmotions(
+  raw: unknown,
+): Record<string, { examples: string[] }> {
+  const emotions: Record<string, { examples: string[] }> = {};
+  if (isRecord(raw)) {
+    for (const [rawName, value] of Object.entries(raw)) {
+      const name = readEmotionName(rawName);
+      if (!name || emotions[name]) continue;
+      emotions[name] = {
+        examples: readTextList(
+          isRecord(value) ? value.examples : undefined,
+          MAX_EXAMPLES,
+          MAX_EXAMPLE,
+        ),
+      };
+    }
+  }
+  if (!emotions.default) emotions.default = { examples: [] };
+  return emotions;
+}
+
+function readEmotionName(value: unknown): string {
+  if (typeof value !== "string") return "";
+  return value.trim().toLowerCase().slice(0, 20);
+}
+
+function pickDefaultEmotion(
+  raw: unknown,
+  emotions: Record<string, { examples: string[] }>,
+): string {
+  const name = readEmotionName(raw);
+  return name && emotions[name] ? name : "default";
+}
+
+function readInterval(value: unknown): number {
+  const num = Number(value);
+  if (!Number.isFinite(num)) return 60 * 60_000;
+  return Math.min(30 * 24 * 60 * 60_000, Math.max(60_000, Math.round(num)));
+}
+
+function readProbability(value: unknown): number {
+  const num = Number(value);
+  if (!Number.isFinite(num)) return 0.2;
+  return Math.min(1, Math.max(0, num));
+}
+
+function readText(value: unknown, maxLength: number): string {
+  return typeof value === "string" ? value.slice(0, maxLength) : "";
+}
+
+function readTextList(
+  value: unknown,
+  maxItems: number,
+  maxLength: number,
+): string[] {
+  if (!Array.isArray(value)) return [];
+  const result: string[] = [];
+  const seen = new Set<string>();
+  for (const item of value) {
+    if (typeof item !== "string") continue;
+    const text = item.trim();
+    if (!text || seen.has(text)) continue;
+    seen.add(text);
+    result.push(text.slice(0, maxLength));
+    if (result.length >= maxItems) break;
+  }
+  return result;
+}
+
+function isRecord(value: unknown): value is Record<string, any> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}