Ethanfly
9614a3d234
- Add GoManager service for downloading and managing Go versions - Implement Go version detection and installation - Add GoManager Vue component with version selection UI - Update main process to handle Go-related IPC calls - Add Jest testing configuration and GoManager unit tests - Update service store to include Go management - Add routing for Go manager page - Include Kiro specs and steering documentation
2048 lines
67 KiB
TypeScript
2048 lines
67 KiB
TypeScript
import { ConfigStore } from './ConfigStore'
|
||
import { exec } from 'child_process'
|
||
import { promisify } from 'util'
|
||
import { existsSync, mkdirSync, readdirSync, rmSync, readFileSync, writeFileSync, unlinkSync, statSync } from 'fs'
|
||
import { join } from 'path'
|
||
import https from 'https'
|
||
import http from 'http'
|
||
import { createWriteStream, createReadStream } from 'fs'
|
||
import { sendDownloadProgress } from '../main'
|
||
import { createHash } from 'crypto'
|
||
|
||
// Import unzipper with any type to avoid type issues
|
||
const unzipper = require('unzipper')
|
||
|
||
const execAsync = promisify(exec)
|
||
|
||
// ==================== 错误处理系统 ====================
|
||
|
||
/**
|
||
* Go 管理器错误类型枚举
|
||
*/
|
||
enum GoErrorType {
|
||
NETWORK_ERROR = 'NETWORK_ERROR',
|
||
DISK_SPACE_ERROR = 'DISK_SPACE_ERROR',
|
||
PERMISSION_ERROR = 'PERMISSION_ERROR',
|
||
VALIDATION_ERROR = 'VALIDATION_ERROR',
|
||
FILE_SYSTEM_ERROR = 'FILE_SYSTEM_ERROR',
|
||
ENVIRONMENT_ERROR = 'ENVIRONMENT_ERROR',
|
||
DOWNLOAD_ERROR = 'DOWNLOAD_ERROR',
|
||
INSTALLATION_ERROR = 'INSTALLATION_ERROR',
|
||
UNINSTALL_ERROR = 'UNINSTALL_ERROR',
|
||
CONFIGURATION_ERROR = 'CONFIGURATION_ERROR'
|
||
}
|
||
|
||
/**
|
||
* Go 管理器自定义错误类
|
||
* 提供结构化的错误信息和解决建议
|
||
*/
|
||
class GoManagerError extends Error {
|
||
public readonly type: GoErrorType
|
||
public readonly suggestion: string
|
||
public readonly retryable: boolean
|
||
public readonly details?: any
|
||
|
||
constructor(
|
||
type: GoErrorType,
|
||
message: string,
|
||
suggestion: string,
|
||
retryable: boolean = false,
|
||
details?: any
|
||
) {
|
||
super(message)
|
||
this.name = 'GoManagerError'
|
||
this.type = type
|
||
this.suggestion = suggestion
|
||
this.retryable = retryable
|
||
this.details = details
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 操作结果接口
|
||
* 统一的操作结果格式，包含成功状态、消息和详细信息
|
||
*/
|
||
interface OperationResult {
|
||
success: boolean
|
||
message: string
|
||
suggestion?: string
|
||
retryable?: boolean
|
||
details?: any
|
||
}
|
||
|
||
/**
|
||
* 系统资源检查结果
|
||
*/
|
||
interface SystemResourceCheck {
|
||
hasPermission: boolean
|
||
hasDiskSpace: boolean
|
||
availableSpace: number
|
||
requiredSpace: number
|
||
permissionDetails?: string
|
||
}
|
||
|
||
/**
|
||
* 网络连接检查结果
|
||
*/
|
||
interface NetworkCheck {
|
||
isConnected: boolean
|
||
canReachGolang: boolean
|
||
responseTime?: number
|
||
error?: string
|
||
}
|
||
|
||
interface GoVersion {
|
||
version: string // 版本号，如 "1.21.5"
|
||
path: string // 安装路径
|
||
isActive: boolean // 是否为当前活动版本
|
||
goroot: string // GOROOT 路径
|
||
gopath?: string // GOPATH 路径（可选）
|
||
installDate?: Date // 安装日期
|
||
size?: number // 安装大小（字节）
|
||
}
|
||
|
||
interface AvailableGoVersion {
|
||
version: string // 版本号
|
||
stable: boolean // 是否为稳定版本
|
||
downloadUrl: string // Windows 64位 ZIP 下载链接
|
||
size: number // 文件大小（字节）
|
||
sha256: string // SHA256 校验和
|
||
releaseDate?: string // 发布日期
|
||
}
|
||
|
||
interface GoInfo {
|
||
version: string // Go 版本
|
||
goroot: string // GOROOT 路径
|
||
gopath: string // GOPATH 路径
|
||
goversion: string // go version 命令输出
|
||
goos: string // 目标操作系统
|
||
goarch: string // 目标架构
|
||
}
|
||
|
||
interface GoRelease {
|
||
version: string
|
||
stable: boolean
|
||
files: GoFile[]
|
||
}
|
||
|
||
interface GoFile {
|
||
filename: string
|
||
os: string
|
||
arch: string
|
||
version: string
|
||
sha256: string
|
||
size: number
|
||
kind: 'archive' | 'installer' | 'source'
|
||
}
|
||
|
||
interface DownloadOptions {
|
||
url: string
|
||
dest: string
|
||
name: string
|
||
expectedSha256?: string
|
||
maxRetries?: number
|
||
timeout?: number
|
||
}
|
||
|
||
interface DownloadProgress {
|
||
percent: number
|
||
downloadedBytes: number
|
||
totalBytes: number
|
||
speed?: number
|
||
}
|
||
|
||
interface DownloadResult {
|
||
success: boolean
|
||
message: string
|
||
suggestion?: string
|
||
retryable?: boolean
|
||
details?: any
|
||
filePath?: string
|
||
}
|
||
|
||
export class GoManager {
|
||
private configStore: ConfigStore
|
||
private versionsCache: AvailableGoVersion[] = []
|
||
private cacheTime: number = 0
|
||
private readonly CACHE_DURATION = 5 * 60 * 1000 // 5 分钟缓存
|
||
|
||
constructor(configStore: ConfigStore) {
|
||
this.configStore = configStore
|
||
}
|
||
|
||
// ==================== 综合错误处理系统 ====================
|
||
|
||
/**
|
||
* 检查系统资源（磁盘空间和权限）
|
||
* Requirements: 8.2, 8.3
|
||
*/
|
||
private async checkSystemResources(requiredSpaceBytes: number = 500 * 1024 * 1024): Promise<SystemResourceCheck> {
|
||
const result: SystemResourceCheck = {
|
||
hasPermission: false,
|
||
hasDiskSpace: false,
|
||
availableSpace: 0,
|
||
requiredSpace: requiredSpaceBytes
|
||
}
|
||
|
||
try {
|
||
// 检查磁盘空间
|
||
const goBasePath = this.getGoBasePath()
|
||
const drive = goBasePath.split(':')[0] + ':'
|
||
|
||
try {
|
||
const { stdout } = await execAsync(`powershell "Get-WmiObject -Class Win32_LogicalDisk -Filter \\"DeviceID='${drive}'\\" | Select-Object FreeSpace"`, { timeout: 10000 })
|
||
const freeSpaceMatch = stdout.match(/(\d+)/)
|
||
if (freeSpaceMatch) {
|
||
result.availableSpace = parseInt(freeSpaceMatch[1], 10)
|
||
result.hasDiskSpace = result.availableSpace >= requiredSpaceBytes
|
||
}
|
||
} catch (error) {
|
||
console.warn('磁盘空间检查失败，使用默认值')
|
||
result.availableSpace = requiredSpaceBytes // 假设有足够空间
|
||
result.hasDiskSpace = true
|
||
}
|
||
|
||
// 检查写入权限
|
||
try {
|
||
const testDir = join(goBasePath, 'permission_test')
|
||
if (!existsSync(goBasePath)) {
|
||
mkdirSync(goBasePath, { recursive: true })
|
||
}
|
||
mkdirSync(testDir, { recursive: true })
|
||
rmSync(testDir, { recursive: true, force: true })
|
||
result.hasPermission = true
|
||
} catch (error: any) {
|
||
result.hasPermission = false
|
||
result.permissionDetails = error.message
|
||
}
|
||
|
||
} catch (error: any) {
|
||
console.error('系统资源检查失败:', error)
|
||
result.permissionDetails = error.message
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* 检查网络连接
|
||
* Requirements: 8.1
|
||
*/
|
||
private async checkNetworkConnection(): Promise<NetworkCheck> {
|
||
const result: NetworkCheck = {
|
||
isConnected: false,
|
||
canReachGolang: false
|
||
}
|
||
|
||
try {
|
||
// 检查基本网络连接
|
||
const startTime = Date.now()
|
||
await new Promise<void>((resolve, reject) => {
|
||
const req = https.get('https://golang.org', { timeout: 10000 }, (res) => {
|
||
result.isConnected = true
|
||
result.canReachGolang = res.statusCode === 200 || res.statusCode === 301 || res.statusCode === 302
|
||
result.responseTime = Date.now() - startTime
|
||
resolve()
|
||
})
|
||
|
||
req.on('error', (error) => {
|
||
result.error = error.message
|
||
reject(error)
|
||
})
|
||
|
||
req.on('timeout', () => {
|
||
req.destroy()
|
||
result.error = '连接超时'
|
||
reject(new Error('连接超时'))
|
||
})
|
||
})
|
||
} catch (error: any) {
|
||
result.error = error.message
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* 创建结构化的错误结果
|
||
* Requirements: 8.5
|
||
*/
|
||
private createErrorResult(error: GoManagerError | Error, operation: string): OperationResult {
|
||
if (error instanceof GoManagerError) {
|
||
return {
|
||
success: false,
|
||
message: `${operation}失败: ${error.message}`,
|
||
suggestion: error.suggestion,
|
||
retryable: error.retryable,
|
||
details: error.details
|
||
}
|
||
}
|
||
|
||
// 处理普通错误，提供通用建议
|
||
let suggestion = '请检查网络连接和系统权限，然后重试'
|
||
let retryable = true
|
||
|
||
// 根据错误消息提供具体建议
|
||
const errorMessage = error.message.toLowerCase()
|
||
if (errorMessage.includes('network') || errorMessage.includes('timeout') || errorMessage.includes('连接')) {
|
||
suggestion = '网络连接失败，请检查网络设置并重试。如果问题持续，请尝试使用VPN或更换网络环境'
|
||
retryable = true
|
||
} else if (errorMessage.includes('permission') || errorMessage.includes('access') || errorMessage.includes('权限')) {
|
||
suggestion = '权限不足，请以管理员身份运行程序，或检查目标目录的写入权限'
|
||
retryable = false
|
||
} else if (errorMessage.includes('space') || errorMessage.includes('disk') || errorMessage.includes('磁盘')) {
|
||
suggestion = '磁盘空间不足，请清理磁盘空间后重试。建议至少保留500MB可用空间'
|
||
retryable = false
|
||
} else if (errorMessage.includes('sha256') || errorMessage.includes('checksum') || errorMessage.includes('校验')) {
|
||
suggestion = '文件校验失败，可能是下载过程中文件损坏。请删除临时文件并重新下载'
|
||
retryable = true
|
||
}
|
||
|
||
return {
|
||
success: false,
|
||
message: `${operation}失败: ${error.message}`,
|
||
suggestion,
|
||
retryable
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 创建成功结果
|
||
* Requirements: 8.4
|
||
*/
|
||
private createSuccessResult(message: string, details?: any): OperationResult {
|
||
return {
|
||
success: true,
|
||
message,
|
||
details
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理网络错误并提供重试选项
|
||
* Requirements: 8.1
|
||
*/
|
||
private async handleNetworkError(operation: () => Promise<any>, maxRetries: number = 3): Promise<any> {
|
||
let lastError: Error | null = null
|
||
|
||
for (let attempt = 1; attempt <= maxRetries; attempt++) {
|
||
try {
|
||
// 在重试前检查网络连接
|
||
if (attempt > 1) {
|
||
console.log(`第 ${attempt} 次尝试前检查网络连接...`)
|
||
const networkCheck = await this.checkNetworkConnection()
|
||
if (!networkCheck.isConnected) {
|
||
throw new GoManagerError(
|
||
GoErrorType.NETWORK_ERROR,
|
||
'网络连接不可用',
|
||
'请检查网络连接后重试。确保可以访问 golang.org',
|
||
true,
|
||
{ networkCheck }
|
||
)
|
||
}
|
||
}
|
||
|
||
return await operation()
|
||
} catch (error: any) {
|
||
lastError = error
|
||
console.error(`尝试 ${attempt}/${maxRetries} 失败:`, error.message)
|
||
|
||
if (attempt < maxRetries) {
|
||
// 指数退避重试
|
||
const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000)
|
||
console.log(`等待 ${delay}ms 后重试...`)
|
||
await new Promise(resolve => setTimeout(resolve, delay))
|
||
}
|
||
}
|
||
}
|
||
|
||
// 所有重试都失败了
|
||
throw new GoManagerError(
|
||
GoErrorType.NETWORK_ERROR,
|
||
`网络操作失败（已重试 ${maxRetries} 次）: ${lastError?.message || '未知错误'}`,
|
||
'请检查网络连接，确保可以访问 golang.org。如果问题持续，请尝试使用VPN或联系网络管理员',
|
||
true,
|
||
{ attempts: maxRetries, lastError: lastError?.message }
|
||
)
|
||
}
|
||
|
||
/**
|
||
* 验证系统环境并抛出具体错误
|
||
* Requirements: 8.2, 8.3
|
||
*/
|
||
private async validateSystemEnvironment(requiredSpaceBytes: number = 500 * 1024 * 1024): Promise<void> {
|
||
const resourceCheck = await this.checkSystemResources(requiredSpaceBytes)
|
||
|
||
if (!resourceCheck.hasDiskSpace) {
|
||
const availableMB = Math.round(resourceCheck.availableSpace / (1024 * 1024))
|
||
const requiredMB = Math.round(requiredSpaceBytes / (1024 * 1024))
|
||
|
||
throw new GoManagerError(
|
||
GoErrorType.DISK_SPACE_ERROR,
|
||
`磁盘空间不足，可用空间 ${availableMB}MB，需要 ${requiredMB}MB`,
|
||
`请清理磁盘空间，至少需要 ${requiredMB}MB 可用空间。建议清理临时文件、回收站或卸载不需要的程序`,
|
||
false,
|
||
{ availableSpace: resourceCheck.availableSpace, requiredSpace: requiredSpaceBytes }
|
||
)
|
||
}
|
||
|
||
if (!resourceCheck.hasPermission) {
|
||
throw new GoManagerError(
|
||
GoErrorType.PERMISSION_ERROR,
|
||
'权限不足，无法写入目标目录',
|
||
'请以管理员身份运行程序，或确保当前用户对安装目录有写入权限。您也可以尝试更改安装目录到用户文件夹',
|
||
false,
|
||
{ permissionDetails: resourceCheck.permissionDetails }
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取 Go 基础安装路径
|
||
*/
|
||
getGoBasePath(): string {
|
||
return join(this.configStore.getBasePath(), 'go')
|
||
}
|
||
|
||
/**
|
||
* 获取指定版本的 Go 路径
|
||
*/
|
||
getGoPath(version: string): string {
|
||
return join(this.getGoBasePath(), `go-${version}`)
|
||
}
|
||
|
||
/**
|
||
* 获取默认 GOPATH 工作空间路径
|
||
*/
|
||
getDefaultGoPath(): string {
|
||
return join(this.getGoBasePath(), 'workspace')
|
||
}
|
||
|
||
/**
|
||
* 获取已安装的 Go 版本
|
||
*/
|
||
async getInstalledVersions(): Promise<GoVersion[]> {
|
||
const versions: GoVersion[] = []
|
||
const goBasePath = this.getGoBasePath()
|
||
|
||
if (!existsSync(goBasePath)) {
|
||
return versions
|
||
}
|
||
|
||
const dirs = readdirSync(goBasePath, { withFileTypes: true })
|
||
const activeVersion = this.configStore.get('activeGoVersion' as any) || ''
|
||
|
||
for (const dir of dirs) {
|
||
if (dir.isDirectory() && dir.name.startsWith('go-')) {
|
||
const versionDir = join(goBasePath, dir.name)
|
||
const goExe = join(versionDir, 'bin', 'go.exe')
|
||
const gofmtExe = join(versionDir, 'bin', 'gofmt.exe')
|
||
|
||
// 验证安装完整性
|
||
if (existsSync(goExe) && existsSync(gofmtExe)) {
|
||
const version = dir.name.replace('go-', '')
|
||
const goroot = versionDir
|
||
const gopath = this.getDefaultGoPath()
|
||
|
||
// 获取安装日期和大小信息
|
||
let installDate: Date | undefined
|
||
let size: number | undefined
|
||
|
||
try {
|
||
const stats = require('fs').statSync(versionDir)
|
||
installDate = stats.birthtime || stats.mtime
|
||
|
||
// 计算目录大小（简化版本，只统计主要文件）
|
||
const binDir = join(versionDir, 'bin')
|
||
if (existsSync(binDir)) {
|
||
const binFiles = readdirSync(binDir)
|
||
size = binFiles.reduce((total, file) => {
|
||
try {
|
||
const filePath = join(binDir, file)
|
||
const fileStats = require('fs').statSync(filePath)
|
||
return total + fileStats.size
|
||
} catch {
|
||
return total
|
||
}
|
||
}, 0)
|
||
}
|
||
} catch {
|
||
// 忽略统计错误
|
||
}
|
||
|
||
versions.push({
|
||
version,
|
||
path: versionDir,
|
||
isActive: version === activeVersion,
|
||
goroot,
|
||
gopath,
|
||
installDate,
|
||
size
|
||
})
|
||
}
|
||
}
|
||
}
|
||
|
||
// 按版本号排序（降序）
|
||
versions.sort((a, b) => {
|
||
const aParts = a.version.replace('go', '').split('.').map(Number)
|
||
const bParts = b.version.replace('go', '').split('.').map(Number)
|
||
for (let i = 0; i < 3; i++) {
|
||
if (aParts[i] !== bParts[i]) {
|
||
return bParts[i] - aParts[i]
|
||
}
|
||
}
|
||
return 0
|
||
})
|
||
|
||
return versions
|
||
}
|
||
|
||
/**
|
||
* 获取可用的 Go 版本列表
|
||
* 增强的错误处理，包含网络重试机制
|
||
* Requirements: 8.1
|
||
*/
|
||
async getAvailableVersions(): Promise<AvailableGoVersion[]> {
|
||
// 检查缓存
|
||
if (this.versionsCache.length > 0 && Date.now() - this.cacheTime < this.CACHE_DURATION) {
|
||
return this.versionsCache
|
||
}
|
||
|
||
try {
|
||
// 使用网络错误处理包装器
|
||
const versions = await this.handleNetworkError(async () => {
|
||
return await this.fetchGoVersions()
|
||
}, 3)
|
||
|
||
if (versions.length > 0) {
|
||
this.versionsCache = versions
|
||
this.cacheTime = Date.now()
|
||
return versions
|
||
}
|
||
} catch (error) {
|
||
console.error('获取 Go 版本列表失败:', error)
|
||
|
||
// 如果是网络错误，记录详细信息但不抛出异常
|
||
if (error instanceof GoManagerError && error.type === GoErrorType.NETWORK_ERROR) {
|
||
console.warn('使用备用版本列表，因为网络获取失败:', error.message)
|
||
}
|
||
}
|
||
|
||
// 返回硬编码的版本列表作为后备
|
||
console.log('使用备用版本列表')
|
||
return this.getFallbackVersions()
|
||
}
|
||
|
||
/**
|
||
* 从 golang.org API 获取版本列表
|
||
*/
|
||
private async fetchGoVersions(): Promise<AvailableGoVersion[]> {
|
||
return new Promise((resolve, reject) => {
|
||
const url = 'https://golang.org/dl/?mode=json'
|
||
|
||
https.get(url, {
|
||
headers: {
|
||
'User-Agent': 'PHPer-Dev-Manager/1.0'
|
||
},
|
||
timeout: 30000
|
||
}, (res) => {
|
||
if (res.statusCode === 301 || res.statusCode === 302) {
|
||
const redirectUrl = res.headers.location
|
||
if (redirectUrl) {
|
||
https.get(redirectUrl, (redirectRes) => {
|
||
this.handleVersionResponse(redirectRes, resolve, reject)
|
||
}).on('error', reject)
|
||
return
|
||
}
|
||
}
|
||
this.handleVersionResponse(res, resolve, reject)
|
||
}).on('error', reject)
|
||
.on('timeout', () => reject(new Error('请求超时')))
|
||
})
|
||
}
|
||
|
||
private handleVersionResponse(res: http.IncomingMessage, resolve: (value: AvailableGoVersion[]) => void, reject: (reason?: any) => void) {
|
||
let data = ''
|
||
res.on('data', chunk => data += chunk)
|
||
res.on('end', () => {
|
||
try {
|
||
const releases: GoRelease[] = JSON.parse(data)
|
||
const availableVersions: AvailableGoVersion[] = []
|
||
|
||
for (const release of releases) {
|
||
if (release.stable) {
|
||
const windowsFile = release.files.find(f =>
|
||
f.os === 'windows' && f.arch === 'amd64' && f.kind === 'archive'
|
||
)
|
||
|
||
if (windowsFile) {
|
||
availableVersions.push({
|
||
version: release.version,
|
||
stable: release.stable,
|
||
downloadUrl: `https://golang.org/dl/${windowsFile.filename}`,
|
||
size: windowsFile.size,
|
||
sha256: windowsFile.sha256
|
||
})
|
||
}
|
||
}
|
||
}
|
||
|
||
// 只返回前 20 个版本
|
||
resolve(availableVersions.slice(0, 20))
|
||
} catch (e) {
|
||
reject(e)
|
||
}
|
||
})
|
||
res.on('error', reject)
|
||
}
|
||
|
||
/**
|
||
* 安装 Go 版本
|
||
* 包含完整的安装流程：下载、解压、验证、配置
|
||
* 增强的错误处理和用户反馈
|
||
* Requirements: 8.1, 8.2, 8.3, 8.4, 8.5
|
||
*/
|
||
async install(version: string, downloadUrl: string, expectedSha256?: string): Promise<OperationResult> {
|
||
try {
|
||
console.log(`开始安装 Go ${version}...`)
|
||
|
||
// 1. 系统环境验证（磁盘空间和权限检查）
|
||
console.log('检查系统环境...')
|
||
await this.validateSystemEnvironment(500 * 1024 * 1024) // 500MB 最小空间要求
|
||
|
||
const goBasePath = this.getGoBasePath()
|
||
const tempPath = this.configStore.getTempPath()
|
||
const zipPath = join(tempPath, `go-${version}.zip`)
|
||
const extractDir = join(goBasePath, `go-${version}`)
|
||
|
||
// 确保目录存在
|
||
if (!existsSync(goBasePath)) {
|
||
mkdirSync(goBasePath, { recursive: true })
|
||
}
|
||
if (!existsSync(tempPath)) {
|
||
mkdirSync(tempPath, { recursive: true })
|
||
}
|
||
|
||
// 2. 重复安装检测和防护
|
||
if (await this.isVersionInstalled(version)) {
|
||
return {
|
||
success: false,
|
||
message: `Go ${version} 已安装`,
|
||
suggestion: '如需重新安装，请先卸载现有版本',
|
||
retryable: false
|
||
}
|
||
}
|
||
|
||
console.log(`系统环境检查通过，开始安装 Go ${version}`)
|
||
|
||
try {
|
||
// 3. 下载（使用增强的下载管理器，包含网络重试和 SHA256 验证）
|
||
console.log(`正在下载 Go ${version}...`)
|
||
await this.downloadFile(downloadUrl, zipPath, `go-${version}`, expectedSha256)
|
||
|
||
// 4. ZIP 文件解压到目标目录
|
||
console.log(`正在解压 Go ${version}...`)
|
||
await this.extractGoArchive(zipPath, goBasePath, version)
|
||
|
||
// 5. 安装后验证和完整性检查
|
||
console.log(`正在验证 Go ${version} 安装...`)
|
||
const validationResult = await this.performInstallationValidation(version)
|
||
if (!validationResult.isValid) {
|
||
// 如果验证失败，清理安装目录
|
||
await this.cleanupFailedInstallation(extractDir)
|
||
throw new GoManagerError(
|
||
GoErrorType.VALIDATION_ERROR,
|
||
`安装验证失败: ${validationResult.error}`,
|
||
'安装文件可能损坏，请重新下载安装。如果问题持续，请检查网络连接或尝试其他版本',
|
||
true,
|
||
{ validationError: validationResult.error }
|
||
)
|
||
}
|
||
|
||
// 6. 更新配置
|
||
await this.updateInstallationConfig(version)
|
||
|
||
// 7. 如果是第一个版本，设为默认
|
||
const installedVersions = await this.getInstalledVersions()
|
||
let activationMessage = ''
|
||
if (installedVersions.length === 1) {
|
||
const activationResult = await this.setActive(version)
|
||
if (activationResult.success) {
|
||
activationMessage = '，并已设为默认版本'
|
||
}
|
||
}
|
||
|
||
// 8. 返回详细的成功信息
|
||
const installPath = this.getGoPath(version)
|
||
return this.createSuccessResult(
|
||
`Go ${version} 安装成功${activationMessage}`,
|
||
{
|
||
version,
|
||
installPath,
|
||
isActive: installedVersions.length === 1,
|
||
totalVersions: installedVersions.length,
|
||
nextSteps: installedVersions.length === 1
|
||
? ['Go 已设为默认版本，可以在新的命令行窗口中使用 go 命令']
|
||
: [`使用 "设为默认" 按钮来激活 Go ${version}`, '或继续安装其他版本']
|
||
}
|
||
)
|
||
|
||
} finally {
|
||
// 清理临时文件（无论成功还是失败）
|
||
await this.cleanupTempFiles(zipPath)
|
||
}
|
||
|
||
} catch (error: any) {
|
||
console.error(`Go ${version} 安装失败:`, error)
|
||
return this.createErrorResult(error, `Go ${version} 安装`)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 卸载 Go 版本
|
||
* 包含完整的文件系统清理、环境变量清理和配置状态更新
|
||
* 增强的错误处理和用户反馈
|
||
* Requirements: 2.2, 2.3, 2.4, 2.5, 8.3, 8.4, 8.5
|
||
*/
|
||
async uninstall(version: string): Promise<OperationResult> {
|
||
try {
|
||
console.log(`开始卸载 Go ${version}...`)
|
||
|
||
// 1. 权限检查
|
||
await this.validateSystemEnvironment(0) // 卸载不需要磁盘空间，但需要权限
|
||
|
||
const goBasePath = this.getGoBasePath()
|
||
const versionDir = join(goBasePath, `go-${version}`)
|
||
|
||
// 2. 检查版本是否存在
|
||
if (!existsSync(versionDir)) {
|
||
return {
|
||
success: false,
|
||
message: `Go ${version} 未安装`,
|
||
suggestion: '请检查版本号是否正确，或刷新版本列表',
|
||
retryable: false
|
||
}
|
||
}
|
||
|
||
// 3. 获取当前活动版本
|
||
const activeVersion = this.configStore.get('activeGoVersion' as any)
|
||
const isActiveVersion = activeVersion === version
|
||
|
||
console.log(`版本目录: ${versionDir}`)
|
||
console.log(`是否为活动版本: ${isActiveVersion}`)
|
||
|
||
// 4. 如果是当前活动版本，执行环境变量清理
|
||
if (isActiveVersion) {
|
||
console.log('清理活动版本的环境变量...')
|
||
try {
|
||
await this.cleanupActiveVersionEnvironment(version)
|
||
} catch (error: any) {
|
||
throw new GoManagerError(
|
||
GoErrorType.ENVIRONMENT_ERROR,
|
||
`环境变量清理失败: ${error.message}`,
|
||
'请手动清理环境变量，或以管理员身份重试。您可以在系统设置中手动删除 GOROOT 和 GOPATH 环境变量',
|
||
true,
|
||
{ environmentError: error.message }
|
||
)
|
||
}
|
||
}
|
||
|
||
// 5. 执行文件系统清理和目录删除
|
||
console.log('执行文件系统清理...')
|
||
try {
|
||
await this.performFileSystemCleanup(versionDir, version)
|
||
} catch (error: any) {
|
||
throw new GoManagerError(
|
||
GoErrorType.FILE_SYSTEM_ERROR,
|
||
`文件系统清理失败: ${error.message}`,
|
||
'可能有文件正在使用中。请关闭所有相关程序（如 IDE、终端）后重试，或重启计算机后再次尝试',
|
||
true,
|
||
{ fileSystemError: error.message }
|
||
)
|
||
}
|
||
|
||
// 6. 更新配置状态
|
||
console.log('更新配置状态...')
|
||
try {
|
||
await this.updateUninstallConfiguration(version, isActiveVersion)
|
||
} catch (error: any) {
|
||
// 配置更新失败不应该阻止卸载成功
|
||
console.warn('配置状态更新失败，但文件已删除:', error.message)
|
||
}
|
||
|
||
// 7. 检查剩余版本并提供建议
|
||
const remainingVersions = await this.getInstalledVersions()
|
||
let nextSteps: string[] = []
|
||
|
||
if (remainingVersions.length === 0) {
|
||
nextSteps.push('所有 Go 版本已卸载，环境变量已清理')
|
||
} else if (isActiveVersion && remainingVersions.length > 0) {
|
||
nextSteps.push(`还有 ${remainingVersions.length} 个版本可用`)
|
||
nextSteps.push('请选择一个版本设为默认，或安装新版本')
|
||
}
|
||
|
||
console.log(`Go ${version} 卸载完成`)
|
||
return this.createSuccessResult(
|
||
`Go ${version} 已成功卸载`,
|
||
{
|
||
version,
|
||
wasActive: isActiveVersion,
|
||
remainingVersions: remainingVersions.length,
|
||
nextSteps
|
||
}
|
||
)
|
||
|
||
} catch (error: any) {
|
||
console.error(`Go ${version} 卸载失败:`, error)
|
||
return this.createErrorResult(error, `Go ${version} 卸载`)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 清理活动版本的环境变量
|
||
* 移除 GOROOT、GOPATH 和 PATH 中的相关配置
|
||
* 增强的错误处理
|
||
* Requirements: 2.3, 8.3, 8.5
|
||
*/
|
||
private async cleanupActiveVersionEnvironment(version: string): Promise<void> {
|
||
try {
|
||
const versionDir = this.getGoPath(version)
|
||
|
||
console.log(`清理活动版本 ${version} 的环境变量`)
|
||
|
||
// 使用专门的环境变量清理脚本
|
||
const cleanupScript = this.generateActiveVersionCleanupScript()
|
||
await this.executePowerShellScript(cleanupScript)
|
||
|
||
console.log(`活动版本环境变量清理完成`)
|
||
|
||
} catch (error: any) {
|
||
console.error(`环境变量清理失败: ${error.message}`)
|
||
|
||
// 如果是 GoManagerError，直接重新抛出
|
||
if (error instanceof GoManagerError) {
|
||
throw error
|
||
}
|
||
|
||
// 否则包装为 GoManagerError
|
||
throw new GoManagerError(
|
||
GoErrorType.ENVIRONMENT_ERROR,
|
||
`环境变量清理失败: ${error.message}`,
|
||
'请以管理员身份运行程序，或在系统设置中手动清理 GOROOT、GOPATH 和 PATH 环境变量',
|
||
true,
|
||
{ version, originalError: error.message }
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 执行文件系统清理和目录删除
|
||
* 完全删除版本目录及其所有内容
|
||
* 增强的错误处理
|
||
* Requirements: 2.2, 8.5
|
||
*/
|
||
private async performFileSystemCleanup(versionDir: string, version: string): Promise<void> {
|
||
try {
|
||
console.log(`开始删除目录: ${versionDir}`)
|
||
|
||
// 检查目录是否存在
|
||
if (!existsSync(versionDir)) {
|
||
console.log(`目录不存在，跳过删除: ${versionDir}`)
|
||
return
|
||
}
|
||
|
||
// 获取目录信息用于日志记录
|
||
const dirStats = this.getDirectoryStats(versionDir)
|
||
console.log(`目录统计: ${dirStats.fileCount} 个文件, ${dirStats.dirCount} 个子目录`)
|
||
|
||
// 尝试删除目录（使用强制删除）
|
||
rmSync(versionDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 1000 })
|
||
|
||
// 验证删除是否成功
|
||
if (existsSync(versionDir)) {
|
||
throw new GoManagerError(
|
||
GoErrorType.FILE_SYSTEM_ERROR,
|
||
`目录删除失败，目录仍然存在: ${versionDir}`,
|
||
'可能有文件正在使用中。请关闭所有相关程序（如 IDE、终端、Go 进程）后重试，或重启计算机后再次尝试',
|
||
true,
|
||
{ versionDir, dirStats }
|
||
)
|
||
}
|
||
|
||
console.log(`目录删除成功: ${versionDir}`)
|
||
|
||
} catch (error: any) {
|
||
console.error(`文件系统清理失败: ${error.message}`)
|
||
|
||
// 如果是 GoManagerError，直接重新抛出
|
||
if (error instanceof GoManagerError) {
|
||
throw error
|
||
}
|
||
|
||
// 根据错误类型提供具体建议
|
||
let suggestion = '请关闭所有相关程序后重试，或重启计算机后再次尝试'
|
||
|
||
if (error.code === 'EBUSY' || error.code === 'ENOTEMPTY') {
|
||
suggestion = '文件正在使用中，请关闭所有 Go 相关程序（IDE、终端、Go 进程）后重试'
|
||
} else if (error.code === 'EACCES' || error.code === 'EPERM') {
|
||
suggestion = '权限不足，请以管理员身份运行程序'
|
||
} else if (error.code === 'ENOENT') {
|
||
suggestion = '目录不存在或已被删除'
|
||
return // 目录不存在就不需要删除了
|
||
}
|
||
|
||
throw new GoManagerError(
|
||
GoErrorType.FILE_SYSTEM_ERROR,
|
||
`文件系统清理失败: ${error.message}`,
|
||
suggestion,
|
||
true,
|
||
{ versionDir, errorCode: error.code, originalError: error.message }
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 更新卸载后的配置状态
|
||
* 从已安装版本列表中移除，清除活动版本配置
|
||
* 增强的错误处理
|
||
* Requirements: 2.4, 2.5, 8.5
|
||
*/
|
||
private async updateUninstallConfiguration(version: string, wasActiveVersion: boolean): Promise<void> {
|
||
try {
|
||
console.log(`更新配置状态: 移除版本 ${version}`)
|
||
|
||
// 从已安装版本列表中移除
|
||
const goVersions = this.configStore.get('goVersions' as any) || []
|
||
const index = goVersions.indexOf(version)
|
||
if (index > -1) {
|
||
goVersions.splice(index, 1)
|
||
this.configStore.set('goVersions' as any, goVersions)
|
||
console.log(`已从版本列表中移除: ${version}`)
|
||
} else {
|
||
console.log(`版本不在配置列表中: ${version}`)
|
||
}
|
||
|
||
// 如果卸载的是活动版本，清除活动版本配置
|
||
if (wasActiveVersion) {
|
||
this.configStore.set('activeGoVersion' as any, '')
|
||
console.log(`已清除活动版本配置`)
|
||
|
||
// 如果还有其他版本，可以提示用户选择新的活动版本
|
||
const remainingVersions = await this.getInstalledVersions()
|
||
if (remainingVersions.length > 0) {
|
||
console.log(`提示: 还有 ${remainingVersions.length} 个版本可用，可以设置新的活动版本`)
|
||
}
|
||
}
|
||
|
||
console.log(`配置状态更新完成`)
|
||
|
||
} catch (error: any) {
|
||
console.error(`配置状态更新失败: ${error.message}`)
|
||
|
||
throw new GoManagerError(
|
||
GoErrorType.CONFIGURATION_ERROR,
|
||
`配置状态更新失败: ${error.message}`,
|
||
'配置文件可能损坏或权限不足。请检查应用程序配置目录权限，或重新启动应用程序',
|
||
true,
|
||
{ version, wasActiveVersion, originalError: error.message }
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 生成活动版本清理的 PowerShell 脚本
|
||
* 清除 GOROOT、GOPATH 和 PATH 中的所有 Go 相关配置
|
||
*/
|
||
private generateActiveVersionCleanupScript(): string {
|
||
return `
|
||
# Go 活动版本环境变量清理脚本
|
||
Write-Host "开始清理 Go 活动版本环境变量..."
|
||
|
||
try {
|
||
# 获取当前用户 PATH
|
||
$userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
|
||
if ($userPath) {
|
||
Write-Host "当前 PATH: $userPath"
|
||
|
||
$pathArray = $userPath -split ';' | Where-Object { $_ -ne '' -and $_ -ne $null }
|
||
|
||
# 移除所有 Go 相关路径（更全面的清理）
|
||
$filteredPaths = $pathArray | Where-Object {
|
||
-not ($_ -like '*\\go\\go-*\\bin' -or
|
||
$_ -like '*\\go-*\\bin' -or
|
||
$_ -like '*\\golang\\*\\bin' -or
|
||
$_ -like '*\\Go\\*\\bin' -or
|
||
$_ -like '*\\go\\bin' -or
|
||
$_ -like '*\\golang\\bin')
|
||
}
|
||
|
||
$finalPath = ($filteredPaths | Where-Object { $_ -ne '' -and $_ -ne $null } | Select-Object -Unique) -join ';'
|
||
[Environment]::SetEnvironmentVariable('PATH', $finalPath, 'User')
|
||
Write-Host "已清理 PATH 中的所有 Go 路径"
|
||
}
|
||
|
||
# 清除 GOROOT
|
||
$currentGoRoot = [Environment]::GetEnvironmentVariable('GOROOT', 'User')
|
||
if ($currentGoRoot) {
|
||
[Environment]::SetEnvironmentVariable('GOROOT', $null, 'User')
|
||
Write-Host "已清除 GOROOT: $currentGoRoot"
|
||
}
|
||
|
||
# 清除 GOPATH
|
||
$currentGoPath = [Environment]::GetEnvironmentVariable('GOPATH', 'User')
|
||
if ($currentGoPath) {
|
||
[Environment]::SetEnvironmentVariable('GOPATH', $null, 'User')
|
||
Write-Host "已清除 GOPATH: $currentGoPath"
|
||
}
|
||
|
||
Write-Host "活动版本环境变量清理完成"
|
||
|
||
} catch {
|
||
Write-Error "活动版本环境变量清理失败: $_"
|
||
throw $_
|
||
}
|
||
`
|
||
}
|
||
|
||
/**
|
||
* 获取目录统计信息
|
||
* 用于日志记录和验证
|
||
*/
|
||
private getDirectoryStats(dirPath: string): { fileCount: number; dirCount: number; totalSize: number } {
|
||
let fileCount = 0
|
||
let dirCount = 0
|
||
let totalSize = 0
|
||
|
||
try {
|
||
const items = readdirSync(dirPath, { withFileTypes: true })
|
||
|
||
for (const item of items) {
|
||
const itemPath = join(dirPath, item.name)
|
||
|
||
if (item.isDirectory()) {
|
||
dirCount++
|
||
const subStats = this.getDirectoryStats(itemPath)
|
||
fileCount += subStats.fileCount
|
||
dirCount += subStats.dirCount
|
||
totalSize += subStats.totalSize
|
||
} else if (item.isFile()) {
|
||
fileCount++
|
||
try {
|
||
const stats = statSync(itemPath)
|
||
totalSize += stats.size
|
||
} catch {
|
||
// 忽略无法访问的文件
|
||
}
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.warn(`获取目录统计信息失败: ${dirPath}`, error)
|
||
}
|
||
|
||
return { fileCount, dirCount, totalSize }
|
||
}
|
||
|
||
/**
|
||
* 设置活动的 Go 版本
|
||
* 增强的错误处理和详细反馈
|
||
* Requirements: 8.3, 8.4, 8.5
|
||
*/
|
||
async setActive(version: string): Promise<OperationResult> {
|
||
try {
|
||
console.log(`设置 Go ${version} 为活动版本...`)
|
||
|
||
// 1. 权限检查
|
||
await this.validateSystemEnvironment(0) // 不需要磁盘空间，但需要权限
|
||
|
||
const goBasePath = this.getGoBasePath()
|
||
const versionDir = join(goBasePath, `go-${version}`)
|
||
|
||
// 2. 验证版本是否已安装
|
||
if (!existsSync(join(versionDir, 'bin', 'go.exe'))) {
|
||
return {
|
||
success: false,
|
||
message: `Go ${version} 未安装`,
|
||
suggestion: '请先安装此版本，然后再设为默认版本',
|
||
retryable: false
|
||
}
|
||
}
|
||
|
||
// 3. 更新环境变量
|
||
try {
|
||
await this.updateEnvironmentVariables(version)
|
||
} catch (error: any) {
|
||
throw new GoManagerError(
|
||
GoErrorType.ENVIRONMENT_ERROR,
|
||
`环境变量更新失败: ${error.message}`,
|
||
'请以管理员身份运行程序，或手动设置环境变量。您可以在系统设置中手动添加 GOROOT 和 PATH 配置',
|
||
true,
|
||
{ environmentError: error.message }
|
||
)
|
||
}
|
||
|
||
// 4. 更新配置
|
||
this.configStore.set('activeGoVersion' as any, version)
|
||
|
||
// 5. 验证设置是否生效
|
||
try {
|
||
const goInfo = await this.getGoInfo(version)
|
||
if (!goInfo) {
|
||
console.warn('无法验证 Go 版本设置，但配置已更新')
|
||
}
|
||
} catch (error) {
|
||
console.warn('Go 版本验证失败，但配置已更新:', error)
|
||
}
|
||
|
||
console.log(`Go ${version} 已设为活动版本`)
|
||
return this.createSuccessResult(
|
||
`已将 Go ${version} 设为默认版本`,
|
||
{
|
||
version,
|
||
goroot: this.getGoPath(version),
|
||
gopath: this.getDefaultGoPath(),
|
||
nextSteps: [
|
||
'请重新打开命令行窗口以使环境变量生效',
|
||
'使用 "go version" 命令验证版本是否正确'
|
||
]
|
||
}
|
||
)
|
||
} catch (error: any) {
|
||
console.error(`设置活动版本失败:`, error)
|
||
return this.createErrorResult(error, `设置 Go ${version} 为活动版本`)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 验证 Go 安装
|
||
*/
|
||
async validateInstallation(version: string): Promise<boolean> {
|
||
const goPath = this.getGoPath(version)
|
||
const goExe = join(goPath, 'bin', 'go.exe')
|
||
const gofmtExe = join(goPath, 'bin', 'gofmt.exe')
|
||
|
||
try {
|
||
// 检查核心可执行文件
|
||
if (!existsSync(goExe)) return false
|
||
if (!existsSync(gofmtExe)) return false
|
||
|
||
// 验证版本
|
||
const { stdout } = await execAsync(`"${goExe}" version`)
|
||
if (!stdout.includes(version)) return false
|
||
|
||
// 验证环境和基本命令
|
||
await execAsync(`"${goExe}" env GOROOT`)
|
||
|
||
// 验证 go mod 功能
|
||
await execAsync(`"${goExe}" help mod`)
|
||
|
||
return true
|
||
} catch {
|
||
return false
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取 Go 环境信息
|
||
*/
|
||
async getGoInfo(version: string): Promise<GoInfo | null> {
|
||
const goPath = this.getGoPath(version)
|
||
const goExe = join(goPath, 'bin', 'go.exe')
|
||
|
||
if (!existsSync(goExe)) {
|
||
return null
|
||
}
|
||
|
||
try {
|
||
const { stdout: goVersion } = await execAsync(`"${goExe}" version`, { timeout: 5000 })
|
||
const { stdout: goRoot } = await execAsync(`"${goExe}" env GOROOT`, { timeout: 5000 })
|
||
const { stdout: goOs } = await execAsync(`"${goExe}" env GOOS`, { timeout: 5000 })
|
||
const { stdout: goArch } = await execAsync(`"${goExe}" env GOARCH`, { timeout: 5000 })
|
||
|
||
return {
|
||
version,
|
||
goroot: goRoot.trim(),
|
||
gopath: this.getDefaultGoPath(),
|
||
goversion: goVersion.trim(),
|
||
goos: goOs.trim(),
|
||
goarch: goArch.trim()
|
||
}
|
||
} catch (error) {
|
||
return null
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检测系统已安装的 Go 版本
|
||
*/
|
||
async detectSystemGoVersion(): Promise<GoVersion | null> {
|
||
try {
|
||
// 尝试执行系统的 go 命令
|
||
const { stdout: goVersion } = await execAsync('go version', { timeout: 5000 })
|
||
const { stdout: goRoot } = await execAsync('go env GOROOT', { timeout: 5000 })
|
||
const { stdout: goPath } = await execAsync('go env GOPATH', { timeout: 5000 })
|
||
|
||
// 解析版本号
|
||
const versionMatch = goVersion.match(/go(\d+\.\d+\.\d+)/)
|
||
if (!versionMatch) return null
|
||
|
||
const version = versionMatch[1]
|
||
const systemGoRoot = goRoot.trim()
|
||
const systemGoPath = goPath.trim()
|
||
|
||
return {
|
||
version: `go${version}`,
|
||
path: systemGoRoot,
|
||
isActive: false, // 系统版本不算作我们管理的活动版本
|
||
goroot: systemGoRoot,
|
||
gopath: systemGoPath,
|
||
installDate: undefined,
|
||
size: undefined
|
||
}
|
||
} catch (error) {
|
||
// 系统没有安装 Go 或者不在 PATH 中
|
||
return null
|
||
}
|
||
}
|
||
|
||
// ==================== 私有方法 ====================
|
||
|
||
/**
|
||
* 检查版本是否已安装（重复安装检测）
|
||
*/
|
||
private async isVersionInstalled(version: string): Promise<boolean> {
|
||
const extractDir = join(this.getGoBasePath(), `go-${version}`)
|
||
const goExe = join(extractDir, 'bin', 'go.exe')
|
||
const gofmtExe = join(extractDir, 'bin', 'gofmt.exe')
|
||
|
||
// 检查目录和关键文件是否存在
|
||
if (!existsSync(extractDir) || !existsSync(goExe) || !existsSync(gofmtExe)) {
|
||
return false
|
||
}
|
||
|
||
// 进一步验证安装完整性
|
||
try {
|
||
const { stdout } = await execAsync(`"${goExe}" version`, { timeout: 5000 })
|
||
return stdout.includes(version)
|
||
} catch {
|
||
return false
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 解压 Go 归档文件
|
||
* 增强的错误处理
|
||
* Requirements: 8.5
|
||
*/
|
||
private async extractGoArchive(zipPath: string, destDir: string, version: string): Promise<void> {
|
||
const extractDir = join(destDir, `go-${version}`)
|
||
|
||
try {
|
||
// 先解压到临时位置
|
||
await this.extractZip(zipPath, destDir)
|
||
|
||
// Go 的 ZIP 文件解压后会创建一个 'go' 目录，需要重命名
|
||
const extractedGoDir = join(destDir, 'go')
|
||
if (existsSync(extractedGoDir)) {
|
||
// 如果目标目录已存在，先删除
|
||
if (existsSync(extractDir)) {
|
||
rmSync(extractDir, { recursive: true, force: true })
|
||
}
|
||
// 重命名为版本特定的目录
|
||
require('fs').renameSync(extractedGoDir, extractDir)
|
||
} else {
|
||
throw new GoManagerError(
|
||
GoErrorType.INSTALLATION_ERROR,
|
||
'解压后未找到 Go 目录',
|
||
'下载的文件可能损坏或格式不正确。请重新下载安装包',
|
||
true,
|
||
{ zipPath, destDir, expectedDir: extractedGoDir }
|
||
)
|
||
}
|
||
|
||
} catch (error: any) {
|
||
// 如果是 GoManagerError，直接重新抛出
|
||
if (error instanceof GoManagerError) {
|
||
throw error
|
||
}
|
||
|
||
let suggestion = '请检查下载文件是否完整，或重新下载安装包'
|
||
|
||
if (error.code === 'EACCES' || error.code === 'EPERM') {
|
||
suggestion = '权限不足，请以管理员身份运行程序'
|
||
} else if (error.code === 'ENOSPC') {
|
||
suggestion = '磁盘空间不足，请清理磁盘空间后重试'
|
||
} else if (error.message.includes('invalid') || error.message.includes('corrupt')) {
|
||
suggestion = '文件损坏，请重新下载安装包'
|
||
}
|
||
|
||
throw new GoManagerError(
|
||
GoErrorType.INSTALLATION_ERROR,
|
||
`解压失败: ${error.message}`,
|
||
suggestion,
|
||
true,
|
||
{ zipPath, destDir, version, errorCode: error.code, originalError: error.message }
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 执行安装后验证和完整性检查
|
||
*/
|
||
private async performInstallationValidation(version: string): Promise<{ isValid: boolean; error?: string }> {
|
||
const goPath = this.getGoPath(version)
|
||
const goExe = join(goPath, 'bin', 'go.exe')
|
||
const gofmtExe = join(goPath, 'bin', 'gofmt.exe')
|
||
|
||
try {
|
||
// 1. 检查核心可执行文件是否存在
|
||
if (!existsSync(goExe)) {
|
||
return { isValid: false, error: 'go.exe 文件不存在' }
|
||
}
|
||
if (!existsSync(gofmtExe)) {
|
||
return { isValid: false, error: 'gofmt.exe 文件不存在' }
|
||
}
|
||
|
||
// 2. 验证 go version 命令
|
||
const { stdout: versionOutput } = await execAsync(`"${goExe}" version`, { timeout: 10000 })
|
||
if (!versionOutput.includes(version)) {
|
||
return { isValid: false, error: `版本验证失败，期望 ${version}，实际 ${versionOutput.trim()}` }
|
||
}
|
||
|
||
// 3. 验证 go env 命令
|
||
await execAsync(`"${goExe}" env GOROOT`, { timeout: 10000 })
|
||
|
||
// 4. 验证 go mod 功能
|
||
await execAsync(`"${goExe}" help mod`, { timeout: 10000 })
|
||
|
||
// 5. 验证 go build 命令可用
|
||
await execAsync(`"${goExe}" help build`, { timeout: 10000 })
|
||
|
||
// 6. 检查标准库目录
|
||
const srcDir = join(goPath, 'src')
|
||
if (!existsSync(srcDir)) {
|
||
return { isValid: false, error: '标准库源码目录不存在' }
|
||
}
|
||
|
||
return { isValid: true }
|
||
|
||
} catch (error: any) {
|
||
return { isValid: false, error: `验证过程出错: ${error.message}` }
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 清理失败的安装
|
||
*/
|
||
private async cleanupFailedInstallation(installDir: string): Promise<void> {
|
||
try {
|
||
if (existsSync(installDir)) {
|
||
console.log(`清理失败的安装目录: ${installDir}`)
|
||
rmSync(installDir, { recursive: true, force: true })
|
||
}
|
||
} catch (error) {
|
||
console.warn(`清理安装目录失败: ${error}`)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 更新安装配置
|
||
*/
|
||
private async updateInstallationConfig(version: string): Promise<void> {
|
||
const goVersions = this.configStore.get('goVersions' as any) || []
|
||
if (!goVersions.includes(version)) {
|
||
goVersions.push(version)
|
||
this.configStore.set('goVersions' as any, goVersions)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 清理临时文件
|
||
*/
|
||
private async cleanupTempFiles(zipPath: string): Promise<void> {
|
||
try {
|
||
// 清理下载的 ZIP 文件
|
||
if (existsSync(zipPath)) {
|
||
unlinkSync(zipPath)
|
||
console.log(`已清理临时文件: ${zipPath}`)
|
||
}
|
||
|
||
// 清理部分下载文件
|
||
const partialFile = `${zipPath}.partial`
|
||
if (existsSync(partialFile)) {
|
||
unlinkSync(partialFile)
|
||
console.log(`已清理部分下载文件: ${partialFile}`)
|
||
}
|
||
|
||
} catch (error) {
|
||
console.warn(`清理临时文件时出错: ${error}`)
|
||
// 不抛出错误，因为这不应该影响安装结果
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 增强的文件下载管理器
|
||
* 支持 HTTPS 下载、进度跟踪、SHA256 校验、下载中断和重试
|
||
* Requirements: 8.1, 8.5
|
||
*/
|
||
private async downloadFile(url: string, dest: string, name: string, expectedSha256?: string): Promise<void> {
|
||
const options: DownloadOptions = {
|
||
url,
|
||
dest,
|
||
name,
|
||
expectedSha256,
|
||
maxRetries: 3,
|
||
timeout: 600000 // 10 分钟超时
|
||
}
|
||
|
||
const result = await this.downloadWithRetry(options)
|
||
if (!result.success) {
|
||
// 如果下载结果包含建议，创建 GoManagerError
|
||
if (result.suggestion) {
|
||
throw new GoManagerError(
|
||
GoErrorType.DOWNLOAD_ERROR,
|
||
result.message,
|
||
result.suggestion,
|
||
result.retryable || false,
|
||
result.details
|
||
)
|
||
} else {
|
||
throw new Error(result.message)
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 带重试机制的下载
|
||
* 增强的网络错误处理和用户反馈
|
||
* Requirements: 8.1
|
||
*/
|
||
private async downloadWithRetry(options: DownloadOptions): Promise<DownloadResult> {
|
||
const { maxRetries = 3 } = options
|
||
let lastError: Error | null = null
|
||
|
||
for (let attempt = 1; attempt <= maxRetries; attempt++) {
|
||
try {
|
||
console.log(`下载尝试 ${attempt}/${maxRetries}: ${options.name}`)
|
||
|
||
// 在重试前检查网络连接
|
||
if (attempt > 1) {
|
||
console.log(`第 ${attempt} 次尝试前检查网络连接...`)
|
||
const networkCheck = await this.checkNetworkConnection()
|
||
if (!networkCheck.isConnected) {
|
||
throw new GoManagerError(
|
||
GoErrorType.NETWORK_ERROR,
|
||
'网络连接不可用',
|
||
'请检查网络连接后重试。确保可以访问 golang.org',
|
||
true,
|
||
{ networkCheck, attempt }
|
||
)
|
||
}
|
||
console.log(`网络连接正常，响应时间: ${networkCheck.responseTime}ms`)
|
||
}
|
||
|
||
// 检查是否存在部分下载的文件
|
||
const partialFile = `${options.dest}.partial`
|
||
let resumeFrom = 0
|
||
|
||
if (existsSync(partialFile)) {
|
||
try {
|
||
const stats = statSync(partialFile)
|
||
resumeFrom = stats.size
|
||
console.log(`检测到部分下载文件，从 ${resumeFrom} 字节处恢复下载`)
|
||
} catch (e) {
|
||
// 如果无法读取部分文件，删除它
|
||
try {
|
||
unlinkSync(partialFile)
|
||
} catch {}
|
||
resumeFrom = 0
|
||
}
|
||
}
|
||
|
||
await this.performDownload(options, resumeFrom)
|
||
|
||
// 下载成功后验证 SHA256（如果提供）
|
||
if (options.expectedSha256) {
|
||
console.log('验证文件完整性...')
|
||
const isValid = await this.verifySha256(options.dest, options.expectedSha256)
|
||
if (!isValid) {
|
||
// SHA256 验证失败，删除文件并重试
|
||
try {
|
||
unlinkSync(options.dest)
|
||
} catch {}
|
||
throw new GoManagerError(
|
||
GoErrorType.DOWNLOAD_ERROR,
|
||
'SHA256 校验失败，文件可能损坏',
|
||
'文件下载过程中可能出现错误，正在重新下载。如果问题持续，请检查网络连接',
|
||
true,
|
||
{ attempt, expectedSha256: options.expectedSha256 }
|
||
)
|
||
}
|
||
console.log('文件完整性验证通过')
|
||
}
|
||
|
||
// 清理部分下载文件
|
||
try {
|
||
unlinkSync(partialFile)
|
||
} catch {}
|
||
|
||
return {
|
||
success: true,
|
||
message: '下载完成',
|
||
filePath: options.dest
|
||
}
|
||
|
||
} catch (error: any) {
|
||
lastError = error
|
||
console.error(`下载尝试 ${attempt} 失败:`, error.message)
|
||
|
||
if (attempt < maxRetries) {
|
||
// 等待一段时间后重试（指数退避）
|
||
const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000)
|
||
console.log(`等待 ${delay}ms 后重试...`)
|
||
await new Promise(resolve => setTimeout(resolve, delay))
|
||
}
|
||
}
|
||
}
|
||
|
||
// 所有重试都失败了
|
||
const errorMessage = lastError instanceof GoManagerError
|
||
? lastError.message
|
||
: `下载失败（已重试 ${maxRetries} 次）: ${lastError?.message || '未知错误'}`
|
||
|
||
const suggestion = lastError instanceof GoManagerError
|
||
? lastError.suggestion
|
||
: '请检查网络连接，确保可以访问 golang.org。如果问题持续，请尝试使用VPN或更换网络环境'
|
||
|
||
return {
|
||
success: false,
|
||
message: errorMessage,
|
||
suggestion,
|
||
retryable: true,
|
||
details: { attempts: maxRetries, lastError: lastError?.message }
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 执行实际的下载操作
|
||
* 增强的错误处理和网络状态检测
|
||
* Requirements: 8.1
|
||
*/
|
||
private async performDownload(options: DownloadOptions, resumeFrom: number = 0): Promise<void> {
|
||
return new Promise((resolve, reject) => {
|
||
const protocol = options.url.startsWith('https') ? https : http
|
||
const partialFile = `${options.dest}.partial`
|
||
const isResume = resumeFrom > 0
|
||
|
||
const requestOptions: any = {
|
||
headers: {
|
||
'User-Agent': 'PHPer-Dev-Manager/1.0'
|
||
},
|
||
timeout: options.timeout || 600000
|
||
}
|
||
|
||
// 如果是断点续传，添加 Range 头
|
||
if (isResume) {
|
||
requestOptions.headers['Range'] = `bytes=${resumeFrom}-`
|
||
}
|
||
|
||
const request = protocol.get(options.url, requestOptions, (response) => {
|
||
// 处理重定向
|
||
if (response.statusCode === 301 || response.statusCode === 302) {
|
||
const redirectUrl = response.headers.location
|
||
if (redirectUrl) {
|
||
const redirectOptions = { ...options, url: redirectUrl }
|
||
this.performDownload(redirectOptions, resumeFrom).then(resolve).catch(reject)
|
||
return
|
||
}
|
||
}
|
||
|
||
// 检查响应状态码
|
||
const expectedStatus = isResume ? 206 : 200 // 206 for partial content
|
||
if (response.statusCode !== expectedStatus && response.statusCode !== 200) {
|
||
const errorMsg = `下载失败: HTTP ${response.statusCode}`
|
||
let suggestion = '请检查网络连接和下载链接'
|
||
|
||
if (response.statusCode === 404) {
|
||
suggestion = '下载链接不存在，请尝试其他版本或联系支持'
|
||
} else if (response.statusCode === 403) {
|
||
suggestion = '访问被拒绝，可能需要VPN或代理服务器'
|
||
} else if (response.statusCode === 500 || response.statusCode === 502 || response.statusCode === 503) {
|
||
suggestion = '服务器暂时不可用，请稍后重试'
|
||
}
|
||
|
||
reject(new GoManagerError(
|
||
GoErrorType.NETWORK_ERROR,
|
||
errorMsg,
|
||
suggestion,
|
||
true,
|
||
{ statusCode: response.statusCode, url: options.url }
|
||
))
|
||
return
|
||
}
|
||
|
||
const totalSize = isResume
|
||
? resumeFrom + parseInt(response.headers['content-length'] || '0', 10)
|
||
: parseInt(response.headers['content-length'] || '0', 10)
|
||
let downloadedSize = resumeFrom
|
||
|
||
// 创建写入流（追加模式如果是断点续传）
|
||
const file = createWriteStream(isResume ? partialFile : options.dest,
|
||
isResume ? { flags: 'a' } : undefined)
|
||
|
||
let lastProgressTime = 0
|
||
let lastDownloadedSize = downloadedSize
|
||
let downloadSpeed = 0
|
||
|
||
response.on('data', (chunk) => {
|
||
downloadedSize += chunk.length
|
||
const now = Date.now()
|
||
|
||
// 每500ms更新一次进度和速度
|
||
if (now - lastProgressTime > 500) {
|
||
const timeDiff = (now - lastProgressTime) / 1000
|
||
const sizeDiff = downloadedSize - lastDownloadedSize
|
||
downloadSpeed = sizeDiff / timeDiff // bytes per second
|
||
|
||
const progress = totalSize > 0 ? Math.round((downloadedSize / totalSize) * 100) : 0
|
||
sendDownloadProgress('go', progress, downloadedSize, totalSize)
|
||
|
||
lastProgressTime = now
|
||
lastDownloadedSize = downloadedSize
|
||
}
|
||
})
|
||
|
||
response.pipe(file)
|
||
|
||
file.on('finish', () => {
|
||
file.close()
|
||
|
||
// 如果是部分下载文件，重命名为最终文件
|
||
if (isResume) {
|
||
try {
|
||
if (existsSync(options.dest)) {
|
||
unlinkSync(options.dest)
|
||
}
|
||
require('fs').renameSync(partialFile, options.dest)
|
||
} catch (e) {
|
||
reject(new GoManagerError(
|
||
GoErrorType.FILE_SYSTEM_ERROR,
|
||
`重命名文件失败: ${e}`,
|
||
'可能是权限问题或磁盘空间不足，请检查目标目录权限',
|
||
false,
|
||
{ renameError: e }
|
||
))
|
||
return
|
||
}
|
||
}
|
||
|
||
sendDownloadProgress('go', 100, totalSize, totalSize)
|
||
resolve()
|
||
})
|
||
|
||
file.on('error', (err) => {
|
||
try {
|
||
if (!isResume) {
|
||
unlinkSync(options.dest)
|
||
}
|
||
} catch {}
|
||
reject(new GoManagerError(
|
||
GoErrorType.FILE_SYSTEM_ERROR,
|
||
`文件写入失败: ${err.message}`,
|
||
'可能是磁盘空间不足或权限问题，请检查目标目录权限和可用空间',
|
||
false,
|
||
{ fileError: err.message }
|
||
))
|
||
})
|
||
})
|
||
|
||
request.on('error', (err) => {
|
||
reject(new GoManagerError(
|
||
GoErrorType.NETWORK_ERROR,
|
||
`网络错误: ${err.message}`,
|
||
'请检查网络连接，确保可以访问互联网。如果使用代理，请检查代理设置',
|
||
true,
|
||
{ networkError: err.message }
|
||
))
|
||
})
|
||
|
||
request.on('timeout', () => {
|
||
request.destroy()
|
||
reject(new GoManagerError(
|
||
GoErrorType.NETWORK_ERROR,
|
||
'下载超时',
|
||
'网络连接较慢或不稳定，请检查网络环境后重试',
|
||
true,
|
||
{ timeout: options.timeout }
|
||
))
|
||
})
|
||
})
|
||
}
|
||
|
||
/**
|
||
* 验证文件的 SHA256 校验和
|
||
*/
|
||
private async verifySha256(filePath: string, expectedSha256: string): Promise<boolean> {
|
||
return new Promise((resolve) => {
|
||
try {
|
||
const hash = createHash('sha256')
|
||
const stream = createReadStream(filePath)
|
||
|
||
stream.on('data', (data) => {
|
||
hash.update(data)
|
||
})
|
||
|
||
stream.on('end', () => {
|
||
const actualSha256 = hash.digest('hex').toLowerCase()
|
||
const expected = expectedSha256.toLowerCase()
|
||
resolve(actualSha256 === expected)
|
||
})
|
||
|
||
stream.on('error', () => {
|
||
resolve(false)
|
||
})
|
||
} catch {
|
||
resolve(false)
|
||
}
|
||
})
|
||
}
|
||
|
||
private async extractZip(zipPath: string, destDir: string): Promise<void> {
|
||
return new Promise((resolve, reject) => {
|
||
const readStream = require('fs').createReadStream(zipPath)
|
||
readStream
|
||
.pipe(unzipper.Extract({ path: destDir }))
|
||
.on('close', resolve)
|
||
.on('error', reject)
|
||
})
|
||
}
|
||
|
||
/**
|
||
* 更新环境变量以支持指定的 Go 版本
|
||
* 设置 GOROOT、GOPATH 和 PATH，清理旧版本的路径配置
|
||
* 增强的错误处理和权限检查
|
||
* Requirements: 3.1, 6.1, 6.2, 6.3, 6.4, 8.3, 8.5
|
||
*/
|
||
private async updateEnvironmentVariables(goVersion: string): Promise<void> {
|
||
const goRoot = this.getGoPath(goVersion)
|
||
const goBin = join(goRoot, 'bin')
|
||
const goPath = this.getDefaultGoPath()
|
||
|
||
console.log(`更新环境变量为 Go ${goVersion}`)
|
||
console.log(`GOROOT: ${goRoot}`)
|
||
console.log(`GOPATH: ${goPath}`)
|
||
console.log(`Go Binary Path: ${goBin}`)
|
||
|
||
try {
|
||
// 确保 GOPATH 工作空间目录存在
|
||
await this.ensureGoPathStructure(goPath)
|
||
|
||
// 使用 PowerShell 脚本更新用户环境变量
|
||
const psScript = this.generateEnvironmentUpdateScript(goRoot, goPath, goBin)
|
||
|
||
await this.executePowerShellScript(psScript)
|
||
console.log(`环境变量更新成功: Go ${goVersion}`)
|
||
|
||
} catch (error: any) {
|
||
console.error(`环境变量更新失败: ${error.message}`)
|
||
|
||
// 根据错误类型提供具体建议
|
||
let suggestion = '请以管理员身份运行程序，或手动设置环境变量'
|
||
|
||
if (error.message.includes('ExecutionPolicy')) {
|
||
suggestion = '请以管理员身份运行 PowerShell 并执行: Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser'
|
||
} else if (error.message.includes('Access') || error.message.includes('权限')) {
|
||
suggestion = '权限不足，请以管理员身份运行程序，或在系统设置中手动配置环境变量'
|
||
} else if (error.message.includes('timeout')) {
|
||
suggestion = '操作超时，请重试。如果问题持续，请手动配置环境变量'
|
||
}
|
||
|
||
throw new GoManagerError(
|
||
GoErrorType.ENVIRONMENT_ERROR,
|
||
`环境变量更新失败: ${error.message}`,
|
||
suggestion,
|
||
true,
|
||
{
|
||
goVersion,
|
||
goRoot,
|
||
goPath,
|
||
goBin,
|
||
originalError: error.message
|
||
}
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 确保 GOPATH 工作空间目录结构存在
|
||
* 创建标准的 Go 工作空间结构：src, pkg, bin
|
||
* 增强的错误处理
|
||
* Requirements: 8.2, 8.3
|
||
*/
|
||
private async ensureGoPathStructure(goPath: string): Promise<void> {
|
||
try {
|
||
if (!existsSync(goPath)) {
|
||
mkdirSync(goPath, { recursive: true })
|
||
console.log(`创建 GOPATH 目录: ${goPath}`)
|
||
}
|
||
|
||
// 创建标准的 Go 工作空间结构
|
||
const subdirs = ['src', 'pkg', 'bin']
|
||
for (const subdir of subdirs) {
|
||
const dirPath = join(goPath, subdir)
|
||
if (!existsSync(dirPath)) {
|
||
mkdirSync(dirPath, { recursive: true })
|
||
console.log(`创建 GOPATH 子目录: ${dirPath}`)
|
||
}
|
||
}
|
||
} catch (error: any) {
|
||
let suggestion = '请检查目标目录权限，或选择其他位置作为 GOPATH'
|
||
|
||
if (error.code === 'EACCES' || error.code === 'EPERM') {
|
||
suggestion = '权限不足，请以管理员身份运行程序，或选择用户目录下的位置'
|
||
} else if (error.code === 'ENOSPC') {
|
||
suggestion = '磁盘空间不足，请清理磁盘空间或选择其他磁盘'
|
||
} else if (error.code === 'ENOTDIR') {
|
||
suggestion = '路径中存在同名文件，请删除该文件或选择其他路径'
|
||
}
|
||
|
||
throw new GoManagerError(
|
||
GoErrorType.FILE_SYSTEM_ERROR,
|
||
`创建 GOPATH 结构失败: ${error.message}`,
|
||
suggestion,
|
||
false,
|
||
{ goPath, errorCode: error.code, originalError: error.message }
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 生成环境变量更新的 PowerShell 脚本
|
||
* 包含 GOROOT、GOPATH 设置和 PATH 清理更新
|
||
*/
|
||
private generateEnvironmentUpdateScript(goRoot: string, goPath: string, goBin: string): string {
|
||
// 转义路径中的反斜杠
|
||
const escapedGoRoot = goRoot.replace(/\\/g, '\\\\')
|
||
const escapedGoPath = goPath.replace(/\\/g, '\\\\')
|
||
const escapedGoBin = goBin.replace(/\\/g, '\\\\')
|
||
|
||
return `
|
||
# Go 环境变量更新脚本
|
||
Write-Host "开始更新 Go 环境变量..."
|
||
|
||
try {
|
||
# 设置 GOROOT
|
||
Write-Host "设置 GOROOT: ${escapedGoRoot}"
|
||
[Environment]::SetEnvironmentVariable('GOROOT', '${escapedGoRoot}', 'User')
|
||
|
||
# 设置 GOPATH
|
||
Write-Host "设置 GOPATH: ${escapedGoPath}"
|
||
[Environment]::SetEnvironmentVariable('GOPATH', '${escapedGoPath}', 'User')
|
||
|
||
# 更新 PATH
|
||
Write-Host "更新 PATH 环境变量..."
|
||
$userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
|
||
if (-not $userPath) { $userPath = '' }
|
||
|
||
$pathArray = $userPath -split ';' | Where-Object { $_ -ne '' -and $_ -ne $null }
|
||
|
||
# 移除所有旧的 Go 路径（更全面的清理）
|
||
$filteredPaths = $pathArray | Where-Object {
|
||
-not ($_ -like '*\\go\\go-*\\bin' -or
|
||
$_ -like '*\\go-*\\bin' -or
|
||
$_ -like '*\\golang\\*\\bin' -or
|
||
$_ -like '*\\Go\\*\\bin')
|
||
}
|
||
|
||
# 添加新的 Go 路径到开头
|
||
$newPathArray = @('${escapedGoBin}') + $filteredPaths
|
||
$finalPath = ($newPathArray | Where-Object { $_ -ne '' -and $_ -ne $null } | Select-Object -Unique) -join ';'
|
||
|
||
Write-Host "新的 PATH: $finalPath"
|
||
[Environment]::SetEnvironmentVariable('PATH', $finalPath, 'User')
|
||
|
||
Write-Host "环境变量更新完成"
|
||
|
||
} catch {
|
||
Write-Error "环境变量更新失败: $_"
|
||
throw $_
|
||
}
|
||
`
|
||
}
|
||
|
||
/**
|
||
* 从环境变量中移除指定 Go 版本的路径
|
||
* 清理 GOROOT、GOPATH 和 PATH 中的相关配置
|
||
* 增强的错误处理
|
||
* Requirements: 8.3, 8.5
|
||
*/
|
||
private async removeFromPath(goPath: string): Promise<void> {
|
||
const goBin = join(goPath, 'bin')
|
||
|
||
console.log(`从环境变量中移除 Go 路径: ${goBin}`)
|
||
|
||
const psScript = this.generateEnvironmentCleanupScript(goBin)
|
||
|
||
try {
|
||
await this.executePowerShellScript(psScript)
|
||
console.log(`环境变量清理成功`)
|
||
} catch (error: any) {
|
||
console.error(`环境变量清理失败: ${error.message}`)
|
||
|
||
// 如果是 GoManagerError，直接重新抛出
|
||
if (error instanceof GoManagerError) {
|
||
throw error
|
||
}
|
||
|
||
throw new GoManagerError(
|
||
GoErrorType.ENVIRONMENT_ERROR,
|
||
`环境变量清理失败: ${error.message}`,
|
||
'请以管理员身份运行程序，或在系统设置中手动清理环境变量',
|
||
true,
|
||
{ goBin, originalError: error.message }
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 生成环境变量清理的 PowerShell 脚本
|
||
* 移除指定的 Go 路径并清理 GOROOT、GOPATH
|
||
*/
|
||
private generateEnvironmentCleanupScript(goBin: string): string {
|
||
const escapedGoBin = goBin.replace(/\\/g, '\\\\')
|
||
|
||
return `
|
||
# Go 环境变量清理脚本
|
||
Write-Host "开始清理 Go 环境变量..."
|
||
|
||
try {
|
||
# 获取当前用户 PATH
|
||
$userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
|
||
if ($userPath) {
|
||
$pathArray = $userPath -split ';' | Where-Object { $_ -ne '' -and $_ -ne $null }
|
||
|
||
# 移除指定的 Go 路径
|
||
$filteredPaths = $pathArray | Where-Object {
|
||
$_ -ne '${escapedGoBin}'
|
||
}
|
||
|
||
$finalPath = ($filteredPaths | Where-Object { $_ -ne '' -and $_ -ne $null } | Select-Object -Unique) -join ';'
|
||
[Environment]::SetEnvironmentVariable('PATH', $finalPath, 'User')
|
||
Write-Host "已从 PATH 中移除: ${escapedGoBin}"
|
||
}
|
||
|
||
# 清除 GOROOT 和 GOPATH（如果没有其他活动版本）
|
||
[Environment]::SetEnvironmentVariable('GOROOT', $null, 'User')
|
||
[Environment]::SetEnvironmentVariable('GOPATH', $null, 'User')
|
||
Write-Host "已清除 GOROOT 和 GOPATH"
|
||
|
||
Write-Host "环境变量清理完成"
|
||
|
||
} catch {
|
||
Write-Error "环境变量清理失败: $_"
|
||
throw $_
|
||
}
|
||
`
|
||
}
|
||
|
||
/**
|
||
* 执行 PowerShell 脚本
|
||
* 创建临时脚本文件并执行，完成后清理
|
||
* 增强的错误处理和权限检查
|
||
* Requirements: 8.3, 8.5
|
||
*/
|
||
private async executePowerShellScript(script: string): Promise<void> {
|
||
const tempPs1 = join(this.configStore.getTempPath(), `go_env_${Date.now()}.ps1`)
|
||
|
||
try {
|
||
// 确保临时目录存在
|
||
const tempDir = this.configStore.getTempPath()
|
||
if (!existsSync(tempDir)) {
|
||
mkdirSync(tempDir, { recursive: true })
|
||
}
|
||
|
||
// 写入脚本文件
|
||
writeFileSync(tempPs1, script, 'utf-8')
|
||
|
||
// 执行 PowerShell 脚本
|
||
const command = `powershell -ExecutionPolicy Bypass -File "${tempPs1}"`
|
||
const { stdout, stderr } = await execAsync(command, { timeout: 30000 })
|
||
|
||
// 检查 PowerShell 脚本的输出
|
||
if (stderr && stderr.trim()) {
|
||
console.warn('PowerShell 脚本警告:', stderr)
|
||
|
||
// 某些警告不应该被视为错误
|
||
const ignorableWarnings = [
|
||
'WARNING:',
|
||
'Get-WmiObject',
|
||
'deprecated'
|
||
]
|
||
|
||
const isIgnorable = ignorableWarnings.some(warning =>
|
||
stderr.toLowerCase().includes(warning.toLowerCase())
|
||
)
|
||
|
||
if (!isIgnorable && stderr.includes('Error')) {
|
||
throw new Error(stderr)
|
||
}
|
||
}
|
||
|
||
if (stdout && stdout.trim()) {
|
||
console.log('PowerShell 脚本输出:', stdout)
|
||
}
|
||
|
||
} catch (error: any) {
|
||
console.error('PowerShell 脚本执行失败:', error)
|
||
|
||
let suggestion = '请以管理员身份运行程序，或手动配置环境变量'
|
||
let errorType = GoErrorType.ENVIRONMENT_ERROR
|
||
|
||
const errorMessage = error.message.toLowerCase()
|
||
|
||
if (errorMessage.includes('executionpolicy')) {
|
||
suggestion = '执行策略限制，请以管理员身份运行 PowerShell 并执行: Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser'
|
||
errorType = GoErrorType.PERMISSION_ERROR
|
||
} else if (errorMessage.includes('access') || errorMessage.includes('denied') || errorMessage.includes('权限')) {
|
||
suggestion = '权限不足，请以管理员身份运行程序。您也可以在系统设置中手动配置环境变量'
|
||
errorType = GoErrorType.PERMISSION_ERROR
|
||
} else if (errorMessage.includes('timeout')) {
|
||
suggestion = '操作超时，可能是系统响应较慢。请重试，或手动配置环境变量'
|
||
} else if (errorMessage.includes('not found') || errorMessage.includes('找不到')) {
|
||
suggestion = 'PowerShell 不可用，请确保 Windows PowerShell 已正确安装'
|
||
}
|
||
|
||
throw new GoManagerError(
|
||
errorType,
|
||
`PowerShell 脚本执行失败: ${error.message}`,
|
||
suggestion,
|
||
true,
|
||
{
|
||
scriptPath: tempPs1,
|
||
command: 'powershell -ExecutionPolicy Bypass',
|
||
originalError: error.message
|
||
}
|
||
)
|
||
} finally {
|
||
// 清理临时脚本文件
|
||
try {
|
||
if (existsSync(tempPs1)) {
|
||
unlinkSync(tempPs1)
|
||
}
|
||
} catch (e) {
|
||
console.warn('清理临时脚本文件失败:', e)
|
||
}
|
||
}
|
||
}
|
||
|
||
private getFallbackVersions(): AvailableGoVersion[] {
|
||
return [
|
||
{ version: 'go1.22.0', stable: true, downloadUrl: 'https://golang.org/dl/go1.22.0.windows-amd64.zip', size: 0, sha256: '' },
|
||
{ version: 'go1.21.6', stable: true, downloadUrl: 'https://golang.org/dl/go1.21.6.windows-amd64.zip', size: 0, sha256: '' },
|
||
{ version: 'go1.21.5', stable: true, downloadUrl: 'https://golang.org/dl/go1.21.5.windows-amd64.zip', size: 0, sha256: '' },
|
||
{ version: 'go1.20.13', stable: true, downloadUrl: 'https://golang.org/dl/go1.20.13.windows-amd64.zip', size: 0, sha256: '' },
|
||
{ version: 'go1.20.12', stable: true, downloadUrl: 'https://golang.org/dl/go1.20.12.windows-amd64.zip', size: 0, sha256: '' },
|
||
{ version: 'go1.19.13', stable: true, downloadUrl: 'https://golang.org/dl/go1.19.13.windows-amd64.zip', size: 0, sha256: '' }
|
||
]
|
||
}
|
||
} |