install.ps1

#!/usr/bin/env pwsh

<#
.SYNOPSIS
    准备 PowerShell 脚本开发环境，配置 PATH 并构建子项目

.DESCRIPTION
    该脚本执行以下操作：
    1. 自动检测并添加项目根目录和 bin 目录到 PATH 环境变量 (Windows)。
    2. 同步 bin 目录下的 PowerShell 脚本包装器。
    3. 构建 scripts/bash 下的 Bash 工具集。
    4. 安装并构建 scripts/node 下的 TypeScript/Node.js 工具集。

.EXAMPLE
    .\install.ps1
    安装命令行工具，支持windows，linux平台
    .\install.ps1 -installApp

.EXAMPLE
    .\install.ps1 -Preset Core -WhatIf

.EXAMPLE
    .\install.ps1 -Preset Full -NetworkMode China -OutputFormat Json
#>

[CmdletBinding(SupportsShouldProcess)]
param(
    [switch]$installApp,

    [ValidateSet('Core', 'Full')]
    [string]$Preset = '',

    [switch]$ListSteps,

    [string[]]$Step,

    [string]$FromStep = '',

    [string[]]$SkipStep,

    [ValidateSet('Direct', 'China', 'Auto')]
    [string]$NetworkMode = 'Direct',

    [ValidateSet('Text', 'Json')]
    [string]$OutputFormat = 'Text',

    [switch]$Unattended,

    [switch]$NonInteractive
)


# --- 配置部分 ---
$ProjectRoot = $PSScriptRoot
$BinDir = Join-Path $ProjectRoot 'bin'
$NodeScriptsDir = Join-Path $ProjectRoot 'scripts/node'
$InstallOrchestratorModule = Join-Path $ProjectRoot 'scripts/pwsh/install/InstallOrchestrator.psm1'
$InstallStepRegistry = Join-Path $ProjectRoot 'config/install/steps.psd1'


function Write-InstallCliError {
    <#
    .SYNOPSIS
        按请求的输出格式写入安装入口参数错误。

    .PARAMETER Message
        参数错误说明。

    .PARAMETER Format
        Text 或 Json。

    .OUTPUTS
        None。错误写入 stderr 或 JSON stdout。
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [string]$Message,

        [ValidateSet('Text', 'Json')]
        [string]$Format = 'Text'
    )

    if ($Format -eq 'Json') {
        [pscustomobject]@{
            SchemaVersion = 1
            Status        = 'InvalidArguments'
            ExitCode      = 2
            Message       = $Message
        } | ConvertTo-Json -Depth 5
        return
    }
    [Console]::Error.WriteLine($Message)
}

$orchestratorParameterNames = @(
    'Preset',
    'ListSteps',
    'Step',
    'FromStep',
    'SkipStep',
    'NetworkMode',
    'OutputFormat',
    'Unattended',
    'NonInteractive'
)
$hasOrchestratorIntent = @($orchestratorParameterNames | Where-Object { $PSBoundParameters.ContainsKey($_) }).Count -gt 0

if ($installApp -and $hasOrchestratorIntent) {
    Write-InstallCliError -Message 'installApp 不能与 Preset、步骤选择或编排输出参数组合' -Format $OutputFormat
    exit 2
}
$listStepsExecutionArguments = -not [string]::IsNullOrWhiteSpace($Preset) -or
    @($Step | Where-Object { $_ }).Count -gt 0 -or
    -not [string]::IsNullOrWhiteSpace($FromStep) -or
    @($SkipStep | Where-Object { $_ }).Count -gt 0 -or
    $PSBoundParameters.ContainsKey('NetworkMode') -or
    $Unattended -or
    $NonInteractive -or
    $PSBoundParameters.ContainsKey('WhatIf')
if ($ListSteps -and $listStepsExecutionArguments) {
    Write-InstallCliError -Message 'ListSteps 只能与 OutputFormat 组合，不能携带执行参数' -Format $OutputFormat
    exit 2
}
if ($PSBoundParameters.ContainsKey('OutputFormat') -and -not $ListSteps -and
    [string]::IsNullOrWhiteSpace($Preset) -and -not $installApp) {
    Write-InstallCliError -Message 'OutputFormat 必须与 ListSteps 或 Preset Core/Full 一起使用' -Format $OutputFormat
    exit 2
}
if ($Unattended -and $NonInteractive) {
    Write-InstallCliError -Message 'Unattended 与 NonInteractive 不能同时使用' -Format $OutputFormat
    exit 2
}
if (@($Step | Where-Object { $_ }).Count -gt 0 -and -not [string]::IsNullOrWhiteSpace($FromStep)) {
    Write-InstallCliError -Message 'Step 与 FromStep 不能同时使用' -Format $OutputFormat
    exit 2
}

$hasExecutionFilter = @($Step | Where-Object { $_ }).Count -gt 0 -or
    -not [string]::IsNullOrWhiteSpace($FromStep) -or
    @($SkipStep | Where-Object { $_ }).Count -gt 0 -or
    $PSBoundParameters.ContainsKey('NetworkMode') -or
    $Unattended -or
    $NonInteractive -or
    $PSBoundParameters.ContainsKey('WhatIf')
if ($hasExecutionFilter -and [string]::IsNullOrWhiteSpace($Preset) -and -not $installApp) {
    Write-InstallCliError -Message '步骤执行参数必须与 Preset Core 或 Full 一起使用' -Format $OutputFormat
    exit 2
}

if ($ListSteps -or -not [string]::IsNullOrWhiteSpace($Preset)) {
    if (-not (Test-Path -LiteralPath $InstallOrchestratorModule -PathType Leaf)) {
        Write-InstallCliError -Message "安装编排模块不存在: $InstallOrchestratorModule" -Format $OutputFormat
        exit 1
    }
    Import-Module $InstallOrchestratorModule -Force
    try {
        $registry = Import-InstallStepRegistry -Path $InstallStepRegistry
        $platform = Resolve-InstallPlatform
        if ($ListSteps) {
            $steps = Get-InstallStepCatalog -Registry $registry -Platform $platform
            if ($OutputFormat -eq 'Json') {
                [pscustomobject]@{
                    SchemaVersion = 1
                    Platform      = $platform
                    Steps         = @($steps)
                } | ConvertTo-Json -Depth 20
            }
            else {
                $steps | Format-Table Number, Id, Supported, Path -AutoSize
            }
            exit 0
        }

        $document = Invoke-InstallOrchestrator `
            -Registry $registry `
            -RepoRoot $ProjectRoot `
            -Platform $platform `
            -Preset $Preset `
            -Step $Step `
            -FromStep $FromStep `
            -SkipStep $SkipStep `
            -NetworkMode $NetworkMode `
            -Preview:$WhatIfPreference `
            -Unattended:$Unattended `
            -NonInteractive:$NonInteractive `
            -ShowProgress:($OutputFormat -eq 'Text')
        if ($OutputFormat -eq 'Json') {
            [Console]::Out.WriteLine((ConvertTo-InstallRunJson -Document $document))
        }
        else {
            Write-InstallRunText -Document $document
        }
        exit $document.ExitCode
    }
    catch {
        Write-InstallCliError -Message $_.Exception.Message -Format $OutputFormat
        exit 2
    }
}


if ($installApp) {
    Write-Warning 'installApp 已弃用；该兼容入口暂时保留，且不等价于 -Preset Full'
    Write-Host "安装应用..." -ForegroundColor Cyan
    if ($IsWindows) {
        . "$ProjectRoot/profile/installer/installApp.ps1"
    }
    elseif ( $IsLinux) {
        & "$ProjectRoot/linux/05installCoreCli.ps1" -Preset Core -WhatIf:$WhatIfPreference
        exit $LASTEXITCODE
    }
    elseif ($IsMacOS) {
        . "$ProjectRoot/profile/installer/installApp.ps1"
    }
    else {
        Write-Host "不支持的平台: $($PSVersionTable.OS)" -ForegroundColor Red
    }
 
    exit 0
}


# --- 函数定义 ---

function Test-DirectoryInPath {
    param(
        [Parameter(Mandatory = $true)]
        [string]$DirectoryPath
    )
    
    # 获取当前 PATH 环境变量（优先 User 级别，然后 Machine 级别）
    # 注意：在非 Windows 平台上，GetEnvironmentVariable 的 Target 参数可能行为不同或被忽略
    if ($IsWindows) {
        $userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
        $machinePath = [Environment]::GetEnvironmentVariable('PATH', 'Machine')
    }
    $processPath = $env:PATH
    
    # 合并所有级别的 PATH
    $allPaths = @()
    if ($userPath) { $allPaths += $userPath }
    if ($machinePath) { $allPaths += $machinePath }
    if ($processPath) { $allPaths += $processPath }
    
    # 获取目标目录的绝对路径
    try {
        $targetAbsolutePath = (Resolve-Path -Path $DirectoryPath).Path
        if ($IsWindows) { $targetAbsolutePath = $targetAbsolutePath.ToLowerInvariant() }
    }
    catch {
        Write-Warning "无法解析目标路径: $DirectoryPath"
        return $false
    }
    
    # 检查每个 PATH 条目
    foreach ($pathString in $allPaths) {
        $pathEntries = $pathString -split [IO.Path]::PathSeparator
        
        foreach ($entry in $pathEntries) {
            if ([string]::IsNullOrWhiteSpace($entry)) { continue }
            
            $trimmedEntry = $entry.Trim()
            
            # 简单字符串比较
            if ($IsWindows) {
                if ($trimmedEntry.ToLowerInvariant() -eq $targetAbsolutePath) { return $true }
            }
            else {
                if ($trimmedEntry -eq $targetAbsolutePath) { return $true }
            }
            
            # 解析路径后比较
            if (Test-Path $trimmedEntry) {
                try {
                    $resolvedEntry = (Resolve-Path -Path $trimmedEntry).Path
                    if ($IsWindows) { $resolvedEntry = $resolvedEntry.ToLowerInvariant() }
                    
                    if ($resolvedEntry -eq $targetAbsolutePath) {
                        return $true
                    }
                }
                catch { continue }
            }
        }
    }
    
    return $false
}

function Add-DirectoryToPath {
    param(
        [Parameter(Mandatory = $true)]
        [string]$DirectoryPath,
        
        [Parameter(Mandatory = $true)]
        [string]$Scope
    )
    
    try {
        $currentPath = [Environment]::GetEnvironmentVariable('PATH', $Scope)
        
        if ([string]::IsNullOrWhiteSpace($currentPath)) {
            $newPath = $DirectoryPath
        }
        else {
            $newPath = $currentPath + [IO.Path]::PathSeparator + $DirectoryPath
        }
        
        [Environment]::SetEnvironmentVariable('PATH', $newPath, $Scope)
        Write-Host "成功将目录添加到 $Scope PATH: $DirectoryPath" -ForegroundColor Green
        return $true
    }
    catch {
        Write-Error "添加目录到 PATH 失败: $($_.Exception.Message)"
        return $false
    }
}

function Update-CurrentSessionPath {
    param(
        [Parameter(Mandatory = $true)]
        [string]$DirectoryPath
    )
    $env:PATH = $env:PATH + [IO.Path]::PathSeparator + $DirectoryPath
    Write-Host "已更新当前会话 PATH: $DirectoryPath" -ForegroundColor Cyan
}

function Ensure-PathSetup {
    param(
        [string]$Path,
        [string]$Description
    )

    if (-not $IsWindows) {
        # 非 Windows 环境暂不支持自动修改持久化 PATH
        Write-Warning "非 Windows 环境跳过 PATH 自动配置: $Description"
        return $false
    }

    if (-not (Test-Path $Path)) {
        Write-Warning "目录不存在，跳过 PATH 配置: $Path"
        return $false
    }

    Write-Host "`n检测 $Description 是否在 PATH 中..." -ForegroundColor Yellow
    if (Test-DirectoryInPath -DirectoryPath $Path) {
        Write-Host "✓ $Description 已在 PATH 中" -ForegroundColor Green
        return $false
    }
    else {
        Write-Host "✗ $Description 不在 PATH 中，正在添加..." -ForegroundColor Red
        if (Add-DirectoryToPath -DirectoryPath $Path -Scope 'User') {
            Update-CurrentSessionPath -DirectoryPath $Path
            return $true
        }
    }
    return $false
}

function Install-NodeScripts {
    param(
        [string]$ScriptDir
    )

    if (-not (Test-Path $ScriptDir)) {
        Write-Warning "Node 脚本目录不存在: $ScriptDir"
        return
    }

    Write-Host "`n=== 开始安装 Node.js 脚本工具集 ===" -ForegroundColor Magenta
    
    # 检查 pnpm
    if (-not (Get-Command "pnpm" -ErrorAction SilentlyContinue)) {
        Write-Error "未找到 pnpm，请先安装 pnpm (npm install -g pnpm)"
        return
    }

    # 禁止 Corepack 下载提示
    $env:COREPACK_ENABLE_DOWNLOAD_PROMPT = '0'

    Push-Location $ScriptDir
    try {
        Write-Host "正在安装依赖..." -ForegroundColor Cyan
        pnpm install --ignore-scripts
        if ($LASTEXITCODE -ne 0) { throw "pnpm install 失败" }

        Write-Host "正在构建项目..." -ForegroundColor Cyan
        pnpm run build
        if ($LASTEXITCODE -ne 0) { throw "pnpm run build 失败" }

        Write-Host "✓ Node.js 脚本安装完成" -ForegroundColor Green
    }
    catch {
        Write-Error "Node.js 脚本安装过程中出错: $_"
    }
    finally {
        Pop-Location
    }
}

function Install-BashScripts {
    <#
    .SYNOPSIS
        构建 scripts/bash 下的 Bash 工具。

    .DESCRIPTION
        调用 scripts/bash/build.sh 统一刷新 Bash 单文件产物与构建型产物。

    .PARAMETER RootPath
        仓库根目录。

    .OUTPUTS
        System.Boolean。成功执行或无需执行时返回 $true；构建失败返回 $false。
    #>
    param(
        [Parameter(Mandatory = $true)]
        [string]$RootPath
    )

    $bashBuildScript = Join-Path $RootPath 'scripts/bash/build.sh'
    if (-not (Test-Path -LiteralPath $bashBuildScript -PathType Leaf)) {
        Write-Warning "未找到 Bash 构建脚本: $bashBuildScript"
        return $true
    }

    if (-not (Get-Command 'bash' -ErrorAction SilentlyContinue)) {
        if ($IsWindows) {
            Write-Warning "未找到 bash，跳过 Bash 工具构建。"
            return $true
        }

        Write-Error "未找到 bash，无法构建 Bash 工具。"
        return $false
    }

    Write-Host "`n=== 开始构建 Bash 脚本工具集 ===" -ForegroundColor Magenta
    & bash $bashBuildScript
    if ($LASTEXITCODE -ne 0) {
        Write-Error "Bash 脚本工具集构建失败，退出码: $LASTEXITCODE"
        return $false
    }

    Write-Host "✓ Bash 脚本工具集构建完成" -ForegroundColor Green
    return $true
}

function Install-NbStripout {
    Write-Host "`n=== 开始安装与配置 nbstripout ===" -ForegroundColor Magenta
    
    # 1. 检查 nbstripout 是否已安装在系统中
    if (-not (Get-Command "nbstripout" -ErrorAction SilentlyContinue)) {
        Write-Host "未找到 nbstripout，尝试通过 pip 安装..." -ForegroundColor Cyan
        if (Get-Command "pip" -ErrorAction SilentlyContinue) {
            pip install nbstripout
            if ($LASTEXITCODE -ne 0) {
                Write-Error "pip install nbstripout 失败"
                return
            }
        }
        else {
            Write-Warning "未找到 pip，请先安装 Python 和 pip，或者手动安装 nbstripout"
            return
        }
    }
    else {
        Write-Host "✓ nbstripout 已安装在系统中" -ForegroundColor Green
    }
}

function Install-AutoHotkey {
    # 使用脚本内的 $ProjectRoot 变量，需通过参数传入或作用域获取
    # 这里我们定义参数以明确依赖
    param($RootPath)

    if (-not $IsWindows) { return }
    
    Write-Host "`n=== 配置 AutoHotkey 环境 ===" -ForegroundColor Magenta
    
    $AhkDir = Join-Path $RootPath 'scripts/ahk'
    
    if (-not (Test-Path $AhkDir)) {
        return
    }
    
    Push-Location $AhkDir
    try {
        if (Test-Path ".\makeScripts.ps1") {
            Write-Host "正在检查 AutoHotkey 配置..." -ForegroundColor Cyan
            # 执行构建脚本
            & .\makeScripts.ps1
            
            if ($LASTEXITCODE -eq 0) {
                Write-Host "✓ AutoHotkey 配置完成" -ForegroundColor Green
            }
            else {
                Write-Warning "AutoHotkey 配置脚本可能有警告或错误 (Exit Code: $LASTEXITCODE)"
            }
        }
    }
    catch {
        Write-Error "AutoHotkey 配置执行失败: $_"
    }
    finally {
        Pop-Location
    }
}

# --- 主执行逻辑 ---

Write-Host "开始准备 PowerShell 脚本开发环境..." -ForegroundColor Green
Write-Host "项目根目录: $ProjectRoot" -ForegroundColor White

$changesMade = $false

# 1. 配置项目根目录 PATH (仅 Windows)
if (Ensure-PathSetup -Path $ProjectRoot -Description "项目根目录") {
    $changesMade = $true
}

# 2. 同步 bin 目录脚本
Write-Host "`n=== 同步脚本到 bin 目录 ===" -ForegroundColor Magenta
try {
    & (Join-Path $ProjectRoot 'Manage-BinScripts.ps1') -Action 'sync' -Force
}
catch {
    Write-Warning "同步脚本失败: $($_.Exception.Message)"
}

if (-not $IsWindows) {
    # 3. 构建 Bash 脚本工具集
    if (-not (Install-BashScripts -RootPath $ProjectRoot)) {
        exit 1
    }
}

# 4. 安装 Node.js 脚本 (跨平台)
Install-NodeScripts -ScriptDir $NodeScriptsDir

# 5. 配置 bin 目录 PATH (仅 Windows)
#    注意：Node 脚本构建后会生成文件到 bin，所以确保 bin 在 PATH 中很重要
if (Ensure-PathSetup -Path $BinDir -Description "Bin 目录") {
    $changesMade = $true
}

# 6. 安装与配置 nbstripout (Python 工具)
Install-NbStripout

# 7. 配置 AutoHotkey (仅 Windows)
Install-AutoHotkey -RootPath $ProjectRoot

# --- 结束汇总 ---
Write-Host "`n=== 环境准备完成! ===" -ForegroundColor Green
if ($changesMade) {
    Write-Host "⚠️  环境变量已更新，建议重新启动终端以确保所有更改生效" -ForegroundColor Yellow
}
else {
    Write-Host "✓ 环境变量无需更新" -ForegroundColor Green
}

# 设置win环境path
if ($IsWindows) {
    Write-Host "`n当前 PATH 包含 (相关项):" -ForegroundColor Cyan
    $env:PATH -split [IO.Path]::PathSeparator | Where-Object { 
        $_ -match [regex]::Escape($ProjectRoot) -or $_ -match [regex]::Escape($BinDir) 
    } | ForEach-Object {
        Write-Host "  - $_" -ForegroundColor White
    }
}

# 设置 Shell 环境 (Linux/macOS)
if ($IsLinux -or $IsMacOS) {
    Write-Host "`n=== 配置 Shell 环境 ===" -ForegroundColor Magenta
    
    # 检测默认 Shell
    $defaultShell = $env:SHELL
    if ([string]::IsNullOrWhiteSpace($defaultShell)) {
        $defaultShell = "Unknown"
    }
    Write-Host "检测到默认 Shell: $defaultShell" -ForegroundColor Cyan

    $ShellScript = Join-Path $ProjectRoot 'shell/deploy.sh'
    
    if (Test-Path $ShellScript) {
        try {
            Write-Host "正在执行 Shell 配置脚本: $ShellScript" -ForegroundColor Cyan
            
            # 确保脚本具有执行权限
            if ($IsLinux -or $IsMacOS) {
                & chmod +x $ShellScript
            }
            
            # 执行脚本
            & $ShellScript
            
            if ($LASTEXITCODE -eq 0) {
                Write-Host "✓ Shell 配置脚本执行成功" -ForegroundColor Green
            }
            else {
                Write-Warning "Shell 配置脚本执行失败，退出码: $LASTEXITCODE"
            }
        }
        catch {
            Write-Error "执行 Shell 配置脚本时出错: $($_.Exception.Message)"
        }
    }
    else {
        Write-Warning "未找到 Shell 配置脚本: $ShellScript"
    }
}