[CmdletBinding()]
param()

$ErrorActionPreference = "Stop"
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12

$baseUrl = "https://cpa.dongailin.cn/downloads"
$claudeOfficialBaseUrl = "https://downloads.claude.ai/claude-code-releases"
$nodeOfficialBaseUrl = "https://nodejs.org/dist"
$relayBaseUrl = "https://zgo.2000521.xyz:25501/relay"
$claudeRelayBaseUrl = "$relayBaseUrl/claude-code-releases"
$nodeRelayBaseUrl = "$relayBaseUrl/node-releases"
$authUser = "admin"
$script:UseChinese = $false

function Initialize-ConsoleEncoding {
  try {
    $utf8 = New-Object Text.UTF8Encoding($false)
    [Console]::InputEncoding = $utf8
    [Console]::OutputEncoding = $utf8
    $global:OutputEncoding = $utf8

    if ($env:OS -eq "Windows_NT") {
      $chcpPath = Join-Path $env:SystemRoot "System32\chcp.com"
      if (Test-Path -LiteralPath $chcpPath) {
        & $chcpPath 65001 | Out-Null
      }
    }
  }
  catch {
    # Some non-interactive hosts do not expose console encoding handles.
  }
}

function Get-CurrentConsoleFontName {
  if ($Host.Name -ne "ConsoleHost") {
    return $null
  }

  try {
    if (-not ("DalClaudeConsole.NativeMethods" -as [type])) {
      Add-Type -TypeDefinition @"
using System;
using System.Runtime.InteropServices;

namespace DalClaudeConsole {
  [StructLayout(LayoutKind.Sequential)]
  public struct Coord {
    public short X;
    public short Y;
  }

  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
  public struct ConsoleFontInfoEx {
    public uint cbSize;
    public uint nFont;
    public Coord dwFontSize;
    public int FontFamily;
    public int FontWeight;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string FaceName;
  }

  public static class NativeMethods {
    [DllImport("kernel32.dll", SetLastError = true)]
    public static extern IntPtr GetStdHandle(int nStdHandle);

    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool GetCurrentConsoleFontEx(
      IntPtr hConsoleOutput,
      bool bMaximumWindow,
      ref ConsoleFontInfoEx lpConsoleCurrentFontEx
    );
  }
}
"@ -ErrorAction Stop
    }

    $fontInfo = New-Object DalClaudeConsole.ConsoleFontInfoEx
    $fontInfo.cbSize = [Runtime.InteropServices.Marshal]::SizeOf($fontInfo)
    $consoleOutput = [DalClaudeConsole.NativeMethods]::GetStdHandle(-11)
    if ($consoleOutput -eq [IntPtr]::Zero -or
      -not [DalClaudeConsole.NativeMethods]::GetCurrentConsoleFontEx(
        $consoleOutput,
        $false,
        [ref]$fontInfo
      )) {
      return $null
    }

    return ([string]$fontInfo.FaceName).Trim()
  }
  catch {
    return $null
  }
}

function Test-ChineseFontAvailable {
  if ($env:DAL_CLAUDE_LANG -eq "en") {
    return $false
  }
  if ($env:DAL_CLAUDE_LANG -eq "zh") {
    return $true
  }
  $cultureNames = @(
    [Globalization.CultureInfo]::CurrentUICulture.Name,
    [Globalization.CultureInfo]::CurrentCulture.Name
  )
  if (-not ($cultureNames | Where-Object { $_ -like "zh-*" })) {
    return $false
  }
  if (-not $env:WINDIR) {
    return $false
  }

  $fontDirectory = Join-Path $env:WINDIR "Fonts"
  $knownChineseFonts = @(
    "msyh.ttc",
    "msyhl.ttc",
    "msyhm.ttc",
    "simsun.ttc",
    "simhei.ttf",
    "Deng.ttf",
    "Dengb.ttf",
    "Dengl.ttf"
  )
  foreach ($fontFile in $knownChineseFonts) {
    if (Test-Path -LiteralPath (Join-Path $fontDirectory $fontFile) -PathType Leaf) {
      $consoleFontName = Get-CurrentConsoleFontName
      if (-not $consoleFontName) {
        return $false
      }

      return ($consoleFontName -match "(?i)(NSimSun|SimSun|YaHei|DengXian|FangSong|KaiTi|Noto.*CJK|Source Han|Sarasa|新宋体|宋体|微软雅黑|等线|仿宋|楷体)")
    }
  }
  return $false
}

function Get-DisplayText([string]$Chinese, [string]$English) {
  if ($script:UseChinese) {
    return $Chinese
  }
  return $English
}

Initialize-ConsoleEncoding
$script:UseChinese = Test-ChineseFontAvailable

function Write-Step([string]$Message) {
  Write-Host "[DAL Claude]" $Message -ForegroundColor Cyan
}

function Start-WaitProgress([string]$Message) {
  if ([string]::IsNullOrWhiteSpace($Message)) {
    return $null
  }

  Write-Host ("[DAL Claude] {0} " -f $Message) -NoNewline -ForegroundColor Cyan
  Write-Host "." -NoNewline -ForegroundColor DarkGray
  return [PSCustomObject]@{
    Stopwatch = [Diagnostics.Stopwatch]::StartNew()
    DotCount = 1
  }
}

function Update-WaitProgress($State) {
  if (-not $State) {
    return
  }

  $targetDotCount = [Math]::Floor($State.Stopwatch.Elapsed.TotalSeconds) + 1
  while ($State.DotCount -lt $targetDotCount) {
    Write-Host "." -NoNewline -ForegroundColor DarkGray
    $State.DotCount++
  }
}

function Complete-WaitProgress($State, [string]$Result) {
  if (-not $State) {
    return
  }

  $State.Stopwatch.Stop()
  $status = switch ($Result) {
    "success" { Get-DisplayText "完成" "done" }
    "timeout" { Get-DisplayText "超时" "timed out" }
    default { Get-DisplayText "失败" "failed" }
  }
  $elapsedText = if ($script:UseChinese) {
    "{0}（{1:N1} 秒）" -f $status, $State.Stopwatch.Elapsed.TotalSeconds
  }
  else {
    "{0} ({1:N1} s)" -f $status, $State.Stopwatch.Elapsed.TotalSeconds
  }
  $color = switch ($Result) {
    "success" { [ConsoleColor]::Green }
    "timeout" { [ConsoleColor]::Yellow }
    default { [ConsoleColor]::Red }
  }

  # Always finish the progress indicator with a newline. This avoids the
  # following installer message being drawn on the same console row.
  Write-Host (" {0}" -f $elapsedText) -ForegroundColor $color
}

function Ensure-Directory([string]$Path) {
  if (-not (Test-Path -LiteralPath $Path)) {
    New-Item -ItemType Directory -Path $Path -Force | Out-Null
  }
}

function Get-CurrentUserProfile {
  if ($env:USERPROFILE -and $env:USERPROFILE.Trim()) {
    return $env:USERPROFILE
  }

  $profilePath = [Environment]::GetFolderPath("UserProfile")
  if ($profilePath -and $profilePath.Trim()) {
    return $profilePath
  }

  throw (Get-DisplayText "无法确定当前用户目录。" "Unable to determine the current user profile directory.")
}

function Get-PlainTextFromSecureString([Security.SecureString]$SecureValue) {
  $pointer = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($SecureValue)
  try {
    return [Runtime.InteropServices.Marshal]::PtrToStringBSTR($pointer)
  }
  finally {
    [Runtime.InteropServices.Marshal]::ZeroFreeBSTR($pointer)
  }
}

function Get-BasicAuthHeader([string]$UserName, [string]$Password) {
  $bytes = [Text.Encoding]::UTF8.GetBytes("${UserName}:${Password}")
  return "Basic " + [Convert]::ToBase64String($bytes)
}

function Get-HttpStatusCodeFromError($ErrorRecord) {
  if (-not $ErrorRecord) {
    return $null
  }

  $exception = $ErrorRecord.Exception
  while ($exception) {
    if ($exception.Data -and $exception.Data.Contains("HttpStatusCode")) {
      return [int]$exception.Data["HttpStatusCode"]
    }
    if ($exception.Response -and $exception.Response.StatusCode) {
      return [int]$exception.Response.StatusCode
    }
    $exception = $exception.InnerException
  }

  return $null
}

function Download-File(
  [string]$Uri,
  [string]$Destination,
  [hashtable]$Headers = @{},
  [int]$TimeoutSec = 0,
  [string]$DisplayName = ""
) {
  $request = $null
  $response = $null
  $sourceStream = $null
  $destinationStream = $null
  $downloadSucceeded = $false
  $showProgress = -not [string]::IsNullOrWhiteSpace($DisplayName)
  $progressId = 42001
  $stopwatch = [Diagnostics.Stopwatch]::StartNew()

  try {
    $request = [Net.HttpWebRequest]::Create($Uri)
    $request.Method = "GET"
    $request.UserAgent = "DAL-Claude-Installer/1.0"
    $request.AllowAutoRedirect = $true
    if ($TimeoutSec -gt 0) {
      $request.Timeout = $TimeoutSec * 1000
      $request.ReadWriteTimeout = $TimeoutSec * 1000
    }

    foreach ($headerName in $Headers.Keys) {
      $request.Headers[[string]$headerName] = [string]$Headers[$headerName]
    }

    $response = [Net.HttpWebResponse]$request.GetResponse()
    $contentLength = [Int64]$response.ContentLength
    $sourceStream = $response.GetResponseStream()
    $destinationStream = [IO.File]::Open(
      $Destination,
      [IO.FileMode]::Create,
      [IO.FileAccess]::Write,
      [IO.FileShare]::None
    )

    $buffer = New-Object byte[] (1024 * 1024)
    $totalBytes = [Int64]0
    $lastProgressMilliseconds = [Int64](-1000)
    # Legacy Windows PowerShell miscalculates CJK character widths inside
    # Write-Progress. Keep the dynamic progress title ASCII-only so it does
    # not overlap; the surrounding installer steps remain localized.
    $activity = "Downloading: $DisplayName"

    while (($bytesRead = $sourceStream.Read($buffer, 0, $buffer.Length)) -gt 0) {
      $destinationStream.Write($buffer, 0, $bytesRead)
      $totalBytes += $bytesRead

      if ($showProgress -and
        ($stopwatch.ElapsedMilliseconds - $lastProgressMilliseconds -ge 500 -or
          ($contentLength -gt 0 -and $totalBytes -ge $contentLength))) {
        $elapsedSeconds = [Math]::Max($stopwatch.Elapsed.TotalSeconds, 0.001)
        $speedMb = ($totalBytes / 1MB) / $elapsedSeconds

        if ($contentLength -gt 0) {
          $percent = [Math]::Min(
            100,
            [Math]::Floor(($totalBytes * 100.0) / $contentLength)
          )
          $status = "{0:N1} / {1:N1} MB | {2}% | {3:N1} MB/s" -f `
            ($totalBytes / 1MB),
            ($contentLength / 1MB),
            $percent,
            $speedMb
          Write-Progress `
            -Id $progressId `
            -Activity $activity `
            -Status $status `
            -PercentComplete $percent
        }
        else {
          $status = "{0:N1} MB | {1:N1} MB/s" -f ($totalBytes / 1MB), $speedMb
          Write-Progress `
            -Id $progressId `
            -Activity $activity `
            -Status $status `
            -PercentComplete -1
        }

        $lastProgressMilliseconds = $stopwatch.ElapsedMilliseconds
      }
    }

    $destinationStream.Flush()
    if ($contentLength -ge 0 -and $totalBytes -ne $contentLength) {
      throw (Get-DisplayText `
        "下载中断：预期 $contentLength 字节，实际收到 $totalBytes 字节。" `
        "Download interrupted: expected $contentLength bytes but received $totalBytes bytes.")
    }

    $downloadSucceeded = $true
    if ($showProgress) {
      Write-Progress -Id $progressId -Activity $activity -Completed
      $elapsedSeconds = [Math]::Max($stopwatch.Elapsed.TotalSeconds, 0.001)
      $averageSpeedMb = ($totalBytes / 1MB) / $elapsedSeconds
      $completedMessage = Get-DisplayText `
        ("下载完成：{0}（{1:N1} MB，平均 {2:N1} MB/s）" -f $DisplayName, ($totalBytes / 1MB), $averageSpeedMb) `
        ("Download complete: {0} ({1:N1} MB, average {2:N1} MB/s)" -f $DisplayName, ($totalBytes / 1MB), $averageSpeedMb)
      Write-Host $completedMessage -ForegroundColor Green
    }
  }
  finally {
    $stopwatch.Stop()
    if ($showProgress) {
      Write-Progress -Id $progressId -Activity $DisplayName -Completed -ErrorAction SilentlyContinue
    }
    if ($destinationStream) {
      $destinationStream.Dispose()
    }
    if ($sourceStream) {
      $sourceStream.Dispose()
    }
    if ($response) {
      $response.Dispose()
    }
    if ($request) {
      $request.Abort()
    }
    if (-not $downloadSucceeded -and (Test-Path -LiteralPath $Destination)) {
      Remove-Item -LiteralPath $Destination -Force -ErrorAction SilentlyContinue
    }
  }
}

function Get-Text(
  [string]$Uri,
  [int]$TimeoutSec = 0,
  [string]$WaitMessage = ""
) {
  $request = $null
  $response = $null
  $responseStream = $null
  $reader = $null
  $waitResult = "failure"
  $waitState = Start-WaitProgress $WaitMessage
  $requestStopwatch = [Diagnostics.Stopwatch]::StartNew()

  try {
    $request = [Net.HttpWebRequest]::Create($Uri)
    $request.Method = "GET"
    $request.UserAgent = "DAL-Claude-Installer/1.0"
    $request.AllowAutoRedirect = $true
    if ($TimeoutSec -gt 0) {
      $request.Timeout = $TimeoutSec * 1000
      $request.ReadWriteTimeout = $TimeoutSec * 1000
    }

    $asyncResponse = $request.BeginGetResponse($null, $null)
    while (-not $asyncResponse.AsyncWaitHandle.WaitOne(200)) {
      if ($TimeoutSec -gt 0 -and
        $requestStopwatch.Elapsed.TotalSeconds -ge $TimeoutSec) {
        $waitResult = "timeout"
        $request.Abort()
        throw (Get-DisplayText "网络请求超时。" "The network request timed out.")
      }

      Update-WaitProgress $waitState
    }

    $response = [Net.HttpWebResponse]$request.EndGetResponse($asyncResponse)
    $responseStream = $response.GetResponseStream()
    $reader = New-Object IO.StreamReader(
      $responseStream,
      [Text.Encoding]::UTF8,
      $true
    )
    $text = $reader.ReadToEnd()
    $waitResult = "success"
    return $text.Trim()
  }
  finally {
    $requestStopwatch.Stop()
    if ($reader) {
      $reader.Dispose()
    }
    if ($responseStream) {
      $responseStream.Dispose()
    }
    if ($response) {
      $response.Dispose()
    }
    if ($request) {
      $request.Abort()
    }
    Complete-WaitProgress -State $waitState -Result $waitResult
  }
}

function Assert-Sha256([string]$Path, [string]$Expected) {
  $actual = (Get-FileHash -LiteralPath $Path -Algorithm SHA256).Hash.ToLowerInvariant()
  if ($actual -ne $Expected.ToLowerInvariant()) {
    throw (Get-DisplayText "SHA256 校验失败：$Path" "SHA256 verification failed: $Path")
  }
}

function Get-SemanticVersionText([string]$Uri, [int]$TimeoutSec = 15) {
  $sourceLabel = if ($Uri.StartsWith($claudeOfficialBaseUrl, [StringComparison]::OrdinalIgnoreCase)) {
    Get-DisplayText "Claude 官方" "Claude official"
  }
  elseif ($Uri.StartsWith($claudeRelayBaseUrl, [StringComparison]::OrdinalIgnoreCase)) {
    Get-DisplayText "DAL 高速中转" "DAL high-speed relay"
  }
  elseif ($Uri.StartsWith("$baseUrl/claude-code-releases", [StringComparison]::OrdinalIgnoreCase)) {
    Get-DisplayText "腾讯云镜像" "Tencent Cloud mirror"
  }
  else {
    Get-DisplayText "远程来源" "the remote source"
  }
  $waitMessage = Get-DisplayText `
    "正在查询$sourceLabel最新版本" `
    "Checking the latest version from $sourceLabel"
  $versionText = Get-Text `
    -Uri $Uri `
    -TimeoutSec $TimeoutSec `
    -WaitMessage $waitMessage
  if ($versionText -notmatch "^\d+\.\d+\.\d+$") {
    throw (Get-DisplayText "版本号无效：$versionText" "Invalid version number: $versionText")
  }
  return $versionText
}

function Test-PartialDownload(
  [string]$Uri,
  [int]$ExpectedBytes = 262144,
  [int]$TimeoutSec = 15
) {
  $request = $null
  $response = $null
  $stream = $null
  $probeSucceeded = $false
  $waitResult = "failure"
  $probeStopwatch = [Diagnostics.Stopwatch]::StartNew()
  $sourceLabel = if ($Uri.StartsWith($claudeOfficialBaseUrl, [StringComparison]::OrdinalIgnoreCase)) {
    Get-DisplayText "Claude 官方" "Claude official"
  }
  elseif ($Uri.StartsWith($claudeRelayBaseUrl, [StringComparison]::OrdinalIgnoreCase)) {
    Get-DisplayText "DAL 高速中转" "DAL high-speed relay"
  }
  else {
    Get-DisplayText "当前来源" "the selected source"
  }
  $waitMessage = Get-DisplayText `
    "正在探测$sourceLabel下载链路" `
    "Testing the $sourceLabel download path"
  $waitState = Start-WaitProgress $waitMessage

  try {
    $request = [Net.HttpWebRequest]::Create($Uri)
    $request.Method = "GET"
    $request.UserAgent = "DAL-Claude-Installer/1.0"
    $request.AllowAutoRedirect = $true
    $request.Timeout = $TimeoutSec * 1000
    $request.ReadWriteTimeout = $TimeoutSec * 1000
    $request.AddRange([Int64]0, [Int64]($ExpectedBytes - 1))

    $asyncResponse = $request.BeginGetResponse($null, $null)
    while (-not $asyncResponse.AsyncWaitHandle.WaitOne(200)) {
      if ($probeStopwatch.Elapsed.TotalSeconds -ge $TimeoutSec) {
        $waitResult = "timeout"
        $request.Abort()
        return $false
      }

      Update-WaitProgress $waitState
    }

    $response = [Net.HttpWebResponse]$request.EndGetResponse($asyncResponse)
    if ([int]$response.StatusCode -ne 206 -or $response.ContentLength -ne $ExpectedBytes) {
      return $false
    }

    $stream = $response.GetResponseStream()
    $buffer = New-Object byte[] 32768
    $totalBytes = 0
    while ($totalBytes -lt $ExpectedBytes) {
      $remaining = $ExpectedBytes - $totalBytes
      $readSize = [Math]::Min($buffer.Length, $remaining)
      $asyncRead = $stream.BeginRead($buffer, 0, $readSize, $null, $null)
      while (-not $asyncRead.AsyncWaitHandle.WaitOne(200)) {
        if ($probeStopwatch.Elapsed.TotalSeconds -ge $TimeoutSec) {
          $waitResult = "timeout"
          $request.Abort()
          return $false
        }

        Update-WaitProgress $waitState
      }
      $bytesRead = $stream.EndRead($asyncRead)
      if ($bytesRead -le 0) {
        return $false
      }
      $totalBytes += $bytesRead
    }

    $probeSucceeded = ($totalBytes -eq $ExpectedBytes)
    if ($probeSucceeded) {
      $waitResult = "success"
    }
    return $probeSucceeded
  }
  catch {
    return $false
  }
  finally {
    $probeStopwatch.Stop()
    if ($stream) {
      $stream.Dispose()
    }
    if ($response) {
      $response.Dispose()
    }
    if ($request) {
      $request.Abort()
    }
    Complete-WaitProgress -State $waitState -Result $waitResult
  }
}

function Get-ClaudeManifestInfo(
  [string]$ManifestUri,
  [string]$ExpectedVersion,
  [int]$TimeoutSec = 30
) {
  $manifest = Invoke-RestMethod -Uri $ManifestUri -TimeoutSec $TimeoutSec
  if ([string]$manifest.version -ne $ExpectedVersion) {
    throw (Get-DisplayText "Claude Code 清单版本与目标版本不一致。" "The Claude Code manifest version does not match the target version.")
  }

  $windowsBuild = $manifest.platforms."win32-x64"
  if (-not $windowsBuild -or [string]$windowsBuild.checksum -notmatch "^[0-9a-fA-F]{64}$") {
    throw (Get-DisplayText "Claude Code 清单缺少 Windows x64 校验信息。" "The Claude Code manifest is missing Windows x64 verification data.")
  }

  $expectedSize = [Int64]0
  if (-not [Int64]::TryParse([string]$windowsBuild.size, [ref]$expectedSize) -or $expectedSize -le 0) {
    throw (Get-DisplayText "Claude Code 清单中的 Windows x64 文件大小无效。" "The Windows x64 file size in the Claude Code manifest is invalid.")
  }

  return [PSCustomObject]@{
    Checksum = ([string]$windowsBuild.checksum).ToLowerInvariant()
    Size = $expectedSize
  }
}

function Download-VerifiedClaude(
  [string]$SourceBaseUrl,
  [string]$Version,
  [string]$Destination
) {
  $manifestInfo = Get-ClaudeManifestInfo `
    -ManifestUri "$SourceBaseUrl/$Version/manifest.json" `
    -ExpectedVersion $Version

  Download-File `
    -Uri "$SourceBaseUrl/$Version/win32-x64/claude.exe" `
    -Destination $Destination `
    -DisplayName "Claude Code $Version"

  $actualSize = (Get-Item -LiteralPath $Destination).Length
  if ($actualSize -ne $manifestInfo.Size) {
    throw (Get-DisplayText "Claude Code 下载文件大小不正确。" "The downloaded Claude Code file size is incorrect.")
  }
  Assert-Sha256 -Path $Destination -Expected $manifestInfo.Checksum
}

function Get-ClaudeSourceInfo([string]$Kind) {
  switch ($Kind) {
    "official" {
      return [PSCustomObject]@{
        Kind = "official"
        BaseUrl = $claudeOfficialBaseUrl
        Label = Get-DisplayText "Claude 官方" "Claude official"
        RequiresProbe = $true
      }
    }
    "relay" {
      return [PSCustomObject]@{
        Kind = "relay"
        BaseUrl = $claudeRelayBaseUrl
        Label = Get-DisplayText "DAL 高速中转" "DAL high-speed relay"
        RequiresProbe = $true
      }
    }
    "mirror" {
      return [PSCustomObject]@{
        Kind = "mirror"
        BaseUrl = "$baseUrl/claude-code-releases"
        Label = Get-DisplayText "腾讯云镜像" "Tencent Cloud mirror"
        RequiresProbe = $false
      }
    }
    default {
      throw "Unknown Claude source: $Kind"
    }
  }
}

function Get-StandardNodeLtsInfo(
  [string]$SourceBaseUrl,
  [string]$SourceDescription
) {
  $nodeIndex = Invoke-RestMethod -Uri "$SourceBaseUrl/index.json" -TimeoutSec 15
  $release = $nodeIndex | Where-Object { $_.lts } | Select-Object -First 1
  if (-not $release -or [string]$release.version -notmatch "^v\d+\.\d+\.\d+$") {
    throw (Get-DisplayText `
      "$SourceDescription 的 Node.js 索引中没有有效的 LTS 版本。" `
      "No valid Node.js LTS release was found through $SourceDescription.")
  }

  $version = [string]$release.version
  $fileName = "node-$version-win-x64.zip"
  return [PSCustomObject]@{
    Version = $version
    File = $fileName
  }
}

function Get-NodeChecksumFromShasums([string]$Shasums, [string]$FileName) {
  $escapedFileName = [regex]::Escape($FileName)
  $match = [regex]::Match(
    $Shasums,
    "(?mi)^([0-9a-f]{64})\s+\*?$escapedFileName\s*$"
  )
  if (-not $match.Success) {
    throw (Get-DisplayText "Node.js 官方校验清单中找不到 $FileName。" "The official Node.js checksum list does not contain $FileName.")
  }
  return $match.Groups[1].Value.ToLowerInvariant()
}

function Download-VerifiedStandardNode(
  [string]$SourceBaseUrl,
  [string]$SourceDescription,
  [string]$Destination
) {
  $nodeInfo = Get-StandardNodeLtsInfo `
    -SourceBaseUrl $SourceBaseUrl `
    -SourceDescription $SourceDescription
  $shasums = Get-Text "$SourceBaseUrl/$($nodeInfo.Version)/SHASUMS256.txt" 15
  $checksum = Get-NodeChecksumFromShasums `
    -Shasums $shasums `
    -FileName $nodeInfo.File

  Download-File `
    -Uri "$SourceBaseUrl/$($nodeInfo.Version)/$($nodeInfo.File)" `
    -Destination $Destination `
    -DisplayName "Node.js $($nodeInfo.Version)"
  Assert-Sha256 -Path $Destination -Expected $checksum
  return $nodeInfo
}

function Download-VerifiedMirrorNode([string]$Destination) {
  $version = Get-Text "$baseUrl/node-releases/latest" 15
  if ($version -notmatch "^v\d+\.\d+\.\d+$") {
    throw (Get-DisplayText "Node.js 镜像版本号无效。" "The Node.js mirror returned an invalid version number.")
  }

  $manifest = Invoke-RestMethod `
    -Uri "$baseUrl/node-releases/$version/manifest.json" `
    -TimeoutSec 30
  if ([string]$manifest.checksum -notmatch "^[0-9a-fA-F]{64}$" -or
    [string]$manifest.file -notmatch "^node-v\d+\.\d+\.\d+-win-x64\.zip$") {
    throw (Get-DisplayText `
      "Node.js 镜像清单缺少有效的校验信息。" `
      "The Node.js mirror manifest is missing valid verification data.")
  }

  $archiveName = [string]$manifest.file
  Download-File `
    -Uri "$baseUrl/node-releases/$version/$archiveName" `
    -Destination $Destination `
    -DisplayName "Node.js $version"
  Assert-Sha256 -Path $Destination -Expected ([string]$manifest.checksum)

  return [PSCustomObject]@{
    Version = $version
    File = $archiveName
  }
}

function Get-ClaudeVersionInfo([string[]]$CandidatePaths) {
  $seenPaths = @{}
  $bestMatch = $null

  foreach ($candidatePath in $CandidatePaths) {
    if (-not $candidatePath -or -not (Test-Path -LiteralPath $candidatePath -PathType Leaf)) {
      continue
    }

    try {
      $resolvedPath = (Resolve-Path -LiteralPath $candidatePath).Path
      $pathKey = $resolvedPath.ToLowerInvariant()
      if ($seenPaths.ContainsKey($pathKey)) {
        continue
      }
      $seenPaths[$pathKey] = $true

      $versionOutput = (& $resolvedPath --version 2>$null | Out-String).Trim()
      $versionMatch = [regex]::Match($versionOutput, "(?<!\d)(\d+\.\d+\.\d+)(?!\d)")
      if (-not $versionMatch.Success) {
        continue
      }

      $parsedVersion = [version]$versionMatch.Groups[1].Value
      if (-not $bestMatch -or $parsedVersion -gt $bestMatch.ParsedVersion) {
        $bestMatch = [PSCustomObject]@{
          Path = $resolvedPath
          Version = $versionMatch.Groups[1].Value
          ParsedVersion = $parsedVersion
          DisplayVersion = $versionOutput
        }
      }
    }
    catch {
      continue
    }
  }

  return $bestMatch
}

function Read-LatestVersionAction {
  while ($true) {
    Write-Host ""
    Write-Host (Get-DisplayText `
      "1. 仅更新默认 Claude 配置并检查 Node/PATH（推荐）" `
      "1. Refresh default Claude settings and check Node/PATH (recommended)") -ForegroundColor Cyan
    Write-Host (Get-DisplayText `
      "2. 直接退出，不做任何修改" `
      "2. Exit without making any changes") -ForegroundColor Cyan
    Write-Host ""
    $choicePrompt = Get-DisplayText `
      "请输入 1 或 2（直接按回车默认选择 1）" `
      "Enter 1 or 2 (press Enter to select 1)"
    $choice = Read-Host $choicePrompt

    if ([string]::IsNullOrWhiteSpace($choice) -or $choice.Trim() -eq "1") {
      return "refresh"
    }
    if ($choice.Trim() -eq "2") {
      return "exit"
    }

    Write-Host (Get-DisplayText "请输入 1 或 2。" "Please enter 1 or 2.") -ForegroundColor Yellow
  }
}

function Read-DownloadSourceChoice {
  while ($true) {
    Write-Host ""
    Write-Host (Get-DisplayText `
      "请选择安装文件下载来源：" `
      "Choose an installation-file download source:") -ForegroundColor Cyan
    Write-Host ""
    Write-Host (Get-DisplayText `
      "1. 自动选择（推荐：官方直连 → DAL 高速中转 → 腾讯云镜像）" `
      "1. Automatic (recommended: official direct, DAL relay, then Tencent Cloud mirror)") -ForegroundColor Cyan
    Write-Host (Get-DisplayText `
      "2. Claude 官方直连（国外，需要网络代理）" `
      "2. Claude official direct (overseas; network proxy required in mainland China)") -ForegroundColor Cyan
    Write-Host (Get-DisplayText `
      "3. DAL 高速中转（无需代理，实时获取官方文件）" `
      "3. DAL high-speed relay (no proxy required; streams official files)") -ForegroundColor Cyan
    Write-Host (Get-DisplayText `
      "4. 腾讯云镜像（国内备用，速度较慢）" `
      "4. Tencent Cloud mirror (domestic fallback; slower)") -ForegroundColor Cyan
    Write-Host ""
    $choicePrompt = Get-DisplayText `
      "请输入 1、2、3 或 4（直接按回车默认选择 1）" `
      "Enter 1, 2, 3, or 4 (press Enter to select 1)"
    $choice = Read-Host $choicePrompt

    if ([string]::IsNullOrWhiteSpace($choice) -or $choice.Trim() -eq "1") {
      return "auto"
    }
    if ($choice.Trim() -eq "2") {
      return "official"
    }
    if ($choice.Trim() -eq "3") {
      return "relay"
    }
    if ($choice.Trim() -eq "4") {
      return "mirror"
    }

    Write-Host (Get-DisplayText "请输入 1、2、3 或 4。" "Please enter 1, 2, 3, or 4.") -ForegroundColor Yellow
  }
}

function Publish-FileAtomic([string]$StagedPath, [string]$Destination) {
  if (Test-Path -LiteralPath $Destination) {
    $replaceBackup = "$Destination.replace-backup-$([Guid]::NewGuid().ToString("N"))"
    [IO.File]::Replace($StagedPath, $Destination, $replaceBackup)
    Remove-Item -LiteralPath $replaceBackup -Force -ErrorAction SilentlyContinue
  }
  else {
    [IO.File]::Move($StagedPath, $Destination)
  }
}

function Add-ProcessPath([string[]]$Entries) {
  $current = @($env:Path -split ";" | Where-Object { $_ -and $_.Trim() })
  $merged = @()
  foreach ($entry in $Entries) {
    if ($entry -and -not ($current | Where-Object { $_.TrimEnd("\") -ieq $entry.TrimEnd("\") })) {
      $merged += $entry
    }
  }
  $env:Path = (@($merged + $current) | Select-Object -Unique) -join ";"
}

function Add-UserPath([string[]]$Entries) {
  $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
  $parts = @()
  if ($userPath) {
    $parts = @($userPath -split ";" | Where-Object { $_ -and $_.Trim() })
  }

  foreach ($entry in $Entries) {
    if ($entry -and -not ($parts | Where-Object { $_.TrimEnd("\") -ieq $entry.TrimEnd("\") })) {
      $parts += $entry
    }
  }

  [Environment]::SetEnvironmentVariable("Path", ($parts -join ";"), "User")
}

if ($env:OS -ne "Windows_NT") {
  throw (Get-DisplayText "当前一键安装只支持 Windows。" "This one-click installer supports Windows only.")
}
$nativeArchitecture = if ($env:PROCESSOR_ARCHITEW6432) {
  $env:PROCESSOR_ARCHITEW6432
}
else {
  $env:PROCESSOR_ARCHITECTURE
}
if (-not [Environment]::Is64BitOperatingSystem -or $nativeArchitecture -ne "AMD64") {
  throw (Get-DisplayText `
    "当前一键安装只支持 Windows x64，暂不支持 32 位或 ARM64。" `
    "This one-click installer supports Windows x64 only; 32-bit and ARM64 are not supported.")
}
if ($PSVersionTable.PSVersion.Major -lt 5) {
  throw (Get-DisplayText "需要 PowerShell 5.0 或更高版本。" "PowerShell 5.0 or later is required.")
}
if (-not $script:UseChinese) {
  Write-Step "Chinese console support was not detected; using English."
}

$userProfileDir = Get-CurrentUserProfile
$claudeDir = Join-Path $userProfileDir ".claude"
$settingsPath = Join-Path $claudeDir "settings.json"
$claudeBinDir = Join-Path $userProfileDir ".local\bin"
$claudePath = Join-Path $claudeBinDir "claude.exe"
$nodeRoot = Join-Path $env:LOCALAPPDATA "Programs\DALClaudeBootstrap\node"

Write-Step (Get-DisplayText "检查 Claude Code 本地版本和最新版本" "Checking local and latest Claude Code versions")
$downloadSourceChoice = "auto"
$claudeVersionSource = $null
$claudeVersionSourceLabel = $null
$claudeVersion = $null
$preflightVersions = @{}

foreach ($preflightKind in @("official", "relay", "mirror")) {
  $preflightSource = Get-ClaudeSourceInfo $preflightKind
  try {
    # The latest pointer is only a few bytes. In automatic mode, five
    # seconds is enough to distinguish a usable route without making users
    # in mainland China wait 15 seconds for the official endpoint.
    $claudeVersion = Get-SemanticVersionText `
      -Uri "$($preflightSource.BaseUrl)/latest" `
      -TimeoutSec 5
    $preflightVersions[$preflightKind] = $claudeVersion
    $claudeVersionSource = $preflightSource.Kind
    $claudeVersionSourceLabel = $preflightSource.Label
    break
  }
  catch {
    $nextLabel = switch ($preflightKind) {
      "official" { Get-DisplayText "DAL 高速中转" "the DAL high-speed relay" }
      "relay" { Get-DisplayText "腾讯云镜像" "the Tencent Cloud mirror" }
      default { $null }
    }
    if ($nextLabel) {
      Write-Step (Get-DisplayText `
        "$($preflightSource.Label)最新版接口不可用，尝试$nextLabel" `
        "The $($preflightSource.Label) latest-version endpoint is unavailable; trying $nextLabel")
    }
  }
}

if (-not $claudeVersion) {
  throw (Get-DisplayText `
    "无法通过 Claude 官方、DAL 高速中转或腾讯云镜像查询最新版本。Admin Key 尚未输入，本机未作修改，请稍后重试。" `
    "Unable to query the latest Claude Code version through the official source, DAL relay, or Tencent Cloud mirror. No Admin Key was requested and no changes were made. Please try again later.")
}

$pathClaudeCommand = Get-Command claude.exe -ErrorAction SilentlyContinue
$candidatePaths = @($claudePath)
if ($pathClaudeCommand -and $pathClaudeCommand.Source) {
  $candidatePaths += $pathClaudeCommand.Source
}

$localClaude = Get-ClaudeVersionInfo -CandidatePaths $candidatePaths
$installClaude = -not ($localClaude -and $localClaude.ParsedVersion -ge ([version]$claudeVersion))
$activeClaudePath = $claudePath
$latestAction = $null

if ($installClaude) {
  $downloadSourceChoice = Read-DownloadSourceChoice
  $sourceCandidates = switch ($downloadSourceChoice) {
    "official" { @("official") }
    "relay" { @("relay") }
    "mirror" { @("mirror") }
    default {
      # Reuse the preflight result. If the official endpoint already timed
      # out before the source prompt, do not make the user wait for the same
      # timeout again after pressing Enter.
      switch ($claudeVersionSource) {
        "official" { @("official", "relay", "mirror") }
        "relay" { @("relay", "mirror") }
        "mirror" { @("mirror") }
        default { @("official", "relay", "mirror") }
      }
    }
  }

  $sourceResolved = $false
  foreach ($candidateKind in $sourceCandidates) {
    $candidateSource = Get-ClaudeSourceInfo $candidateKind
    if ($preflightVersions.ContainsKey($candidateKind)) {
      $candidateVersion = [string]$preflightVersions[$candidateKind]
    }
    else {
      try {
        $candidateLatestTimeout = if ($downloadSourceChoice -eq "auto") {
          5
        }
        else {
          15
        }
        $candidateVersion = Get-SemanticVersionText `
          -Uri "$($candidateSource.BaseUrl)/latest" `
          -TimeoutSec $candidateLatestTimeout
      }
      catch {
        if ($downloadSourceChoice -ne "auto") {
          throw (Get-DisplayText `
            "$($candidateSource.Label)不可用或版本号无效。你选择了仅使用此来源，因此不会自动切换；Admin Key 尚未输入，本机未作修改。" `
            "$($candidateSource.Label) is unavailable or returned an invalid version. Because this source was explicitly selected, no automatic fallback will be used. No Admin Key was requested and no changes were made.")
        }
        Write-Step (Get-DisplayText `
          "$($candidateSource.Label)最新版接口不可用，尝试下一个来源" `
          "The $($candidateSource.Label) latest-version endpoint is unavailable; trying the next source")
        continue
      }
    }

    $candidateInstall = -not (
      $localClaude -and
      $localClaude.ParsedVersion -ge ([version]$candidateVersion)
    )

    if ($candidateInstall -and $candidateSource.RequiresProbe) {
      Write-Step (Get-DisplayText `
        "探测$($candidateSource.Label)下载链路（256 KiB）" `
        "Testing the $($candidateSource.Label) download path (256 KiB)")
      $candidateBinaryUri = "$($candidateSource.BaseUrl)/$candidateVersion/win32-x64/claude.exe"
      if (-not (Test-PartialDownload `
          -Uri $candidateBinaryUri `
          -ExpectedBytes 262144 `
          -TimeoutSec 15)) {
        if ($downloadSourceChoice -ne "auto") {
          throw (Get-DisplayText `
            "$($candidateSource.Label)下载探测失败。你选择了仅使用此来源，因此不会自动切换；Admin Key 尚未输入，本机未作修改。" `
            "The $($candidateSource.Label) download test failed. Because this source was explicitly selected, no automatic fallback will be used. No Admin Key was requested and no changes were made.")
        }
        Write-Step (Get-DisplayText `
          "$($candidateSource.Label)下载链路不可用，尝试下一个来源" `
          "The $($candidateSource.Label) download path is unavailable; trying the next source")
        continue
      }
      Write-Step (Get-DisplayText `
        "$($candidateSource.Label)下载链路可用" `
        "The $($candidateSource.Label) download path is available")
    }

    $claudeVersion = $candidateVersion
    $claudeVersionSource = $candidateSource.Kind
    $claudeVersionSourceLabel = $candidateSource.Label
    $installClaude = $candidateInstall
    $sourceResolved = $true
    break
  }

  if (-not $sourceResolved) {
    throw (Get-DisplayText `
      "Claude 官方直连、DAL 高速中转和腾讯云镜像均不可用。Admin Key 尚未输入，本机未作修改，请稍后重试。" `
      "The Claude official source, DAL high-speed relay, and Tencent Cloud mirror are all unavailable. No Admin Key was requested and no changes were made. Please try again later.")
  }
}

if (-not $installClaude) {
  $activeClaudePath = $localClaude.Path
  Write-Host ""
  Write-Host (Get-DisplayText `
    "检测到本机 Claude Code $($localClaude.Version)" `
    "Installed Claude Code: $($localClaude.Version)") -ForegroundColor Green
  Write-Host (Get-DisplayText `
    "$($claudeVersionSourceLabel)最新版本 $claudeVersion" `
    "Latest $claudeVersionSourceLabel version: $claudeVersion") -ForegroundColor Green
  if ($localClaude.ParsedVersion -gt ([version]$claudeVersion)) {
    Write-Host (Get-DisplayText `
      "本机版本更高，不会执行降级。" `
      "The installed version is newer and will not be downgraded.") -ForegroundColor Green
  }

  $latestAction = Read-LatestVersionAction
  if ($latestAction -eq "exit") {
    Write-Host ""
    Write-Host (Get-DisplayText `
      "已退出：未输入 Admin Key，也未修改 Claude、Node、PATH 或配置。" `
      "Exited: no Admin Key was requested and Claude, Node, PATH, and settings were not changed.") -ForegroundColor Green
    return
  }

  Write-Step (Get-DisplayText `
    "已跳过 Claude Code 程序下载，将检查 Node/PATH，最后刷新默认 Claude 配置" `
    "Skipping the Claude Code download; Node/PATH will be checked before the final default Claude settings refresh")
}
else {
  if ($localClaude) {
    Write-Step (Get-DisplayText `
      "检测到 Claude Code $($localClaude.Version)，将通过$($claudeVersionSourceLabel)源升级到 $claudeVersion" `
      "Claude Code $($localClaude.Version) was found and will be upgraded to $claudeVersion from the $claudeVersionSourceLabel source")
  }
  else {
    Write-Step (Get-DisplayText `
      "未检测到有效的 Claude Code，将通过$($claudeVersionSourceLabel)源安装 $claudeVersion" `
      "No valid Claude Code installation was found; $claudeVersion will be installed from the $claudeVersionSourceLabel source")
  }
}

$tempRoot = Join-Path $env:TEMP ("dal-claude-install-" + [Guid]::NewGuid().ToString("N"))
$downloadedSettings = Join-Path $tempRoot "settings.json"
$downloadedClaude = Join-Path $tempRoot "claude.exe"
$nodeZip = Join-Path $tempRoot "node.zip"

Ensure-Directory $tempRoot

try {
  if ($installClaude) {
    $claudeDownloadAttempts = if ($downloadSourceChoice -eq "auto") {
      switch ($claudeVersionSource) {
        "official" { @("official", "relay", "mirror") }
        "relay" { @("relay", "mirror") }
        default { @("mirror") }
      }
    }
    else {
      @($claudeVersionSource)
    }

    $claudeDownloadComplete = $false
    foreach ($attemptKind in $claudeDownloadAttempts) {
      $attemptSource = Get-ClaudeSourceInfo $attemptKind

      if ($attemptKind -ne $claudeVersionSource) {
        try {
          $attemptLatestTimeout = if ($downloadSourceChoice -eq "auto") {
            5
          }
          else {
            15
          }
          $attemptVersion = Get-SemanticVersionText `
            -Uri "$($attemptSource.BaseUrl)/latest" `
            -TimeoutSec $attemptLatestTimeout
        }
        catch {
          Write-Step (Get-DisplayText `
            "$($attemptSource.Label)最新版接口不可用，继续尝试下一个来源" `
            "The $($attemptSource.Label) latest-version endpoint is unavailable; continuing to the next source")
          continue
        }

        if ($attemptVersion -ne $claudeVersion) {
          Write-Step (Get-DisplayText `
            "$($attemptSource.Label)尚未提供 $claudeVersion，不会安装旧版本" `
            "$($attemptSource.Label) does not provide $claudeVersion yet; an older version will not be installed")
          continue
        }
      }

      try {
        Write-Step (Get-DisplayText `
          "从$($attemptSource.Label)下载 Claude Code $claudeVersion（Windows x64）" `
          "Downloading Claude Code $claudeVersion through $($attemptSource.Label) (Windows x64)")
        Download-VerifiedClaude `
          -SourceBaseUrl $attemptSource.BaseUrl `
          -Version $claudeVersion `
          -Destination $downloadedClaude
        $claudeVersionSource = $attemptSource.Kind
        $claudeVersionSourceLabel = $attemptSource.Label
        $claudeDownloadComplete = $true
        break
      }
      catch {
        Remove-Item -LiteralPath $downloadedClaude -Force -ErrorAction SilentlyContinue
        if ($downloadSourceChoice -ne "auto") {
          throw (Get-DisplayText `
            "$($attemptSource.Label)下载中断或校验失败。你选择了仅使用此来源，因此不会自动切换；Admin Key 尚未输入，本机未作修改。" `
            "The $($attemptSource.Label) download failed or did not pass verification. Because this source was explicitly selected, no automatic fallback will be used. No Admin Key was requested and no changes were made.")
        }

        Write-Step (Get-DisplayText `
          "$($attemptSource.Label)下载中断或校验失败，尝试下一个来源" `
          "The $($attemptSource.Label) download failed or did not pass verification; trying the next source")
      }
    }

    if (-not $claudeDownloadComplete) {
      throw (Get-DisplayText `
        "Claude 官方直连、DAL 高速中转和腾讯云镜像下载均失败，或备用来源尚未提供目标版本。原配置和程序均未修改，请稍后重试。" `
        "All Claude download sources failed, or the fallback sources do not provide the target version yet. Existing settings and programs were not changed. Please try again later.")
    }
  }

  $nodeCommand = Get-Command node.exe -ErrorAction SilentlyContinue
  $installNode = -not $nodeCommand
  $nodeVersion = $null
  $nodeExpandedDir = $null
  if ($installNode) {
    $nodeSourceCandidates = switch ($downloadSourceChoice) {
      "official" { @("official") }
      "relay" { @("relay") }
      "mirror" { @("mirror") }
      default {
        # Automatic mode has already tested and selected a working Claude
        # route. Reuse that route for Node.js instead of starting over from
        # nodejs.org, which may be reachable but extremely slow in China.
        switch ($claudeVersionSource) {
          "official" { @("official", "relay", "mirror") }
          "relay" { @("relay", "mirror") }
          "mirror" { @("mirror") }
          default { @("official", "relay", "mirror") }
        }
      }
    }

    $nodeDownloadComplete = $false
    foreach ($nodeSourceKind in $nodeSourceCandidates) {
      Remove-Item -LiteralPath $nodeZip -Force -ErrorAction SilentlyContinue

      try {
        switch ($nodeSourceKind) {
          "official" {
            Write-Step (Get-DisplayText `
              "未检测到 Node.js，从 nodejs.org 下载最新 LTS" `
              "Node.js was not found; downloading the latest LTS from nodejs.org")
            $nodeInfo = Download-VerifiedStandardNode `
              -SourceBaseUrl $nodeOfficialBaseUrl `
              -SourceDescription (Get-DisplayText "Node.js 官方" "the official Node.js source") `
              -Destination $nodeZip
          }
          "relay" {
            Write-Step (Get-DisplayText `
              "通过 DAL 高速中转下载最新 Node.js LTS" `
              "Downloading the latest Node.js LTS through the DAL high-speed relay")
            $nodeInfo = Download-VerifiedStandardNode `
              -SourceBaseUrl $nodeRelayBaseUrl `
              -SourceDescription (Get-DisplayText "DAL 高速中转" "the DAL high-speed relay") `
              -Destination $nodeZip
          }
          "mirror" {
            Write-Step (Get-DisplayText `
              "从腾讯云镜像下载最新 Node.js LTS" `
              "Downloading the latest Node.js LTS from the Tencent Cloud mirror")
            $nodeInfo = Download-VerifiedMirrorNode -Destination $nodeZip
          }
        }

        $nodeVersion = $nodeInfo.Version
        $nodeArchiveName = $nodeInfo.File
        $nodeDownloadComplete = $true
        break
      }
      catch {
        Remove-Item -LiteralPath $nodeZip -Force -ErrorAction SilentlyContinue
        if ($downloadSourceChoice -ne "auto") {
          throw (Get-DisplayText `
            "所选来源的 Node.js 下载或校验失败。Admin Key 尚未输入，原配置、Claude、Node 和 PATH 均未修改。" `
            "The Node.js download from the selected source failed or did not pass verification. No Admin Key was requested, and existing settings, Claude, Node, and PATH were not changed.")
        }
        Write-Step (Get-DisplayText `
          "当前 Node.js 来源不可用或校验失败，尝试下一个来源" `
          "The current Node.js source is unavailable or failed verification; trying the next source")
      }
    }

    if (-not $nodeDownloadComplete) {
      throw (Get-DisplayText `
        "Node.js 官方、DAL 高速中转和腾讯云镜像下载均失败。原配置、Claude、Node 和 PATH 均未修改，请稍后重试。" `
        "The official Node.js source, DAL high-speed relay, and Tencent Cloud mirror all failed. Existing settings, Claude, Node, and PATH were not changed. Please try again later.")
    }

    $nodeExtractRoot = Join-Path $tempRoot "node-extract"
    Expand-Archive -LiteralPath $nodeZip -DestinationPath $nodeExtractRoot -Force
    $nodeExpandedDir = Join-Path $nodeExtractRoot ([IO.Path]::GetFileNameWithoutExtension($nodeArchiveName))
    if (-not (Test-Path -LiteralPath (Join-Path $nodeExpandedDir "node.exe"))) {
      throw (Get-DisplayText `
        "Node.js 压缩包结构不正确。原配置未被修改。" `
        "The Node.js archive structure is invalid. Existing settings were not changed.")
    }
  }

  Write-Step (Get-DisplayText "安装已校验的文件" "Installing verified files")
  if ($installClaude) {
    Ensure-Directory $claudeBinDir
  }

  if ($installNode) {
    Ensure-Directory (Split-Path -Parent $nodeRoot)
    $stagedNodeRoot = "$nodeRoot.new-$([Guid]::NewGuid().ToString("N"))"
    Move-Item -LiteralPath $nodeExpandedDir -Destination $stagedNodeRoot
    if (Test-Path -LiteralPath $nodeRoot) {
      $oldNodeRoot = "$nodeRoot.bak-$(Get-Date -Format 'yyyyMMddHHmmss')"
      Move-Item -LiteralPath $nodeRoot -Destination $oldNodeRoot
    }
    Move-Item -LiteralPath $stagedNodeRoot -Destination $nodeRoot
    $nodeCommandPath = Join-Path $nodeRoot "node.exe"
  }
  else {
    $nodeCommandPath = $nodeCommand.Source
  }

  if ($installClaude) {
    $stagedClaude = Join-Path $claudeBinDir ("claude.exe.new-" + [Guid]::NewGuid().ToString("N"))
    Copy-Item -LiteralPath $downloadedClaude -Destination $stagedClaude
    Publish-FileAtomic -StagedPath $stagedClaude -Destination $claudePath
    $activeClaudePath = $claudePath
  }

  $pathEntries = @((Split-Path -Parent $activeClaudePath))
  if ($installNode) {
    $pathEntries += $nodeRoot
  }
  Add-ProcessPath -Entries $pathEntries
  Add-UserPath -Entries $pathEntries

  $installedClaudeVersion = (& $activeClaudePath --version | Out-String).Trim()
  $installedNodeVersion = (& $nodeCommandPath --version | Out-String).Trim()

  Write-Host ""
  Write-Host (Get-DisplayText `
    "Claude、Node 和 PATH 已处理完成。" `
    "Claude, Node, and PATH are ready.") -ForegroundColor Green
  Write-Host "Claude: $installedClaudeVersion" -ForegroundColor Green
  Write-Host "Node:   $installedNodeVersion" -ForegroundColor Green
  Write-Host ""

  Write-Step (Get-DisplayText `
    "最后一步：输入配置 Key 并更新默认 Claude 配置" `
    "Final step: enter a configuration Key and update the default Claude settings")
  $keyPrompt = Get-DisplayText `
    "请输入 Admin Key 或个人 API Key" `
    "Enter an Admin Key or personal API Key"
  $secureKey = Read-Host $keyPrompt -AsSecureString
  $plainKey = Get-PlainTextFromSecureString $secureKey
  if (-not $plainKey) {
    if ($secureKey) {
      $secureKey.Dispose()
    }
    throw (Get-DisplayText `
      "配置 Key 不能为空。Claude、Node 和 PATH 已处理完成，原配置未修改。" `
      "The configuration Key cannot be empty. Claude, Node, and PATH are ready; existing settings were not changed.")
  }

  $settingsMode = "administrator"
  $headers = @{ Authorization = Get-BasicAuthHeader -UserName $authUser -Password $plainKey }
  try {
    try {
      Download-File `
        -Uri "$baseUrl/claude/settings.json" `
        -Destination $downloadedSettings `
        -Headers $headers `
        -TimeoutSec 15
    }
    catch {
      $settingsStatusCode = Get-HttpStatusCodeFromError $_
      if ($settingsStatusCode -ne 401) {
        throw (Get-DisplayText `
          "默认 Claude 配置接口暂时不可用。Claude、Node 和 PATH 已处理完成，原配置未修改；请稍后重新运行安装器。" `
          "The default Claude settings endpoint is temporarily unavailable. Claude, Node, and PATH are ready; existing settings were not changed. Run the installer again later.")
      }

      Write-Step (Get-DisplayText `
        "Admin Key 未匹配，将输入内容作为个人 API Key 写入默认 Claude 配置" `
        "The Admin Key did not match; writing the entered personal API Key to the default Claude settings")
      try {
        Download-File `
          -Uri "$baseUrl/claude/settings-template.json" `
          -Destination $downloadedSettings `
          -TimeoutSec 15

        $templateSettings = Get-Content `
          -LiteralPath $downloadedSettings `
          -Raw `
          -Encoding UTF8 | ConvertFrom-Json
        if (-not $templateSettings.env -or
          [string]$templateSettings.env.ANTHROPIC_API_KEY -ne
            "__ANTHROPIC_API_KEY__") {
          throw "Invalid settings template placeholder."
        }

        $templateSettings.env.ANTHROPIC_API_KEY = $plainKey
        $personalSettingsJson = $templateSettings | ConvertTo-Json -Depth 100
        [IO.File]::WriteAllText(
          $downloadedSettings,
          $personalSettingsJson,
          (New-Object Text.UTF8Encoding($false))
        )
        $settingsMode = "personal"
      }
      catch {
        throw (Get-DisplayText `
          "个人配置模板暂时不可用或格式无效。Claude、Node 和 PATH 已处理完成，原配置未修改；请稍后重新运行安装器。" `
          "The personal settings template is unavailable or invalid. Claude, Node, and PATH are ready; existing settings were not changed. Run the installer again later.")
      }
    }
  }
  finally {
    $plainKey = $null
    if ($secureKey) {
      $secureKey.Dispose()
    }
  }

  try {
    Get-Content -LiteralPath $downloadedSettings -Raw -Encoding UTF8 | ConvertFrom-Json | Out-Null
  }
  catch {
    throw (Get-DisplayText `
      "服务器返回的 settings.json 不是合法 JSON。Claude、Node 和 PATH 已处理完成，原配置未修改。" `
      "The server returned an invalid settings.json file. Claude, Node, and PATH are ready; existing settings were not changed.")
  }

  Ensure-Directory $claudeDir
  if (Test-Path -LiteralPath $settingsPath) {
    $backupPath = "$settingsPath.bak-$(Get-Date -Format 'yyyyMMddHHmmss')"
    Copy-Item -LiteralPath $settingsPath -Destination $backupPath
    Write-Host (Get-DisplayText `
      "原配置已备份：$backupPath" `
      "Existing settings backup: $backupPath") -ForegroundColor Yellow
  }
  $stagedSettings = Join-Path $claudeDir ("settings.json.new-" + [Guid]::NewGuid().ToString("N"))
  Copy-Item -LiteralPath $downloadedSettings -Destination $stagedSettings
  Publish-FileAtomic -StagedPath $stagedSettings -Destination $settingsPath

  Write-Host ""
  $completionMessage = if ($installClaude) {
    Get-DisplayText "Claude Code 安装与配置完成。" "Claude Code installation and configuration are complete."
  }
  else {
    Get-DisplayText "Claude Code 已是最新版，默认 Claude 配置刷新完成。" "Claude Code is already current and the default Claude settings refresh is complete."
  }
  Write-Host $completionMessage -ForegroundColor Green
  if ($settingsMode -eq "personal") {
    Write-Host (Get-DisplayText `
      "配置方式：已写入输入的个人 API Key" `
      "Settings mode: the entered personal API Key was written") -ForegroundColor Green
  }
  else {
    Write-Host (Get-DisplayText `
      "配置方式：已复制默认 Claude 配置" `
      "Settings mode: default Claude settings copied") -ForegroundColor Green
  }
  Write-Host "Claude: $installedClaudeVersion" -ForegroundColor Green
  Write-Host "Node:   $installedNodeVersion" -ForegroundColor Green
  Write-Host ((Get-DisplayText "配置" "Settings") + ": $settingsPath") -ForegroundColor Green
  Write-Host ""
  Write-Host (Get-DisplayText "现在可以运行：" "You can now run:") -ForegroundColor Cyan
  Write-Host "claude" -ForegroundColor Yellow
  Write-Host (Get-DisplayText `
    "如果旧终端找不到 claude，请关闭后重新打开 PowerShell。" `
    "If this terminal cannot find claude, close it and open a new PowerShell window.") -ForegroundColor DarkYellow
}
finally {
  if (Test-Path -LiteralPath $tempRoot) {
    Remove-Item -LiteralPath $tempRoot -Recurse -Force -ErrorAction SilentlyContinue
  }
}