# Sundy Handbook · Claude Code installer for Windows
#
# Recommended:
#   try { $env:CLAUDE_SUNDY_NO_PAUSE='1'; $u='https://sundy.tumpai.site/install-claude.ps1'; iex ([System.Text.Encoding]::UTF8.GetString((New-Object Net.WebClient).DownloadData($u))) } catch { Write-Host ('Installer failed to start: ' + $_.Exception.Message) -ForegroundColor Red } finally { if (-not [Console]::IsInputRedirected) { Read-Host 'Press Enter to exit' } }
#
# Unattended:
#   $env:SUNDY_API_KEY='sk-xxx'; $env:CLAUDE_SUNDY_YES='1'; try { $env:CLAUDE_SUNDY_NO_PAUSE='1'; $u='https://sundy.tumpai.site/install-claude.ps1'; iex ([System.Text.Encoding]::UTF8.GetString((New-Object Net.WebClient).DownloadData($u))) } catch { Write-Host ('Installer failed to start: ' + $_.Exception.Message) -ForegroundColor Red } finally { if (-not [Console]::IsInputRedirected) { Read-Host 'Press Enter to exit' } }

$ErrorActionPreference = "Stop"

try {
  [Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)
  $OutputEncoding = [Console]::OutputEncoding
  if ($PSVersionTable.PSEdition -eq "Desktop") { chcp 65001 > $null }
  [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor [System.Net.SecurityProtocolType]::Tls12
} catch {}

$LogFile = Join-Path $env:TEMP "claude-sundy-install-last.log"

function Add-Log {
  param([string]$Message)
  if (-not $LogFile) { return }
  try { Add-Content -Encoding UTF8 -Path $LogFile -Value $Message } catch {}
}

try {
  "Claude Code installer started at $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')" | Set-Content -Encoding UTF8 -Path $LogFile
} catch {}

$BaseUrl = if ($env:ANTHROPIC_BASE_URL) { $env:ANTHROPIC_BASE_URL } elseif ($env:CLAUDE_BASE_URL) { $env:CLAUDE_BASE_URL } else { "https://sundy-api.tumpai.site:2053" }
$BaseUrl = $BaseUrl.TrimEnd("/")
if ($BaseUrl.EndsWith("/v1")) {
  $BaseUrl = $BaseUrl.Substring(0, $BaseUrl.Length - 3).TrimEnd("/")
}

$NonInteractive = $false
try {
  if ([Console]::IsInputRedirected) { $NonInteractive = $true }
} catch {
  $NonInteractive = $true
}

$AssumeYes = ($env:CLAUDE_SUNDY_YES -eq "1") -or ($env:CLAUDE_YES -eq "1") -or $NonInteractive

function Write-Title {
  param([string]$Message)
  Write-Host ""
  Write-Host "==> $Message" -ForegroundColor Cyan
  Add-Log "==> $Message"
}

function Write-Ok {
  param([string]$Message)
  Write-Host "OK: $Message" -ForegroundColor Green
  Add-Log "OK: $Message"
}

function Write-Info {
  param([string]$Message)
  Write-Host "INFO: $Message" -ForegroundColor Cyan
  Add-Log "INFO: $Message"
}

function Write-Warn2 {
  param([string]$Message)
  Write-Host "WARN: $Message" -ForegroundColor Yellow
  Add-Log "WARN: $Message"
}

function Write-Fail {
  param([string]$Message)
  throw $Message
}

function Wait-BeforeExit {
  if ($env:CLAUDE_SUNDY_NO_PAUSE -eq "1" -or $env:CI -eq "true") { return }
  try {
    Write-Host ""
    Read-Host "Press Enter to exit" | Out-Null
  } catch {
    try { cmd.exe /c pause | Out-Null } catch {}
  }
}

function Handle-InstallError {
  param([object]$Err)
  Write-Host ""
  Write-Host ("ERROR: Installation stopped: " + $Err.Exception.Message) -ForegroundColor Red
  Add-Log ("ERROR: " + $Err.Exception.Message)
  if ($LogFile) {
    Write-Host ("Log file: " + $LogFile) -ForegroundColor Yellow
  }
  Wait-BeforeExit
}

function Write-Utf8NoBom {
  param([string]$Path, [string]$Content)
  $utf8NoBom = [System.Text.UTF8Encoding]::new($false)
  [System.IO.File]::WriteAllText($Path, $Content, $utf8NoBom)
}

function Read-Line {
  param([string]$Prompt, [string]$Default = "")
  if ($NonInteractive) { return $Default }
  try {
    $value = Read-Host $Prompt
    if ([string]::IsNullOrWhiteSpace($value)) { return $Default }
    return $value
  } catch {
    Write-Warn2 "Read-Host failed. Using default: $Default"
    return $Default
  }
}

function Refresh-ProcessPath {
  $parts = @(
    [System.Environment]::GetEnvironmentVariable("Path", "Machine"),
    [System.Environment]::GetEnvironmentVariable("Path", "User"),
    (Join-Path $HOME ".local\bin"),
    (Join-Path $HOME ".claude\local")
  )

  if ($env:LOCALAPPDATA) {
    $parts += (Join-Path $env:LOCALAPPDATA "Microsoft\WindowsApps")
  }
  if ($env:APPDATA) {
    $parts += (Join-Path $env:APPDATA "npm")
  }

  $env:Path = ($parts | Where-Object { $_ -and $_.Trim() } | Select-Object -Unique) -join ";"
}

function Get-TextFilePreview {
  param([string]$Path, [int]$MaxChars = 4096)
  try {
    $text = [System.IO.File]::ReadAllText($Path, [System.Text.Encoding]::UTF8)
    if ($text.Length -le $MaxChars) { return $text }
    return $text.Substring(0, $MaxChars)
  } catch {
    return ""
  }
}

function Test-PowerShellInstallerFile {
  param([string]$Path)

  if (-not (Test-Path $Path)) {
    return "downloaded file is missing"
  }

  $item = Get-Item $Path
  if ($item.Length -lt 20) {
    return "downloaded file is empty or too small"
  }

  $preview = Get-TextFilePreview -Path $Path
  if ([string]::IsNullOrWhiteSpace($preview)) {
    return "downloaded file is not readable as text"
  }

  $trimmed = $preview.TrimStart()
  if ($trimmed.StartsWith([string][char]0xFEFF)) {
    $trimmed = $trimmed.Substring(1).TrimStart()
  }

  $lowerPreview = $preview.ToLowerInvariant()
  $lowerHead = $trimmed
  if ($lowerHead.Length -gt 256) {
    $lowerHead = $lowerHead.Substring(0, 256)
  }
  $lowerHead = $lowerHead.ToLowerInvariant()

  if ($lowerHead.StartsWith("<!doctype html") -or $lowerHead.StartsWith("<html") -or $lowerHead.StartsWith("<script")) {
    return "downloaded content is HTML, not PowerShell"
  }
  if ($lowerPreview.Contains("app unavailable in region")) {
    return "the official installer URL returned an app-unavailable-in-region page"
  }
  if ($lowerPreview.Contains("<script") -or $lowerPreview.Contains("</html>") -or $lowerPreview.Contains("<body")) {
    return "downloaded content contains HTML markup, not a PowerShell installer"
  }
  if ($preview -notmatch '(?m)^\s*(#|param\s*\(|function\s+|\$[A-Za-z_][A-Za-z0-9_]*\s*=|try\s*\{|Set-StrictMode\b)') {
    return "downloaded content does not look like a PowerShell installer"
  }

  return $null
}

function Get-PowerShellExecutable {
  try {
    $procPath = (Get-Process -Id $PID).Path
    if ($procPath -and (Test-Path $procPath)) { return $procPath }
  } catch {}

  $pwsh = Get-Command pwsh -ErrorAction SilentlyContinue
  if ($pwsh) { return $pwsh.Source }

  $powershell = Get-Command powershell.exe -ErrorAction SilentlyContinue
  if ($powershell) { return $powershell.Source }

  return "powershell.exe"
}

function Invoke-OfficialClaudeInstaller {
  $officialUrl = "https://claude.ai/install.ps1"
  $installerFile = Join-Path $env:TEMP "claude-official-install.ps1"

  Write-Info "Downloading the official Claude Code installer"
  Add-Log "Official installer URL: $officialUrl"
  try { Remove-Item $installerFile -Force -ErrorAction SilentlyContinue } catch {}

  try {
    $headers = @{
      "User-Agent" = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Claude-Code-Sundy-Installer"
      "Accept" = "text/plain, application/x-powershell, */*"
    }
    Invoke-WebRequest -Uri $officialUrl -OutFile $installerFile -UseBasicParsing -MaximumRedirection 5 -TimeoutSec 60 -Headers $headers | Out-Null
  } catch {
    Write-Warn2 ("Could not download the official installer: " + $_.Exception.Message)
    return $false
  }

  $validationError = Test-PowerShellInstallerFile -Path $installerFile
  if ($validationError) {
    Write-Warn2 ("Official installer was not executed: " + $validationError)
    Write-Warn2 ("Saved the response for debugging: " + $installerFile)
    Add-Log ("Official installer validation failed: " + $validationError)
    return $false
  }

  Write-Info "Running the validated official Claude Code installer"
  $psExe = Get-PowerShellExecutable
  & $psExe -NoLogo -NoProfile -ExecutionPolicy Bypass -File $installerFile
  if ($LASTEXITCODE -ne 0) {
    Write-Warn2 ("Official installer exited with code " + $LASTEXITCODE)
    return $false
  }

  return $true
}

function Install-ClaudeCodeWithWinGet {
  $winget = Get-Command winget -ErrorAction SilentlyContinue
  if (-not $winget) {
    Write-Warn2 "WinGet is not available on this Windows installation."
    return $false
  }

  Write-Info "Trying WinGet fallback: winget install Anthropic.ClaudeCode"
  $wingetArgs = @(
    "install",
    "--id", "Anthropic.ClaudeCode",
    "--source", "winget",
    "--accept-package-agreements",
    "--accept-source-agreements"
  )
  if ($NonInteractive) {
    $wingetArgs += "--disable-interactivity"
  }

  & $winget.Source @wingetArgs
  $wingetExitCode = $LASTEXITCODE
  if ($wingetExitCode -ne 0 -and $NonInteractive) {
    Write-Warn2 "WinGet failed with --disable-interactivity. Retrying without that flag for older WinGet versions."
    $wingetArgs = $wingetArgs | Where-Object { $_ -ne "--disable-interactivity" }
    & $winget.Source @wingetArgs
    $wingetExitCode = $LASTEXITCODE
  }

  if ($wingetExitCode -ne 0) {
    Write-Warn2 ("WinGet installer exited with code " + $wingetExitCode)
    return $false
  }

  return $true
}

function Install-ClaudeCodeWithNpm {
  $node = Get-Command node -ErrorAction SilentlyContinue
  $npm = Get-Command npm -ErrorAction SilentlyContinue
  if (-not $node -or -not $npm) {
    Write-Warn2 "npm fallback is not available because node/npm was not found."
    return $false
  }

  $major = $null
  try {
    $major = [int](& $node.Source -p "process.versions.node.split('.')[0]")
  } catch {}
  if ($major -and $major -lt 18) {
    Write-Warn2 "npm fallback requires Node.js 18 or newer."
    return $false
  }

  Write-Info "Trying npm fallback: npm install -g @anthropic-ai/claude-code"
  & $npm.Source install -g "@anthropic-ai/claude-code"
  if ($LASTEXITCODE -ne 0) {
    Write-Warn2 ("npm installer exited with code " + $LASTEXITCODE)
    return $false
  }

  return $true
}

function Install-ClaudeCode {
  $claude = Get-Command claude -ErrorAction SilentlyContinue
  if ($claude) {
    try {
      Write-Ok ("Claude Code is installed: " + (claude --version))
    } catch {
      Write-Ok "Claude Code is installed"
    }
    return
  }

  if (-not (Invoke-OfficialClaudeInstaller)) {
    Write-Warn2 "The official installer could not be used. This is often caused by a region/network block returning an HTML page."
    if (-not (Install-ClaudeCodeWithWinGet)) {
      Write-Warn2 "WinGet fallback did not complete."
      if (-not (Install-ClaudeCodeWithNpm)) {
        Write-Fail "Could not install Claude Code. Try a supported network, or install manually with: winget install Anthropic.ClaudeCode"
      }
    }
  }

  Refresh-ProcessPath
  $claude = Get-Command claude -ErrorAction SilentlyContinue
  if ($claude) {
    try {
      Write-Ok ("Claude Code installed: " + (claude --version))
    } catch {
      Write-Ok "Claude Code installed"
    }
  } else {
    Write-Warn2 "The installer finished, but claude is not visible in the current PATH. Open a new PowerShell window after this script."
  }
}

try {
  Write-Host ""
  Write-Host "================================================" -ForegroundColor Cyan
  Write-Host "  Sundy Claude Code setup - Windows installer" -ForegroundColor Cyan
  Write-Host "================================================" -ForegroundColor Cyan
  Write-Host ""
  Write-Host "This script will:"
  Write-Host "  1. Install Claude Code CLI if needed (official installer, then WinGet fallback)"
  Write-Host "  2. Ask for the Sundy client API key"
  Write-Host "  3. Set ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN as user environment variables"
  Write-Host "  4. Disable Claude Code gateway model discovery so /model stays on Claude Code presets"
  Write-Host "  5. Enable YOLO mode (bypassPermissions; skip all permission prompts)"
  Write-Host "  6. Test gateway connectivity"
  Write-Host ""
  Write-Host "Claude Code base URL will be: $BaseUrl"
  Write-Host "Do not add /v1 to ANTHROPIC_BASE_URL; Claude Code calls /v1/messages itself."
  Write-Host "Models: use Claude Code built-in choices; do not append all gateway /v1/models entries."
  Write-Host "Permission mode: bypassPermissions (YOLO)"
  Write-Host ""

  if ($AssumeYes) {
    Write-Info "Auto-confirm mode is enabled. Continuing..."
  } else {
    $go = Read-Line -Prompt "Continue? [Y/n]" -Default "Y"
    if ($go -and $go -notmatch '^[Yy]') {
      Write-Info "Cancelled."
      Wait-BeforeExit
      return
    }
  }

  Write-Title "1/4 Installing Claude Code"
  Install-ClaudeCode

  Write-Title "2/4 API key"
  $ApiKey = $env:SUNDY_API_KEY
  if (-not $ApiKey) { $ApiKey = $env:ANTHROPIC_AUTH_TOKEN }
  if (-not $ApiKey) { $ApiKey = $env:CLAUDE_API_KEY }

  if ($ApiKey) {
    Write-Ok ("Read API key from environment (" + $ApiKey.Length + " chars)")
  } elseif ($NonInteractive) {
    Write-Fail "Non-interactive mode requires SUNDY_API_KEY or ANTHROPIC_AUTH_TOKEN."
  } else {
    Write-Host "Paste the Sundy client API key issued by the service provider."
    Write-Host "It will be saved as ANTHROPIC_AUTH_TOKEN for Claude Code."
    Write-Host ""
    while (-not $ApiKey) {
      $ApiKey = Read-Host "API Key"
      if (-not $ApiKey) { Write-Warn2 "API key is empty. Try again." }
    }
    Write-Ok ("Received API key (" + $ApiKey.Length + " chars)")
  }

  Write-Title "3/4 Writing user environment variables"
  [System.Environment]::SetEnvironmentVariable("SUNDY_API_KEY", $ApiKey, "User")
  [System.Environment]::SetEnvironmentVariable("ANTHROPIC_AUTH_TOKEN", $ApiKey, "User")
  [System.Environment]::SetEnvironmentVariable("ANTHROPIC_BASE_URL", $BaseUrl, "User")
  [System.Environment]::SetEnvironmentVariable("ANTHROPIC_DEFAULT_OPUS_MODEL", $null, "User")
  [System.Environment]::SetEnvironmentVariable("ANTHROPIC_DEFAULT_SONNET_MODEL", $null, "User")
  [System.Environment]::SetEnvironmentVariable("ANTHROPIC_DEFAULT_HAIKU_MODEL", $null, "User")
  [System.Environment]::SetEnvironmentVariable("ANTHROPIC_MODEL", $null, "User")
  [System.Environment]::SetEnvironmentVariable("ANTHROPIC_SMALL_FAST_MODEL", $null, "User")
  [System.Environment]::SetEnvironmentVariable("CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY", $null, "User")

  $env:SUNDY_API_KEY = $ApiKey
  $env:ANTHROPIC_AUTH_TOKEN = $ApiKey
  $env:ANTHROPIC_BASE_URL = $BaseUrl
  Remove-Item Env:ANTHROPIC_DEFAULT_OPUS_MODEL -ErrorAction SilentlyContinue
  Remove-Item Env:ANTHROPIC_DEFAULT_SONNET_MODEL -ErrorAction SilentlyContinue
  Remove-Item Env:ANTHROPIC_DEFAULT_HAIKU_MODEL -ErrorAction SilentlyContinue
  Remove-Item Env:ANTHROPIC_MODEL -ErrorAction SilentlyContinue
  Remove-Item Env:ANTHROPIC_SMALL_FAST_MODEL -ErrorAction SilentlyContinue
  Remove-Item Env:CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY -ErrorAction SilentlyContinue

  Write-Ok "Wrote SUNDY_API_KEY"
  Write-Ok "Wrote ANTHROPIC_AUTH_TOKEN"
  Write-Ok "Wrote ANTHROPIC_BASE_URL=$BaseUrl"
  Write-Ok "Cleared pinned Claude model environment variables"
  Write-Ok "Disabled Claude Code gateway model discovery"

  $claudeConfigDir = Join-Path $HOME ".claude"
  $claudeSettingsFile = Join-Path $claudeConfigDir "settings.json"
  $claudeGatewayModelsCache = Join-Path $claudeConfigDir "cache\gateway-models.json"
  New-Item -ItemType Directory -Force -Path $claudeConfigDir | Out-Null

  if (Test-Path $claudeGatewayModelsCache) {
    Remove-Item $claudeGatewayModelsCache -Force
    Write-Ok "Cleared Claude Code gateway model cache"
  }

  if (Test-Path $claudeSettingsFile) {
    $settingsBackup = "$claudeSettingsFile.bak-" + (Get-Date -Format "yyyyMMdd-HHmmss")
    Copy-Item $claudeSettingsFile $settingsBackup
    Write-Ok "Backed up Claude Code settings to $settingsBackup"
  }

  try {
    if (Test-Path $claudeSettingsFile) {
      $rawSettings = Get-Content -Raw -Path $claudeSettingsFile
      if ([string]::IsNullOrWhiteSpace($rawSettings)) {
        $settings = [pscustomobject]@{}
      } else {
        $settings = $rawSettings | ConvertFrom-Json
      }
    } else {
      $settings = [pscustomobject]@{}
    }
  } catch {
    Write-Warn2 "Existing Claude Code settings.json is not valid JSON. Rewriting it after backup."
    $settings = [pscustomobject]@{}
  }

  if (-not $settings.PSObject.Properties["`$schema"]) {
    $settings | Add-Member -MemberType NoteProperty -Name '$schema' -Value "https://json.schemastore.org/claude-code-settings.json"
  }
  if (-not $settings.PSObject.Properties["permissions"] -or $null -eq $settings.permissions) {
    $settings | Add-Member -MemberType NoteProperty -Name "permissions" -Value ([pscustomobject]@{})
  }
  if (-not $settings.permissions.PSObject.Properties["defaultMode"]) {
    $settings.permissions | Add-Member -MemberType NoteProperty -Name "defaultMode" -Value "bypassPermissions"
  } else {
    $settings.permissions.defaultMode = "bypassPermissions"
  }
  if (-not $settings.permissions.PSObject.Properties["skipDangerousModePermissionPrompt"]) {
    $settings.permissions | Add-Member -MemberType NoteProperty -Name "skipDangerousModePermissionPrompt" -Value $true
  } else {
    $settings.permissions.skipDangerousModePermissionPrompt = $true
  }

  $settingsJson = $settings | ConvertTo-Json -Depth 20
  Write-Utf8NoBom -Path $claudeSettingsFile -Content ($settingsJson + "`n")
  Write-Ok "Enabled Claude Code YOLO mode: permissions.defaultMode=bypassPermissions"

  Write-Title "4/4 Testing gateway"
  try {
    $response = Invoke-WebRequest -Uri "$BaseUrl/v1/models" -Headers @{ "Authorization" = "Bearer $ApiKey" } -UseBasicParsing -TimeoutSec 15
    if ($response.StatusCode -eq 200) {
      Write-Ok "Gateway is reachable and the key looks valid"
    } else {
      Write-Warn2 ("HTTP " + $response.StatusCode + ". You can continue and test Claude Code manually.")
    }
  } catch {
    $code = $null
    try { $code = $_.Exception.Response.StatusCode.value__ } catch {}
    if ($code -eq 401 -or $code -eq 403) {
      Write-Warn2 "The key was rejected (HTTP $code). Check your API key."
    } else {
      Write-Warn2 "Connectivity test failed: $($_.Exception.Message). You can try again later."
    }
  }

  Write-Host ""
  Write-Host "================================================" -ForegroundColor Green
  Write-Host "  Install complete" -ForegroundColor Green
  Write-Host "================================================" -ForegroundColor Green
  Write-Host ""
  Write-Host "Important: open a new PowerShell window before running Claude Code." -ForegroundColor Yellow
  Write-Host ""
  Write-Host "Next:"
  Write-Host "  1. Close this PowerShell window."
  Write-Host "  2. Open a new PowerShell window."
  Write-Host "  3. Run: claude"
  Write-Host ""
  Write-Host "If Claude Code cannot connect, check:"
  Write-Host "  ANTHROPIC_BASE_URL=$BaseUrl"
  Write-Host "  ANTHROPIC_AUTH_TOKEN is the Sundy client API key"
  Write-Host "  If /model still shows From gateway, open a new terminal and make sure CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY is not set"
  Write-Host "  The gateway supports POST /v1/messages"
  Write-Host "  YOLO settings file: $claudeSettingsFile"
  Write-Host ""
  Write-Host "Log file: $LogFile"
  Write-Host ""

  Wait-BeforeExit
} catch {
  Handle-InstallError $_
  return
}