mioku-service-webui 4.3.0 → 4.4.1

package/config-page-loader.ts

@@ -27,25 +27,40 @@ export interface ConfigPageManifest {
 }
 
 export function loadPluginConfigPage(pluginName: string): ConfigPageManifest | null {
-  // 支持两种路径：本地 plugins 目录和 npm 包
   const possiblePaths = [
     path.join(process.cwd(), "plugins", pluginName),
     path.join(process.cwd(), "node_modules", `mioku-plugin-${pluginName}`),
   ];
 
+  return loadConfigPage(pluginName, possiblePaths);
+}
+
+export function loadServiceConfigPage(serviceName: string): ConfigPageManifest | null {
+  const possiblePaths = [
+    path.join(process.cwd(), "services", serviceName),
+    path.join(process.cwd(), "node_modules", `mioku-service-${serviceName}`),
+  ];
+
+  return loadConfigPage(serviceName, possiblePaths);
+}
+
+function loadConfigPage(
+  packageName: string,
+  possiblePaths: string[],
+): ConfigPageManifest | null {
   let configMdPath: string | null = null;
-  let pluginDir: string | null = null;
+  let packageDir: string | null = null;
 
   for (const dir of possiblePaths) {
     const candidate = path.join(dir, "config.md");
     if (fs.existsSync(candidate)) {
       configMdPath = candidate;
-      pluginDir = dir;
+      packageDir = dir;
       break;
     }
   }
 
-  if (!configMdPath || !pluginDir) {
+  if (!configMdPath || !packageDir) {
     return null;
   }
 
@@ -56,29 +71,27 @@ export function loadPluginConfigPage(pluginName: string): ConfigPageManifest | n
     const frontmatter = parsed.data as any;
     const fields = (frontmatter.fields || []) as ConfigField[];
 
-    // Validate fields
     for (const field of fields) {
       if (!field.key || !field.label || !field.type) {
-        logger.warn(`Invalid field in ${pluginName}/config.md: missing key, label, or type`);
+        logger.warn(`Invalid field in ${packageName}/config.md: missing key, label, or type`);
         continue;
       }
 
-      // Validate key format: <configName>.<jsonPath>
       if (!field.key.includes(".")) {
-        logger.warn(`Invalid field key in ${pluginName}/config.md: ${field.key} (must be <configName>.<path>)`);
+        logger.warn(`Invalid field key in ${packageName}/config.md: ${field.key} (must be <configName>.<path>)`);
       }
     }
 
     return {
-      plugin: pluginName,
-      title: frontmatter.title || `${pluginName} Configuration`,
+      plugin: packageName,
+      title: frontmatter.title || `${packageName} Configuration`,
       description: frontmatter.description,
       markdown: parsed.content,
       fields,
       hasCustomPage: true,
     };
   } catch (error: any) {
-    logger.error(`Failed to load config page for ${pluginName}: ${error.message}`);
+    logger.error(`Failed to load config page for ${packageName}: ${error.message}`);
     return null;
   }
 }

package/index.ts

@@ -22,6 +22,7 @@ import {
   createAIRoutes,
   createDBRoutes,
   createPluginConfigRoutes,
+  createServiceConfigRoutes,
   createMemeRoutes,
   createManageRoutes,
   createStoreRoutes,
@@ -29,6 +30,7 @@ import {
   createStrangerRoutes,
   createAccessControlRoutes,
 } from "./routes";
+import { freePort } from "./port-utils";
 
 export interface WebUIServiceAPI {
   getSettings(): WebUISettings;
@@ -43,7 +45,7 @@ class WebUIRuntime {
     logger.info(`[webui-action] ${action}${text}`);
   }
 
-  public initRoutes(): void {
+  public async initRoutes(): Promise<void> {
     const { upgradeWebSocket, injectWebSocket } = createNodeWebSocket({
       app: this.app,
     });
@@ -105,6 +107,7 @@ class WebUIRuntime {
     this.app.route("/api/store", createStoreRoutes());
     this.app.route("/api/db", createDBRoutes());
     this.app.route("/api/plugin-config", createPluginConfigRoutes());
+    this.app.route("/api/service-config", createServiceConfigRoutes());
     this.app.route("/api/meme", createMemeRoutes());
     this.app.route("/api/data-management", createDataManagementRoutes());
     this.app.route("/api/stranger", createStrangerRoutes());
@@ -170,6 +173,12 @@ class WebUIRuntime {
     });
 
     const settings = getWebUISettings();
+    const freed = await freePort(settings.port);
+    if (freed.remainingPids.length > 0) {
+      throw new Error(
+        `webui 端口 ${settings.port} 被占用且无法结束 (PID: ${freed.remainingPids.join(", ")})`,
+      );
+    }
     const server = serve({
       fetch: this.app.fetch,
       port: settings.port,
@@ -230,7 +239,7 @@ const webUIService: MiokuService = {
     initBuiltinDatasources();
     ensureAuthConfig();
     await ensureWebUIDist();
-    runtime.initRoutes();
+    await runtime.initRoutes();
   },
 
   async dispose() {

package/package.json

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

package/port-utils.ts

@@ -0,0 +1,159 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { logger } from "mioki";
+
+const execFileAsync = promisify(execFile);
+
+export interface FreePortLogger {
+  info: (msg: string) => void;
+  warn: (msg: string) => void;
+  error: (msg: string) => void;
+}
+
+export interface FreePortOptions {
+  logger?: FreePortLogger;
+  graceMs?: number;
+  sigkillDelayMs?: number;
+}
+
+export interface FreePortResult {
+  port: number;
+  wasOccupied: boolean;
+  killedPids: number[];
+  remainingPids: number[];
+  lsofAvailable: boolean;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function parsePids(raw: string): number[] {
+  const pids = new Set<number>();
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const pid = Number(trimmed);
+    if (Number.isFinite(pid) && pid > 0 && Math.floor(pid) === pid) {
+      pids.add(pid);
+    }
+  }
+  return Array.from(pids);
+}
+
+async function listListeningPids(
+  port: number,
+): Promise<{ pids: number[]; lsofAvailable: boolean }> {
+  try {
+    const { stdout } = await execFileAsync("lsof", [
+      "-nP",
+      `-iTCP:${port}`,
+      "-sTCP:LISTEN",
+      "-t",
+    ]);
+    return { pids: parsePids(stdout), lsofAvailable: true };
+  } catch (err: any) {
+    if (err?.code === "ENOENT") {
+      return { pids: [], lsofAvailable: false };
+    }
+    return { pids: [], lsofAvailable: true };
+  }
+}
+
+async function sendSignal(
+  pid: number,
+  signal: NodeJS.Signals,
+): Promise<boolean> {
+  if (pid === process.pid) return false;
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function freePort(
+  port: number,
+  options: FreePortOptions = {},
+): Promise<FreePortResult> {
+  const log = options.logger ?? (logger as unknown as FreePortLogger);
+  const graceMs = options.graceMs ?? 1500;
+  const sigkillDelayMs = options.sigkillDelayMs ?? 500;
+
+  const initial = await listListeningPids(port);
+
+  if (!initial.lsofAvailable) {
+    log.warn(
+      `未检测到 lsof 命令，无法定位端口 ${port} 的占用进程，建议安装 lsof`,
+    );
+    return {
+      port,
+      wasOccupied: false,
+      killedPids: [],
+      remainingPids: [],
+      lsofAvailable: false,
+    };
+  }
+
+  const occupied = initial.pids.filter((pid) => pid !== process.pid);
+  if (occupied.length === 0) {
+    return {
+      port,
+      wasOccupied: false,
+      killedPids: [],
+      remainingPids: [],
+      lsofAvailable: true,
+    };
+  }
+
+  log.warn(
+    `端口 ${port} 被占用，进程 PID: ${occupied.join(", ")}，正在尝试结束...`,
+  );
+
+  const killed: number[] = [];
+  for (const pid of occupied) {
+    if (await sendSignal(pid, "SIGTERM")) {
+      killed.push(pid);
+    }
+  }
+
+  if (killed.length > 0) {
+    await sleep(graceMs);
+  }
+
+  let remaining = (await listListeningPids(port)).pids.filter(
+    (pid) => pid !== process.pid,
+  );
+
+  if (remaining.length > 0) {
+    log.warn(
+      `端口 ${port} 仍被占用 (PID: ${remaining.join(", ")})，发送 SIGKILL 强制结束...`,
+    );
+    for (const pid of remaining) {
+      if (await sendSignal(pid, "SIGKILL")) {
+        killed.push(pid);
+      }
+    }
+    await sleep(sigkillDelayMs);
+    remaining = (await listListeningPids(port)).pids.filter(
+      (pid) => pid !== process.pid,
+    );
+  }
+
+  if (remaining.length > 0) {
+    log.error(
+      `端口 ${port} 仍被占用，无法结束进程 PID: ${remaining.join(", ")}`,
+    );
+  } else {
+    log.info(`端口 ${port} 已释放`);
+  }
+
+  return {
+    port,
+    wasOccupied: true,
+    killedPids: killed,
+    remainingPids: remaining,
+    lsofAvailable: true,
+  };
+}

package/routes/data-management.ts

@@ -514,7 +514,7 @@ export function createDataManagementRoutes() {
 
   app.post("/node-modules/refresh", async (c) => {
     const settings = getWebUISettings();
-    const command = getInstallCommand(settings.packageManager);
+    const command = getInstallCommand();
     const startedAt = Date.now();
     const result = await runCommand(command.cmd, command.args, process.cwd());
     const finishedAt = Date.now();

package/routes/db.ts

@@ -14,8 +14,12 @@ import {
   updateMessage,
 } from "../database";
 import { CHAT_DATA_DIR } from "../utils";
-import { loadPluginConfigPage } from "../config-page-loader";
+import { loadPluginConfigPage, loadServiceConfigPage } from "../config-page-loader";
 import { getDatasource } from "../datasources";
+import {
+  getServiceConfigs,
+  updateServiceConfig,
+} from "mioku";
 
 export function createDBRoutes() {
   const app = new Hono();
@@ -219,3 +223,98 @@ export function createMemeRoutes() {
 
   return app;
 }
+
+export function createServiceConfigRoutes() {
+  const app = new Hono();
+  const SERVICE_CONFIG_ROOT = path.join(process.cwd(), "config", "service");
+
+  app.get("/overview", (c) => {
+    const modulesPath = path.join(process.cwd(), "node_modules");
+    if (!fs.existsSync(modulesPath)) {
+      return c.json({ ok: true, data: [] });
+    }
+
+    const services: string[] = [];
+    const entries = fs.readdirSync(modulesPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith("mioku-service-")) {
+        services.push(entry.name.replace(/^mioku-service-/, ""));
+      }
+    }
+
+    const overview = services
+      .map((name) => {
+        const configDir = path.join(SERVICE_CONFIG_ROOT, name);
+        const manifest = loadServiceConfigPage(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 = loadServiceConfigPage(name);
+    const configs = getServiceConfigs(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("/:name", (c) => {
+    const name = c.req.param("name");
+    return c.json({ ok: true, data: getServiceConfigs(name) });
+  });
+
+  app.put("/:name/:config", async (c) => {
+    const serviceName = c.req.param("name");
+    const configName = c.req.param("config");
+    const body = await c.req.json();
+    updateServiceConfig(serviceName, configName, body);
+    return c.json({ ok: true });
+  });
+
+  return app;
+}

package/routes/index.ts

@@ -1,7 +1,7 @@
 export { createConfigRoutes } from "./config";
 export { createWebUISettingsRoutes } from "./webui";
 export { createAIRoutes } from "./ai";
-export { createDBRoutes, createPluginConfigRoutes, createMemeRoutes } from "./db";
+export { createDBRoutes, createPluginConfigRoutes, createMemeRoutes, createServiceConfigRoutes } from "./db";
 export { createManageRoutes } from "./manage";
 export { createStoreRoutes } from "./store";
 export { createDataManagementRoutes } from "./data-management";

package/system.ts

@@ -96,6 +96,66 @@ const BOOT_CONFIG_PATH = path.join(
   "base.json",
 );
 
+export interface BootSystemCommandsConfig {
+  update: {
+    enabled: boolean;
+    selectTimeoutMs: number;
+  };
+  install: {
+    enabled: boolean;
+  };
+  market: {
+    enabled: boolean;
+  };
+  restart: {
+    enabled: boolean;
+  };
+}
+
+const DEFAULT_BOOT_SYSTEM_COMMANDS_CONFIG: BootSystemCommandsConfig = {
+  update: {
+    enabled: true,
+    selectTimeoutMs: 60000,
+  },
+  install: {
+    enabled: true,
+  },
+  market: {
+    enabled: true,
+  },
+  restart: {
+    enabled: true,
+  },
+};
+
+function normalizeBootSystemCommandsConfig(
+  input: any,
+): BootSystemCommandsConfig {
+  const merged = deepMerge(
+    cloneJson(DEFAULT_BOOT_SYSTEM_COMMANDS_CONFIG),
+    input || {},
+  );
+  const rawTimeout = Number(merged?.update?.selectTimeoutMs);
+  return {
+    update: {
+      enabled: Boolean(merged?.update?.enabled),
+      selectTimeoutMs:
+        Number.isFinite(rawTimeout) && rawTimeout >= 1000
+          ? Math.floor(rawTimeout)
+          : DEFAULT_BOOT_SYSTEM_COMMANDS_CONFIG.update.selectTimeoutMs,
+    },
+    install: {
+      enabled: Boolean(merged?.install?.enabled),
+    },
+    market: {
+      enabled: Boolean(merged?.market?.enabled),
+    },
+    restart: {
+      enabled: Boolean(merged?.restart?.enabled),
+    },
+  };
+}
+
 interface AccessRuleConfig {
   whitelist: Array<string | number>;
   blacklist: Array<string | number>;
@@ -1345,8 +1405,7 @@ export async function getManagedPackageDetail(
   const missingServices = checkDependentServices(pkg);
 
   const isSystemPlugin = target === "plugin" ? isSystemPluginName(name) : false;
-  const isSystemService =
-    target === "service" ? isSystemServiceName(name) : false;
+  const isSystemService = false;
   return {
     ok: true,
     data: {