@zhin.js/console 1.0.50 → 1.0.52

package/src/build.ts

@@ -0,0 +1,90 @@
+import * as vite from 'vite'
+import { existsSync, promises as fs } from 'fs'
+import {join} from 'path'
+import react from '@vitejs/plugin-react'
+import tailwindcss from "@tailwindcss/vite";
+export async function build(root: string, config: vite.UserConfig = {}) {
+  if (!existsSync(root + '/client')) return
+
+  const outDir = root + '/dist'
+  if (existsSync(outDir)) {
+    await fs.rm(outDir, { recursive: true })
+  }
+  const maybeFiles=[
+    join(root, 'client', 'index.tsx'),
+    join(root, 'client', 'index.ts'),
+    join(root, 'client', 'index.js'),
+    join(root, 'client', 'index.jsx'),
+  ]
+  const entry = maybeFiles.find(file => existsSync(file))
+  if (!entry) {
+    throw new Error('No entry file found')
+  }
+  await fs.mkdir(root + '/dist', { recursive: true })
+
+  const results = await vite.build(vite.mergeConfig({
+    root,
+    build: {
+      write: false,
+      outDir: 'dist',
+      assetsDir: '',
+      minify: true,
+      emptyOutDir: true,
+      commonjsOptions: {
+        strictRequires: true,
+      },
+      lib: {
+        entry,
+        fileName: 'index',
+        formats: ['es'],
+      },
+      rollupOptions: {
+        makeAbsoluteExternalsRelative: true,
+        external: [
+          'react',
+          'react-dom',
+          'react/jsx-runtime',
+          'react/jsx-dev-runtime',
+          'radix-ui',
+          'class-variance-authority',
+          'lucide-react',
+          "@zhin.js/client",
+        ],
+        resolve: {
+          alias: {
+            'react/jsx-runtime': root + '/react-jsx-runtime.js',
+            'react/jsx-dev-runtime': root + '/react-jsx-dev-runtime.js',
+            'react': root + '/react.js',
+            'react-dom': root + '/react-dom.js',
+            'radix-ui': root + '/radix-ui.js',
+            'class-variance-authority': root + '/cva.js',
+          },
+        },
+        output: {
+          format: 'iife',
+        },
+      },
+    },
+    plugins: [
+      react(),
+      tailwindcss(),
+    ],
+    define: {
+      'process.env.NODE_ENV': '"production"',
+    },
+  } as vite.InlineConfig, config)) as vite.Rollup.RollupOutput[]
+
+  for (const item of results[0].output) {
+    if (item.fileName === 'index.mjs') item.fileName = 'index.js'
+    const dest = root + '/dist/' + item.fileName
+    if (item.type === 'asset') {
+      await fs.writeFile(dest, item.source)
+    } else {
+      const result = await vite.transformWithEsbuild(item.code, dest, {
+        minifyWhitespace: true,
+        charset: 'utf8',
+      })
+      await fs.writeFile(dest, result.code)
+    }
+  }
+}

package/src/dev.ts

@@ -0,0 +1,107 @@
+import type { ViteDevServer } from "vite";
+import path from "path";
+import fs from "fs";
+
+export interface DevServerOptions {
+  /** 客户端代码根目录 */
+  root: string;
+  /** 基础路径，默认 /vite/ */
+  base?: string;
+  /** 是否启用 tailwindcss，默认 true */
+  enableTailwind?: boolean;
+}
+
+/**
+ * 创建 Vite 开发服务器
+ * @param options 开发服务器选项
+ * @returns Vite 开发服务器实例
+ */
+export async function createViteDevServer(
+  options: DevServerOptions
+): Promise<ViteDevServer> {
+  const { root, base = "/vite/", enableTailwind = true } = options;
+  
+  try {
+    // 动态导入所有 Vite 相关依赖（避免提前加载）
+    const [
+      { createServer, searchForWorkspaceRoot },
+      { default: react },
+      { default: tailwindcss }
+    ] = await Promise.all([
+      import('vite'),
+      import('@vitejs/plugin-react'),
+      import('@tailwindcss/vite')
+    ]);
+    
+  const plugins = [react()];
+  if (enableTailwind) {
+    plugins.push(tailwindcss());
+  }
+  const clientPath = path.resolve(process.cwd(), 'node_modules/@zhin.js/client/client')
+  if (!fs.existsSync(clientPath)) {
+    throw new Error('@zhin.js/client not found')
+  }
+    return await createServer({
+    root,
+    base,
+    plugins: [react(), tailwindcss()],
+    server: {
+      middlewareMode: true,
+      allowedHosts: true,
+      fs: {
+        strict: false,
+        // 添加文件访问过滤，避免访问特殊文件
+        allow: [
+          // 允许访问的目录
+          root,
+          searchForWorkspaceRoot(root),
+          path.resolve(process.cwd(), 'node_modules'),
+          path.resolve(process.cwd(), 'client'),
+          path.resolve(process.cwd(), 'src'),
+        ],
+        // 拒绝访问某些文件模式
+        deny: [
+          '**/.git/**',
+          '**/node_modules/.cache/**',
+          '**/*.socket',
+          '**/*.pipe',
+          '**/Dockerfile*',
+          '**/.env*',
+        ],
+      },
+    },
+    resolve: {
+      dedupe: [
+        "react",
+        "react-dom",
+        "clsx",
+        "tailwind-merge",
+        "@reduxjs/toolkit",
+        "react-router",
+        "react-redux",
+        "redux-persist",
+      ],
+      alias: {
+        "@zhin.js/client": path.resolve(process.cwd(), "node_modules/@zhin.js/client/client"),
+        "@": path.resolve(root, "../client/src"),
+      },
+    },
+    optimizeDeps: {
+      include: ["react", "react-dom"],
+    },
+    build: {
+      rollupOptions: {
+        input: root + "/index.html",
+      },
+    },
+  });
+  } catch (error) {
+    throw new Error(
+      `Failed to create Vite dev server. ` +
+      `Make sure all development dependencies are installed: ` +
+      `vite, @vitejs/plugin-react, @tailwindcss/vite. ` +
+      `Run: pnpm install --include=optional\n` +
+      `Original error: ${(error as Error).message}`
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,337 @@
+import { usePlugin } from "@zhin.js/core";
+import { WebSocketServer } from "ws";
+import mime from "mime";
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+import { setupWebSocket, notifyDataUpdate } from "./websocket.js";
+import { transformFile, isTransformable } from "./transform.js";
+import { registerBotModels } from "./bot-db-models.js";
+import { initBotPersistence } from "./bot-persistence.js";
+
+export interface ConsoleConfig {
+  /** 是否启用控制台插件，默认 true */
+  enabled?: boolean;
+  /** 端口号（继承自 http 配置） */
+  port?: number;
+}
+
+export type WebEntry =
+  | string
+  | {
+      production: string;
+      development: string;
+    };
+
+export interface WebServer {
+  addEntry(entry: WebEntry): () => void;
+  entries: Record<string, string>;
+  ws: WebSocketServer;
+}
+
+declare module "@zhin.js/core" {
+  namespace Plugin {
+    interface Contexts {
+      web: WebServer;
+      router: import("@zhin.js/http").Router;
+    }
+  }
+}
+
+interface WebSocketMessage {
+  type: string;
+  requestId?: string;
+  data?: unknown;
+  error?: string;
+}
+
+interface SyncMessage {
+  type: "sync";
+  data: {
+    key: string;
+    value: unknown;
+  };
+}
+
+interface AddMessage {
+  type: "add";
+  data: {
+    key: string;
+    value: unknown;
+  };
+}
+
+interface DeleteMessage {
+  type: "delete";
+  data: {
+    key: string;
+    value: unknown;
+  };
+}
+
+const { provide, root, useContext, logger, inject, onDispose } = usePlugin();
+
+// 读取配置
+const configService = inject('config');
+const appConfig = (configService?.get('zhin.config.yml') || {}) as any;
+const consoleConfig: ConsoleConfig = appConfig.plugins?.console || {};
+const {
+  enabled = true,// 默认不延迟加载，避免 addEntry 等功能不可用
+} = consoleConfig;
+
+if (enabled) {
+  registerBotModels(root as { defineModel?: (name: string, def: unknown) => void });
+  initBotPersistence(root as { inject: (key: string) => unknown });
+
+  const createSyncMsg = (key: string, value: unknown): SyncMessage => ({
+    type: "sync",
+    data: { key, value },
+  });
+
+  const createAddMsg = (key: string, value: unknown): AddMessage => ({
+    type: "add",
+    data: { key, value },
+  });
+
+  const createDeleteMsg = (key: string, value: unknown): DeleteMessage => ({
+    type: "delete",
+    data: { key, value },
+  });
+
+  useContext("router", async (router) => {
+    const base = "/vite/";
+
+    const isDev = process.env.NODE_ENV === "development";
+
+    // ── Token 映射：隐藏绝对路径 ──────────────────────────────────────────
+    // token → 目录绝对路径。URL 只暴露 token + 相对文件名，不暴露服务器路径。
+    const entryBases = new Map<string, string>();
+    const genToken = () => crypto.randomBytes(6).toString('hex');
+
+    // ── 开发模式文件监听（轻量 HMR：文件变更 → 通知客户端刷新） ──────────────
+    const watchedDirs = new Set<string>();
+    const watchers: fs.FSWatcher[] = [];
+    let reloadTimer: ReturnType<typeof setTimeout> | null = null;
+
+    /** 广播刷新通知给所有 WebSocket 客户端，300ms 防抖 */
+    const broadcastReload = (file: string) => {
+      if (reloadTimer) clearTimeout(reloadTimer);
+      reloadTimer = setTimeout(() => {
+        const msg = JSON.stringify({ type: "hmr:reload", data: { file } });
+        // webServer.ws 可能还未初始化，延迟访问
+        const wss = webServer?.ws;
+        if (wss) {
+          for (const ws of wss.clients || []) {
+            ws.send(msg);
+          }
+        }
+        logger.info(`[HMR] 文件变更: ${file}，已通知客户端刷新`);
+      }, 300);
+    };
+
+    /** 对一个目录启动 recursive watch，排除 node_modules */
+    const watchDir = (dir: string) => {
+      if (watchedDirs.has(dir)) return;
+      watchedDirs.add(dir);
+      try {
+        const watcher = fs.watch(dir, { recursive: true }, (event, filename) => {
+          if (!filename) return;
+          // 排除 node_modules 内的变更
+          if (filename.includes("node_modules")) return;
+          broadcastReload(filename);
+        });
+        watcher.on("error", (err) => {
+          logger.warn(`[HMR] 文件监听错误 (${dir}):`, (err as Error).message);
+        });
+        watchers.push(watcher);
+        logger.info(`[HMR] 正在监听目录: ${dir}`);
+      } catch (err) {
+        logger.warn(`[HMR] 无法监听目录 (${dir}):`, (err as Error).message);
+      }
+    };
+
+    // ── 双目录解析 ─────────────────────────────────────────────────────────
+    // dev  → 源码从 client/，vendor 预构建文件从 dist/
+    // prod → 全部从 dist/
+    const clientDir = path.join(import.meta.dirname, "../client");
+    const distDir = path.join(import.meta.dirname, "../dist");
+
+    /** 解析文件路径：dev 先查 client/，再查 dist/；prod 只查 dist/ */
+    const resolveFile = (name: string): string | null => {
+      if (isDev) {
+        const clientPath = path.resolve(clientDir, name);
+        if (fs.existsSync(clientPath)) return clientPath;
+      }
+      const distPath = path.resolve(distDir, name);
+      if (fs.existsSync(distPath)) return distPath;
+      return null;
+    };
+
+    // 初始化 WebServer 对象
+    const webServer: WebServer = {
+      entries: {},
+      addEntry(entry) {
+        const hash = crypto.randomBytes(8).toString('hex');
+        const entryFile =
+          typeof entry === "string"
+            ? entry
+            : isDev
+              ? entry.development
+              : entry.production;
+
+        // 统一使用 token URL，dev/prod 都不暴露绝对路径
+        const dir = path.dirname(entryFile);
+        const filename = path.basename(entryFile);
+        let token: string | undefined;
+        for (const [t, d] of entryBases) {
+          if (d === dir) { token = t; break; }
+        }
+        if (!token) { token = genToken(); entryBases.set(token, dir); }
+        this.entries[hash] = `/vite/@ext/${token}/${filename}`;
+
+        // 开发模式：监听入口文件所在目录，文件变更时通知客户端刷新
+        if (isDev) watchDir(dir);
+
+        // 延迟访问 ws，确保它已初始化
+        if (this.ws) {
+          for (const ws of this.ws.clients || []) {
+            ws.send(JSON.stringify(createAddMsg("entries", this.entries[hash])));
+          }
+        }
+        return () => {
+          if (this.ws) {
+            for (const ws of this.ws.clients || []) {
+              ws.send(JSON.stringify(createDeleteMsg("entries", this.entries[hash])));
+            }
+          }
+          delete this.entries[hash];
+        };
+      },
+      ws: router.ws("/server"),
+    } as WebServer;
+
+    logger.info(`Web 控制台已启动 (${isDev ? "开发模式, esbuild 按需转译 + 文件监听" : "生产模式, 静态文件 + 按需转译"})`);
+
+    // SPA 回退路由 - 处理所有未匹配的路由
+    router.all("*all", async (ctx, next) => {
+      // 跳过 API、/pub 等后端路由，交给其他路由处理器
+      if (ctx.path.startsWith("/api/") || ctx.path === "/api" || ctx.path.startsWith("/pub/") || ctx.path === "/pub") {
+        return next();
+      }
+
+      // 跳过其他插件注册的路由（如 /mcp），避免 SPA fallback 拦截
+      const whiteList: (string | RegExp)[] = (router as any).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: string) => {
+        // 安全检查：确保是常规文件
+        try {
+          const stat = fs.statSync(filename);
+          if (!stat.isFile()) {
+            ctx.status = 404;
+            return;
+          }
+        } catch (error) {
+          ctx.status = 404;
+          return;
+        }
+
+        // TSX/TS/JSX 按需转译（dev 和 prod 都启用）
+        if (isTransformable(filename)) {
+          try {
+            const code = await transformFile(filename);
+            ctx.type = "application/javascript";
+            ctx.body = code;
+            return;
+          } catch (e) {
+            logger.warn(`转译失败: ${filename}`, (e as Error).message);
+            ctx.status = 500;
+            ctx.body = `/* transform error: ${(e as Error).message} */`;
+            return;
+          }
+        }
+
+        ctx.type = path.extname(filename);
+        ctx.type = mime.getType(filename) || ctx.type;
+        return (ctx.body = fs.createReadStream(filename));
+      };
+
+      // 0. 处理 /vite/@ext/ 路径（token 隐藏真实路径，dev/prod 均启用）
+      if (ctx.path.startsWith("/vite/@ext/")) {
+        const rest = ctx.path.replace("/vite/@ext/", "");
+        const slashIdx = rest.indexOf("/");
+        if (slashIdx === -1) { ctx.status = 404; return; }
+
+        const token = rest.slice(0, slashIdx);
+        const relPath = rest.slice(slashIdx + 1);
+        const baseDir = entryBases.get(token);
+        if (!baseDir) { ctx.status = 404; return; }
+
+        const fullPath = path.resolve(baseDir, relPath);
+        // 安全检查：防止 ../../ 路径穿越
+        const safePfx = baseDir.endsWith(path.sep) ? baseDir : baseDir + path.sep;
+        if (!fullPath.startsWith(safePfx) && fullPath !== baseDir) { ctx.status = 403; return; }
+
+        if (fs.existsSync(fullPath)) {
+          return sendFile(fullPath);
+        }
+        ctx.status = 404;
+        return;
+      }
+
+      // 1. 静态文件解析（dev: client/ → dist/ 双目录，prod: dist/ 单目录）
+      const resolved = resolveFile(name);
+      if (resolved) {
+        try {
+          const fileState = fs.statSync(resolved);
+          if (fileState.isFile() && !fileState.isSocket() && !fileState.isFIFO()) {
+            return sendFile(resolved);
+          }
+        } catch (error) {
+          logger.warn(`文件访问错误: ${resolved}`, (error as Error).message);
+        }
+      }
+
+      // 2. 所有其他路径（包括 SPA 路由）都返回 index.html
+      const indexFile = resolveFile("index.html");
+      if (indexFile) return sendFile(indexFile);
+      ctx.status = 404;
+    });
+
+     // 初始化 WebSocket（触发 getter）
+     const _ = webServer.ws;
+     
+     // 定时通知客户端更新数据
+     const dataUpdateInterval = setInterval(() => {
+       notifyDataUpdate(webServer);
+     }, 5000); // 每5秒通知一次更新
+
+     setupWebSocket(webServer);
+
+    // 插件卸载时清理定时器和文件监听（使用 onDispose 而不是 process.on，支持热重载）
+    onDispose(() => {
+      clearInterval(dataUpdateInterval);
+      if (reloadTimer) clearTimeout(reloadTimer);
+      for (const w of watchers) w.close();
+      watchers.length = 0;
+      watchedDirs.clear();
+    });
+
+    // 注册 web 上下文
+    provide({
+      name: "web",
+      description: "web服务",
+      value: webServer,
+      dispose(server) {
+        return new Promise<void>((resolve) => {
+          server.ws.close(() => resolve());
+        });
+      },
+    });
+  });
+}