mioku-service-webui 4.5.0 → 4.6.0

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.5.0",
+  "version": "4.6.0",
   "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/config.ts

@@ -4,6 +4,8 @@ import {
   getMiokuConfig,
   updateMiokuConfig,
   getAvailablePlugins,
+  getPluginStatusList,
+  togglePlugin,
   checkMiokuReleaseUpdate,
   updateMiokuFromMain,
 } from "../system";
@@ -48,5 +50,20 @@ export function createConfigRoutes() {
     return c.json({ ok: true, data });
   });
 
+  app.get("/plugins", (c) => {
+    const data = getPluginStatusList();
+    return c.json({ ok: true, data });
+  });
+
+  app.post("/plugins/toggle", async (c) => {
+    const body = (await c.req.json()) as { name: string; enabled: boolean };
+    const data = togglePlugin(body.name, body.enabled);
+    logger.info(`[webui-action] config.plugins.toggle`, {
+      name: body.name,
+      enabled: body.enabled,
+    });
+    return c.json({ ok: true, data });
+  });
+
   return app;
 }

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 "";
@@ -1251,9 +1213,46 @@ export async function removeManagedPackage(
     throw new Error("系统服务不可卸载");
   }
 
-  const dir = resolveManagedDir(input.target, input.name);
+  // construct full package name from short name
+  const fullName = input.name.startsWith("mioku-plugin-") || input.name.startsWith("mioku-service-")
+    ? input.name
+    : input.target === "plugin"
+      ? `mioku-plugin-${input.name}`
+      : `mioku-service-${input.name}`;
+
+  const installCmd = getInstallCommand();
+  const removeArgs = installCmd.args.map((a) =>
+    a === "add" ? "remove" : a,
+  );
+
+  const result = await runCommand(
+    installCmd.cmd,
+    [...removeArgs, fullName],
+    process.cwd(),
+  );
 
-  fs.rmSync(dir, { recursive: true, force: true });
+  if (result.code !== 0) {
+    throw new Error(`bun remove 失败: ${result.stderr || result.stdout}`);
+  }
+
+  // clean up mioki.plugins list for plugins
+  if (input.target === "plugin") {
+    const pkgPath = ROOT_PACKAGE_PATH;
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        const mioki = pkg.mioki ?? {};
+        const plugins: string[] = Array.isArray(mioki.plugins) ? mioki.plugins : [];
+        const shortName = fullName.replace(/^mioku-plugin-/, "");
+        if (plugins.includes(shortName)) {
+          pkg.mioki = { ...mioki, plugins: plugins.filter((p: string) => p !== shortName) };
+          fs.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+        }
+      } catch {
+        // silently ignore package.json parse errors
+      }
+    }
+  }
 
   managedPackageUpdateCache.delete(
     makeManagedUpdateCacheKey(input.target, input.name),
@@ -1912,58 +1911,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(
@@ -2414,3 +2386,53 @@ export function getAvailablePlugins(): string[] {
   }
   return plugins.sort((a, b) => a.localeCompare(b));
 }
+
+export interface PluginStatusItem {
+  name: string;
+  enabled: boolean;
+  system: boolean;
+  description: string;
+}
+
+export function getPluginStatusList(): PluginStatusItem[] {
+  const allPlugins = getAvailablePlugins();
+  const miokuConfig = getMiokuConfig();
+  const enabledPlugins = new Set(miokuConfig.plugins || []);
+
+  return allPlugins.map((name) => {
+    const fullPath = path.join(NODE_MODULES_DIR, `mioku-plugin-${name}`);
+    const pkg = readPackageJson(fullPath);
+    return {
+      name,
+      enabled: enabledPlugins.has(name),
+      system: SYSTEM_PLUGIN_NAMES.has(name.toLowerCase()),
+      description: pkg?.description ?? "",
+    };
+  });
+}
+
+export function togglePlugin(name: string, enabled: boolean): PluginStatusItem {
+  const safeName = String(name || "").trim();
+  if (!safeName) throw new Error("插件名称为空");
+
+  const config = getMiokuConfig();
+  const plugins = new Set(config.plugins || []);
+
+  if (enabled) {
+    plugins.add(safeName);
+  } else {
+    if (safeName.toLowerCase() === "boot") {
+      throw new Error("boot 插件不可关闭");
+    }
+    plugins.delete(safeName);
+  }
+
+  updateMiokuConfig({ ...config, plugins: Array.from(plugins) });
+
+  return {
+    name: safeName,
+    enabled: plugins.has(safeName),
+    system: SYSTEM_PLUGIN_NAMES.has(safeName.toLowerCase()),
+    description: "",
+  };
+}

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[] } {