coding-tool-x 3.8.4 → 3.8.5

package/src/server/api/workspaces.js

@@ -5,6 +5,7 @@ const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
 const workspaceService = require('../services/workspace-service');
+const { resolveKnownProjectPath } = require('../services/project-path-validation');
 
 function normalizeBranchName(branchName) {
   if (typeof branchName !== 'string') {
@@ -51,6 +52,7 @@ function validateBranchMode(branchMode) {
   return { valid: true, normalized };
 }
 
+
 /**
  * GET /api/workspaces
  * 获取所有工作区列表
@@ -75,7 +77,7 @@ router.get('/', (req, res) => {
  * 读取工作区中的文件内容（仅限 CLAUDE.md 等配置文件）
  * Query: path=文件路径
  */
-router.get('/read-file', (req, res) => {
+router.get('/read-file', async (req, res) => {
   try {
     const filePath = req.query.path;
 
@@ -97,19 +99,52 @@ router.get('/read-file', (req, res) => {
       });
     }
 
-    if (!fs.existsSync(filePath)) {
-      return res.status(404).json({
+    const canonicalPath = await resolveKnownProjectPath(filePath);
+    if (!canonicalPath || !allowedFiles.includes(path.basename(canonicalPath))) {
+      return res.status(403).json({
         success: false,
-        message: '文件不存在'
+        message: '仅允许读取已登记项目或工作区中的配置文件'
       });
     }
 
-    const content = fs.readFileSync(filePath, 'utf8');
-
-    res.json({
-      success: true,
-      content: content
-    });
+    let fileDescriptor;
+    try {
+      const noFollow = fs.constants.O_NOFOLLOW || 0;
+      fileDescriptor = fs.openSync(canonicalPath, fs.constants.O_RDONLY | noFollow);
+      const openedStat = fs.fstatSync(fileDescriptor);
+      const revalidatedPath = await resolveKnownProjectPath(canonicalPath);
+      const pathStat = fs.statSync(canonicalPath);
+      const sameFile = openedStat.dev === pathStat.dev && openedStat.ino === pathStat.ino;
+      if (revalidatedPath !== canonicalPath || !sameFile) {
+        return res.status(403).json({
+          success: false,
+          message: '仅允许读取已登记项目或工作区中的配置文件'
+        });
+      }
+      if (!openedStat.isFile()) {
+        return res.status(403).json({
+          success: false,
+          message: '仅允许读取配置文件'
+        });
+      }
+      const content = fs.readFileSync(fileDescriptor, 'utf8');
+      return res.json({
+        success: true,
+        content
+      });
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return res.status(404).json({
+          success: false,
+          message: '文件不存在'
+        });
+      }
+      throw error;
+    } finally {
+      if (fileDescriptor !== undefined) {
+        fs.closeSync(fileDescriptor);
+      }
+    }
   } catch (error) {
     res.status(500).json({
       success: false,
@@ -217,7 +252,7 @@ router.get('/:id', (req, res, next) => {
  *   }]
  * }
  */
-router.post('/', (req, res) => {
+router.post('/', async (req, res) => {
   try {
     const { name, description, baseDir, projects, configTemplateId } = req.body;
 
@@ -280,7 +315,7 @@ router.post('/', (req, res) => {
       }
     }
 
-    const workspace = workspaceService.createWorkspace({
+    const workspace = await workspaceService.createWorkspace({
       name,
       description,
       baseDir,

package/src/server/index.js

@@ -4,7 +4,12 @@ const express = require('express');
 const path = require('path');
 const chalk = require('chalk');
 const { loadConfig } = require('../config/loader');
-const { PATHS, ensureStorageDirMigrated } = require('../config/paths');
+const {
+  PATHS,
+  ensureStorageDirMigrated,
+  getPlatformStatePath,
+  persistOmpAgentPath
+} = require('../config/paths');
 const { startWebSocketServer: attachWebSocketServer } = require('./websocket-server');
 const {
   isPortInUse,
@@ -13,24 +18,19 @@ const {
   getPortToolIssue,
   formatPortToolIssue
 } = require('../utils/port-helper');
-const { isProxyConfig } = require('./services/settings-manager');
-const {
-  isProxyConfig: isCodexProxyConfig,
-  setProxyConfig: setCodexProxyConfig
-} = require('./services/codex-settings-manager');
-const { setProxyConfig: setOpenCodeProxyConfig } = require('./services/opencode-settings-manager');
-const { startProxyServer } = require('./proxy-server');
-const { startCodexProxyServer } = require('./codex-proxy-server');
-const { startGeminiProxyServer } = require('./gemini-proxy-server');
-const { startOpenCodeProxyServer, collectProxyModelList } = require('./opencode-proxy-server');
-const { startOmpProxyServer } = require('./omp-proxy-server');
 const {
   createRemoteMutationGuard,
-  isRemoteMutationAllowedByEnv
+  isRemoteMutationAllowedByEnv,
+  createSameOriginGuard
 } = require('./services/network-access');
 const { createApiRequestLogger } = require('./services/request-logger');
 const { inspectWebBuildState, ensureWebDistReady } = require('./services/web-build');
 const { ensureHttpsCredentials } = require('./services/https-cert');
+const notificationHooks = require('../platforms/notification-hooks');
+const {
+  prepareNativeCliLogObserver,
+  startNativeCliLogObserver
+} = require('./services/native-log-observer');
 
 function getInquirer() {
   return require('inquirer');
@@ -46,6 +46,18 @@ function isInteractivePortConflictMode(options = {}) {
   return Boolean(process.stdin && process.stdin.isTTY && process.stdout && process.stdout.isTTY);
 }
 
+function traceStartupMemory(stage) {
+  if (process.env.CC_TOOL_MEMORY_TRACE !== '1') return;
+  const usage = process.memoryUsage();
+  console.log(`[MEM] ${stage} ${JSON.stringify({
+    rss: usage.rss,
+    heapUsed: usage.heapUsed,
+    heapTotal: usage.heapTotal,
+    external: usage.external,
+    arrayBuffers: usage.arrayBuffers
+  })}`);
+}
+
 function printPortConflictHelp(port) {
   console.log(chalk.yellow('\n[TIP] 解决方案:'));
   console.log(chalk.gray('   1. 运行 ctx 命令，选择"配置端口"修改端口'));
@@ -67,6 +79,9 @@ function printPortToolIssue(issue = getPortToolIssue()) {
 async function startServer(port, host = '127.0.0.1', options = {}) {
   ensureStorageDirMigrated();
   const config = loadConfig();
+  if (typeof persistOmpAgentPath === 'function') {
+    persistOmpAgentPath();
+  }
   // 使用配置的端口，如果没有传入参数
   if (!port) {
     port = config.ports?.webUI || 19999;
@@ -182,62 +197,41 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
     }));
 
   }
+  app.use(['/api/skills', '/api/project-config', '/api/mcp', '/api/config-registry'], createSameOriginGuard({
+    enabled: true,
+    message: 'Skill/MCP/project configuration requires same-origin access.'
+  }));
 
-  // API Routes
-  app.use('/api/projects', require('./api/projects')(config));
-  app.use('/api/sessions', require('./api/sessions')(config));
-
-  // Codex API Routes
-  app.use('/api/codex/projects', require('./api/codex-projects')(config));
-  app.use('/api/codex/sessions', require('./api/codex-sessions')(config));
-  app.use('/api/codex/channels', require('./api/codex-channels')(config));
-
-  // Gemini API Routes
-  app.use('/api/gemini/projects', require('./api/gemini-projects')(config));
-  app.use('/api/gemini/sessions', require('./api/gemini-sessions')(config));
-  app.use('/api/gemini/channels', require('./api/gemini-channels')(config));
-  app.use('/api/gemini/proxy', require('./api/gemini-proxy'));
-
-  // OpenCode API Routes
-  app.use('/api/opencode/projects', require('./api/opencode-projects')(config));
-  app.use('/api/opencode/sessions', require('./api/opencode-sessions')(config));
-  app.use('/api/opencode/channels', require('./api/opencode-channels')(config));
-  app.use('/api/opencode/proxy', require('./api/opencode-proxy'));
-  app.use('/api/opencode/statistics', require('./api/opencode-statistics'));
-
-  // OMP API Routes
-  app.use('/api/omp/projects', require('./api/omp-projects')(config));
-  app.use('/api/omp/sessions', require('./api/omp-sessions')(config));
-  app.use('/api/omp/channels', require('./api/omp-channels')(config));
-  app.use('/api/omp/proxy', require('./api/omp-proxy'));
-  app.use('/api/omp/statistics', require('./api/omp-statistics'));
-  app.use('/api/omp/config', require('./api/omp-config'));
+  // Keep the legacy /api/hooks endpoint ahead of Claude's rootAlias /hooks route.
+  app.use('/api/hooks', require('./api/hooks'));
+
+  const { getPlatformContext } = require('./platform-context');
+  const platformContext = getPlatformContext({ dependencies: { config } });
+  app.use('/api/platforms', require('./api/platforms')({
+    ...platformContext,
+    config
+  }));
+  app.use('/api', require('./api/platform-routes')({
+    ...platformContext,
+    config
+  }));
 
   app.use('/api/aliases', require('./api/aliases')());
   app.use('/api/favorites', require('./api/favorites'));
   app.use('/api/ui-config', require('./api/ui-config'));
   app.use('/api/channel-balances', require('./api/channel-balances'));
   app.use('/api/security', require('./api/security'));
-  app.use('/api/channels', require('./api/channels'));
-  app.use('/api/proxy', require('./api/proxy'));
-  app.use('/api/codex/proxy', require('./api/codex-proxy'));
   app.use('/api/settings', require('./api/settings'));
   app.use('/api/config', require('./api/config'));
   app.use('/api/convert', require('./api/convert'));
   app.use('/api/statistics', require('./api/statistics'));
-  app.use('/api/claude/statistics', require('./api/claude-statistics'));
-  app.use('/api/codex/statistics', require('./api/codex-statistics'));
-  app.use('/api/gemini/statistics', require('./api/gemini-statistics'));
   app.use('/api/pm2-autostart', require('./api/pm2-autostart')());
   app.use('/api/dashboard', require('./api/dashboard'));
   app.use('/api/mcp', require('./api/mcp'));
   app.use('/api/prompts', require('./api/prompts'));
   app.use('/api/env', require('./api/env'));
   app.use('/api/skills', require('./api/skills'));
-  const claudeHooks = require('./api/claude-hooks');
-  const notificationHooks = require('./services/notification-hooks');
-  app.use('/api/claude/hooks', claudeHooks);
-  app.use('/api/hooks', require('./api/hooks'));
+  app.use('/api/project-config', require('./api/project-config'));
 
   // 初始化 Claude hooks 默认配置（自动开启任务完成通知）
   notificationHooks.initDefaultHooks();
@@ -256,7 +250,6 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
 
   // 配置导出/导入 API
   app.use('/api/config-export', require('./api/config-export'));
-  app.use('/api/oauth-credentials', require('./api/oauth-credentials'));
 
   // 配置同步 API
   app.use('/api/config-sync', require('./api/config-sync'));
@@ -264,8 +257,6 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
   // 配置注册表 API (集中管理 skills/commands/agents/plugins 的启用/禁用)
   app.use('/api/config-registry', require('./api/config-registry'));
 
-  // 健康检查 API
-  app.use('/api/health-check', require('./api/health-check')(config));
 
   // Serve static files in production
   const distPath = path.join(__dirname, '../../dist/web');
@@ -322,6 +313,14 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
 
   // 附加 WebSocket 服务器到同一个端口
   attachWebSocketServer(server, { host });
+  const nativeCliLogs = config.nativeCliLogs || {};
+  const nativeLogOptions = {
+    enabled: nativeCliLogs.enabled !== false,
+    intervalSeconds: Number.isInteger(nativeCliLogs.intervalSeconds) ? nativeCliLogs.intervalSeconds : 5
+  };
+  traceStartupMemory('http-ready');
+  prepareNativeCliLogObserver(nativeLogOptions);
+  traceStartupMemory('log-baseline-ready');
   console.log(`   ${wsProtocol}://localhost:${port}/ws\n`);
 
   if (useHttps) {
@@ -330,188 +329,140 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
 
   if (host === '0.0.0.0') {
     if (allowRemoteMutation) {
-      console.log(chalk.yellow('   [WARN]  LAN 远程写操作已启用（默认行为）'));
-      console.log(chalk.gray('   如需禁止，请设置 CC_TOOL_ALLOW_REMOTE_WRITE=false'));
+      console.log(chalk.yellow('   [WARN]  LAN 远程写操作已启用（显式授权）'));
+      console.log(chalk.gray('   默认远程写操作关闭；如需关闭显式授权，请移除 CC_TOOL_ALLOW_REMOTE_WRITE=true'));
     } else {
-      console.log(chalk.yellow('   [LOCK] 已启用 LAN 安全保护：远程写操作被 CC_TOOL_ALLOW_REMOTE_WRITE=false 禁止'));
+      console.log(chalk.yellow('   [LOCK] 已启用 LAN 安全保护：远程写操作默认关闭'));
     }
   }
   // 自动恢复代理状态
-  autoRestoreProxies();
-
-  // 延迟执行健康检查，避免阻塞启动
-  setTimeout(() => performStartupHealthCheck(), 2000);
-
-  return server;
+  try {
+    await autoRestoreProxies({ ...platformContext, config });
+    traceStartupMemory('proxy-restore-complete');
+    await performStartupHealthCheck({ config });
+    traceStartupMemory('health-check-complete');
+    return server;
+  } finally {
+    try {
+      startNativeCliLogObserver({ pollImmediately: true });
+    } catch (error) {
+      console.error(chalk.yellow(`[WARN] 原生日志轮询启动失败: ${error.message}`));
+    }
+    traceStartupMemory('native-log-poll-started');
+  }
 }
 
 // 自动恢复代理状态
-function autoRestoreProxies() {
-  const config = loadConfig();
-  const fs = require('fs');
-
-  // 检查 Claude 代理状态文件
-  const claudeActiveFile = PATHS.activeChannel.claude;
-  if (fs.existsSync(claudeActiveFile)) {
-    console.log(chalk.cyan('\n[SYNC] 检测到 Claude 代理状态文件，正在自动启动...'));
-    const proxyPort = config.ports?.proxy || 20088;
-    startProxyServer(proxyPort)
-      .then(() => {
-        console.log(chalk.green(`[OK] Claude 代理已自动启动，端口: ${proxyPort}`));
-      })
-      .catch((err) => {
-        console.error(chalk.red(`[ERROR] Claude 代理启动失败: ${err.message}`));
-      });
-  }
-
-  // 检查 Codex 代理状态文件
-  const codexActiveFile = PATHS.activeChannel.codex;
-  if (fs.existsSync(codexActiveFile)) {
-    console.log(chalk.cyan('\n[SYNC] 检测到 Codex 代理状态文件，正在自动启动...'));
-    const codexProxyPort = config.ports?.codexProxy || 20089;
-    startCodexProxyServer(codexProxyPort)
-      .then((result) => {
-        const port = result?.port || codexProxyPort;
-        console.log(chalk.green(`[OK] Codex 代理已自动启动，端口: ${port}`));
-
-        // 重启后重新写入 cc-proxy 配置与环境变量，避免缺少 provider/env 导致报错
-        try {
-          const cfgResult = setCodexProxyConfig(port);
-          if (cfgResult?.success) {
-            console.log(chalk.gray('   已同步 codex config.toml 与 CC_PROXY_KEY'));
-          }
-        } catch (err) {
-          console.error(chalk.red(`[ERROR] Codex 代理配置同步失败: ${err.message}`));
-        }
-      })
-      .catch((err) => {
-        console.error(chalk.red(`[ERROR] Codex 代理启动失败: ${err.message}`));
-      });
-  }
-
-  // 检查 Gemini 代理状态文件
-  const geminiActiveFile = PATHS.activeChannel.gemini;
-  if (fs.existsSync(geminiActiveFile)) {
-    console.log(chalk.cyan('\n[SYNC] 检测到 Gemini 代理状态文件，正在自动启动...'));
-    const geminiProxyPort = config.ports?.geminiProxy || 20090;
-    startGeminiProxyServer(geminiProxyPort)
-      .then((result) => {
-        if (result.success) {
-          console.log(chalk.green(`[OK] Gemini 代理已自动启动，端口: ${result.port}`));
-        } else {
-          console.error(chalk.red(`[ERROR] Gemini 代理启动失败: ${result.error || 'Unknown error'}`));
-        }
-      })
-      .catch((err) => {
-        console.error(chalk.red(`[ERROR] Gemini 代理启动失败: ${err.message}`));
-      });
-  } else {
-    console.log(chalk.gray('\n[TIP] 提示: 如需使用 Gemini 代理，请在前端界面激活 Gemini 渠道'));
-  }
-
-  // 检查 OpenCode 代理状态文件
-  const opencodeActiveFile = PATHS.activeChannel.opencode;
-  if (fs.existsSync(opencodeActiveFile)) {
-    console.log(chalk.cyan('\n[SYNC] 检测到 OpenCode 代理状态文件，正在自动启动...'));
-    const opencodeProxyPort = config.ports?.opencodeProxy || 20091;
-    startOpenCodeProxyServer(opencodeProxyPort)
-      .then(async (result) => {
-        if (result.success) {
-          console.log(chalk.green(`[OK] OpenCode 代理已自动启动，端口: ${result.port}`));
-          try {
-            const { getEnabledChannels: getEnabledOpenCodeChannels } = require('./services/opencode-channels');
-            const enabledChs = getEnabledOpenCodeChannels();
-            const allModels = [];
-            const seen = new Set();
-            enabledChs.forEach((ch) => {
-              [ch.model, ch.speedTestModel].forEach((m) => {
-                if (typeof m === 'string' && m.trim() && !seen.has(m.trim().toLowerCase())) {
-                  seen.add(m.trim().toLowerCase());
-                  allModels.push(m.trim());
-                }
-              });
-            });
-            const detectedModels = await collectProxyModelList(enabledChs, { useCacheOnly: true });
-            if (Array.isArray(detectedModels)) {
-              detectedModels.forEach((m) => {
-                if (typeof m === 'string' && m.trim() && !seen.has(m.trim().toLowerCase())) {
-                  seen.add(m.trim().toLowerCase());
-                  allModels.push(m.trim());
-                }
-              });
-            }
-            const firstChannel = enabledChs[0];
-            const activeModel = firstChannel && (firstChannel.model || firstChannel.speedTestModel) || null;
-            const cfgResult = setOpenCodeProxyConfig(result.port, { model: activeModel, models: allModels });
-            if (cfgResult?.success) {
-              console.log(chalk.gray('   已同步 OpenCode 配置文件'));
-            }
-          } catch (err) {
-            console.error(chalk.red(`[ERROR] OpenCode 代理配置同步失败: ${err.message}`));
-          }
-        } else {
-          console.error(chalk.red(`[ERROR] OpenCode 代理启动失败: ${result.error || 'Unknown error'}`));
-        }
-      })
-      .catch((err) => {
-        console.error(chalk.red(`[ERROR] OpenCode 代理启动失败: ${err.message}`));
-      });
-  }
-
-  // 检查 OMP 受管 provider 配置状态文件
-  const ompActiveFile = PATHS.activeChannel.omp;
-  if (fs.existsSync(ompActiveFile)) {
-    console.log(chalk.cyan('\n[SYNC] 检测到 OMP 受管渠道状态文件，正在自动恢复...'));
-    startOmpProxyServer({ preserveStartTime: true })
-      .then((result) => {
-        if (result.success) {
-          console.log(chalk.green(`[OK] OMP 动态网关已自动恢复: http://127.0.0.1:${result.port}`));
-        } else {
-          console.error(chalk.red(`[ERROR] OMP 动态网关恢复失败: ${result.error || 'Unknown error'}`));
-        }
-      })
-      .catch((err) => {
-        console.error(chalk.red(`[ERROR] OMP 动态网关恢复失败: ${err.message}`));
-      });
+async function autoRestoreProxies({ registry, runtime, config, fsImpl = require('fs') } = {}) {
+  const resolvedRegistry = registry || require('../platforms/runtime').getPlatformRegistry();
+  const resolvedRuntime = runtime || require('../platforms/runtime').getPlatformRuntime();
+  const resolvedConfig = config || loadConfig();
+  const platforms = typeof resolvedRegistry.list === 'function'
+    ? resolvedRegistry.list({ enabledOnly: true })
+    : [];
+
+  const summary = { attempted: 0, restored: 0, failed: 0 };
+  for (const platform of platforms) {
+    const key = platform && platform.key;
+    const markerPath = key && getPlatformStatePath('activeChannel', key);
+    if (!key || !markerPath || !fsImpl.existsSync(markerPath)) continue;
+
+    let driver;
+    try {
+      driver = resolvedRuntime.getDriver(key, 'proxy');
+    } catch (error) {
+      console.error(chalk.red(`[ERROR] ${platform.label || key} 代理恢复失败: ${error.message}`));
+      continue;
+    }
+    if (!driver || typeof driver.restoreOnBoot !== 'function') continue;
+    summary.attempted += 1;
+
+    const serviceLabel = platform.proxyLabels?.serviceLabel || `${platform.label || key} 代理服务`;
+    console.log(chalk.cyan(`\n[SYNC] 检测到 ${serviceLabel} 状态文件，正在自动恢复...`));
+    try {
+      const result = await driver.restoreOnBoot({ config: resolvedConfig });
+      if (!result || result.status === 'ok') {
+        const port = result?.port;
+        const suffix = port
+          ? platform.proxyMode === 'managed'
+            ? `: http://127.0.0.1:${port}`
+            : `，端口: ${port}`
+          : '';
+        const action = platform.proxyMode === 'managed' ? '动态网关已自动恢复' : '代理已自动启动';
+        console.log(chalk.green(`[OK] ${platform.label || key} ${action}${suffix}`));
+        summary.restored += 1;
+      } else {
+        summary.failed += 1;
+        console.error(chalk.red(`[ERROR] ${platform.label || key} 代理恢复失败: ${result.error || result.status}`));
+      }
+    } catch (error) {
+      summary.failed += 1;
+      console.error(chalk.red(`[ERROR] ${platform.label || key} 代理恢复失败: ${error.message}`));
+    }
   }
+  return summary;
 }
 
 // 启动时执行健康检查
-async function performStartupHealthCheck() {
-  const { healthCheckAllProjects } = require('./services/health-check');
-  const { getProjects } = require('./services/sessions');
-
+async function performStartupHealthCheck({ config = loadConfig() } = {}) {
   try {
     console.log(chalk.cyan('\n[SEARCH] 正在进行启动健康检查...'));
 
-    // 获取所有项目
-    const config = loadConfig();
-    const projects = await getProjects(config);
-
-    if (projects.length === 0) {
-      console.log(chalk.gray('   未发现项目，跳过健康检查'));
-      return;
+    const { getPlatformCatalog } = require('./services/platform-catalog');
+    const catalog = getPlatformCatalog();
+    const platforms = catalog.list({ capability: 'health' });
+    const summary = { total: 0, created: 0, errors: 0, healthy: 0 };
+    if (platforms.length === 0) {
+      console.log(chalk.gray('   未配置健康检查能力，跳过健康检查'));
+      return { success: true, summary };
     }
 
-    // 检查并创建缺失的目录
-    const healthResult = healthCheckAllProjects(projects);
-
-    if (healthResult.summary.created > 0) {
-      console.log(chalk.green(`   [v] 已为 ${healthResult.summary.created} 个项目创建 .claude/sessions 目录`));
+    for (const platform of platforms) {
+      try {
+        const driver = catalog.driver(platform.key, 'health');
+        if (!driver || typeof driver.healthCheck !== 'function') continue;
+        const result = await driver.healthCheck({ config, detail: false });
+        if (result?.success === false) {
+          summary.errors += 1;
+          console.error(chalk.yellow(`   [!] ${platform.label || platform.key} 健康检查失败: ${result.error || 'unknown error'}`));
+          continue;
+        }
+        const platformSummary = result?.summary || {};
+        summary.total += Number(platformSummary.total || 0);
+        summary.created += Number(platformSummary.created || 0);
+        summary.errors += Number(platformSummary.errors || 0);
+        summary.healthy += Number(platformSummary.healthy || 0);
+      } catch (error) {
+        summary.errors += 1;
+        console.error(chalk.yellow(`   [!] ${platform.label || platform.key} 健康检查失败: ${error.message}`));
+      }
     }
 
-    if (healthResult.summary.errors > 0) {
-      console.log(chalk.yellow(`   [!] ${healthResult.summary.errors} 个项目检查失败`));
+    if (summary.total === 0 && summary.errors === 0) {
+      console.log(chalk.gray('   没有可执行的健康检查'));
+      return { success: true, summary };
     }
 
-    if (healthResult.summary.created === 0 && healthResult.summary.errors === 0) {
-      console.log(chalk.green(`   [v] 所有 ${healthResult.summary.healthy} 个项目状态正常`));
-    }
+    const { created, errors, healthy } = summary;
 
+    if (created > 0) {
+      console.log(chalk.green(`   [v] 已为 ${created} 个项目创建缺失的配置目录`));
+    }
+    if (errors > 0) {
+      console.log(chalk.yellow(`   [!] ${errors} 个项目检查失败`));
+    }
+    if (created === 0 && errors === 0) {
+      console.log(chalk.green(`   [v] 所有 ${healthy} 个项目状态正常`));
+    }
     console.log('');
+    return { success: true, summary };
   } catch (err) {
     console.error(chalk.red('   [x] 健康检查失败:'), err.message);
+    return { success: false, error: err.message, summary: { total: 0, created: 0, errors: 1, healthy: 0 } };
   }
 }
 
-module.exports = { startServer };
+module.exports = {
+  startServer,
+  _test: { autoRestoreProxies, performStartupHealthCheck, traceStartupMemory }
+};