# Oh My OpenCode Windows 部署问题分析

## 问题描述

在某些 Windows 系统下，oh-my-opencode 插件未能正确部署，但后续手工部署却可以成功。有些环境能够成功，问题间歇性出现。

## 代码分析

### 当前的安装逻辑

```javascript
async installOhMyOpenCode() {
  this.log('开始安装 Oh My OpenCode...', 'info');

  try {
    // 检查 Bun 是否可用
    if (!this.commandExists('bun')) {
      throw new Error('Bun 未安装，无法安装 Oh My OpenCode');
    }

    this.log('执行: bunx oh-my-opencode install --no-tui --claude=no --chatgpt=no --gemini=no', 'info');
    execSync('bunx oh-my-opencode install --no-tui --claude=no --chatgpt=no --gemini=no', {
      stdio: this.options.silent ? 'pipe' : 'inherit',
      timeout: 300000
    });

    this.log('Oh My OpenCode 安装成功', 'success');
    return true;
  } catch (error) {
    this.log(`Oh My OpenCode 安装失败: ${error.message}`, 'error');
    throw error;
  }
}
```

### 安装顺序

1. Git → 2. OpenCode → 3. Bun → 4. Oh My OpenCode

## 可能的原因分析

### 1. 🔴 **PATH 环境变量未刷新**（最可能）

**问题：**
```javascript
// 刚安装完 Bun
await this.installBun();  // npm install -g bun

// 立即使用 bunx
execSync('bunx oh-my-opencode install ...');  // ❌ bunx 可能找不到
```

**原因：**
- Bun 通过 npm 全局安装
- npm 将 Bun 安装到全局目录（如 `C:\Users\XXX\AppData\Roaming\npm`）
- 当前 Node.js 进程的 `process.env.PATH` **不会自动更新**
- `execSync()` 使用当前进程的 PATH
- 如果 PATH 中没有 Bun 的路径，`bunx` 命令会失败

**验证方法：**
```javascript
console.log('PATH:', process.env.PATH);
console.log('which bun:', which.sync('bun', { nothrow: true }));
```

**为什么手工可以成功：**
- 手工在新终端中运行
- 新终端继承了更新后的 PATH 环境变量
- 所以 `bunx` 能找到

### 2. 🟡 **OpenCode 依赖问题**

**问题：**
```javascript
// Oh My OpenCode 可能需要 OpenCode
// 但如果 OpenCode 安装失败或跳过，Oh My OpenCode 也会失败
```

**场景：**
- Windows ARM64：OpenCode 被跳过
- OpenCode 安装失败但没抛出异常（返回 false）
- Oh My OpenCode 尝试使用 OpenCode 但找不到

**验证方法：**
检查 `opencode` 命令是否可用：
```javascript
if (!this.commandExists('opencode')) {
  this.log('警告: OpenCode 未安装，Oh My OpenCode 可能无法正常工作', 'warning');
}
```

### 3. 🟡 **Windows 命令执行环境问题**

**问题：**
```javascript
execSync('bunx oh-my-opencode install ...', {
  stdio: this.options.silent ? 'pipe' : 'inherit',
});
```

**原因：**
- Windows 上 `execSync` 默认使用 `cmd.exe`
- `bunx` 是一个 shell 脚本（Unix）或批处理文件（Windows）
- 在某些环境下，`bunx` 可能：
  - 在 PowerShell 中不工作
  - 在 CMD 中有路径问题
  - 需要 Git Bash 环境

**验证方法：**
尝试不同的 shell：
```javascript
// 使用 PowerShell
execSync('powershell.exe -Command "bunx oh-my-opencode install ..."');

// 使用 Git Bash
execSync('"C:\\Program Files\\Git\\bin\\bash.exe" -c "bunx oh-my-opencode install ..."');

// 直接使用 npx
execSync('npx --bun oh-my-opencode install ...');
```

### 4. 🟡 **Bun 安装验证不准确**

**问题：**
```javascript
// 检查 Bun 是否可用
if (!this.commandExists('bun')) {
  throw new Error('Bun 未安装，无法安装 Oh My OpenCode');
}
```

**问题：**
- `commandExists` 使用 `which.sync('bun')`
- 这只检查 `bun` 命令是否存在
- **不检查 `bunx` 命令是否存在**
- Bun 安装时，`bunx` 可能与 `bun` 在不同的位置

**验证方法：**
```javascript
console.log('bun path:', which.sync('bun'));
console.log('bunx path:', which.sync('bunx', { nothrow: true }));
```

### 5. 🟢 **权限问题**

**场景：**
- npm 全局目录权限不足
- 用户目录权限不足
- Oh My OpenCode 需要写入配置文件

**症状：**
- 错误信息包含 `EACCES`、`EPERM` 等

### 6. 🟢 **网络问题**

**场景：**
- Oh My OpenCode 需要下载资源
- 某些网络环境可能失败
- 防火墙或代理问题

### 7. 🟢 **时序问题**

**问题：**
- Bun 刚安装完，文件系统可能还没完全更新
- 特别是在 Windows 上，文件系统缓存可能导致延迟

**验证方法：**
添加短暂延迟：
```javascript
await this.installBun();
// 等待文件系统更新
await new Promise(resolve => setTimeout(resolve, 1000));
await this.installOhMyOpenCode();
```

## 为什么手工可以成功？

1. **新终端会话**：
   - 手工在新终端运行
   - 新终端有完整的 PATH 环境变量
   - 包括 Bun 的路径

2. **环境变量已刷新**：
   - 系统环境变量已更新
   - 终端重新加载了配置

3. **文件系统已稳定**：
   - Bun 安装已完成
   - 文件系统缓存已刷新

4. **用户有权限**：
   - 交互式安装可能有更高权限
   - 或者用户手动确认了权限提示

## 诊断工具

创建诊断脚本来检查所有可能的问题：

```javascript
async diagnoseOhMyOpenCode() {
  console.log('='.repeat(70));
  console.log('Oh My OpenCode 环境诊断');
  console.log('='.repeat(70));

  // 1. 检查 OpenCode
  console.log('\n【1. OpenCode 检查】');
  const opencodeExists = this.commandExists('opencode');
  console.log(`OpenCode 命令: ${opencodeExists ? '✅ 可用' : '❌ 不可用'}`);
  if (opencodeExists) {
    try {
      const version = execSync('opencode --version', { encoding: 'utf-8' });
      console.log(`OpenCode 版本: ${version.trim()}`);
    } catch (error) {
      console.log('⚠️  OpenCode 命令存在但无法获取版本');
    }
  }

  // 2. 检查 Bun
  console.log('\n【2. Bun 检查】');
  const bunExists = this.commandExists('bun');
  console.log(`Bun 命令: ${bunExists ? '✅ 可用' : '❌ 不可用'}`);

  let bunxExists = false;
  try {
    const bunxPath = which.sync('bunx');
    bunxExists = true;
    console.log(`✅ bunx 命令: ${bunxPath}`);
  } catch (error) {
    console.log('❌ bunx 命令: 不可用');
  }

  if (bunExists) {
    try {
      const version = execSync('bun --version', { encoding: 'utf-8' });
      console.log(`Bun 版本: ${version.trim()}`);
    } catch (error) {
      console.log('⚠️  Bun 命令存在但无法获取版本');
    }
  }

  // 3. 检查 PATH
  console.log('\n【3. PATH 环境变量】');
  const pathDirs = process.env.PATH.split(path.delimiter);
  const npmGlobalPath = path.join(process.env.APPDATA || '', 'npm');
  const hasNpmGlobalInPath = pathDirs.some(p => p.includes('npm') || p.includes(npmGlobalPath));
  console.log(`PATH 包含 npm 全局路径: ${hasNpmGlobalInPath ? '✅ 是' : '❌ 否'}`);

  // 4. 检查 Shell
  console.log('\n【4. Shell 环境】');
  console.log(`当前平台: ${os.platform()}`);
  console.log(`默认 shell: ${process.env.comspec || 'cmd.exe'}`);
  const gitBashPath = this.findGitBashPath();
  console.log(`Git Bash: ${gitBashPath || '未找到'}`);

  // 5. 检查权限
  console.log('\n【5. 权限检查】');
  const homeDir = os.homedir();
  try {
    fs.accessSync(homeDir, fs.constants.W_OK);
    console.log(`✅ 用户目录可写: ${homeDir}`);
  } catch (error) {
    console.log(`❌ 用户目录不可写: ${homeDir}`);
  }

  // 6. 总结
  console.log('\n【6. 诊断总结】');
  const issues = [];

  if (!opencodeExists) {
    issues.push('OpenCode 未安装');
  }
  if (!bunExists) {
    issues.push('Bun 未安装');
  }
  if (!bunxExists) {
    issues.push('bunx 命令不可用（PATH 问题）');
  }
  if (!hasNpmGlobalInPath) {
    issues.push('PATH 中缺少 npm 全局路径');
  }

  if (issues.length === 0) {
    console.log('✅ 所有检查通过，环境正常');
    return true;
  } else {
    console.log('⚠️  发现以下问题：');
    issues.forEach(issue => console.log(`  - ${issue}`));
    return false;
  }
}
```

## 解决方案

### 方案 1：刷新 PATH（推荐）

在安装 Bun 后刷新当前进程的 PATH：

```javascript
async installBun() {
  // ... 安装 Bun ...

  // 刷新当前进程的 PATH
  const npmGlobalPath = path.join(process.env.APPDATA || '', 'npm');
  if (!process.env.PATH.includes(npmGlobalPath)) {
    process.env.PATH = `${npmGlobalPath};${process.env.PATH}`;
    this.log('已刷新 PATH 环境变量', 'info');
  }

  return true;
}
```

### 方案 2：使用完整路径

直接使用 Bun 的完整路径：

```javascript
async installOhMyOpenCode() {
  try {
    // 获取 Bun 的完整路径
    const bunPath = which.sync('bun');
    const bunDir = path.dirname(bunPath);
    const bunxPath = path.join(bunDir, 'bunx');

    // 使用完整路径执行
    execSync(`"${bunxPath}" oh-my-opencode install --no-tui --claude=no --chatgpt=no --gemini=no`, {
      stdio: this.options.silent ? 'pipe' : 'inherit',
      timeout: 300000
    });

    return true;
  } catch (error) {
    // 处理错误
  }
}
```

### 方案 3：使用 npx 替代 bunx

```javascript
execSync('npx --bun oh-my-opencode install --no-tui --claude=no --chatgpt=no --gemini=no', {
  stdio: this.options.silent ? 'pipe' : 'inherit',
  timeout: 300000
});
```

### 方案 4：添加重试机制

```javascript
async installOhMyOpenCode(retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      // 尝试安装
      execSync('bunx oh-my-opencode install --no-tui --claude=no --chatgpt=no --gemini=no', {
        stdio: this.options.silent ? 'pipe' : 'inherit',
        timeout: 300000
      });
      return true;
    } catch (error) {
      if (i < retries - 1) {
        this.log(`安装失败，${2 ** i} 秒后重试...`, 'warning');
        await new Promise(resolve => setTimeout(resolve, 1000 * (2 ** i)));
      } else {
        throw error;
      }
    }
  }
}
```

### 方案 5：检查 OpenCode 依赖

```javascript
async installOhMyOpenCode() {
  // 检查 OpenCode
  if (!this.commandExists('opencode')) {
    this.log('警告: OpenCode 未安装，Oh My OpenCode 可能无法正常工作', 'warning');
    this.log('是否继续？(推荐先安装 OpenCode)', 'info');

    // 仍然尝试安装，但给出警告
    // 或者跳过安装
  }

  // ... 继续安装
}
```

### 方案 6：添加详细日志

```javascript
async installOhMyOpenCode() {
  this.log('开始安装 Oh My OpenCode...', 'info');

  // 详细的环境检查
  this.log('检查环境...', 'info');
  this.log(`  OpenCode: ${this.commandExists('opencode') ? '✅' : '❌'}`, 'info');
  this.log(`  Bun: ${this.commandExists('bun') ? '✅' : '❌'}`, 'info');

  try {
    which.sync('bunx');
    this.log(`  bunx: ✅`, 'info');
  } catch (error) {
    this.log(`  bunx: ❌`, 'info');
    this.log('警告: bunx 命令不可用，可能由于 PATH 未更新', 'warning');
  }

  this.log(`  PATH: ${process.env.PATH}`, 'debug');

  // ... 继续安装
}
```

## 推荐的综合解决方案

结合以上方案，创建一个健壮的安装流程：

```javascript
async installOhMyOpenCode() {
  this.log('开始安装 Oh My OpenCode...', 'info');

  // 1. 检查依赖
  this.log('检查依赖...', 'info');

  if (!this.commandExists('bun')) {
    throw new Error('Bun 未安装，无法安装 Oh My OpenCode');
  }

  const opencodeExists = this.commandExists('opencode');
  if (!opencodeExists) {
    this.log('⚠️  OpenCode 未安装，Oh My OpenCode 可能无法正常工作', 'warning');
  }

  // 2. 检查 bunx
  let bunxPath = 'bunx';
  try {
    bunxPath = which.sync('bunx');
    this.log(`✅ bunx 可用: ${bunxPath}`, 'info');
  } catch (error) {
    this.log('⚠️  bunx 命令不可用，尝试刷新 PATH...', 'warning');

    // 刷新 PATH
    const npmGlobalPath = path.join(process.env.APPDATA || '', 'npm');
    process.env.PATH = `${npmGlobalPath};${process.env.PATH}`;

    // 再次检查
    try {
      bunxPath = which.sync('bunx');
      this.log(`✅ bunx 现在可用: ${bunxPath}`, 'success');
    } catch (error2) {
      // 使用 npx 作为后备
      this.log('使用 npx 作为后备方案', 'info');
      bunxPath = 'npx --bun';
    }
  }

  // 3. 尝试安装（带重试）
  const maxRetries = 3;
  for (let i = 0; i < maxRetries; i++) {
    try {
      this.log(`尝试安装 Oh My OpenCode (尝试 ${i + 1}/${maxRetries})...`, 'info');

      const command = `"${bunxPath}" oh-my-opencode install --no-tui --claude=no --chatgpt=no --gemini=no`;

      execSync(command, {
        stdio: this.options.silent ? 'pipe' : 'inherit',
        timeout: 300000,
        env: {
          ...process.env,
          PATH: process.env.PATH // 确保使用更新后的 PATH
        }
      });

      this.log('Oh My OpenCode 安装成功', 'success');
      return true;

    } catch (error) {
      this.log(`安装失败: ${error.message}`, 'error');

      if (i < maxRetries - 1) {
        const delay = 1000 * (2 ** i); // 1s, 2s, 4s
        this.log(`${delay / 1000} 秒后重试...`, 'info');
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        // 最后一次尝试也失败了
        this.log('', 'info');
        this.log('Oh My OpenCode 自动安装失败', 'error');
        this.log('', 'info');
        this.log('可能的解决方案：', 'info');
        this.log('  1. 重启终端后手动运行:', 'info');
        this.log('     bunx oh-my-opencode install --no-tui --claude=no --chatgpt=no --gemini=no', 'info');
        if (!opencodeExists) {
          this.log('  2. 先安装 OpenCode，然后重试', 'info');
        }
        this.log('  3. 检查网络连接和防火墙设置', 'info');
        this.log('', 'info');

        throw new Error(`Oh My OpenCode 安装失败: ${error.message}`);
      }
    }
  }
}
```

## 测试建议

创建测试脚本模拟不同场景：

```javascript
// 测试 PATH 问题
// 测试 bunx 不可用
// 测试 OpenCode 缺失
// 测试网络问题
```

## 总结

最可能的原因是 **PATH 环境变量未刷新**，导致刚安装的 Bun 和 bunx 命令在当前进程中不可用。手工部署成功是因为新终端有完整的环境变量。

推荐的解决方案是：
1. ✅ 刷新 PATH 环境变量
2. ✅ 使用完整路径或 npx 后备方案
3. ✅ 添加重试机制
4. ✅ 提供清晰的错误信息和手工安装指导
5. ✅ 检查 OpenCode 依赖