mioku-service-webui 4.1.0 → 4.4.0

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

@@ -8,7 +8,12 @@ import { createNodeWebSocket } from "@hono/node-ws";
 import type { MiokuService } from "mioku";
 import type { WebUISettings } from "./types";
 import { ensureAuthConfig, loginWithToken, requireAuth } from "./auth";
-import { ensureWebUIDist, getWebUISettings, getSystemOverview, getSaying } from "./system";
+import {
+  ensureWebUIDist,
+  getWebUISettings,
+  getSystemOverview,
+  getSaying,
+} from "./system";
 import { CHAT_CONFIG_DIR, CHAT_DATA_DIR, LOGS_DIR, WEBUI_DIST } from "./utils";
 import { initBuiltinDatasources } from "./datasources";
 import {
@@ -17,11 +22,13 @@ import {
   createAIRoutes,
   createDBRoutes,
   createPluginConfigRoutes,
+  createServiceConfigRoutes,
   createMemeRoutes,
   createManageRoutes,
   createStoreRoutes,
   createDataManagementRoutes,
   createStrangerRoutes,
+  createAccessControlRoutes,
 } from "./routes";
 
 export interface WebUIServiceAPI {
@@ -99,9 +106,11 @@ 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());
+    this.app.route("/api/access-control", createAccessControlRoutes());
 
     this.app.get(
       "/api/ws/logs",
@@ -213,7 +222,7 @@ const runtime = new WebUIRuntime();
 
 const webUIService: MiokuService = {
   name: "webui",
-  version: "2.0.0",
+  version: "4.2.0",
   description: "Mioku WebUI 管理服务",
   api: {
     getSettings: () => getWebUISettings(),

package/package.json

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

package/routes/access-control.ts

@@ -0,0 +1,162 @@
+import { Hono } from "hono";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logger } from "mioki";
+import { readJsonFile, writeJsonFile, NODE_MODULES_DIR } from "../utils";
+
+const ACCESS_CONFIG_PATH = path.resolve(
+  process.cwd(),
+  "config/boot/access-control.json",
+);
+
+const DEFAULT_CONFIG = {
+  version: 1,
+  global: { plugins: {}, commands: {} },
+  groups: {},
+  users: {},
+};
+
+export function normalizeAccessConfig(input: any) {
+  return {
+    version: 1,
+    global: {
+      plugins: input?.global?.plugins ?? {},
+      commands: input?.global?.commands ?? {},
+    },
+    groups: input?.groups ?? {},
+    users: input?.users ?? {},
+  };
+}
+
+type AccessItemKind = "plugin" | "command";
+
+interface AccessItem {
+  kind: AccessItemKind;
+  plugin: string;
+  id: string;
+  label: string;
+  desc?: string;
+  match?: string;
+  event?: string;
+  fromHook: boolean;
+}
+
+function readAccessCatalog(): AccessItem[] {
+  if (!fs.existsSync(NODE_MODULES_DIR)) return [];
+  const entries = fs.readdirSync(NODE_MODULES_DIR, { withFileTypes: true });
+  const items: AccessItem[] = [];
+
+  for (const entry of entries) {
+    if (!entry.name.startsWith("mioku-plugin-")) continue;
+    const fullPath = path.join(NODE_MODULES_DIR, entry.name);
+    let stat: fs.Stats;
+    try {
+      stat = fs.lstatSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory() && !stat.isSymbolicLink()) continue;
+
+    const pkgPath = path.join(fullPath, "package.json");
+    if (!fs.existsSync(pkgPath)) continue;
+    let pkg: any;
+    try {
+      pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    } catch {
+      continue;
+    }
+
+    const name = entry.name.replace(/^mioku-plugin-/, "");
+    const mioku = pkg.mioku || {};
+    const help = mioku.help || { title: name, description: "", commands: [] };
+    const hooks: Array<{ id: string; match?: string; event?: string; description?: string }> =
+      mioku.accessHooks || [];
+    const helpCommands: Array<any> = help.commands || [];
+
+    items.push({
+      kind: "plugin",
+      plugin: name,
+      id: name,
+      label: help.title || name,
+      desc: help.description,
+      fromHook: false,
+    });
+
+    const seen = new Set<string>();
+    for (const hook of hooks) {
+      seen.add(hook.id);
+      items.push({
+        kind: "command",
+        plugin: name,
+        id: hook.id,
+        label: hook.id,
+        desc: hook.description,
+        match: hook.match,
+        event: hook.event,
+        fromHook: true,
+      });
+    }
+    for (const c of helpCommands) {
+      const id = String(c.cmd || "").trim();
+      if (!id || seen.has(id)) continue;
+      items.push({
+        kind: "command",
+        plugin: name,
+        id,
+        label: id,
+        desc: c.desc,
+        fromHook: false,
+      });
+    }
+  }
+
+  return items.sort((a, b) => {
+    if (a.kind !== b.kind) return a.kind === "plugin" ? -1 : 1;
+    if (a.plugin !== b.plugin) return a.plugin.localeCompare(b.plugin);
+    return a.id.localeCompare(b.id);
+  });
+}
+
+function filterCatalog(items: AccessItem[], query?: string): AccessItem[] {
+  if (!query) return items;
+  const q = query.trim().toLowerCase();
+  if (!q) return items;
+  return items.filter((it) => {
+    return (
+      it.id.toLowerCase().includes(q) ||
+      it.label.toLowerCase().includes(q) ||
+      it.plugin.toLowerCase().includes(q) ||
+      (it.desc || "").toLowerCase().includes(q)
+    );
+  });
+}
+
+export function createAccessControlRoutes() {
+  const app = new Hono();
+
+  app.get("/", (c) => {
+    const data = readJsonFile(ACCESS_CONFIG_PATH, DEFAULT_CONFIG);
+    return c.json({ ok: true, data: normalizeAccessConfig(data) });
+  });
+
+  app.put("/", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (!body) {
+      return c.json({ ok: false, error: "INVALID_BODY" }, 400);
+    }
+    const data = normalizeAccessConfig(body);
+    writeJsonFile(ACCESS_CONFIG_PATH, data);
+    logger.info(
+      `[webui-action] access-control.update | groups=${Object.keys(data.groups).length} users=${Object.keys(data.users).length}`,
+    );
+    return c.json({ ok: true, data });
+  });
+
+  app.get("/catalog", (c) => {
+    const q = c.req.query("q");
+    const data = filterCatalog(readAccessCatalog(), q);
+    return c.json({ ok: true, data });
+  });
+
+  return app;
+}

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,8 +1,9 @@
 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";
 export { createStrangerRoutes } from "./stranger";
+export { createAccessControlRoutes } from "./access-control";

package/system.ts

@@ -322,6 +322,26 @@ function readPackageJson(dir: string): any {
   }
 }
 
+const WEBUI_PLUGIN_PREFIX = "mioku-plugin-";
+
+function appendToMiokiPlugins(cwd: string, pkgName: string): boolean {
+  if (!pkgName.startsWith(WEBUI_PLUGIN_PREFIX)) return false;
+  const shortName = pkgName.slice(WEBUI_PLUGIN_PREFIX.length);
+
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(packageJsonPath)) return false;
+
+  const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  const mioki = pkg.mioki ?? {};
+  const plugins = Array.isArray(mioki.plugins) ? [...mioki.plugins] : [];
+  if (plugins.includes(shortName)) return false;
+
+  plugins.push(shortName);
+  pkg.mioki = { ...mioki, plugins };
+  fs.writeFileSync(packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`);
+  return true;
+}
+
 function readRootPackageJson(): any {
   return JSON.parse(fs.readFileSync(ROOT_PACKAGE_PATH, "utf-8"));
 }
@@ -1020,12 +1040,18 @@ export async function installManagedPackage(
     makeManagedUpdateCacheKey(input.target, installedName),
   );
 
+  let enabled = false;
+  if (input.target === "plugin") {
+    enabled = appendToMiokiPlugins(installDir, installedName);
+  }
+
   return {
     ok: true,
     name: installedName,
     missingServices,
     packageManager: "bun",
     restartRequired: true,
+    enabled,
     installOutput: install.stdout || install.stderr,
   };
 }