@zhin.js/console 1.0.40 → 1.0.42

package/lib/index.js

@@ -1,40 +1,45 @@
 import { usePlugin } from '@zhin.js/core';
 import mime from 'mime';
-import * as fs2 from 'fs';
-import * as path2 from 'path';
+import * as fs from 'fs';
+import fs__default from 'fs';
+import * as path3 from 'path';
+import path3__default from 'path';
 import WebSocket from 'ws';
 import { transform } from 'esbuild';
 
 // src/index.ts
 var { root, logger } = usePlugin();
+var ENV_WHITELIST = [".env", ".env.development", ".env.production"];
+function resolveConfigKey(pluginName) {
+  const schemaService = root.inject("schema");
+  return schemaService?.resolveConfigKey(pluginName) ?? pluginName;
+}
+function getPluginKeys() {
+  const schemaService = root.inject("schema");
+  if (!schemaService) return [];
+  const keys = /* @__PURE__ */ new Set();
+  for (const [, configKey] of schemaService.getPluginKeyMap()) {
+    keys.add(configKey);
+  }
+  return Array.from(keys);
+}
+function getConfigFilePath() {
+  return path3__default.resolve(process.cwd(), "zhin.config.yml");
+}
 function setupWebSocket(webServer) {
   webServer.ws.on("connection", (ws) => {
-    ws.send(
-      JSON.stringify({
-        type: "sync",
-        data: {
-          key: "entries",
-          value: Object.values(webServer.entries)
-        }
-      })
-    );
-    ws.send(
-      JSON.stringify({
-        type: "init-data",
-        timestamp: Date.now()
-      })
-    );
+    ws.send(JSON.stringify({
+      type: "sync",
+      data: { key: "entries", value: Object.values(webServer.entries) }
+    }));
+    ws.send(JSON.stringify({ type: "init-data", timestamp: Date.now() }));
     ws.on("message", async (data) => {
       try {
         const message = JSON.parse(data.toString());
         await handleWebSocketMessage(ws, message, webServer);
       } catch (error) {
         console.error("WebSocket \u6D88\u606F\u5904\u7406\u9519\u8BEF:", error);
-        ws.send(
-          JSON.stringify({
-            error: "Invalid message format"
-          })
-        );
+        ws.send(JSON.stringify({ error: "Invalid message format" }));
       }
     });
     ws.on("close", () => {
@@ -51,19 +56,50 @@ async function handleWebSocketMessage(ws, message, webServer) {
       ws.send(JSON.stringify({ type: "pong", requestId }));
       break;
     case "entries:get":
-      ws.send(
-        JSON.stringify({
-          requestId,
-          data: Object.values(webServer.entries)
-        })
-      );
+      ws.send(JSON.stringify({ requestId, data: Object.values(webServer.entries) }));
+      break;
+    // ================================================================
+    // 配置文件原始 YAML 读写（用于配置管理页面）
+    // ================================================================
+    case "config:get-yaml":
+      try {
+        const filePath = getConfigFilePath();
+        const yaml = fs__default.existsSync(filePath) ? fs__default.readFileSync(filePath, "utf-8") : "";
+        ws.send(JSON.stringify({ requestId, data: { yaml, pluginKeys: getPluginKeys() } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to read config: ${error.message}` }));
+      }
       break;
+    case "config:save-yaml":
+      try {
+        const { yaml } = message;
+        if (typeof yaml !== "string") {
+          ws.send(JSON.stringify({ requestId, error: "yaml field is required" }));
+          break;
+        }
+        const filePath = getConfigFilePath();
+        fs__default.writeFileSync(filePath, yaml, "utf-8");
+        const configService2 = root.inject("config");
+        const loader = configService2.configs.get("zhin.config.yml");
+        if (loader) loader.load();
+        ws.send(JSON.stringify({ requestId, data: { success: true, message: "\u914D\u7F6E\u5DF2\u4FDD\u5B58\uFF0C\u9700\u91CD\u542F\u751F\u6548" } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to save config: ${error.message}` }));
+      }
+      break;
+    // ================================================================
+    // 插件配置（供 PluginConfigForm 使用）
+    // ================================================================
     case "config:get":
       try {
         const configService2 = root.inject("config");
-        const appConfig2 = configService2.get("zhin.config.yml");
-        const config = pluginName ? appConfig2[pluginName] || {} : appConfig2;
-        ws.send(JSON.stringify({ requestId, data: config }));
+        const rawConfig = configService2.getRaw("zhin.config.yml");
+        if (!pluginName) {
+          ws.send(JSON.stringify({ requestId, data: rawConfig }));
+        } else {
+          const configKey = resolveConfigKey(pluginName);
+          ws.send(JSON.stringify({ requestId, data: rawConfig[configKey] || {} }));
+        }
       } catch (error) {
         ws.send(JSON.stringify({ requestId, error: `Failed to get config: ${error.message}` }));
       }
@@ -71,8 +107,17 @@ async function handleWebSocketMessage(ws, message, webServer) {
     case "config:get-all":
       try {
         const configService2 = root.inject("config");
-        const appConfig2 = configService2.get("zhin.config.yml");
-        ws.send(JSON.stringify({ requestId, data: appConfig2 }));
+        const rawConfig = configService2.getRaw("zhin.config.yml");
+        const allConfigs = { ...rawConfig };
+        const schemaService = root.inject("schema");
+        if (schemaService) {
+          for (const [pName, configKey] of schemaService.getPluginKeyMap()) {
+            if (pName !== configKey) {
+              allConfigs[pName] = rawConfig[configKey] || {};
+            }
+          }
+        }
+        ws.send(JSON.stringify({ requestId, data: allConfigs }));
       } catch (error) {
         ws.send(JSON.stringify({ requestId, error: `Failed to get all configs: ${error.message}` }));
       }
@@ -84,28 +129,45 @@ async function handleWebSocketMessage(ws, message, webServer) {
           ws.send(JSON.stringify({ requestId, error: "Plugin name is required" }));
           break;
         }
+        const configKey = resolveConfigKey(pluginName);
         const configService2 = root.inject("config");
-        const appConfig2 = configService2.get("zhin.config.yml");
-        appConfig2[pluginName] = data;
-        configService2.set("zhin.config.yml", appConfig2);
-        ws.send(JSON.stringify({ requestId, success: true }));
-        broadcastToAll(webServer, {
-          type: "config:updated",
-          data: { pluginName, config: data }
-        });
+        const loader = configService2.configs.get("zhin.config.yml");
+        if (!loader) {
+          ws.send(JSON.stringify({ requestId, error: "Config file not loaded" }));
+          break;
+        }
+        loader.patchKey(configKey, data);
+        broadcastToAll(webServer, { type: "config:updated", data: { pluginName, config: data } });
+        const schemaService = root.inject("schema");
+        const reloadable = schemaService?.isReloadable?.(pluginName) ?? false;
+        if (reloadable) {
+          const target = findPluginByConfigKey(root, pluginName);
+          if (target) {
+            try {
+              await target.reload();
+              ws.send(JSON.stringify({ requestId, data: { success: true, reloaded: true } }));
+            } catch (reloadErr) {
+              logger.warn(`\u91CD\u8F7D\u63D2\u4EF6 ${pluginName} \u5931\u8D25: ${reloadErr.message}`);
+              ws.send(JSON.stringify({ requestId, data: { success: true, reloaded: false, message: "\u914D\u7F6E\u5DF2\u4FDD\u5B58\uFF0C\u4F46\u91CD\u8F7D\u5931\u8D25" } }));
+            }
+          } else {
+            ws.send(JSON.stringify({ requestId, data: { success: true, reloaded: false, message: "\u914D\u7F6E\u5DF2\u4FDD\u5B58" } }));
+          }
+        } else {
+          ws.send(JSON.stringify({ requestId, data: { success: true, reloaded: false, message: "\u914D\u7F6E\u5DF2\u4FDD\u5B58\uFF0C\u9700\u91CD\u542F\u8FDB\u7A0B\u624D\u80FD\u751F\u6548" } }));
+        }
       } catch (error) {
         ws.send(JSON.stringify({ requestId, error: `Failed to set config: ${error.message}` }));
       }
       break;
+    // ================================================================
+    // Schema（供 PluginConfigForm 使用）
+    // ================================================================
     case "schema:get":
       try {
         const schemaService = root.inject("schema");
         const schema = pluginName && schemaService ? schemaService.get(pluginName) : null;
-        if (schema) {
-          ws.send(JSON.stringify({ requestId, data: schema.toJSON() }));
-        } else {
-          ws.send(JSON.stringify({ requestId, data: null }));
-        }
+        ws.send(JSON.stringify({ requestId, data: schema ? schema.toJSON() : null }));
       } catch (error) {
         ws.send(JSON.stringify({ requestId, error: `Failed to get schema: ${error.message}` }));
       }
@@ -115,8 +177,15 @@ async function handleWebSocketMessage(ws, message, webServer) {
         const schemaService = root.inject("schema");
         const schemas = {};
         if (schemaService) {
-          for (const [name, schema] of schemaService.items.entries()) {
-            schemas[name] = schema.toJSON();
+          for (const record of schemaService.items) {
+            if (record.key && record.schema) {
+              schemas[record.key] = record.schema.toJSON();
+            }
+          }
+          for (const [pName, configKey] of schemaService.getPluginKeyMap()) {
+            if (pName !== configKey && schemas[configKey]) {
+              schemas[pName] = schemas[configKey];
+            }
           }
         }
         ws.send(JSON.stringify({ requestId, data: schemas }));
@@ -124,15 +193,67 @@ async function handleWebSocketMessage(ws, message, webServer) {
         ws.send(JSON.stringify({ requestId, error: `Failed to get all schemas: ${error.message}` }));
       }
       break;
+    // ================================================================
+    // 环境变量文件管理
+    // ================================================================
+    case "env:list":
+      try {
+        const cwd = process.cwd();
+        const files = ENV_WHITELIST.map((name) => ({
+          name,
+          exists: fs__default.existsSync(path3__default.resolve(cwd, name))
+        }));
+        ws.send(JSON.stringify({ requestId, data: { files } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to list env files: ${error.message}` }));
+      }
+      break;
+    case "env:get":
+      try {
+        const { filename } = message;
+        if (!filename || !ENV_WHITELIST.includes(filename)) {
+          ws.send(JSON.stringify({ requestId, error: `Invalid env file: ${filename}` }));
+          break;
+        }
+        const envPath = path3__default.resolve(process.cwd(), filename);
+        const content = fs__default.existsSync(envPath) ? fs__default.readFileSync(envPath, "utf-8") : "";
+        ws.send(JSON.stringify({ requestId, data: { content } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to read env file: ${error.message}` }));
+      }
+      break;
+    case "env:save":
+      try {
+        const { filename, content } = message;
+        if (!filename || !ENV_WHITELIST.includes(filename)) {
+          ws.send(JSON.stringify({ requestId, error: `Invalid env file: ${filename}` }));
+          break;
+        }
+        if (typeof content !== "string") {
+          ws.send(JSON.stringify({ requestId, error: "content field is required" }));
+          break;
+        }
+        const envPath = path3__default.resolve(process.cwd(), filename);
+        fs__default.writeFileSync(envPath, content, "utf-8");
+        ws.send(JSON.stringify({ requestId, data: { success: true, message: "\u73AF\u5883\u53D8\u91CF\u5DF2\u4FDD\u5B58\uFF0C\u9700\u91CD\u542F\u751F\u6548" } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to save env file: ${error.message}` }));
+      }
+      break;
     default:
-      ws.send(
-        JSON.stringify({
-          requestId,
-          error: `Unknown message type: ${type}`
-        })
-      );
+      ws.send(JSON.stringify({ requestId, error: `Unknown message type: ${type}` }));
   }
 }
+function findPluginByConfigKey(rootPlugin, configKey) {
+  for (const child of rootPlugin.children) {
+    if (child.name === configKey || child.name.endsWith(`-${configKey}`) || child.name.includes(configKey)) {
+      return child;
+    }
+    const found = findPluginByConfigKey(child, configKey);
+    if (found) return found;
+  }
+  return null;
+}
 function broadcastToAll(webServer, message) {
   for (const ws of webServer.ws.clients || []) {
     if (ws.readyState === WebSocket.OPEN) {
@@ -141,16 +262,13 @@ function broadcastToAll(webServer, message) {
   }
 }
 function notifyDataUpdate(webServer) {
-  broadcastToAll(webServer, {
-    type: "data-update",
-    timestamp: Date.now()
-  });
+  broadcastToAll(webServer, { type: "data-update", timestamp: Date.now() });
 }
 var cache = /* @__PURE__ */ new Map();
 var TRANSFORMABLE_EXTS = [".ts", ".tsx", ".jsx"];
 var RESOLVE_EXTS = [".tsx", ".ts", ".jsx", ".js"];
 function isTransformable(filePath) {
-  const ext = path2.extname(filePath).toLowerCase();
+  const ext = path3.extname(filePath).toLowerCase();
   return TRANSFORMABLE_EXTS.includes(ext);
 }
 var IMPORT_RE = /(?:import|export)\s+.*?\s+from\s+['"]([^'"]+)['"]|import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
@@ -159,22 +277,22 @@ function isRelative(specifier) {
   return specifier.startsWith("./") || specifier.startsWith("../");
 }
 function hasExtension(specifier) {
-  const base = path2.basename(specifier);
+  const base = path3.basename(specifier);
   return base.includes(".") && !base.startsWith(".");
 }
 function resolveRelativeImport(specifier, fromFile) {
   if (!isRelative(specifier)) return specifier;
   if (hasExtension(specifier)) return specifier;
-  const dir = path2.dirname(fromFile);
-  const target = path2.resolve(dir, specifier);
+  const dir = path3.dirname(fromFile);
+  const target = path3.resolve(dir, specifier);
   for (const ext of RESOLVE_EXTS) {
-    if (fs2.existsSync(target + ext)) {
+    if (fs.existsSync(target + ext)) {
       return specifier + ext;
     }
   }
-  if (fs2.existsSync(target) && fs2.statSync(target).isDirectory()) {
+  if (fs.existsSync(target) && fs.statSync(target).isDirectory()) {
     for (const ext of RESOLVE_EXTS) {
-      if (fs2.existsSync(path2.join(target, `index${ext}`))) {
+      if (fs.existsSync(path3.join(target, `index${ext}`))) {
         return specifier + `/index${ext}`;
       }
     }
@@ -194,13 +312,13 @@ function rewriteImports(code, fromFile) {
   return code;
 }
 async function transformFile(filePath) {
-  const stat = fs2.statSync(filePath);
+  const stat = fs.statSync(filePath);
   const cached = cache.get(filePath);
   if (cached && cached.mtime === stat.mtimeMs) {
     return cached.code;
   }
-  const source = fs2.readFileSync(filePath, "utf-8");
-  const ext = path2.extname(filePath).toLowerCase();
+  const source = fs.readFileSync(filePath, "utf-8");
+  const ext = path3.extname(filePath).toLowerCase();
   const loader = ext === ".tsx" ? "tsx" : ext === ".ts" ? "ts" : ext === ".jsx" ? "jsx" : "js";
   const result = await transform(source, {
     loader,
@@ -238,11 +356,11 @@ if (enabled) {
     const genToken = () => Math.random().toString(36).slice(2, 8);
     const watchedDirs = /* @__PURE__ */ new Set();
     const watchers = [];
-    path2.join(import.meta.dirname, "../client");
-    const distDir = path2.join(import.meta.dirname, "../dist");
+    path3.join(import.meta.dirname, "../client");
+    const distDir = path3.join(import.meta.dirname, "../dist");
     const resolveFile = (name) => {
-      const distPath = path2.resolve(distDir, name);
-      if (fs2.existsSync(distPath)) return distPath;
+      const distPath = path3.resolve(distDir, name);
+      if (fs.existsSync(distPath)) return distPath;
       return null;
     };
     const webServer = {
@@ -250,8 +368,8 @@ if (enabled) {
       addEntry(entry) {
         const hash = Date.now().toString(16) + Math.random().toString(16).slice(2, 8);
         const entryFile = typeof entry === "string" ? entry : entry.production;
-        const dir = path2.dirname(entryFile);
-        const filename = path2.basename(entryFile);
+        const dir = path3.dirname(entryFile);
+        const filename = path3.basename(entryFile);
         let token;
         for (const [t, d] of entryBases) {
           if (d === dir) {
@@ -285,10 +403,15 @@ if (enabled) {
       if (ctx.path.startsWith("/api/") || ctx.path === "/api" || ctx.path.startsWith("/pub/") || ctx.path === "/pub") {
         return next();
       }
+      const whiteList = router.whiteList || [];
+      const isRegistered = whiteList.some(
+        (p) => typeof p === "string" && !p.includes("*") && !p.startsWith("/vite") && ctx.path.startsWith(p)
+      );
+      if (isRegistered) return next();
       const name = ctx.path.slice(1);
       const sendFile = async (filename) => {
         try {
-          const stat = fs2.statSync(filename);
+          const stat = fs.statSync(filename);
           if (!stat.isFile()) {
             ctx.status = 404;
             return;
@@ -310,9 +433,9 @@ if (enabled) {
             return;
           }
         }
-        ctx.type = path2.extname(filename);
+        ctx.type = path3.extname(filename);
         ctx.type = mime.getType(filename) || ctx.type;
-        return ctx.body = fs2.createReadStream(filename);
+        return ctx.body = fs.createReadStream(filename);
       };
       if (ctx.path.startsWith("/vite/@ext/")) {
         const rest = ctx.path.replace("/vite/@ext/", "");
@@ -328,13 +451,13 @@ if (enabled) {
           ctx.status = 404;
           return;
         }
-        const fullPath = path2.resolve(baseDir, relPath);
-        const safePfx = baseDir.endsWith(path2.sep) ? baseDir : baseDir + path2.sep;
+        const fullPath = path3.resolve(baseDir, relPath);
+        const safePfx = baseDir.endsWith(path3.sep) ? baseDir : baseDir + path3.sep;
         if (!fullPath.startsWith(safePfx) && fullPath !== baseDir) {
           ctx.status = 403;
           return;
         }
-        if (fs2.existsSync(fullPath)) {
+        if (fs.existsSync(fullPath)) {
           return sendFile(fullPath);
         }
         ctx.status = 404;
@@ -343,7 +466,7 @@ if (enabled) {
       const resolved = resolveFile(name);
       if (resolved) {
         try {
-          const fileState = fs2.statSync(resolved);
+          const fileState = fs.statSync(resolved);
           if (fileState.isFile() && !fileState.isSocket() && !fileState.isFIFO()) {
             return sendFile(resolved);
           }

package/lib/websocket.d.ts

@@ -2,17 +2,8 @@ import { WebServer } from './index.js';
 import '@zhin.js/http';
 import 'ws';
 
-/**
- * 设置 WebSocket 连接处理
- */
 declare function setupWebSocket(webServer: WebServer): void;
-/**
- * 广播消息给所有连接的客户端
- */
 declare function broadcastToAll(webServer: WebServer, message: any): void;
-/**
- * 通知数据更新
- */
 declare function notifyDataUpdate(webServer: WebServer): void;
 
 export { broadcastToAll, notifyDataUpdate, setupWebSocket };