@wanggangqi/workspace-cli 1.0.0

package/lib/workspace.js

@@ -0,0 +1,1591 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const chalk = require("chalk");
+const inquirer = require("inquirer");
+
+class WorkspaceManager {
+  constructor(targetDir = null) {
+    if (targetDir) {
+      this.baseDir = path.resolve(targetDir);
+    } else {
+      // 自动查找工作空间根目录
+      this.baseDir = this.findWorkspaceRoot(process.cwd()) || process.cwd();
+    }
+    this.workspaceDir = path.join(this.baseDir, ".workspace");
+    this.configPath = path.join(this.workspaceDir, "config.json");
+  }
+
+  /**
+   * 向上查找工作空间根目录
+   */
+  findWorkspaceRoot(startDir) {
+    let currentDir = startDir;
+    while (currentDir !== path.dirname(currentDir)) {
+      const workspaceDir = path.join(currentDir, ".workspace");
+      if (
+        fs.existsSync(workspaceDir) &&
+        fs.existsSync(path.join(workspaceDir, "config.json"))
+      ) {
+        return currentDir;
+      }
+      currentDir = path.dirname(currentDir);
+    }
+    return null;
+  }
+
+  /**
+   * 更新基础目录（用于指定目录初始化时）
+   */
+  setBaseDir(targetDir) {
+    this.baseDir = path.resolve(targetDir);
+    this.workspaceDir = path.join(this.baseDir, ".workspace");
+    this.configPath = path.join(this.workspaceDir, "config.json");
+  }
+
+  /**
+   * 获取默认配置（从包自带的 config.json）
+   */
+  getDefaultConfig() {
+    try {
+      // 尝试从多个位置查找默认配置
+      const possiblePaths = [
+        path.join(__dirname, "..", "config.json"),
+        path.join(process.cwd(), "config.json"),
+        path.join(__dirname, "..", "..", "config.json"),
+      ];
+
+      for (const configPath of possiblePaths) {
+        if (fs.existsSync(configPath)) {
+          const content = fs.readFileSync(configPath, "utf-8");
+          const config = JSON.parse(content);
+          // 保留平台组的仓库信息，清空 other 分组的 repos
+          for (const [groupName, group] of Object.entries(config.groups)) {
+            if (groupName !== "平台组") {
+              group.repos = [];
+            }
+          }
+          return config;
+        }
+      }
+    } catch (error) {
+      // 忽略错误，返回空配置
+    }
+
+    return {
+      version: "1.0",
+      groups: {},
+    };
+  }
+
+  /**
+   * 确保配置文件存在
+   */
+  ensureConfig(useDefault = false) {
+    if (!fs.existsSync(this.workspaceDir)) {
+      fs.mkdirSync(this.workspaceDir, { recursive: true });
+    }
+    if (!fs.existsSync(this.configPath)) {
+      const defaultConfig = useDefault
+        ? this.getDefaultConfig()
+        : {
+            version: "1.0",
+            groups: {},
+          };
+      this.saveConfig(defaultConfig);
+    }
+  }
+
+  /**
+   * 读取配置文件
+   */
+  loadConfig() {
+    this.ensureConfig();
+    const content = fs.readFileSync(this.configPath, "utf-8");
+    return JSON.parse(content);
+  }
+
+  /**
+   * 保存配置文件
+   */
+  saveConfig(config) {
+    fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+  }
+
+  /**
+   * 获取支持的 AI 编辑器列表
+   */
+  getSupportedEditors() {
+    return ["claude-code", "trae", "opencode", "iflow"];
+  }
+
+  /**
+   * 获取 AI 编辑器对应的 prompt 文件路径
+   * @param {string} aiEditor - AI 编辑器类型
+   * @returns {object|null} - 包含 targetPath 和 fileName 的对象
+   */
+  getPromptFileInfo(aiEditor) {
+    const supportedEditors = this.getSupportedEditors();
+
+    if (!supportedEditors.includes(aiEditor)) {
+      return null;
+    }
+
+    // 定义各编辑器对应的文件路径
+    const editorFileMap = {
+      "claude-code": { fileName: "CLAUDE.md", dir: "" },
+      trae: { fileName: "prompt.md", dir: ".trae" },
+      opencode: { fileName: "prompt.md", dir: ".opencode" },
+      iflow: { fileName: "prompt.md", dir: ".iflow" },
+    };
+
+    const config = editorFileMap[aiEditor];
+    if (!config) return null;
+
+    const targetDir = config.dir
+      ? path.join(this.baseDir, config.dir)
+      : this.baseDir;
+    const targetPath = path.join(targetDir, config.fileName);
+
+    return { targetPath, targetDir, fileName: config.fileName };
+  }
+
+  /**
+   * 生成 AI 编辑器的 prompt 文件
+   * @param {string} aiEditor - AI 编辑器类型
+   */
+  generatePromptFile(aiEditor) {
+    const supportedEditors = this.getSupportedEditors();
+
+    if (!supportedEditors.includes(aiEditor)) {
+      console.log(chalk.yellow(`⚠ 不支持的编辑器类型: ${aiEditor}`));
+      console.log(chalk.gray(`  支持的类型: ${supportedEditors.join(", ")}`));
+      return false;
+    }
+
+    // 查找通用 prompt.md 模板文件
+    const templatePaths = [
+      path.join(__dirname, "..", "prompts", "prompt.md"),
+      path.join(process.cwd(), "prompt.md"),
+      path.join(__dirname, "..", "..", "prompt.md"),
+    ];
+
+    let templateContent = null;
+    let foundTemplatePath = null;
+    for (const templatePath of templatePaths) {
+      if (fs.existsSync(templatePath)) {
+        templateContent = fs.readFileSync(templatePath, "utf-8");
+        foundTemplatePath = templatePath;
+        break;
+      }
+    }
+
+    if (!templateContent) {
+      console.log(chalk.yellow(`⚠ 未找到 prompt.md 模板文件`));
+      return false;
+    }
+
+    // 获取目标文件信息
+    const fileInfo = this.getPromptFileInfo(aiEditor);
+    if (!fileInfo) {
+      console.log(chalk.yellow(`⚠ 无法获取 ${aiEditor} 的文件配置`));
+      return false;
+    }
+
+    const { targetPath, targetDir } = fileInfo;
+
+    // 确保目录存在
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+
+    // 写入文件
+    fs.writeFileSync(targetPath, templateContent, "utf-8");
+    console.log(chalk.green(`✓ 生成 ${aiEditor} prompt 文件: ${targetPath}`));
+    return true;
+  }
+
+  /**
+   * 初始化工作空间
+   * @param {string|null} directory - 可选的目录名称，如果指定则创建该目录并初始化
+   * @param {string|null} aiEditor - 可选的 AI 编辑器类型
+   */
+  async init(directory = null, aiEditor = null) {
+    // 如果指定了目录，更新路径
+    if (directory) {
+      this.setBaseDir(directory);
+    }
+
+    // 如果指定了目录且目录不存在，创建目录
+    if (directory && !fs.existsSync(this.baseDir)) {
+      fs.mkdirSync(this.baseDir, { recursive: true });
+      console.log(chalk.green(`✓ 创建目录: ${this.baseDir}`));
+    }
+
+    if (fs.existsSync(this.configPath)) {
+      const { overwrite } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "overwrite",
+          message: "工作空间已存在，是否覆盖？",
+          default: false,
+        },
+      ]);
+      if (!overwrite) {
+        console.log(chalk.yellow("已取消初始化"));
+        return;
+      }
+    }
+
+    this.ensureConfig(true); // 使用默认配置
+    console.log(chalk.green("✓ 工作空间初始化成功"));
+    console.log(chalk.gray(`  目录: ${this.baseDir}`));
+    console.log(chalk.gray(`  配置文件: ${this.configPath}`));
+
+    // 显示默认分组和预配置仓库
+    const config = this.loadConfig();
+    const groupNames = Object.keys(config.groups);
+    if (groupNames.length > 0) {
+      console.log(chalk.blue("  默认分组:"));
+      for (const name of groupNames) {
+        const group = config.groups[name];
+        const repoCount = group.repos?.length || 0;
+        console.log(
+          chalk.gray(
+            `    • ${name} (${group.code})${repoCount > 0 ? ` - ${repoCount} 个预配置仓库` : ""}`,
+          ),
+        );
+        if (repoCount > 0) {
+          for (const repo of group.repos) {
+            console.log(chalk.gray(`      - ${repo.name} (${repo.branch})`));
+          }
+        }
+      }
+    }
+
+    // 如果指定了 AI 编辑器，生成对应的 prompt 文件
+    if (aiEditor) {
+      console.log();
+      this.generatePromptFile(aiEditor);
+    }
+  }
+
+  /**
+   * 扫描工作目录下的 Git 项目
+   */
+  async scan(interactive = true) {
+    const config = this.loadConfig();
+    const currentDir = this.baseDir;
+    const dirs = fs
+      .readdirSync(currentDir, { withFileTypes: true })
+      .filter((dirent) => dirent.isDirectory())
+      .filter(
+        (dirent) =>
+          !dirent.name.startsWith(".") && dirent.name !== "node_modules",
+      )
+      .map((dirent) => dirent.name);
+
+    const gitRepos = [];
+    for (const dir of dirs) {
+      const gitDir = path.join(currentDir, dir, ".git");
+      if (fs.existsSync(gitDir)) {
+        try {
+          const url = execSync("git remote get-url origin", {
+            cwd: path.join(currentDir, dir),
+            encoding: "utf-8",
+          }).trim();
+
+          const branch = execSync("git branch --show-current", {
+            cwd: path.join(currentDir, dir),
+            encoding: "utf-8",
+          }).trim();
+
+          gitRepos.push({
+            name: dir,
+            url,
+            branch: branch || "main",
+          });
+        } catch (error) {
+          // 忽略无法获取远程地址的项目
+        }
+      }
+    }
+
+    if (gitRepos.length === 0) {
+      console.log(chalk.yellow("未找到任何 Git 项目"));
+      return;
+    }
+
+    console.log(chalk.blue(`\n发现 ${gitRepos.length} 个 Git 项目:`));
+    console.log();
+
+    for (const repo of gitRepos) {
+      // 检查是否已存在
+      let exists = false;
+      let existingRepo = null;
+      let existingGroup = null;
+
+      for (const [groupName, group] of Object.entries(config.groups)) {
+        const found = group.repos?.find((r) => r.name === repo.name);
+        if (found) {
+          exists = true;
+          existingRepo = found;
+          existingGroup = groupName;
+          break;
+        }
+      }
+
+      if (exists) {
+        console.log(chalk.gray(`  • ${repo.name} (已存在于 ${existingGroup})`));
+        // 更新分支信息
+        if (existingRepo.branch !== repo.branch) {
+          existingRepo.branch = repo.branch;
+          console.log(chalk.gray(`    分支更新为: ${repo.branch}`));
+        }
+      } else {
+        console.log(chalk.cyan(`  • ${repo.name}`));
+        console.log(chalk.gray(`    URL: ${repo.url}`));
+        console.log(chalk.gray(`    分支: ${repo.branch}`));
+
+        if (interactive) {
+          const answers = await inquirer.prompt([
+            {
+              type: "confirm",
+              name: "add",
+              message: `是否添加 ${repo.name}?`,
+              default: true,
+            },
+            {
+              type: "input",
+              name: "descriptions",
+              message: "请输入项目描述（多个描述用逗号分隔）:",
+              when: (answers) => answers.add,
+              default: repo.name,
+            },
+            {
+              type: "list",
+              name: "group",
+              message: "选择分组:",
+              when: (answers) => answers.add,
+              choices: [
+                ...Object.keys(config.groups),
+                new inquirer.Separator(),
+                "创建新分组",
+              ],
+            },
+            {
+              type: "input",
+              name: "newGroupName",
+              message: "输入新分组名称:",
+              when: (answers) => answers.group === "创建新分组",
+            },
+            {
+              type: "input",
+              name: "newGroupCode",
+              message: "输入新分组代码:",
+              when: (answers) => answers.group === "创建新分组",
+            },
+          ]);
+
+          if (answers.add) {
+            const descriptions = answers.descriptions
+              ? answers.descriptions
+                  .split(",")
+                  .map((d) => d.trim())
+                  .filter(Boolean)
+              : [repo.name];
+
+            let groupName =
+              answers.group === "创建新分组"
+                ? answers.newGroupName
+                : answers.group;
+
+            if (answers.group === "创建新分组") {
+              config.groups[groupName] = {
+                code: answers.newGroupCode || "custom",
+                description: groupName,
+                repos: [],
+              };
+            }
+
+            if (!config.groups[groupName]) {
+              config.groups[groupName] = {
+                code: groupName.toLowerCase(),
+                description: groupName,
+                repos: [],
+              };
+            }
+
+            config.groups[groupName].repos.push({
+              name: repo.name,
+              url: repo.url,
+              descriptions,
+              branch: repo.branch,
+            });
+
+            console.log(chalk.green(`    ✓ 已添加到 ${groupName}`));
+          }
+        } else {
+          // 非交互模式，自动添加到 other 分组
+          if (!config.groups.other) {
+            config.groups.other = {
+              code: "other",
+              description: "未分组",
+              repos: [],
+            };
+          }
+          config.groups.other.repos.push({
+            name: repo.name,
+            url: repo.url,
+            descriptions: [repo.name],
+            branch: repo.branch,
+          });
+          console.log(chalk.green(`    ✓ 自动添加到 other 分组`));
+        }
+      }
+      console.log();
+    }
+
+    this.saveConfig(config);
+    console.log(chalk.green("✓ 扫描完成，配置已更新"));
+  }
+
+  /**
+   * 列出所有项目
+   */
+  async list(groupFilter = null) {
+    const config = this.loadConfig();
+
+    for (const [groupName, group] of Object.entries(config.groups)) {
+      if (groupFilter && groupName !== groupFilter) continue;
+
+      console.log(chalk.blue(`\n${groupName} (${group.code})`));
+      console.log(chalk.gray(group.description));
+      console.log();
+
+      if (!group.repos || group.repos.length === 0) {
+        console.log(chalk.gray("  (无项目)"));
+      } else {
+        for (const repo of group.repos) {
+          console.log(chalk.cyan(`  • ${repo.name}`));
+          console.log(chalk.gray(`    URL: ${repo.url}`));
+          console.log(chalk.gray(`    分支: ${repo.branch}`));
+          if (repo.descriptions && repo.descriptions.length > 0) {
+            console.log(
+              chalk.gray(`    描述: ${repo.descriptions.join(", ")}`),
+            );
+          }
+          console.log();
+        }
+      }
+    }
+  }
+
+  /**
+   * 添加项目
+   */
+  async add(name, options) {
+    const config = this.loadConfig();
+    const { url, group, branch, description } = options;
+
+    // 检查是否已存在
+    for (const [groupName, g] of Object.entries(config.groups)) {
+      if (g.repos?.find((r) => r.name === name)) {
+        throw new Error(`项目 ${name} 已存在于 ${groupName} 分组`);
+      }
+    }
+
+    if (!config.groups[group]) {
+      config.groups[group] = {
+        code: group.toLowerCase(),
+        description: group,
+        repos: [],
+      };
+    }
+
+    config.groups[group].repos.push({
+      name,
+      url,
+      descriptions: description ? [description] : [name],
+      branch,
+    });
+
+    this.saveConfig(config);
+    console.log(chalk.green(`✓ 项目 ${name} 已添加到 ${group} 分组`));
+  }
+
+  /**
+   * 移除项目
+   */
+  async remove(name) {
+    const config = this.loadConfig();
+    let removed = false;
+
+    for (const [groupName, group] of Object.entries(config.groups)) {
+      const index = group.repos?.findIndex((r) => r.name === name);
+      if (index >= 0) {
+        group.repos.splice(index, 1);
+        removed = true;
+        console.log(chalk.green(`✓ 项目 ${name} 已从 ${groupName} 分组移除`));
+        break;
+      }
+    }
+
+    if (!removed) {
+      throw new Error(`项目 ${name} 不存在`);
+    }
+
+    this.saveConfig(config);
+  }
+
+  /**
+   * 克隆所有仓库
+   */
+  async cloneAll(groupFilter = null) {
+    const config = this.loadConfig();
+    const reposToClone = [];
+
+    for (const [groupName, group] of Object.entries(config.groups)) {
+      if (groupFilter && groupName !== groupFilter) continue;
+      if (group.repos) {
+        reposToClone.push(...group.repos);
+      }
+    }
+
+    if (reposToClone.length === 0) {
+      console.log(chalk.yellow("没有需要克隆的仓库"));
+      return;
+    }
+
+    console.log(chalk.blue(`\n准备克隆 ${reposToClone.length} 个仓库:\n`));
+
+    for (const repo of reposToClone) {
+      if (fs.existsSync(repo.name)) {
+        console.log(chalk.yellow(`  • ${repo.name} 已存在，跳过`));
+        continue;
+      }
+
+      console.log(chalk.cyan(`  • 正在克隆 ${repo.name}...`));
+      try {
+        execSync(`git clone -b ${repo.branch} ${repo.url} ${repo.name}`, {
+          stdio: "inherit",
+        });
+        console.log(chalk.green(`    ✓ 克隆成功\n`));
+      } catch (error) {
+        console.log(chalk.red(`    ✗ 克隆失败\n`));
+      }
+    }
+
+    console.log(chalk.green("✓ 克隆任务完成"));
+  }
+
+  /**
+   * 获取 nginx-config 目录路径
+   */
+  getNginxConfigDir() {
+    // 尝试多个可能的路径
+    const possiblePaths = [
+      path.join(__dirname, "..", "nginx-config"),
+      path.join(process.cwd(), "nginx-config"),
+      path.join(__dirname, "..", "..", "nginx-config"),
+    ];
+
+    for (const dir of possiblePaths) {
+      if (fs.existsSync(dir)) {
+        return dir;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * 列出可用的 nginx 配置
+   */
+  async listNginxConfigs() {
+    const nginxDir = this.getNginxConfigDir();
+
+    if (!nginxDir) {
+      console.log(chalk.yellow("⚠ 未找到 nginx-config 目录"));
+      return [];
+    }
+
+    const files = fs
+      .readdirSync(nginxDir)
+      .filter((f) => f.endsWith(".conf"))
+      .sort();
+
+    if (files.length === 0) {
+      console.log(chalk.yellow("⚠ 未找到 .conf 配置文件"));
+      return [];
+    }
+
+    console.log(chalk.blue("\n可用的 nginx 配置：\n"));
+
+    files.forEach((file, index) => {
+      const filePath = path.join(nginxDir, file);
+      const content = fs.readFileSync(filePath, "utf-8");
+      const portMatch = content.match(/listen\s+(\d+)/);
+      const port = portMatch ? portMatch[1] : "unknown";
+
+      console.log(chalk.cyan(`  ${index + 1}. ${file}`));
+      console.log(chalk.gray(`     端口: ${port}`));
+    });
+
+    console.log();
+    console.log(chalk.gray("使用方式："));
+    console.log(
+      chalk.gray("  wsc nginx -c 5006_plat          # 复制配置到当前目录"),
+    );
+    console.log(
+      chalk.gray("  wsc nginx -s 5006_plat          # 复制并启动 nginx"),
+    );
+    console.log(
+      chalk.gray("  .\\start-nginx.bat               # 直接运行启动脚本"),
+    );
+
+    return files;
+  }
+
+  /**
+   * 初始化当前工作空间的 nginx 环境
+   * 下载 nginx Windows 绿色版，创建独立配置，解决多空间冲突
+   */
+  async initNginx(options = {}) {
+    const {
+      version = "1.24.0",
+      skipDownload = false,
+      proxyTarget = "http://192.168.10.189",
+    } = options;
+
+    console.log(chalk.blue("\n========================================"));
+    console.log(chalk.blue("   初始化工作空间 Nginx 环境"));
+    console.log(chalk.blue("========================================\n"));
+
+    // 确保工作空间已初始化
+    this.ensureConfig(true);
+
+    // 加载配置
+    const config = this.loadConfig();
+
+    // 检查是否已存在 nginx 配置
+    if (config.nginx?.installed) {
+      const { reinitialize } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "reinitialize",
+          message: `Nginx is already initialized (version: ${config.nginx.version}). Reinitialize?`,
+          default: false,
+        },
+      ]);
+
+      if (!reinitialize) {
+        console.log(chalk.yellow("Initialization cancelled."));
+        return;
+      }
+
+      console.log(chalk.yellow("Removing existing nginx configuration..."));
+      // 停止当前 nginx
+      const nginxDir = path.join(this.workspaceDir, "nginx");
+      if (fs.existsSync(nginxDir)) {
+        try {
+          // 尝试停止 nginx
+          const stopScript = path.join(nginxDir, "stop-nginx.bat");
+          if (fs.existsSync(stopScript)) {
+            execSync(`"${stopScript}"`, { stdio: "ignore", timeout: 10000 });
+          }
+        } catch {
+          // 忽略停止错误
+        }
+      }
+    }
+
+    console.log(chalk.gray(`  代理后端地址: ${proxyTarget}`));
+
+    // 初始化 nginx 配置结构
+    if (!config.nginx) {
+      config.nginx = {};
+    }
+
+    // 设置工作空间 nginx 配置
+    const workspaceNginxConfig = {
+      version: version,
+      proxyTarget: proxyTarget,
+      installed: false,
+      configs: [],
+    };
+
+    config.nginx = workspaceNginxConfig;
+    this.saveConfig(config);
+
+    console.log(chalk.gray(`  工作空间: ${this.baseDir}`));
+    console.log();
+
+    // 定义目录结构
+    const nginxDir = path.join(this.workspaceDir, "nginx");
+    const nginxBinDir = path.join(nginxDir, "nginx-" + version);
+    // 配置文件放在 nginx/conf/conf.d/ 下，使用相对路径
+    const configDir = path.join(nginxBinDir, "conf", "conf.d");
+    // 使用 nginx 自带的 logs 和 temp 目录（相对路径）
+    const logsDir = "logs";
+    const tempDir = "temp";
+
+    // 注意：conf.d 目录在 nginx 解压后才会创建，这里不提前创建
+    // 因为 mkdirSync 的 recursive: true 会连带创建 nginx-1.24.0 目录
+    // 导致 downloadNginx 误以为 nginx 已安装
+
+    // 下载 nginx
+    if (!skipDownload) {
+      await this.downloadNginx(version, nginxDir, nginxBinDir);
+    }
+
+    // 下载完成后，创建 conf.d 目录
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+      console.log(chalk.green(`✓ 创建配置目录: ${configDir}`));
+    }
+
+    // 生成 nginx 主配置文件
+    await this.generateNginxMainConfig(nginxBinDir);
+
+    // 复制 nginx 项目配置到 conf.d（替换占位符，init 时不替换 serveport）
+    await this.copyNginxConfigsToConfigD(
+      configDir,
+      proxyTarget,
+      null, // serveport 在启动时动态分配
+    );
+
+    // 复制并修改管理脚本（PowerShell 版本）
+    await this.copyNginxPowerShellScripts(
+      nginxDir,
+      nginxBinDir,
+      configDir,
+      proxyTarget,
+    );
+
+    // 更新配置
+    config.nginx.installed = true;
+    config.nginx.binDir = nginxBinDir;
+    config.nginx.configDir = configDir;
+    config.nginx.logsDir = logsDir;
+
+    // 扫描 conf.d 目录下的配置
+    const configFiles = fs
+      .readdirSync(configDir)
+      .filter((f) => f.endsWith(".conf"))
+      .map((f) => ({
+        name: f.replace(".conf", ""),
+        file: f,
+        port: this.extractPortFromConfig(path.join(configDir, f)),
+      }));
+    config.nginx.configs = configFiles;
+
+    this.saveConfig(config);
+
+    console.log();
+    console.log(chalk.green("✓ Nginx 初始化完成"));
+    console.log();
+    console.log(chalk.blue("工作空间信息："));
+    console.log(chalk.gray(`  代理: ${proxyTarget}`));
+    console.log();
+
+    console.log(chalk.blue("工作空间 nginx 命令："));
+    console.log(chalk.gray(`  wsc nginx start    # 启动当前空间的 nginx`));
+    console.log(chalk.gray(`  wsc nginx stop     # 停止当前空间的 nginx`));
+    console.log(chalk.gray(`  wsc nginx reload   # 重载当前空间的 nginx`));
+    console.log(chalk.gray(`  wsc nginx status   # 查看当前空间的 nginx 状态`));
+    console.log();
+    console.log(chalk.blue("生成的 PowerShell 脚本（已配置环境变量）："));
+    console.log(chalk.gray(`  ${path.join(nginxDir, "start-nginx.ps1")}`));
+    console.log(chalk.gray(`  ${path.join(nginxDir, "stop-nginx.ps1")}`));
+    console.log(chalk.gray(`  ${path.join(nginxDir, "reload-nginx.ps1")}`));
+    console.log(chalk.gray(`  ${path.join(nginxDir, "status-nginx.ps1")}`));
+    console.log();
+    console.log(
+      chalk.yellow("注意：请勿直接运行 nginx-config 目录下的模板脚本！"),
+    );
+    console.log();
+  }
+
+  /**
+   * 查找可用的基础端口（解决多空间冲突）
+   */
+  findAvailableBasePort(currentConfig) {
+    // 默认起始端口 50000
+    const defaultBasePort = 50000;
+
+    // 扫描工作空间目录查找已使用的端口
+    const usedPorts = new Set();
+
+    try {
+      const parentDir = path.dirname(this.baseDir);
+      const entries = fs.readdirSync(parentDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const otherWorkspaceDir = path.join(
+            parentDir,
+            entry.name,
+            ".workspace",
+          );
+          const otherConfigPath = path.join(otherWorkspaceDir, "config.json");
+
+          if (
+            fs.existsSync(otherConfigPath) &&
+            otherConfigPath !== this.configPath
+          ) {
+            try {
+              const otherConfig = JSON.parse(
+                fs.readFileSync(otherConfigPath, "utf-8"),
+              );
+              if (otherConfig.nginx?.basePort) {
+                usedPorts.add(otherConfig.nginx.basePort);
+              }
+            } catch {
+              // 忽略读取错误的配置
+            }
+          }
+        }
+      }
+    } catch {
+      // 忽略扫描错误
+    }
+
+    // 如果当前配置已有端口且未被其他空间使用，则保留
+    if (
+      currentConfig.nginx?.basePort &&
+      !usedPorts.has(currentConfig.nginx.basePort)
+    ) {
+      return currentConfig.nginx.basePort;
+    }
+
+    // 查找可用端口
+    let basePort = defaultBasePort;
+    while (usedPorts.has(basePort)) {
+      basePort += 1000; // 每个空间间隔1000个端口
+    }
+
+    return basePort;
+  }
+
+  /**
+   * 从配置文件中提取端口
+   */
+  extractPortFromConfig(configPath) {
+    try {
+      const content = fs.readFileSync(configPath, "utf-8");
+      const match = content.match(/listen\s+(\d+)/);
+      return match ? parseInt(match[1]) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 获取 nginx 全局缓存目录
+   */
+  getNginxCacheDir() {
+    // 尝试多种方式获取用户主目录
+    const homeDir =
+      process.env.HOME ||
+      process.env.USERPROFILE ||
+      process.env.HOMEDRIVE + process.env.HOMEPATH ||
+      (process.platform === "win32"
+        ? "C:\\Users\\" + process.env.USERNAME
+        : null);
+
+    if (!homeDir) {
+      console.log(chalk.yellow("  ⚠ 无法确定用户主目录，将使用本地缓存"));
+      return null;
+    }
+
+    return path.join(homeDir, ".wsc-cache", "nginx");
+  }
+
+  /**
+   * 下载 nginx Windows 绿色版（支持全局缓存）
+   */
+  async downloadNginx(version, nginxDir, nginxBinDir) {
+    console.log(chalk.blue("\n下载 nginx..."));
+
+    // 检查是否已存在
+    if (fs.existsSync(nginxBinDir)) {
+      console.log(chalk.yellow(`⚠ nginx ${version} 已存在于 ${nginxBinDir}`));
+      return;
+    }
+
+    const zipFileName = `nginx-${version}.zip`;
+    const zipPath = path.join(nginxDir, zipFileName);
+
+    // 获取全局缓存目录
+    const cacheDir = this.getNginxCacheDir();
+    console.log(
+      chalk.gray(`  缓存目录: ${cacheDir || "无法确定（使用本地目录）"}`),
+    );
+
+    // 确保缓存目录存在（如果可能）
+    if (cacheDir && !fs.existsSync(cacheDir)) {
+      try {
+        fs.mkdirSync(cacheDir, { recursive: true });
+        console.log(chalk.gray(`  ✓ 创建缓存目录: ${cacheDir}`));
+      } catch (error) {
+        console.log(chalk.yellow(`  ⚠ 无法创建缓存目录: ${error.message}`));
+      }
+    }
+
+    const cacheZipPath = cacheDir ? path.join(cacheDir, zipFileName) : null;
+
+    // 检查本地是否已下载且文件有效（大于1MB）
+    const isValidLocalDownload =
+      fs.existsSync(zipPath) && fs.statSync(zipPath).size > 1024 * 1024;
+
+    // 检查缓存是否存在且有效
+    const isValidCache =
+      cacheZipPath &&
+      fs.existsSync(cacheZipPath) &&
+      fs.statSync(cacheZipPath).size > 1024 * 1024;
+
+    let hasValidZip = isValidLocalDownload;
+
+    if (isValidLocalDownload) {
+      console.log(chalk.yellow(`⚠ 安装包已存在: ${zipPath}`));
+    } else if (isValidCache) {
+      // 从缓存复制到本地
+      console.log(chalk.gray(`  从缓存复制: ${cacheZipPath}`));
+      try {
+        // 确保目标目录存在
+        if (!fs.existsSync(nginxDir)) {
+          fs.mkdirSync(nginxDir, { recursive: true });
+        }
+        fs.copyFileSync(cacheZipPath, zipPath);
+        hasValidZip = true;
+        console.log(chalk.green(`  ✓ 从缓存复制成功`));
+      } catch (error) {
+        console.log(
+          chalk.yellow(`  ⚠ 复制缓存失败，将重新下载: ${error.message}`),
+        );
+      }
+    }
+
+    // 如果本地仍然没有有效的 zip 文件，则下载
+    if (
+      !hasValidZip &&
+      (!fs.existsSync(zipPath) || fs.statSync(zipPath).size <= 1024 * 1024)
+    ) {
+      // 删除可能存在的不完整文件
+      if (fs.existsSync(zipPath)) {
+        fs.unlinkSync(zipPath);
+      }
+
+      // 下载 nginx
+      const downloadUrl = `https://github.com/nginx/nginx/releases/download/release-${version}/${zipFileName}`;
+      const backupUrl = `http://nginx.org/download/nginx-${version}.zip`;
+
+      let downloaded = false;
+
+      // 尝试主下载地址 (nginx.org)
+      try {
+        console.log(chalk.gray(`  尝试从 nginx.org 下载...`));
+        // 先下载到缓存目录
+        const downloadTarget = cacheZipPath || zipPath;
+        execSync(`curl -L -o "${downloadTarget}" "${backupUrl}"`, {
+          stdio: "inherit",
+          timeout: 180000,
+        });
+
+        // 验证下载是否成功
+        if (
+          fs.existsSync(downloadTarget) &&
+          fs.statSync(downloadTarget).size > 1024 * 1024
+        ) {
+          downloaded = true;
+          console.log(chalk.green(`  ✓ 从 nginx.org 下载成功`));
+          // 如果下载到缓存，同时复制到本地
+          if (cacheZipPath && downloadTarget === cacheZipPath) {
+            // 确保目标目录存在
+            if (!fs.existsSync(nginxDir)) {
+              fs.mkdirSync(nginxDir, { recursive: true });
+            }
+            fs.copyFileSync(cacheZipPath, zipPath);
+          }
+        } else {
+          console.log(chalk.yellow("  ✗ 下载文件无效或太小，尝试备用源..."));
+        }
+      } catch (error) {
+        console.log(
+          chalk.yellow(
+            `  ✗ nginx.org 下载失败: ${error.message || "网络错误"}`,
+          ),
+        );
+      }
+
+      // 如果主源失败，尝试 GitHub
+      if (!downloaded) {
+        // 清理失败的文件
+        if (cacheZipPath && fs.existsSync(cacheZipPath)) {
+          fs.unlinkSync(cacheZipPath);
+        }
+        if (fs.existsSync(zipPath)) {
+          fs.unlinkSync(zipPath);
+        }
+
+        try {
+          console.log(chalk.gray(`  尝试从 GitHub 下载...`));
+          const downloadTarget = cacheZipPath || zipPath;
+          execSync(`curl -L -o "${downloadTarget}" "${downloadUrl}"`, {
+            stdio: "inherit",
+            timeout: 180000,
+          });
+
+          // 验证下载是否成功
+          if (
+            fs.existsSync(downloadTarget) &&
+            fs.statSync(downloadTarget).size > 1024 * 1024
+          ) {
+            downloaded = true;
+            console.log(chalk.green(`  ✓ 从 GitHub 下载成功`));
+            // 如果下载到缓存，同时复制到本地
+            if (cacheZipPath && downloadTarget === cacheZipPath) {
+              // 确保目标目录存在
+              if (!fs.existsSync(nginxDir)) {
+                fs.mkdirSync(nginxDir, { recursive: true });
+              }
+              fs.copyFileSync(cacheZipPath, zipPath);
+            }
+          } else {
+            console.log(chalk.yellow("  ✗ 下载文件无效或太小"));
+          }
+        } catch (error) {
+          console.log(
+            chalk.yellow(`  ✗ GitHub 下载失败: ${error.message || "网络错误"}`),
+          );
+        }
+      }
+
+      if (!downloaded) {
+        console.log(chalk.red("\n✗ 下载失败，请手动下载并解压到："));
+        console.log(chalk.gray(`  ${nginxBinDir}`));
+        console.log(chalk.gray(`  下载地址: ${backupUrl}`));
+        throw new Error("nginx 下载失败");
+      }
+    }
+
+    // 解压
+    console.log(chalk.gray("  解压中..."));
+    try {
+      // 使用 PowerShell 解压
+      execSync(
+        `powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${nginxDir}' -Force"`,
+        {
+          stdio: "pipe",
+          timeout: 60000,
+        },
+      );
+      console.log(chalk.green(`✓ nginx ${version} 已安装到 ${nginxBinDir}`));
+    } catch (error) {
+      console.log(chalk.red("✗ 解压失败"));
+      throw error;
+    }
+
+    // 删除本地 zip 文件（缓存目录保留）
+    try {
+      fs.unlinkSync(zipPath);
+    } catch {
+      // 忽略删除错误
+    }
+  }
+
+  /**
+   * 生成 nginx 主配置文件
+   */
+  async generateNginxMainConfig(nginxBinDir) {
+    console.log(chalk.blue("\n生成 nginx 主配置..."));
+
+    const mainConfig = `worker_processes  1;
+
+error_log  logs/error.log;
+pid        logs/nginx.pid;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    include       mime.types;
+    default_type  application/octet-stream;
+
+    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
+                      '$status $body_bytes_sent "$http_referer" '
+                      '"$http_user_agent" "$http_x_forwarded_for"';
+
+    access_log  logs/access.log  main;
+
+    sendfile        on;
+    keepalive_timeout  65;
+
+    # 包含 conf.d 目录下的所有配置（使用相对路径）
+    include  conf.d/*.conf;
+}
+`;
+
+    const mainConfigPath = path.join(nginxBinDir, "conf", "nginx.conf");
+
+    // 确保 conf 目录存在
+    const confDir = path.join(nginxBinDir, "conf");
+    if (!fs.existsSync(confDir)) {
+      fs.mkdirSync(confDir, { recursive: true });
+    }
+
+    fs.writeFileSync(mainConfigPath, mainConfig, "utf-8");
+    console.log(chalk.green(`✓ 生成主配置: ${mainConfigPath}`));
+  }
+
+  /**
+   * 复制 nginx 配置到 conf.d 目录
+   * 替换占位符: <serveport>, <workspaceDir>, <proxyTarget>
+   */
+  async copyNginxConfigsToConfigD(configDir, proxyTarget, serveport) {
+    console.log(chalk.blue("\n复制 nginx 项目配置..."));
+
+    const sourceDir = this.getNginxConfigDir();
+
+    if (!sourceDir) {
+      console.log(chalk.yellow("⚠ 未找到源 nginx-config 目录，跳过配置复制"));
+      return;
+    }
+
+    const files = fs.readdirSync(sourceDir).filter((f) => f.endsWith(".conf"));
+
+    if (files.length === 0) {
+      console.log(chalk.yellow("⚠ 未找到 .conf 配置文件"));
+      return;
+    }
+
+    // 准备替换变量
+    const workspaceDir = this.baseDir.replace(/\\/g, "/");
+
+    let copiedCount = 0;
+    for (const file of files) {
+      const srcPath = path.join(sourceDir, file);
+      const dstPath = path.join(configDir, file);
+
+      // 读取并调整配置
+      let content = fs.readFileSync(srcPath, "utf-8");
+
+      // 替换占位符
+      content = this.replaceNginxPlaceholders(
+        content,
+        workspaceDir,
+        proxyTarget,
+        serveport,
+      );
+
+      fs.writeFileSync(dstPath, content, "utf-8");
+      copiedCount++;
+      console.log(chalk.green(`✓ 复制配置: ${file}`));
+    }
+
+    console.log(chalk.gray(`  共复制 ${copiedCount} 个配置`));
+  }
+
+  /**
+   * 查找可用的 PowerShell 命令
+   * 优先使用 pwsh (PowerShell 7)，找不到则使用 powershell (Windows PowerShell 5.1)
+   */
+  findPowerShellCmd() {
+    const fs = require("fs");
+    const path = require("path");
+
+    // 常见 PowerShell 7 安装路径
+    const ps7Paths = [
+      "C:\\Program Files\\PowerShell\\7\\pwsh.exe",
+      "C:\\Program Files (x86)\\PowerShell\\7\\pwsh.exe",
+      path.join(process.env.LOCALAPPDATA || "", "Microsoft\\PowerShell\\pwsh.exe"),
+    ];
+
+    // 检查默认路径
+    for (const psPath of ps7Paths) {
+      if (fs.existsSync(psPath)) {
+        return `"${psPath}"`;
+      }
+    }
+
+    // 尝试从 PATH 找
+    try {
+      execSync("where pwsh", { stdio: "ignore" });
+      return "pwsh";
+    } catch {
+      // 回退到 Windows PowerShell 5.1
+      return "powershell";
+    }
+  }
+
+  /**
+   * 检测从指定端口开始的第一个可用端口
+   * 使用连接测试方式，更可靠地检测端口是否被占用
+   */
+  findAvailablePort(startPort = 5000) {
+    const net = require("net");
+
+    return new Promise((resolve, reject) => {
+      const tryPort = (port) => {
+        // 方法1: 尝试连接该端口，如果连得上说明已被占用
+        const client = new net.Socket();
+        client.setTimeout(500);
+
+        client.once("connect", () => {
+          // 连接成功，端口被占用
+          client.destroy();
+          tryPort(port + 1);
+        });
+
+        client.once("error", (err) => {
+          // 连接失败，端口可用
+          if (err.code === "ECONNREFUSED" || err.code === "ETIMEDOUT") {
+            client.destroy();
+            resolve(port);
+          } else {
+            client.destroy();
+            tryPort(port + 1);
+          }
+        });
+
+        client.once("timeout", () => {
+          // 超时，端口可能可用
+          client.destroy();
+          resolve(port);
+        });
+
+        client.connect(port, "127.0.0.1");
+      };
+
+      tryPort(startPort);
+    });
+  }
+
+  /**
+   * 替换 nginx 配置文件中的占位符
+   */
+  replaceNginxPlaceholders(content, workspaceDir, proxyTarget, serveport) {
+    // 替换 <workspaceDir> 为工作空间根目录
+    content = content.replace(/<workspaceDir>/gi, workspaceDir);
+
+    // 替换 <proxyTarget> 为代理后端地址
+    content = content.replace(/<proxyTarget>/gi, proxyTarget);
+
+    // 替换 <serveport> 为服务端口
+    if (serveport) {
+      content = content.replace(/<serveport>/gi, serveport);
+    }
+
+    return content;
+  }
+
+  /**
+   * 复制 nginx PowerShell 管理脚本并修改路径
+   */
+  async copyNginxPowerShellScripts(
+    nginxDir,
+    nginxBinDir,
+    configDir,
+    proxyTarget,
+  ) {
+    console.log(chalk.blue("\n复制 PowerShell 管理脚本..."));
+
+    const sourceDir = this.getNginxConfigDir();
+    if (!sourceDir) {
+      console.log(chalk.yellow("⚠ 未找到源 nginx-config 目录，跳过脚本复制"));
+      return;
+    }
+
+    const nginxExe = path.join(nginxBinDir, "nginx.exe");
+    const mainConfig = path.join(nginxBinDir, "conf", "nginx.conf");
+
+    // PowerShell 脚本文件列表
+    const scriptFiles = [
+      { name: "start-nginx.ps1", title: "启动" },
+      { name: "stop-nginx.ps1", title: "停止" },
+      { name: "reload-nginx.ps1", title: "重载配置" },
+      { name: "status-nginx.ps1", title: "状态检查" },
+    ];
+
+    for (const scriptInfo of scriptFiles) {
+      const scriptFile = scriptInfo.name;
+      const sourcePath = path.join(sourceDir, scriptFile);
+      const targetPath = path.join(nginxDir, scriptFile);
+
+      if (!fs.existsSync(sourcePath)) {
+        console.log(chalk.yellow(`⚠ 未找到源脚本: ${scriptFile}`));
+        continue;
+      }
+
+      // 读取源脚本
+      let content = fs.readFileSync(sourcePath, "utf-8");
+
+      // 修改脚本，使用工作空间的路径和环境变量
+      // 注意：传入 nginxBinDir 而不是 nginxDir，因为环境变量需要指向具体的 nginx 版本目录
+      content = this.patchPowerShellScript(
+        content,
+        nginxExe,
+        mainConfig,
+        configDir,
+        nginxBinDir,
+        proxyTarget,
+        scriptInfo.title,
+      );
+
+      // 写入修改后的脚本
+      fs.writeFileSync(targetPath, content, "utf-8");
+      console.log(chalk.green(`✓ 复制并修改脚本: ${scriptFile}`));
+    }
+  }
+
+  /**
+   * 修改 PowerShell 脚本，使用工作空间的路径
+   */
+  patchPowerShellScript(
+    content,
+    nginxExe,
+    mainConfig,
+    configDir,
+    nginxDir,
+    proxyTarget,
+    scriptTitle,
+  ) {
+    // 将路径转换为 PowerShell 格式
+    const nginxExeWin = nginxExe.replace(/\\/g, "\\");
+    const mainConfigWin = mainConfig.replace(/\\/g, "\\");
+    const nginxDirWin = nginxDir.replace(/\\/g, "\\");
+    const workspaceDirWin = this.baseDir.replace(/\\/g, "\\");
+
+    // 替换环境变量默认值
+    const envSetup = `
+# 工作空间配置
+$env:NGINX_EXE = '${nginxExeWin}'
+$env:NGINX_CONF = '${mainConfigWin}'
+$env:NGINX_DIR = '${nginxDirWin}'
+$env:WORKSPACE_DIR = '${workspaceDirWin}'
+$env:PROXY_TARGET = '${proxyTarget}'
+`;
+
+    // 在文件开头添加环境变量设置（在所有 #Requires 之后）
+    // 匹配所有的 #Requires 行，并在最后一个之后插入环境变量
+    const requiresMatch = content.match(/(#Requires.*\n)+/);
+    if (requiresMatch) {
+      // 在所有 #Requires 之后插入环境变量
+      content = content.replace(
+        requiresMatch[0],
+        requiresMatch[0] + "\n" + envSetup + "\n",
+      );
+    } else {
+      // 如果没有 #Requires，在文件开头（shebang 之后）插入
+      content = content.replace(/(^#!.*\n)?/, "$1\n" + envSetup + "\n");
+    }
+
+    return content;
+  }
+
+  /**
+   * 管理当前工作空间的 nginx 实例
+   */
+  async manageSpaceNginx(options) {
+    const { start, stop, reload, status } = options;
+
+    // 确保配置存在
+    const config = this.loadConfig();
+
+    if (!config.nginx?.installed) {
+      console.log(chalk.yellow("⚠ 当前工作空间尚未初始化 nginx"));
+      console.log(chalk.gray("  请运行: wsc nginx init"));
+      return;
+    }
+
+    const nginxDir = path.join(this.workspaceDir, "nginx");
+    const startScript = path.join(nginxDir, "start-nginx.ps1");
+    const stopScript = path.join(nginxDir, "stop-nginx.ps1");
+    const reloadScript = path.join(nginxDir, "reload-nginx.ps1");
+    const statusScript = path.join(nginxDir, "status-nginx.ps1");
+
+    if (start) {
+      console.log(chalk.blue("启动工作空间 nginx..."));
+      if (!fs.existsSync(startScript)) {
+        console.log(chalk.red(`✗ 启动脚本不存在: ${startScript}`));
+        return;
+      }
+
+      try {
+        // 检测可用端口（从5000开始）
+        console.log(chalk.gray("  检测可用端口..."));
+        const availablePort = await this.findAvailablePort(5000);
+        console.log(chalk.green(`  ✓ 使用端口: ${availablePort}`));
+
+        // 更新配置文件中的端口
+        const sourceDir = this.getNginxConfigDir();
+        const configDir = config.nginx.configDir;
+        if (sourceDir && configDir && fs.existsSync(configDir)) {
+          const proxyTarget = config.nginx.proxyTarget || "http://localhost:8080";
+          const workspaceDir = this.baseDir.replace(/\\/g, "/");
+
+          const templateFiles = fs.readdirSync(sourceDir).filter(f => f.endsWith(".conf"));
+          for (const file of templateFiles) {
+            const srcPath = path.join(sourceDir, file);
+            const dstPath = path.join(configDir, file);
+
+            let content;
+            if (fs.existsSync(dstPath)) {
+              // 配置文件已存在，读取现有配置并更新端口
+              content = fs.readFileSync(dstPath, "utf-8");
+              // 替换 listen 行中的端口号（包括 <serveport> 占位符或具体数字）
+              content = content.replace(/listen\s+\S+;/gi, `listen       ${availablePort};`);
+              console.log(chalk.gray(`  ✓ 更新端口: ${file} (端口: ${availablePort})`));
+            } else {
+              // 配置文件不存在，从模板复制
+              content = fs.readFileSync(srcPath, "utf-8");
+              content = this.replaceNginxPlaceholders(
+                content,
+                workspaceDir,
+                proxyTarget,
+                availablePort,
+              );
+              console.log(chalk.gray(`  ✓ 复制配置: ${file} (端口: ${availablePort})`));
+            }
+            fs.writeFileSync(dstPath, content, "utf-8");
+          }
+        }
+
+        // 保存端口到配置
+        config.nginx.servePort = availablePort;
+        this.saveConfig(config);
+
+        // 使用 pwsh (PowerShell Core) 执行脚本，支持更好的 UTF-8 编码
+        // 优先使用 pwsh (PowerShell 7)，找不到则使用 powershell (Windows PowerShell 5.1)
+        const psCmd = this.findPowerShellCmd();
+        execSync(`${psCmd} -ExecutionPolicy Bypass -File "${startScript}"`, {
+          stdio: "inherit",
+        });
+
+        // 打印访问地址
+        console.log();
+        console.log(chalk.green("========================================"));
+        console.log(chalk.green("  Nginx 启动成功！"));
+        console.log(chalk.green("========================================"));
+        console.log();
+        console.log(chalk.blue("  访问地址:"));
+        console.log(chalk.cyan(`    http://localhost:${availablePort}`));
+        console.log();
+        console.log(chalk.gray("  代理后端:"));
+        console.log(chalk.gray(`    ${config.nginx.proxyTarget || "http://localhost:8080"}`));
+        console.log();
+      } catch (error) {
+        console.log(chalk.red("✗ 启动失败"), error.message);
+      }
+      return;
+    }
+
+    if (stop) {
+      console.log(chalk.blue("停止工作空间 nginx..."));
+      if (!fs.existsSync(stopScript)) {
+        console.log(chalk.red(`✗ 停止脚本不存在: ${stopScript}`));
+        return;
+      }
+      try {
+        const psCmd = this.findPowerShellCmd();
+        execSync(`${psCmd} -ExecutionPolicy Bypass -File "${stopScript}"`, {
+          stdio: "inherit",
+        });
+        console.log(chalk.green("✓ nginx 已停止"));
+
+        // 清除端口配置
+        if (config.nginx.servePort) {
+          delete config.nginx.servePort;
+          this.saveConfig(config);
+        }
+      } catch (error) {
+        console.log(chalk.yellow("⚠ 停止命令执行失败或 nginx 未运行"));
+      }
+      return;
+    }
+
+    if (reload) {
+      console.log(chalk.blue("重载工作空间 nginx..."));
+      if (!fs.existsSync(reloadScript)) {
+        console.log(chalk.red(`✗ 重载脚本不存在: ${reloadScript}`));
+        return;
+      }
+      try {
+        const psCmd = this.findPowerShellCmd();
+        execSync(`${psCmd} -ExecutionPolicy Bypass -File "${reloadScript}"`, {
+          stdio: "inherit",
+        });
+        console.log(chalk.green("✓ nginx 配置已重载"));
+      } catch (error) {
+        console.log(chalk.red("✗ 重载失败"), error.message);
+      }
+      return;
+    }
+
+    if (status) {
+      console.log(chalk.blue("检查工作空间 nginx 状态..."));
+      if (!fs.existsSync(statusScript)) {
+        // 如果没有状态脚本，直接检查进程
+        try {
+          const output = execSync("tasklist | findstr nginx", {
+            stdio: "pipe",
+            encoding: "utf-8",
+          });
+          console.log(chalk.green("✓ nginx 正在运行"));
+          console.log();
+          console.log(output);
+        } catch {
+          console.log(chalk.yellow("⚠ nginx 未运行"));
+        }
+        return;
+      }
+      try {
+        const psCmd = this.findPowerShellCmd();
+        execSync(`${psCmd} -ExecutionPolicy Bypass -File "${statusScript}"`, {
+          stdio: "inherit",
+        });
+      } catch {
+        // 脚本内部处理错误
+      }
+      return;
+    }
+
+    // 默认显示帮助信息
+    console.log(chalk.blue("\n工作空间 Nginx 管理"));
+    console.log(chalk.gray(`  工作空间: ${this.baseDir}`));
+    console.log(chalk.gray(`  配置目录: ${config.nginx.configDir}`));
+
+    // 显示当前端口配置
+    if (config.nginx.servePort) {
+      console.log(chalk.gray(`  服务端口: ${config.nginx.servePort}`));
+      console.log();
+      console.log(chalk.blue("  访问地址:"));
+      console.log(chalk.cyan(`    http://localhost:${config.nginx.servePort}`));
+    }
+    console.log();
+
+    console.log(chalk.blue("可用命令："));
+    console.log(chalk.gray("  wsc nginx start    # 启动"));
+    console.log(chalk.gray("  wsc nginx stop     # 停止"));
+    console.log(chalk.gray("  wsc nginx reload   # 重载配置"));
+    console.log(chalk.gray("  wsc nginx status   # 查看状态"));
+    console.log();
+
+    // 显示配置列表
+    if (config.nginx.configs?.length > 0) {
+      console.log(chalk.blue("可用配置："));
+      for (const conf of config.nginx.configs) {
+        console.log(
+          chalk.gray(
+            `  • ${conf.name}${conf.port ? ` (端口: ${conf.port})` : ""}`,
+          ),
+        );
+      }
+      console.log();
+    }
+  }
+}
+
+module.exports = WorkspaceManager;