mioku-service-webui 4.4.5 → 4.5.1

package/database.ts

@@ -300,7 +300,9 @@ export function listMemeTree(): Record<string, Record<string, string[]>> {
       tree[character][emotion] = fs
         .readdirSync(emotionDir)
         .filter((name) => /\.(png|jpg|jpeg|gif|webp)$/i.test(name))
-        .map((name) => path.join("data", "chat", "meme", character, emotion, name));
+        .map((name) =>
+          path.posix.join("data", "chat", "meme", character, emotion, name),
+        );
     }
   }
 

package/package.json

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

package/port-utils.ts

@@ -41,9 +41,33 @@ function parsePids(raw: string): number[] {
   return Array.from(pids);
 }
 
+function parseNetstatPids(raw: string, port: number): number[] {
+  const pids = new Set<number>();
+  for (const line of raw.split(/\r?\n/)) {
+    const cols = line.trim().split(/\s+/);
+    if (cols.length < 5 || cols[0].toUpperCase() !== "TCP") continue;
+    if (!/^LISTENING$/i.test(cols[3])) continue;
+    // Local address is host:port — IPv6 forms look like [::]:3339.
+    const localPort = cols[1].slice(cols[1].lastIndexOf(":") + 1);
+    if (Number(localPort) !== port) continue;
+    const pid = Number(cols[4]);
+    if (Number.isInteger(pid) && pid > 0) pids.add(pid);
+  }
+  return Array.from(pids);
+}
+
 async function listListeningPids(
   port: number,
 ): Promise<{ pids: number[]; lsofAvailable: boolean }> {
+  if (process.platform === "win32") {
+    try {
+      const { stdout } = await execFileAsync("netstat", ["-ano", "-p", "TCP"]);
+      return { pids: parseNetstatPids(stdout, port), lsofAvailable: true };
+    } catch (err: any) {
+      return { pids: [], lsofAvailable: err?.code !== "ENOENT" };
+    }
+  }
+
   try {
     const { stdout } = await execFileAsync("lsof", [
       "-nP",
@@ -84,8 +108,9 @@ export async function freePort(
   const initial = await listListeningPids(port);
 
   if (!initial.lsofAvailable) {
+    const missing = process.platform === "win32" ? "netstat" : "lsof";
     log.warn(
-      `未检测到 lsof 命令，无法定位端口 ${port} 的占用进程，建议安装 lsof`,
+      `未检测到 ${missing} 命令，无法定位端口 ${port} 的占用进程，建议安装 ${missing}`,
     );
     return {
       port,

package/routes/ai.ts

@@ -3,7 +3,7 @@ import { logger } from "mioki";
 import { getChatConfig, updateChatConfig } from "../system";
 import { listStickerCatalog } from "../database";
 import aiService from "mioku-service-ai";
-import type { AIUsageRange } from "mioku-service-ai/usage/types";
+import type { AIModelRole, AIProtocol, AIUsageRange } from "mioku";
 
 const DEFAULT_MEMORY_GROUP_HISTORY_LIMIT = 300;
 const DEFAULT_MEMORY_USER_HISTORY_LIMIT = 100;
@@ -12,6 +12,17 @@ const DEFAULT_TOPIC_HISTORY_WINDOW_COUNT = 3;
 const DEFAULT_EXPRESSION_LEARN_AFTER_MESSAGES = 100;
 const DEFAULT_EXPRESSION_SAMPLE_SIZE = 8;
 const usageRanges = new Set<AIUsageRange>(["today", "7d", "30d"]);
+const protocols = new Set<AIProtocol>([
+  "openai-chat",
+  "openai-response",
+  "anthropic",
+  "gemini",
+]);
+const roles = new Set<AIModelRole>(["main", "working", "vision"]);
+
+function getAIApi() {
+  return aiService?.api as any;
+}
 
 function normalizePersonalizationConfig(input: any): any {
   const data =
@@ -122,14 +133,48 @@ function normalizePersonalizationConfig(input: any): any {
   return data;
 }
 
+function sanitizeBaseForSave(body: any): any {
+  if (!body || typeof body !== "object") return body;
+  const next = { ...body };
+  delete next.apiUrl;
+  delete next.apiKey;
+  delete next.model;
+  delete next.workingModel;
+  delete next.multimodalWorkingModel;
+  delete next.isMultimodal;
+  return next;
+}
+
 export function createAIRoutes() {
   const app = new Hono();
 
-  app.get("/base", (c) =>
-    c.json({ ok: true, data: getChatConfig("base.json") }),
-  );
+  app.get("/base", (c) => {
+    const data = getChatConfig("base.json") || {};
+    const api = getAIApi();
+    const rolesData = api?.getRoleBindings?.() ?? {};
+    const models = api?.listModels?.() ?? [];
+    const pickModelId = (full?: string) => {
+      if (!full) return "";
+      const idx = full.indexOf("/");
+      return idx > 0 ? full.slice(idx + 1) : full;
+    };
+    const vision = models.find((item: any) => item.id === rolesData.vision);
+    return c.json({
+      ok: true,
+      data: {
+        ...data,
+        model: pickModelId(rolesData.main) || data.model || "",
+        workingModel: pickModelId(rolesData.working) || data.workingModel || "",
+        multimodalWorkingModel:
+          pickModelId(rolesData.vision) || data.multimodalWorkingModel || "",
+        isMultimodal: vision?.capabilities?.includes?.("vision") ?? true,
+        providersManaged: true,
+      },
+    });
+  });
+
   app.put("/base", async (c) => {
-    const body = await c.req.json();
+    const body = sanitizeBaseForSave(await c.req.json());
     logger.info(`[webui-action] ai.base.update`);
     return c.json({ ok: true, data: updateChatConfig("base.json", body) });
   });
@@ -161,48 +206,230 @@ export function createAIRoutes() {
     });
   });
 
+  app.get("/providers", (c) => {
+    const api = getAIApi();
+    if (!api?.listProviders) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const providers = api.listProviders().map((item: any) => ({
+      ...item,
+      apiKey: item.apiKey ? "***" : "",
+      hasApiKey: Boolean(item.apiKey),
+    }));
+    return c.json({ ok: true, data: providers });
+  });
+
+  app.post("/providers", async (c) => {
+    const api = getAIApi();
+    if (!api?.createProvider) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const body = await c.req.json();
+    const protocol = String(body?.protocol || "openai-chat") as AIProtocol;
+    if (!protocols.has(protocol)) {
+      return c.json({ ok: false, error: "INVALID_PROTOCOL" }, 400);
+    }
+    logger.info(`[webui-action] ai.provider.create`, {
+      name: body?.name,
+      protocol,
+    });
+    const created = await api.createProvider({
+      id: body?.id,
+      name: body?.name,
+      protocol,
+      apiUrl: body?.apiUrl,
+      apiKey: body?.apiKey,
+      enabled: body?.enabled !== false,
+      headers: body?.headers,
+    });
+    return c.json({
+      ok: true,
+      data: {
+        ...created,
+        apiKey: created.apiKey ? "***" : "",
+        hasApiKey: Boolean(created.apiKey),
+      },
+    });
+  });
+
+  app.put("/providers/:id", async (c) => {
+    const api = getAIApi();
+    if (!api?.updateProvider) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const id = c.req.param("id");
+    const body = await c.req.json();
+    logger.info(`[webui-action] ai.provider.update`, { id });
+    const patch: Record<string, unknown> = { ...body };
+    if (patch.apiKey === "***" || patch.apiKey === "") delete patch.apiKey;
+    if (patch.protocol && !protocols.has(patch.protocol as AIProtocol)) {
+      return c.json({ ok: false, error: "INVALID_PROTOCOL" }, 400);
+    }
+    const updated = await api.updateProvider(id, patch);
+    return c.json({
+      ok: true,
+      data: {
+        ...updated,
+        apiKey: updated.apiKey ? "***" : "",
+        hasApiKey: Boolean(updated.apiKey),
+      },
+    });
+  });
+
+  app.delete("/providers/:id", (c) => {
+    const api = getAIApi();
+    if (!api?.removeProvider) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const id = c.req.param("id");
+    logger.info(`[webui-action] ai.provider.remove`, { id });
+    return c.json({ ok: Boolean(api.removeProvider(id)) });
+  });
+
+  app.post("/providers/:id/test", async (c) => {
+    const api = getAIApi();
+    if (!api?.testProvider) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const id = c.req.param("id");
+    logger.info(`[webui-action] ai.provider.test`, { id });
+    const result = await api.testProvider(id);
+    return c.json({ ok: true, data: result });
+  });
+
+  app.post("/providers/:id/models/refresh", async (c) => {
+    const api = getAIApi();
+    if (!api?.refreshModels) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const id = c.req.param("id");
+    logger.info(`[webui-action] ai.models.refresh`, { id });
+    const models = await api.refreshModels(id);
+    return c.json({ ok: true, data: models });
+  });
+
+  app.get("/models", (c) => {
+    const api = getAIApi();
+    if (!api?.listModels) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const providerId = c.req.query("providerId") || undefined;
+    return c.json({ ok: true, data: api.listModels(providerId) });
+  });
+
+  app.post("/models", async (c) => {
+    const api = getAIApi();
+    if (!api?.registerCustomModel) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const body = await c.req.json();
+    logger.info(`[webui-action] ai.model.create`, {
+      providerId: body?.providerId,
+      modelId: body?.modelId,
+    });
+    const model = api.registerCustomModel({
+      providerId: body?.providerId,
+      modelId: body?.modelId,
+      name: body?.name,
+      capabilities: body?.capabilities,
+    });
+    return c.json({ ok: true, data: model });
+  });
+
+  app.delete("/models/:id", (c) => {
+    const api = getAIApi();
+    if (!api?.removeCustomModel) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const id = decodeURIComponent(c.req.param("id"));
+    logger.info(`[webui-action] ai.model.remove`, { id });
+    return c.json({ ok: Boolean(api.removeCustomModel(id)) });
+  });
+
+  app.get("/roles", (c) => {
+    const api = getAIApi();
+    if (!api?.getRoleBindings) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    return c.json({ ok: true, data: api.getRoleBindings() });
+  });
+
+  app.put("/roles", async (c) => {
+    const api = getAIApi();
+    if (!api?.setRoleBinding) {
+      return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
+    }
+    const body = await c.req.json();
+    logger.info(`[webui-action] ai.roles.update`, body);
+    for (const role of ["main", "working", "vision"] as AIModelRole[]) {
+      if (!(role in (body || {}))) continue;
+      const value = body[role];
+      if (value === null || value === undefined || value === "") {
+        api.setRoleBinding(role, undefined);
+      } else {
+        api.setRoleBinding(role, String(value));
+      }
+    }
+    return c.json({ ok: true, data: api.getRoleBindings() });
+  });
+
   app.get("/instances", (c) => {
-    const names = aiService?.api?.list?.() ?? [];
-    return c.json({ ok: true, data: names });
+    const api = getAIApi();
+    if (api?.listInstances) {
+      return c.json({ ok: true, data: api.listInstances() });
+    }
+    const names = api?.list?.() ?? [];
+    return c.json({ ok: true, data: names.map((name: string) => ({ name })) });
   });
 
   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,
+      providerId: body?.providerId,
+      modelId: body?.modelId,
     });
-    if (!aiService?.api?.create) {
+    const api = getAIApi();
+    if (api?.createInstance && body?.providerId && body?.modelId) {
+      await api.createInstance({
+        name: body.name,
+        providerId: body.providerId,
+        modelId: body.modelId,
+        role: roles.has(body.role) ? body.role : undefined,
+      });
+      return c.json({ ok: true, data: api.listInstances?.() ?? api.list?.() });
+    }
+    if (!api?.create) {
       return c.json({ ok: false, error: "AI_SERVICE_UNAVAILABLE" }, 503);
     }
-
-    await aiService.api.create({
+    await api.create({
       name: body.name,
       apiUrl: body.apiUrl,
       apiKey: body.apiKey,
       modelType: body.modelType || "text",
+      model: body.model,
     });
-    return c.json({ ok: true, data: aiService.api.list() });
+    return c.json({ ok: true, data: 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);
+    const ok = getAIApi()?.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);
+    const ok = getAIApi()?.setDefault?.(name);
     return c.json({ ok: Boolean(ok) });
   });
 
   app.get("/skills", (c) => {
-    const skills = aiService?.api?.getAllSkills?.();
-    const tools = aiService?.api?.getAllTools?.();
+    const api = getAIApi();
+    const skills = api?.getAllSkills?.();
+    const tools = api?.getAllTools?.();
     return c.json({
       ok: true,
       data: {
@@ -217,7 +444,8 @@ export function createAIRoutes() {
   );
 
   app.get("/usage", (c) => {
-    if (!aiService?.api?.getUsageSummary) {
+    const api = getAIApi();
+    if (!api?.getUsageSummary) {
       return c.json({ ok: false, error: "AI_USAGE_UNAVAILABLE" }, 503);
     }
 
@@ -236,7 +464,7 @@ export function createAIRoutes() {
 
     return c.json({
       ok: true,
-      data: aiService.api.getUsageSummary({ range, botId }),
+      data: api.getUsageSummary({ range, botId }),
     });
   });
 

package/routes/db.ts

@@ -231,7 +231,10 @@ export function createMemeRoutes() {
     const buffer = Buffer.from(await file.arrayBuffer());
     fs.writeFileSync(filePath, buffer);
 
-    return c.json({ ok: true, path: path.relative(process.cwd(), filePath) });
+    return c.json({
+      ok: true,
+      path: path.relative(process.cwd(), filePath).split(path.sep).join("/"),
+    });
   });
 
   app.delete("/", async (c) => {

package/system.ts

@@ -33,7 +33,7 @@ import {
   WEBUI_DIST,
   writeJsonFile,
 } from "./utils";
-import { spawn } from "node:child_process";
+import * as fsp from "node:fs/promises";
 
 async function fetchJson(url: string): Promise<any> {
   const res = await fetch(url, {
@@ -553,44 +553,6 @@ function getRepositoryFromPackage(pkg: any): string {
   return "";
 }
 
-async function commandExists(cmd: string): Promise<boolean> {
-  const result = await runCommand("which", [cmd], process.cwd());
-  return result.code === 0;
-}
-
-async function ensureUnzipCommand(): Promise<void> {
-  if (await commandExists("unzip")) {
-    return;
-  }
-
-  const platform = os.platform();
-  if (platform === "darwin") {
-    const installRes = await runCommand(
-      "brew",
-      ["install", "unzip"],
-      process.cwd(),
-    );
-    if (installRes.code !== 0) {
-      throw new Error(
-        `未找到 unzip 且自动安装失败: ${installRes.stderr || installRes.stdout}。\n` +
-          `请手动运行: brew install unzip`,
-      );
-    }
-  } else {
-    const installRes = await runCommand(
-      "sudo",
-      ["apt", "install", "-y", "unzip"],
-      process.cwd(),
-    );
-    if (installRes.code !== 0) {
-      throw new Error(
-        `未找到 unzip 且自动安装失败: ${installRes.stderr || installRes.stdout}。\n` +
-          `请手动运行: sudo apt install unzip`,
-      );
-    }
-  }
-}
-
 async function getGitOriginUrl(dir: string): Promise<string> {
   const res = await runCommand("git", ["remote", "get-url", "origin"], dir);
   if (res.code !== 0) return "";
@@ -1912,58 +1874,31 @@ export async function updateWebUIDistFromRelease(): Promise<
     try {
       logger.info(`[webui] 正在下载 WebUI dist...`);
 
-      await new Promise<void>((resolve, reject) => {
-        const curl = spawn(
-          "curl",
-          [
-            "-L",
-            "-o",
-            zipPath,
-            "-A",
-            "mioku-webui-updater/1.0",
-            "--silent",
-            "--show-error",
-            downloadUrl,
-          ],
-          {
-            stdio: ["ignore", "pipe", "pipe"],
-          },
-        );
-
-        let stderr = "";
-        curl.stderr.on("data", (chunk) => {
-          stderr += String(chunk);
-        });
+      const res = await fetch(downloadUrl, {
+        headers: { "User-Agent": "mioku-webui-updater/1.0" },
+        redirect: "follow",
+      });
+      if (!res.ok || !res.body) {
+        throw new Error(`下载失败: HTTP ${res.status}`);
+      }
 
-        curl.on("close", (code) => {
-          if (code === 0) {
-            resolve();
-          } else {
-            reject(new Error(`curl 下载失败 (code ${code}): ${stderr}`));
-          }
-        });
-
-        curl.on("error", (err) => {
-          reject(new Error(`curl 进程异常: ${err.message}`));
-        });
-
-        // Periodically log progress by checking file size
-        const progressTimer = setInterval(() => {
-          if (fs.existsSync(zipPath)) {
-            const stat = fs.statSync(zipPath);
-            const now = Date.now();
-            if (now - lastLogTime >= LOG_INTERVAL_MS) {
-              logger.info(
-                `[webui] 正在下载 WebUI dist... ${(stat.size / 1024 / 1024).toFixed(1)} MB 已下载`,
-              );
-              lastLogTime = now;
-            }
+      let downloaded = 0;
+      const handle = await fsp.open(zipPath, "w");
+      try {
+        for await (const chunk of res.body as unknown as AsyncIterable<Uint8Array>) {
+          await handle.write(chunk);
+          downloaded += chunk.byteLength;
+          const now = Date.now();
+          if (now - lastLogTime >= LOG_INTERVAL_MS) {
+            logger.info(
+              `[webui] 正在下载 WebUI dist... ${(downloaded / 1024 / 1024).toFixed(1)} MB 已下载`,
+            );
+            lastLogTime = now;
           }
-        }, 1000);
-
-        // Clear timer when done
-        curl.on("close", () => clearInterval(progressTimer));
-      });
+        }
+      } finally {
+        await handle.close();
+      }
 
       const zipStat = fs.statSync(zipPath);
       logger.info(

package/utils.ts

@@ -1,13 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { spawn } from "node:child_process";
 import type { PackageManager, WebUISettings } from "./types";
 import {
   getServiceConfigDir,
   getServiceDataDir,
   getConfigDir,
   getDataDir,
+  runCommand as runMiokuCommand,
 } from "mioku";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -86,34 +86,7 @@ export async function runCommand(
   args: string[],
   cwd: string,
 ): Promise<{ stdout: string; stderr: string; code: number }> {
-  return new Promise((resolve) => {
-    const child = spawn(command, args, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    let stdout = "";
-    let stderr = "";
-
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-
-    child.on("close", (code) => {
-      resolve({ stdout, stderr, code: code ?? 1 });
-    });
-
-    child.on("error", (error) => {
-      resolve({
-        stdout,
-        stderr: `${stderr}\n${error.message}`.trim(),
-        code: 1,
-      });
-    });
-  });
+  return runMiokuCommand(command, args, { cwd });
 }
 
 export function getInstallCommand(): { cmd: string; args: string[] } {