@becrafter/prompt-manager 0.1.18 → 0.1.21

package/packages/server/api/admin.routes.js

@@ -16,6 +16,7 @@ import {adminAuthMiddleware} from '../middlewares/auth.middleware.js'
 import { templateManager } from '../services/template.service.js';
 import { modelManager } from '../services/model.service.js';
 import { optimizationService } from '../services/optimization.service.js';
+import { webSocketService } from '../services/WebSocketService.js';
 
 const router = express.Router();
 
@@ -36,6 +37,24 @@ router.get('/config', (req, res) => {
     });
 });
 
+// 获取公开配置端点（无需认证）
+router.get('/config/public', (req, res) => {
+  const publicConfig = config.getPublicConfig();
+
+  // 如果 WebSocket 服务已启动，使用实际分配的端口
+  if (webSocketService.isRunning) {
+    publicConfig.websocketPort = webSocketService.getPort();
+  } else {
+    // 如果 WebSocket 服务未启动，返回 null 表示尚未确定
+    publicConfig.websocketPort = null;
+  }
+
+  res.json({
+    success: true,
+    data: publicConfig
+  });
+});
+
 // 登录端点
 router.post('/login', (req, res) => {
     // 检查是否启用了管理员功能

package/packages/server/mcp/mcp.server.js

@@ -130,12 +130,12 @@ export const getMcpServer = async () => {
                 return handleToolM(args);
             }
         },
-        {
-            name: 'thinking',
-            description: `🧭 **智能思考工具箱**\n\n【规范名称】promptmanager_thinking\n【调用说明】在提示词中使用 promptmanager_thinking，实际调用时自动映射到 mcp__[server]__action\n\n⚠️ **务必先读说明**：每次首次使用某个 scenario 时，先发送仅包含 \`{"scenario":"..."}\` 的请求获取完整描述，确认理解适用场景与参数要求后，再携带 payload 调用。跳过此步骤易导致字段缺失或流程误用。\n\n## 核心特性\n\n- **双模式思考** - 提供顺序思考（exploratory）和思考规划（execution）两种模式\n- **智能引导** - 通过场景参数自动匹配合适的思考策略\n- **结构化流程** - 支持多轮思考追踪和分支管理\n- **错误预防** - 强制预读说明，避免参数配置错误\n- **灵活扩展** - 支持修订、分支和会话管理\n\n## 何时使用 Thinking Toolkit\n\n### 快速决策（IF-THEN 规则）：\n- IF 需要探索性思考、诊断问题、发散推理 → 使用 scenario: "exploratory"\n- IF 需要结构化规划、制定执行步骤 → 使用 scenario: "execution"\n- IF 看到 scenario 参数 → 使用 thinking_toolkit 调用\n- IF 不确定场景用法 → 先用仅包含 scenario 的请求查看说明\n\n### 首次使用任何场景\n⚠️ **必须先发送仅包含 scenario 的请求** 阅读场景完整描述\n⚠️ 示例：thinking_toolkit with scenario: "exploratory" (无payload)\n\n## 如何使用 Thinking Toolkit\n\n### 模式 1：查看场景说明（首次使用）\n\n\`\`\`javascript\nmcp_mcp-router_thinking_toolkit({\n  scenario: "exploratory"\n})\n\`\`\`\n\n**重要**：每次使用新场景前必须先执行此步骤，了解场景的具体参数要求和使用方法。\n\n### 模式 2：执行顺序思考\n\n\`\`\`javascript\nmcp_mcp-router_thinking_toolkit({\n  scenario: "exploratory",\n  payload: {\n    thought: "分析性能下降的可能原因",\n    totalThoughts: 5,\n    nextThoughtNeeded: true\n  }\n})\n\`\`\`\n\n### 模式 3：执行思考规划\n\n\`\`\`javascript\nmcp_mcp-router_thinking_toolkit({\n  scenario: "execution",\n  payload: {\n    thought: "需要上线新版本",\n    plan: "1. 备份 2. 部署 3. 验证",\n    action: "先执行备份脚本",\n    thoughtNumber: "TP-001"\n  }\n})\n\`\`\`\n\n## 关键规则\n\n### ✅ 正确格式\n- 先发送 \`{"scenario": "..."}\` 获取场景说明\n- 根据说明确认参数要求后，再携带 payload 调用\n- scenario 必填：exploratory（顺序思考）或 execution（思考规划）\n- payload 根据场景填写对应字段\n\n### ❌ 常见错误\n- 不要跳过场景说明，直接携带 payload 调用（易导致参数错误）\n- 不要混用不同场景的参数字段\n- 不要在首次使用场景时直接执行 payload\n\n## 支持的思考场景\n\n### Exploratory（顺序思考）\n适合探索、诊断、发散推理场景，支持多轮思考追踪和分支管理。\n\n### Execution（思考规划）\n适合结构化计划制定和行动追踪，按步骤执行任务规划。\n\n更多场景正在开发中...`,
-            inputSchema: thinkingToolkitInputSchema,
-            handler: async (args) => handleThinkingToolkit(args)
-        }
+        // {
+        //     name: 'thinking',
+        //     description: `🧭 **智能思考工具箱**\n\n【规范名称】promptmanager_thinking\n【调用说明】在提示词中使用 promptmanager_thinking，实际调用时自动映射到 mcp__[server]__action\n\n⚠️ **务必先读说明**：每次首次使用某个 scenario 时，先发送仅包含 \`{"scenario":"..."}\` 的请求获取完整描述，确认理解适用场景与参数要求后，再携带 payload 调用。跳过此步骤易导致字段缺失或流程误用。\n\n## 核心特性\n\n- **双模式思考** - 提供顺序思考（exploratory）和思考规划（execution）两种模式\n- **智能引导** - 通过场景参数自动匹配合适的思考策略\n- **结构化流程** - 支持多轮思考追踪和分支管理\n- **错误预防** - 强制预读说明，避免参数配置错误\n- **灵活扩展** - 支持修订、分支和会话管理\n\n## 何时使用 Thinking Toolkit\n\n### 快速决策（IF-THEN 规则）：\n- IF 需要探索性思考、诊断问题、发散推理 → 使用 scenario: "exploratory"\n- IF 需要结构化规划、制定执行步骤 → 使用 scenario: "execution"\n- IF 看到 scenario 参数 → 使用 thinking_toolkit 调用\n- IF 不确定场景用法 → 先用仅包含 scenario 的请求查看说明\n\n### 首次使用任何场景\n⚠️ **必须先发送仅包含 scenario 的请求** 阅读场景完整描述\n⚠️ 示例：thinking_toolkit with scenario: "exploratory" (无payload)\n\n## 如何使用 Thinking Toolkit\n\n### 模式 1：查看场景说明（首次使用）\n\n\`\`\`javascript\nmcp_mcp-router_thinking_toolkit({\n  scenario: "exploratory"\n})\n\`\`\`\n\n**重要**：每次使用新场景前必须先执行此步骤，了解场景的具体参数要求和使用方法。\n\n### 模式 2：执行顺序思考\n\n\`\`\`javascript\nmcp_mcp-router_thinking_toolkit({\n  scenario: "exploratory",\n  payload: {\n    thought: "分析性能下降的可能原因",\n    totalThoughts: 5,\n    nextThoughtNeeded: true\n  }\n})\n\`\`\`\n\n### 模式 3：执行思考规划\n\n\`\`\`javascript\nmcp_mcp-router_thinking_toolkit({\n  scenario: "execution",\n  payload: {\n    thought: "需要上线新版本",\n    plan: "1. 备份 2. 部署 3. 验证",\n    action: "先执行备份脚本",\n    thoughtNumber: "TP-001"\n  }\n})\n\`\`\`\n\n## 关键规则\n\n### ✅ 正确格式\n- 先发送 \`{"scenario": "..."}\` 获取场景说明\n- 根据说明确认参数要求后，再携带 payload 调用\n- scenario 必填：exploratory（顺序思考）或 execution（思考规划）\n- payload 根据场景填写对应字段\n\n### ❌ 常见错误\n- 不要跳过场景说明，直接携带 payload 调用（易导致参数错误）\n- 不要混用不同场景的参数字段\n- 不要在首次使用场景时直接执行 payload\n\n## 支持的思考场景\n\n### Exploratory（顺序思考）\n适合探索、诊断、发散推理场景，支持多轮思考追踪和分支管理。\n\n### Execution（思考规划）\n适合结构化计划制定和行动追踪，按步骤执行任务规划。\n\n更多场景正在开发中...`,
+        //     inputSchema: thinkingToolkitInputSchema,
+        //     handler: async (args) => handleThinkingToolkit(args)
+        // }
         // {
         //     name: 'reload_prompts',
         //     description: 'Force a reload of all preset prompts to overwrite the cache.',

package/packages/server/server.js

@@ -73,7 +73,8 @@ async function _handleConfig(options) {
   promptManager.promptsDir = promptsDir;
   await config.ensurePromptsDir();
   await util.seedPromptsIfEmpty();
-  await util.seedBuiltInConfigsIfEmpty();
+  // 内置配置不需要同步到用户目录，直接从 packages/server/configs/ 读取
+  // await util.seedBuiltInConfigsIfEmpty();
   await config.validate();
   config.showConfig();
 }
@@ -149,10 +150,11 @@ export async function startServer(options = {}) {
             // 设置服务器实例
             serverInstance = server;
             
-            // 启动WebSocket服务
+            // 启动WebSocket服务，传入 HTTP 服务器端口
             try {
-              await webSocketService.start();
-              logger.info(`WebSocket服务启动成功，端口: 5622`);
+                await webSocketService.start({ port: config.getPort() });
+                const wsPort = webSocketService.getPort();
+                logger.info(`WebSocket服务启动成功，端口: ${wsPort}`);
             } catch (wsError) {
               logger.error('WebSocket服务启动失败:', wsError.message);
               // WebSocket服务失败不影响主服务器运行

package/packages/server/services/TerminalService.js

@@ -17,9 +17,10 @@ let PTY_AVAILABLE = false;
 let PTY_LOAD_ERROR = null;
 
 /**
- * 尝试加载 node-pty 模块
+ * 尝试加载 node-pty 模块，如果失败则尝试自动修复
  */
 async function tryLoadNodePty() {
+  logger.info('开始尝试加载 node-pty 模块...');
   try {
     const ptyModule = await import('node-pty');
     pty = ptyModule;
@@ -30,10 +31,52 @@ async function tryLoadNodePty() {
       return true;
     }
   } catch (error) {
+    logger.info('node-pty 模块加载失败，准备自动修复...');
     PTY_LOAD_ERROR = error;
     PTY_AVAILABLE = false;
-    logger.warn('node-pty 模块不可用，终端功能将被禁用:', error.message);
-    logger.warn('提示: 运行 "npm rebuild node-pty" 来修复此问题');
+    logger.warn('node-pty 模块不可用，尝试自动修复...');
+
+    // 尝试自动修复
+    try {
+      const { spawn } = await import('child_process');
+      const { promisify } = await import('util');
+      const exec = promisify(spawn);
+
+      logger.info('正在重新编译 node-pty...');
+      const rebuildProcess = spawn('npm', ['rebuild', 'node-pty'], {
+        stdio: 'inherit',
+        cwd: process.cwd()
+      });
+
+      await new Promise((resolve, reject) => {
+        rebuildProcess.on('close', (code) => {
+          if (code === 0) {
+            resolve();
+          } else {
+            reject(new Error(`npm rebuild 失败，退出码: ${code}`));
+          }
+        });
+        rebuildProcess.on('error', reject);
+      });
+
+      // 重新尝试加载
+      try {
+        const ptyModule = await import('node-pty');
+        pty = ptyModule;
+        if (pty && pty.default && pty.default.spawn) {
+          PTY_AVAILABLE = true;
+          logger.info('node-pty 模块修复成功！');
+          return true;
+        }
+      } catch (retryError) {
+        logger.error('自动修复失败，请手动运行: npm rebuild node-pty');
+      }
+    } catch (fixError) {
+      logger.error('自动修复过程失败:', fixError.message);
+      logger.error('请手动运行: npm rebuild node-pty');
+    }
+
+    logger.warn('终端功能将被禁用，请修复 node-pty 后再重启服务');
     return false;
   }
   return false;
@@ -192,6 +235,64 @@ export class TerminalService {
     }, 60000); // 每分钟检查一次
     
     logger.info('TerminalService initialized');
+    
+    // 修复 node-pty 二进制文件权限
+    this.fixNodePtyPermissions();
+  }
+  
+  /**
+   * 修复 node-pty 二进制文件权限
+   * 这是解决 posix_spawnp failed 错误的关键
+   */
+  async fixNodePtyPermissions() {
+    try {
+      const { execSync } = await import('child_process');
+      const platform = process.platform;
+      
+      // 只在 Unix-like 系统上修复权限（macOS, Linux）
+      if (platform !== 'win32') {
+        logger.info('🔧 检查并修复 node-pty 二进制文件权限...');
+        
+        // 尝试多个可能的 node-pty 路径
+        const possiblePaths = [
+          // 路径1: 在包的 node_modules 中（开发环境）
+          path.join(path.dirname(path.dirname(new URL(import.meta.url).pathname)), 'node_modules', 'node-pty', 'prebuilds'),
+          // 路径2: 在根 node_modules 中（npm 安装环境）
+          path.join(process.cwd(), 'node_modules', 'node-pty', 'prebuilds'),
+          // 路径3: 相对于当前工作目录
+          path.join(process.cwd(), 'node_modules', '@becrafter', 'prompt-manager', 'node_modules', 'node-pty', 'prebuilds')
+        ];
+        
+        let ptyPath = null;
+        const fs = await import('fs');
+        
+        for (const possiblePath of possiblePaths) {
+          if (fs.existsSync(possiblePath)) {
+            ptyPath = possiblePath;
+            break;
+          }
+        }
+        
+        if (ptyPath) {
+          try {
+            // 添加执行权限 - 使用 find 命令来处理所有平台
+            execSync(`find ${ptyPath} -type f -name "*.node" -o -name "spawn-helper" | xargs chmod +x 2>/dev/null || true`, {
+              stdio: 'pipe',
+              timeout: 5000
+            });
+            logger.info('✅ node-pty 权限修复完成');
+          } catch (error) {
+            // 静默失败，不影响服务启动
+            logger.debug('node-pty 权限修复失败:', error.message);
+          }
+        } else {
+          logger.debug('未找到 node-pty prebuilds 目录，跳过权限修复');
+        }
+      }
+    } catch (error) {
+      // 静默失败，不影响服务启动
+      logger.debug('node-pty 权限修复失败:', error.message);
+    }
   }
 
   /**
@@ -252,17 +353,148 @@ export class TerminalService {
     const shell = options.shell || this.getDefaultShellForPlatform();
     const args = this.getShellArgs(shell);
     const cwd = options.workingDirectory || os.homedir();
-    const env = { ...process.env, ...options.environment };
 
-    logger.debug(`Creating PTY with shell: ${shell}, args: ${args.join(' ')}, cwd: ${cwd}`);
+    // 确保环境变量正确，特别是 PATH
+    const env = {
+      ...process.env,
+      ...options.environment,
+      // 确保 SHELL 环境变量正确设置
+      SHELL: shell,
+      // 确保 LANG 和 LC_* 变量设置
+      LANG: process.env.LANG || 'en_US.UTF-8',
+      LC_ALL: process.env.LC_ALL || process.env.LANG || 'en_US.UTF-8',
+      LC_CTYPE: process.env.LC_CTYPE || process.env.LANG || 'en_US.UTF-8',
+      // 确保 TERM 变量设置
+      TERM: process.env.TERM || 'xterm-256color'
+    };
 
-    return pty.default.spawn(shell, args, {
-      name: 'xterm-color',
-      cols: options.size.cols,
-      rows: options.size.rows,
-      cwd: cwd,
-      env: env
-    });
+    logger.info(`🔧 创建终端会话 - Shell: ${shell}, Args: [${args.join(', ')}], CWD: ${cwd}`);
+    logger.info(`🔧 环境变量 - SHELL: ${env.SHELL}, TERM: ${env.TERM}, LANG: ${env.LANG}`);
+    logger.info(`🔧 Shell 可执行性检查: ${shell} ${args.join(' ')}`);
+
+    // 检查 shell 是否可执行
+    try {
+      const fs = await import('fs');
+      if (!fs.existsSync(shell)) {
+        throw new Error(`Shell 不存在: ${shell}`);
+      }
+
+      const stats = fs.statSync(shell);
+      if (!stats.isFile()) {
+        throw new Error(`Shell 不是文件: ${shell}`);
+      }
+
+      if (!(stats.mode & parseInt('111', 8))) {
+        throw new Error(`Shell 没有执行权限: ${shell}`);
+      }
+
+      logger.info(`✅ Shell 验证通过: ${shell}`);
+    } catch (error) {
+      logger.error(`❌ Shell 验证失败:`, error.message);
+      throw error;
+    }
+
+    // 创建 PTY 进程 - 使用多级回退机制
+    logger.info(`🔧 尝试创建 PTY 进程...`);
+
+    // 定义尝试策略的优先级
+    const strategies = [
+      // 策略 1: 使用用户指定的 shell 和 xterm-256color
+      {
+        name: 'User shell with xterm-256color',
+        shell: shell,
+        args: args,
+        term: 'xterm-256color'
+      },
+      // 策略 2: 使用用户指定的 shell 和 xterm
+      {
+        name: 'User shell with xterm',
+        shell: shell,
+        args: args,
+        term: 'xterm'
+      },
+      // 策略 3: 使用 /bin/sh 和 xterm-256color
+      {
+        name: '/bin/sh with xterm-256color',
+        shell: '/bin/sh',
+        args: [],
+        term: 'xterm-256color'
+      },
+      // 策略 4: 使用 /bin/sh 和 xterm
+      {
+        name: '/bin/sh with xterm',
+        shell: '/bin/sh',
+        args: [],
+        term: 'xterm'
+      },
+      // 策略 5: 使用 /bin/sh 和 ansi
+      {
+        name: '/bin/sh with ansi',
+        shell: '/bin/sh',
+        args: [],
+        term: 'ansi'
+      }
+    ];
+
+    let lastError = null;
+
+    for (let i = 0; i < strategies.length; i++) {
+      const strategy = strategies[i];
+      
+      try {
+        logger.info(`🔄 尝试策略 ${i + 1}/${strategies.length}: ${strategy.name}`);
+        
+        const ptyProcess = pty.default.spawn(strategy.shell, strategy.args, {
+          name: strategy.term,
+          cols: options.size.cols,
+          rows: options.size.rows,
+          cwd: cwd,
+          env: {
+            ...env,
+            TERM: strategy.term,
+            SHELL: strategy.shell
+          }
+        });
+
+        logger.info(`✅ PTY 进程创建成功，PID: ${ptyProcess.pid}`);
+        logger.info(`✅ 使用策略: ${strategy.name}`);
+        
+        // 更新会话选项以反映实际使用的 shell
+        options.shell = strategy.shell;
+        
+        return ptyProcess;
+
+      } catch (error) {
+        lastError = error;
+        logger.warn(`❌ 策略 ${i + 1} 失败: ${error.message}`);
+        
+        // 继续尝试下一个策略
+        continue;
+      }
+    }
+
+    // 所有策略都失败了
+    logger.error(`❌ 所有 PTY 创建策略都失败了`);
+    logger.error(`❌ 最后一个错误: ${lastError?.message}`);
+    logger.error(`❌ 系统信息 - 平台: ${process.platform}, Node: ${process.version}`);
+    logger.error(`❌ 环境信息 - SHELL: ${env.SHELL}, TERM: ${env.TERM}`);
+    logger.error(`❌ 原始 Shell 路径: ${shell}, 参数: [${args.join(', ')}]`);
+    logger.error(`❌ 工作目录: ${cwd}`);
+
+    // 提供用户友好的错误信息
+    const error = new Error(
+      `终端创建失败：所有 PTY 创建策略都失败了。\n` +
+      `最后一个错误: ${lastError?.message}\n` +
+      `建议解决方案:\n` +
+      `1. 运行: npm rebuild node-pty\n` +
+      `2. 检查系统权限和 macOS 安全设置\n` +
+      `3. 确认 shell 路径正确: ${shell}\n` +
+      `4. 重启系统后再试\n` +
+      `5. 检查是否有其他进程占用了 PTY 资源`
+    );
+    error.code = 'TERMINAL_CREATION_FAILED';
+    error.originalError = lastError;
+    throw error;
   }
 
   /**
@@ -291,7 +523,9 @@ export class TerminalService {
       }
       return ['/c'];
     }
-    return ['-l'];
+    // 不使用 -l 参数，避免 login shell 导致的 posix_spawnp 失败
+    // 如果需要交互式 shell，可以通过环境变量或 shell 配置来实现
+    return [];
   }
 
   /**

package/packages/server/services/WebSocketService.js

@@ -274,7 +274,7 @@ class WebSocketConnection {
 export class WebSocketService {
   constructor(options = {}) {
     this.options = {
-      port: 5622,
+      port: options.port || 0, // 0 表示让系统自动分配端口，或使用外部指定的端口
       host: '0.0.0.0',
       maxConnections: 100,
       heartbeatInterval: 30000, // 30秒心跳
@@ -318,11 +318,14 @@ export class WebSocketService {
 
         this.wss.on('listening', () => {
           this.isRunning = true;
-          logger.info(`WebSocket server listening on ${this.options.host}:${this.options.port}`);
-          
+          // 获取实际分配的端口
+          const address = this.wss.address();
+          this.actualPort = typeof address === 'string' ? parseInt(address) : address.port;
+          logger.info(`WebSocket server listening on ${this.options.host}:${this.actualPort}`);
+
           // 启动心跳检测
           this.startHeartbeat();
-          
+
           resolve();
         });
 
@@ -457,6 +460,13 @@ export class WebSocketService {
     return Array.from(this.connections.values());
   }
 
+  /**
+   * 获取实际分配的端口
+   */
+  getPort() {
+    return this.actualPort || this.options.port;
+  }
+
   /**
    * 获取服务状态
    */
@@ -467,7 +477,7 @@ export class WebSocketService {
 
     return {
       isRunning: this.isRunning,
-      port: this.options.port,
+      port: this.getPort(),
       host: this.options.host,
       totalConnections: this.connections.size,
       activeConnections: activeConnections.length,

package/packages/server/toolm/tool-sync.service.js

@@ -116,6 +116,14 @@ export async function syncSystemTools() {
         const sandboxToolFile = path.join(sandboxDir, `${toolName}.tool.js`);
         await fs.copyFile(toolFile, sandboxToolFile);
         
+        // 复制 README.md 文件（如果存在）
+        const readmeFile = path.join(toolDir, 'README.md');
+        if (await pathExists(readmeFile)) {
+          const sandboxReadmeFile = path.join(sandboxDir, 'README.md');
+          await fs.copyFile(readmeFile, sandboxReadmeFile);
+          logger.debug(`已复制 README.md: ${toolName}`);
+        }
+        
         // 创建或更新 package.json
         const packageJsonPath = path.join(sandboxDir, 'package.json');
         let packageJson = {};

package/packages/server/utils/config.js

@@ -77,14 +77,12 @@ MCP Prompt Server - 智能 Prompt 管理服务器
   -v, --version              显示版本信息
 
 环境变量:
-  MCP_SERVER_NAME            服务器名称 (默认: prompt-manager)
   SERVER_PORT                服务器端口 (默认: 5621)
   PROMPTS_DIR                Prompts目录路径
-  MCP_SERVER_VERSION         服务器版本
   LOG_LEVEL                  日志级别 (默认: info)
   MAX_PROMPTS                最大prompt数量限制 (默认: 1000)
   RECURSIVE_SCAN             是否启用递归扫描子目录 (默认: true)
-  ADMIN_ENABLE               是否启用管理员功能 (默认: true)
+  ADMIN_ENABLE               是否启用管理界面 (默认: true)
   ADMIN_REQUIRE_AUTH         是否需要登录认证 (默认: true)
   ADMIN_USERNAME             管理员用户名 (默认: admin)
   ADMIN_PASSWORD             管理员密码 (默认: admin)
@@ -120,8 +118,8 @@ export class Config {
     this.port = cliArgs.port || process.env.SERVER_PORT || 5621;
 
     // 其他配置
-    this.serverName = process.env.MCP_SERVER_NAME || 'prompt-manager';
-    this.serverVersion = process.env.MCP_SERVER_VERSION || '0.1.18';
+    this.serverName = 'prompt-manager';
+    this.serverVersion = '0.1.20';
     this.logLevel = process.env.LOG_LEVEL || 'info';
     this.maxPrompts = parseInt(process.env.MAX_PROMPTS) || 1000;
     this.recursiveScan = process.env.RECURSIVE_SCAN !== 'false'; // 默认启用递归扫描
@@ -310,6 +308,26 @@ export class Config {
     }
   }
 
+  /**
+   * 获取公开配置（前端可访问的配置信息）
+   */
+  getPublicConfig() {
+    return {
+      serverName: this.serverName,
+      serverVersion: this.serverVersion,
+      port: this.port,
+      adminEnable: this.adminEnable,
+      adminPath: this.adminPath,
+      websocketPort: null, // 这个会在 admin.routes.js 中动态设置
+      features: {
+        terminal: true,
+        optimization: true,
+        templates: true,
+        models: true
+      }
+    };
+  }
+
   /**
    * 显示当前配置（输出到 stderr，不干扰 MCP 通信）
    */
@@ -322,7 +340,7 @@ export class Config {
     process.stderr.write(`   递归扫描: ${this.recursiveScan ? '启用' : '禁用'}\n`);
     process.stderr.write(`   Prompts目录: ${this.promptsDir}\n`);
     process.stderr.write(`   最大Prompt数量: ${this.maxPrompts}\n`);
-    process.stderr.write(`   管理员功能: ${this.adminEnable ? '启用' : '禁用'}\n`);
+    process.stderr.write(`   管理界面: ${this.adminEnable ? '启用' : '禁用'}\n`);
     if (this.adminEnable) {
       process.stderr.write(`   登录认证: ${this.adminRequireAuth ? '需要' : '不需要'}\n`);
     }

package/packages/server/utils/util.js

@@ -385,39 +385,84 @@ export class Util {
     }
 
     getWebUiRoot() {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+
+        console.log('🔍 getWebUiRoot() called from:', __dirname);
+
         // 检查是否在 Electron 环境中运行
-        const isElectron = typeof process !== 'undefined' && 
-                          process.versions && 
+        const isElectron = typeof process !== 'undefined' &&
+                          process.versions &&
                           process.versions.electron;
-        
+
         // 检查是否是打包应用
         if (isElectron && process.resourcesPath) {
-            // 检查是否在打包模式（在我们的应用目录下有 app.asar）
             const ourAppAsar = path.join(process.resourcesPath, 'app.asar');
             if (fs.existsSync(ourAppAsar)) {
-                // 在打包的 Electron 应用中，web UI 位于 app.asar 内
-                return path.join(process.resourcesPath, 'app.asar', 'web');
+                const asarPath = path.join(process.resourcesPath, 'app.asar', 'web');
+                console.log('📦 Using Electron ASAR path:', asarPath);
+                return asarPath;
             }
         }
-        
-        // 在开发环境中，web UI 位于项目目录中的 packages/web
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
-        const devWebPath = path.join(__dirname, '..', 'web');
 
+        // 在开发环境中，web UI 位于项目目录中的 packages/web
+        const devWebPath = path.join(__dirname, '..', '..', 'web');
+        console.log('🔍 Checking dev path:', devWebPath);
         if (this._pathExistsSync(devWebPath)) {
+            console.log('✅ Using dev environment path:', devWebPath);
             return devWebPath;
         }
 
-        // 在 npm 包环境中，优先查找 packages/web（编译后的）
-        const projectRoot = path.resolve(__dirname, '../../..');
-        const webPath = path.join(projectRoot, 'packages', 'web');
-        if (this._pathExistsSync(webPath)) {
-            return webPath;
+        // 在 npm 包环境中，查找 packages/web
+        // 从当前文件位置向上查找可能的包根目录
+        let currentDir = __dirname;
+        let searchDepth = 0;
+        const maxDepth = 5;
+
+        while (searchDepth < maxDepth) {
+            // 检查 packages/web
+            const webPath = path.join(currentDir, 'packages', 'web');
+            console.log('🔍 Checking npm package path:', webPath);
+            if (this._pathExistsSync(webPath)) {
+                console.log('✅ Found web UI in npm package:', webPath);
+                return webPath;
+            }
+
+            // 检查直接的 web 目录（某些打包场景）
+            const altWebPath = path.join(currentDir, 'web');
+            console.log('🔍 Checking alternative path:', altWebPath);
+            if (this._pathExistsSync(altWebPath)) {
+                console.log('✅ Found web UI in alternative path:', altWebPath);
+                return altWebPath;
+            }
+
+            // 向上查找
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                // 已经到达根目录
+                break;
+            }
+            currentDir = parentDir;
+            searchDepth++;
+        }
+
+        // 如果都找不到，使用当前工作目录作为最后尝试
+        const cwdWebPath = path.join(process.cwd(), 'packages', 'web');
+        console.log('🔍 Checking CWD path:', cwdWebPath);
+        if (this._pathExistsSync(cwdWebPath)) {
+            console.log('✅ Found web UI in CWD:', cwdWebPath);
+            return cwdWebPath;
         }
 
-        // 返回默认路径
-        return devWebPath;
+        // 最后的fallback
+        console.error('❌ Web UI not found in any location. This will cause blank pages.');
+        console.error('Current directory:', __dirname);
+        console.error('Working directory:', process.cwd());
+        console.error('Checked paths:');
+        console.error('  - Dev path:', devWebPath);
+        console.error('  - CWD path:', cwdWebPath);
+
+        return devWebPath; // 返回开发路径作为fallback，虽然它不存在
     };
 
     /**

package/packages/web/css/{main.3b61356b384d2f11f47f.css → main.196f434e6a88cd448158.css}

@@ -891,6 +891,7 @@ aside {
   display: flex;
   align-items: center;
   justify-content: center;
+  pointer-events: none;
 }
 
 .prompt-item:hover {
@@ -991,6 +992,7 @@ aside {
     rgba(238, 238, 238, 0.6) 60%,
     rgba(238, 238, 238, 0) 100%);
   z-index: 1;
+  pointer-events: auto;
 }
 
 .prompt-item {
@@ -5323,6 +5325,10 @@ body .xterm.theme-dark .xterm-selection .xterm-char {
   transition: all 0.3s ease;
 }
 
+.recommended-prompt-modal.hidden {
+  display: none !important;
+}
+
 .recommended-prompt-modal.active {
   opacity: 1;
   visibility: visible;
@@ -5496,6 +5502,10 @@ body .xterm.theme-dark .xterm-selection .xterm-char {
   transition: all 0.3s ease;
 }
 
+.sync-prompt-modal.hidden {
+  display: none !important;
+}
+
 .sync-prompt-modal.active {
   opacity: 1;
   visibility: visible;