Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"

$script_dir = if ($PSScriptRoot) { $PSScriptRoot } else { Split-Path -Parent $MyInvocation.MyCommand.Path }
$repo_root = (Resolve-Path (Join-Path $script_dir "..")).Path
$hf_token_file = if ($env:HF_TOKEN_FILE) { $env:HF_TOKEN_FILE } else { Join-Path $HOME ".cache/huggingface/token" }
$script:RestoreHfLoginRequired = $false
$script:RestoreHfLoginToken = ""
$script:RestoreHfLoginUsername = ""

function Trim-Value {
  param([AllowNull()][string]$Value)

  if ($null -eq $Value) {
    return ""
  }
  return $Value.Trim()
}

function Write-Info {
  param([string]$Message)

  Write-Host $Message
}

$script:BootstrapStepIndex = 0

function Get-LogTimestamp {
  return (Get-Date).ToString("yyyy-MM-dd HH:mm:ss")
}

function Write-StepStart {
  param([string]$Message)

  $script:BootstrapStepIndex += 1
  Write-Info ("[{0}] [bootstrap step {1}] START {2}" -f (Get-LogTimestamp), $script:BootstrapStepIndex, $Message)
}

function Write-StepDone {
  param([string]$Message)

  Write-Info ("[{0}] [bootstrap step {1}] DONE  {2}" -f (Get-LogTimestamp), $script:BootstrapStepIndex, $Message)
}

function Invoke-Step {
  param(
    [string]$Message,
    [ScriptBlock]$Action
  )

  Write-StepStart -Message $Message
  & $Action
  Write-StepDone -Message $Message
}

function Fail {
  param([string]$Message)

  throw $Message
}

function Prompt-Line {
  param(
    [string]$Prompt,
    [string]$DefaultValue = ""
  )

  if ([string]::IsNullOrEmpty($DefaultValue)) {
    $raw = Read-Host -Prompt $Prompt
  } else {
    $raw = Read-Host -Prompt "$Prompt [$DefaultValue]"
  }

  $value = Trim-Value $raw
  if ([string]::IsNullOrEmpty($value)) {
    $value = $DefaultValue
  }
  return $value
}

function Prompt-Required {
  param(
    [string]$Prompt,
    [string]$DefaultValue = ""
  )

  while ($true) {
    $value = Trim-Value (Prompt-Line -Prompt $Prompt -DefaultValue $DefaultValue)
    if (-not [string]::IsNullOrEmpty($value)) {
      return $value
    }
    Write-Host "This value is required." -ForegroundColor Red
  }
}

function Convert-SecureStringToPlainText {
  param([System.Security.SecureString]$SecureValue)

  if ($null -eq $SecureValue) {
    return ""
  }

  $bstr = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($SecureValue)
  try {
    return [Runtime.InteropServices.Marshal]::PtrToStringBSTR($bstr)
  }
  finally {
    [Runtime.InteropServices.Marshal]::ZeroFreeBSTR($bstr)
  }
}

function Prompt-SecretOptional {
  param([string]$Prompt)

  $secure_value = Read-Host -Prompt $Prompt -AsSecureString
  $plain_text = Convert-SecureStringToPlainText -SecureValue $secure_value
  return Trim-Value $plain_text
}

function Prompt-SecretRequired {
  param([string]$Prompt)

  while ($true) {
    $value = Trim-Value (Prompt-SecretOptional -Prompt $Prompt)
    if (-not [string]::IsNullOrEmpty($value)) {
      return $value
    }
    Write-Host "This value is required." -ForegroundColor Red
  }
}

function Prompt-YesNo {
  param(
    [string]$Prompt,
    [ValidateSet("y", "n")][string]$DefaultValue = "n"
  )

  $hint = if ($DefaultValue -eq "y") { "[Y/n]" } else { "[y/N]" }

  while ($true) {
    $answer = Trim-Value (Read-Host -Prompt "$Prompt $hint")
    $answer = $answer.ToLowerInvariant()
    if ([string]::IsNullOrEmpty($answer)) {
      $answer = $DefaultValue
    }

    switch ($answer) {
      { $_ -in @("y", "yes") } { return "yes" }
      { $_ -in @("n", "no") } { return "no" }
      default {
        Write-Host "Please enter y or n." -ForegroundColor Red
      }
    }
  }
}

function Login-WithHfToken {
  param([string]$Token)

  & hf auth login --token $Token *> $null
  if ($LASTEXITCODE -ne 0) {
    Fail "hf auth login with token failed."
  }
}

function Restore-PreviousHfLoginIfNeeded {
  if (-not $script:RestoreHfLoginRequired) {
    return
  }
  if ([string]::IsNullOrEmpty($script:RestoreHfLoginToken)) {
    Write-Error "Skip restoring previous HF login because backup token is empty."
    $script:RestoreHfLoginRequired = $false
    return
  }

  $display_user = if ([string]::IsNullOrEmpty($script:RestoreHfLoginUsername)) { "unknown" } else { $script:RestoreHfLoginUsername }
  Write-Info "Restoring previous HF login for user: $display_user"
  & hf auth login --token $script:RestoreHfLoginToken *> $null
  if ($LASTEXITCODE -eq 0) {
    Write-Info "Previous HF login restored."
  } else {
    Write-Error "Failed to restore previous HF login. Please run: hf auth login"
  }

  $script:RestoreHfLoginRequired = $false
}

function New-RandomHex {
  param([int]$Length)

  if ($Length -le 0 -or ($Length % 2) -ne 0) {
    Fail "Length must be a positive even number."
  }

  $bytes = New-Object byte[] ($Length / 2)
  [System.Security.Cryptography.RandomNumberGenerator]::Fill($bytes)
  return ($bytes | ForEach-Object { $_.ToString("x2") }) -join ""
}

function Ensure-Git {
  if (-not (Get-Command git -ErrorAction SilentlyContinue)) {
    Fail "git is required. Please install git first."
  }
}

function Ensure-HfCli {
  if (Get-Command hf -ErrorAction SilentlyContinue) {
    return
  }

  Write-Info "hf CLI not found. Installing via powershell -ExecutionPolicy ByPass -c `"irm https://hf.co/cli/install.ps1 | iex`" ..."
  & powershell -ExecutionPolicy ByPass -c "irm https://hf.co/cli/install.ps1 | iex"
  if ($LASTEXITCODE -ne 0) {
    Fail "hf CLI install failed. Please install manually and rerun."
  }

  $local_bin = Join-Path $HOME ".local/bin"
  if ((Test-Path $local_bin) -and -not (($env:PATH -split [IO.Path]::PathSeparator) -contains $local_bin)) {
    $env:PATH = "$local_bin$([IO.Path]::PathSeparator)$env:PATH"
  }

  if (-not (Get-Command hf -ErrorAction SilentlyContinue)) {
    Fail "hf CLI install failed. Please install manually and rerun."
  }
}

function Ensure-Python3 {
  if (-not (Get-Command python3 -ErrorAction SilentlyContinue)) {
    Fail "python3 is required. Please install python3 first."
  }
}

function Ensure-HuggingFaceHubPy {
  & python3 -c "import huggingface_hub" 2>$null
  if ($LASTEXITCODE -ne 0) {
    Fail "python3 package 'huggingface_hub' is required. Install with: python3 -m pip install --user 'huggingface_hub[cli]'"
  }
}

function Resolve-LatestOpenclawVersion {
  $python_code = @'
import json
import urllib.request

url = "https://registry.npmjs.org/openclaw/latest"
try:
    with urllib.request.urlopen(url, timeout=8) as response:
        payload = response.read().decode("utf-8", errors="replace")
    data = json.loads(payload)
    version = str(data.get("version", "")).strip()
    if version:
        print(version)
except Exception:
    pass
'@

  $version_output = & python3 -c $python_code 2>$null
  $version = Trim-Value (($version_output | Out-String))
  if ([string]::IsNullOrEmpty($version)) {
    return "latest"
  }
  return $version
}

function Read-CurrentHfToken {
  if (-not [string]::IsNullOrEmpty($env:HUGGINGFACE_HUB_TOKEN)) {
    return Trim-Value $env:HUGGINGFACE_HUB_TOKEN
  }
  if (-not [string]::IsNullOrEmpty($env:HF_TOKEN)) {
    return Trim-Value $env:HF_TOKEN
  }
  if (Test-Path $hf_token_file) {
    return Trim-Value (Get-Content -Path $hf_token_file -TotalCount 1)
  }
  return ""
}

function Test-HfLoggedIn {
  & hf auth whoami *> $null
  return ($LASTEXITCODE -eq 0)
}

function Get-HfUsername {
  $whoami_output = (& hf auth whoami 2>&1 | Out-String)

  $user_match = [regex]::Match($whoami_output, "(?im)^\s*user:\s*([^\s]+)")
  if ($user_match.Success) {
    return Trim-Value $user_match.Groups[1].Value
  }

  $login_match = [regex]::Match($whoami_output, "(?im)logged in as\s+([^\s]+)")
  if ($login_match.Success) {
    return Trim-Value $login_match.Groups[1].Value
  }

  $token_from_cache = Read-CurrentHfToken
  if (-not [string]::IsNullOrEmpty($token_from_cache)) {
    $env:HF_API_TOKEN = $token_from_cache
    $python_code = @'
from huggingface_hub import HfApi
import os

token = (os.environ.get("HF_API_TOKEN") or "").strip() or None
api = HfApi(token=token)
data = api.whoami(token=token)
name = data.get("name", "") if isinstance(data, dict) else ""
print((name or "").strip())
'@

    $name_output = & python3 -c $python_code 2>$null
    $name = Trim-Value (($name_output | Out-String))
    if (-not [string]::IsNullOrEmpty($name)) {
      return $name
    }
  }

  return ""
}

function Set-SpaceVariable {
  param(
    [string]$SpaceRepoId,
    [string]$Key,
    [string]$Value,
    [string]$ApiToken
  )

  $env:SPACE_REPO_ID = $SpaceRepoId
  $env:SPACE_VARIABLE_KEY = $Key
  $env:SPACE_VARIABLE_VALUE = $Value
  $env:HF_API_TOKEN = $ApiToken

  $python_code = @'
from huggingface_hub import HfApi
import os

token = (os.environ.get("HF_API_TOKEN") or "").strip() or None
api = HfApi(token=token)
try:
    api.add_space_variable(
        repo_id=os.environ["SPACE_REPO_ID"],
        key=os.environ["SPACE_VARIABLE_KEY"],
        value=os.environ["SPACE_VARIABLE_VALUE"],
    )
except Exception as exc:
    key = os.environ.get("SPACE_VARIABLE_KEY", "")
    repo_id = os.environ.get("SPACE_REPO_ID", "")
    raise SystemExit(f"failed to set space variable {key} on {repo_id}: {exc}")
'@

  & python3 -c $python_code
  if ($LASTEXITCODE -ne 0) {
    Fail "failed to set space variable $Key"
  }
}

function Set-SpaceSecret {
  param(
    [string]$SpaceRepoId,
    [string]$Key,
    [string]$Value,
    [string]$ApiToken
  )

  $env:SPACE_REPO_ID = $SpaceRepoId
  $env:SPACE_SECRET_KEY = $Key
  $env:SPACE_SECRET_VALUE = $Value
  $env:HF_API_TOKEN = $ApiToken

  $python_code = @'
from huggingface_hub import HfApi
import os

token = (os.environ.get("HF_API_TOKEN") or "").strip() or None
api = HfApi(token=token)
try:
    api.add_space_secret(
        repo_id=os.environ["SPACE_REPO_ID"],
        key=os.environ["SPACE_SECRET_KEY"],
        value=os.environ["SPACE_SECRET_VALUE"],
    )
except Exception as exc:
    key = os.environ.get("SPACE_SECRET_KEY", "")
    repo_id = os.environ.get("SPACE_REPO_ID", "")
    raise SystemExit(f"failed to set space secret {key} on {repo_id}: {exc}")
'@

  & python3 -c $python_code
  if ($LASTEXITCODE -ne 0) {
    Fail "failed to set space secret $Key"
  }
}

function Set-SpaceVariableLogged {
  param(
    [string]$SpaceRepoId,
    [string]$Key,
    [string]$Value,
    [string]$ApiToken
  )

  Invoke-Step -Message "Set Space variable $Key" -Action {
    Set-SpaceVariable -SpaceRepoId $SpaceRepoId -Key $Key -Value $Value -ApiToken $ApiToken
  }
}

function Set-SpaceSecretLogged {
  param(
    [string]$SpaceRepoId,
    [string]$Key,
    [string]$Value,
    [string]$ApiToken
  )

  Invoke-Step -Message "Set Space secret $Key" -Action {
    Set-SpaceSecret -SpaceRepoId $SpaceRepoId -Key $Key -Value $Value -ApiToken $ApiToken
  }
}

function Restart-Space {
  param(
    [string]$SpaceRepoId,
    [string]$ApiToken
  )

  $env:SPACE_RESTART_REPO_ID = $SpaceRepoId
  $env:HF_API_TOKEN = $ApiToken

  $python_code = @'
from huggingface_hub import HfApi
import os

token = (os.environ.get("HF_API_TOKEN") or "").strip() or None
api = HfApi(token=token)
try:
    api.restart_space(repo_id=os.environ["SPACE_RESTART_REPO_ID"])
except Exception as exc:
    repo_id = os.environ.get("SPACE_RESTART_REPO_ID", "")
    raise SystemExit(f"failed to restart space {repo_id}: {exc}")
'@

  & python3 -c $python_code
  if ($LASTEXITCODE -ne 0) {
    Fail "failed to restart space $SpaceRepoId"
  }
}

function Main {
  Invoke-Step -Message "Change directory to repository root" -Action {
    Set-Location $repo_root
  }

  Write-Info "OpenClaw Hugging Face bootstrap (interactive, Windows PowerShell)"
  Invoke-Step -Message "Check dependency git" -Action { Ensure-Git }
  Invoke-Step -Message "Check dependency hf CLI" -Action { Ensure-HfCli }
  Invoke-Step -Message "Check dependency python3" -Action { Ensure-Python3 }
  Invoke-Step -Message "Check dependency python package huggingface_hub" -Action { Ensure-HuggingFaceHubPy }
  Invoke-Step -Message "Print dependency versions" -Action {
    & git --version
    & hf version
    & python3 --version
  }

  $hf_token_for_backup = ""
  Invoke-Step -Message "Resolve HF login and HF_TOKEN" -Action {
    if (-not (Test-HfLoggedIn)) {
      Write-Info "HF CLI is not logged in."
      $hf_token_for_backup = Prompt-SecretRequired -Prompt "HF_TOKEN (required for hf auth login)"
      Login-WithHfToken -Token $hf_token_for_backup
    } else {
      $current_hf_username = Trim-Value (Get-HfUsername)
      if ([string]::IsNullOrEmpty($current_hf_username)) {
        $use_current_hf_user = Prompt-YesNo -Prompt "HF CLI is already logged in. Use current user?" -DefaultValue "y"
      } else {
        $use_current_hf_user = Prompt-YesNo -Prompt "HF CLI is already logged in as '$current_hf_username'. Use this user?" -DefaultValue "y"
      }

      if ($use_current_hf_user -eq "yes") {
        $hf_token_for_backup = Trim-Value (Read-CurrentHfToken)
        if ([string]::IsNullOrEmpty($hf_token_for_backup)) {
          $hf_token_for_backup = Prompt-SecretRequired -Prompt "Cannot read current token. Enter HF_TOKEN"
          Login-WithHfToken -Token $hf_token_for_backup
        }
      } else {
        $script:RestoreHfLoginToken = Trim-Value (Read-CurrentHfToken)
        if ([string]::IsNullOrEmpty($script:RestoreHfLoginToken)) {
          Fail "Cannot backup current HF token. Ensure current token is readable before switching users."
        }
        $script:RestoreHfLoginRequired = $true
        $script:RestoreHfLoginUsername = $current_hf_username

        $switch_hf_token = Prompt-SecretRequired -Prompt "HF_TOKEN for switching HF user"
        Login-WithHfToken -Token $switch_hf_token
        $hf_token_for_backup = $switch_hf_token
      }
    }

    if ([string]::IsNullOrEmpty($hf_token_for_backup)) {
      Fail "HF_TOKEN is required to configure Space secret HF_TOKEN."
    }
  }

  $hf_username = ""
  Invoke-Step -Message "Resolve HF username" -Action {
    $hf_username = Trim-Value (Get-HfUsername)
    if ([string]::IsNullOrEmpty($hf_username)) {
      $hf_username = Prompt-Required -Prompt "HF username (cannot parse from hf auth whoami)"
    }
    Write-Info "HF user: $hf_username"
  }

  $space_name = ""
  $dataset_name = ""
  Invoke-Step -Message "Collect Space and Dataset names" -Action {
    $space_name = Prompt-Required -Prompt "Space name (without username)" -DefaultValue "openclaw-hf"
    $dataset_name = Prompt-Required -Prompt "Dataset name (without username)" -DefaultValue "$space_name-backup"
  }

  $openclaw_version = ""
  Invoke-Step -Message "Resolve and confirm OPENCLAW_VERSION" -Action {
    $default_openclaw_version = Trim-Value $env:OPENCLAW_VERSION
    if ([string]::IsNullOrEmpty($default_openclaw_version)) {
      $default_openclaw_version = Resolve-LatestOpenclawVersion
    }
    $openclaw_version = Prompt-Required -Prompt "OPENCLAW_VERSION (press Enter to use detected latest)" -DefaultValue $default_openclaw_version
  }

  $space_repo_id = "$hf_username/$space_name"
  $dataset_repo_id = "$hf_username/$dataset_name"

  $gateway_token = ""
  $generated_gateway_token = $false
  Invoke-Step -Message "Collect OPENCLAW_GATEWAY_TOKEN" -Action {
    $gateway_token = Prompt-SecretOptional -Prompt "OPENCLAW_GATEWAY_TOKEN (optional, leave empty to auto-generate 32 chars)"
    if ([string]::IsNullOrEmpty($gateway_token)) {
      $gateway_token = New-RandomHex -Length 32
      $generated_gateway_token = $true
      Write-Info "OPENCLAW_GATEWAY_TOKEN generated automatically."
    }
  }

  $gateway_password = ""
  $generated_gateway_password = $false
  Invoke-Step -Message "Collect OPENCLAW_GATEWAY_PASSWORD" -Action {
    $gateway_password = Prompt-SecretOptional -Prompt "OPENCLAW_GATEWAY_PASSWORD (optional, leave empty to auto-generate 16 chars)"
    if ([string]::IsNullOrEmpty($gateway_password)) {
      $gateway_password = New-RandomHex -Length 16
      $generated_gateway_password = $true
      Write-Info "OPENCLAW_GATEWAY_PASSWORD generated automatically."
    }
  }

  $configure_llm = "no"
  $llm_base_url = ""
  $llm_model = ""
  $llm_api_key = ""
  $enable_sshx = "no"
  $sshx_auto_start_value = "false"
  Invoke-Step -Message "Collect custom LLM or sshx bootstrap options" -Action {
    $configure_llm = Prompt-YesNo -Prompt "Configure custom LLM now?" -DefaultValue "n"
    if ($configure_llm -eq "yes") {
      $llm_base_url = Prompt-Required -Prompt "OPENCLAW_LLM_BASE_URL"
      $llm_model = Prompt-Required -Prompt "OPENCLAW_LLM_MODEL"
      $llm_api_key = Prompt-SecretOptional -Prompt "OPENCLAW_LLM_API_KEY"
      if ([string]::IsNullOrEmpty($llm_api_key)) {
        Fail "OPENCLAW_LLM_API_KEY is required when enabling custom LLM config."
      }
    } else {
      $enable_sshx = Prompt-YesNo -Prompt "Set OPENCLAW_SSHX_AUTO_START=true for later sshx setup?" -DefaultValue "y"
    }
  }
  if ($enable_sshx -eq "yes") {
    $sshx_auto_start_value = "true"
  }

  Write-Info ""
  Write-Info "Planned deployment configuration:"
  Write-Info "Space repo: $space_repo_id"
  Write-Info "Dataset repo: $dataset_repo_id"
  Write-Info "OPENCLAW_VERSION: $openclaw_version"
  Write-Info "OPENCLAW_GATEWAY_CONTROLUI_ALLOW_INSECURE_AUTH=false"
  Write-Info "OPENCLAW_GATEWAY_CONTROLUI_DANGEROUSLY_DISABLE_DEVICE_AUTH=false"
  Write-Info "OPENCLAW_SSHX_AUTO_START=$sshx_auto_start_value"
  if ($configure_llm -eq "yes") {
    Write-Info "Custom LLM config: enabled"
  } else {
    Write-Info "Custom LLM config: disabled"
  }
  $proceed_with_deploy = Prompt-YesNo -Prompt "Proceed with these settings?" -DefaultValue "y"
  if ($proceed_with_deploy -ne "yes") {
    Write-Info "Cancelled by user before creating/updating Space or Dataset."
    return
  }

  Invoke-Step -Message "Create Space repo $space_repo_id" -Action {
    & hf repo create $space_repo_id --repo-type space --space-sdk docker --private --exist-ok
    if ($LASTEXITCODE -ne 0) {
      Fail "failed to create Space repo"
    }
  }
  Invoke-Step -Message "Create Dataset repo $dataset_repo_id" -Action {
    & hf repo create $dataset_repo_id --repo-type dataset --private --exist-ok
    if ($LASTEXITCODE -ne 0) {
      Fail "failed to create Dataset repo"
    }
  }
  Invoke-Step -Message "Upload repository to Space $space_repo_id" -Action {
    & hf upload $space_repo_id . --repo-type space --exclude ".git/**" --exclude ".git" --commit-message "feat: deploy Gemma 4 to hf space"
    if ($LASTEXITCODE -ne 0) {
      Fail "failed to upload repository to Space"
    }
  }

  $api_token = ""
  Invoke-Step -Message "Resolve API token for Space configuration" -Action {
    $api_token = Read-CurrentHfToken
    if ([string]::IsNullOrEmpty($api_token)) {
      $api_token = $hf_token_for_backup
    }
    if ([string]::IsNullOrEmpty($api_token)) {
      Fail "unable to resolve API token for Space configuration."
    }
  }

  Set-SpaceVariableLogged -SpaceRepoId $space_repo_id -Key "OPENCLAW_BACKUP_DATASET_REPO" -Value $dataset_repo_id -ApiToken $api_token
  Set-SpaceVariableLogged -SpaceRepoId $space_repo_id -Key "OPENCLAW_VERSION" -Value $openclaw_version -ApiToken $api_token
  Set-SpaceVariableLogged -SpaceRepoId $space_repo_id -Key "OPENCLAW_GATEWAY_CONTROLUI_ALLOW_INSECURE_AUTH" -Value "false" -ApiToken $api_token
  Set-SpaceVariableLogged -SpaceRepoId $space_repo_id -Key "OPENCLAW_GATEWAY_CONTROLUI_DANGEROUSLY_DISABLE_DEVICE_AUTH" -Value "false" -ApiToken $api_token
  Set-SpaceSecretLogged -SpaceRepoId $space_repo_id -Key "OPENCLAW_GATEWAY_TOKEN" -Value $gateway_token -ApiToken $api_token
  Set-SpaceSecretLogged -SpaceRepoId $space_repo_id -Key "OPENCLAW_GATEWAY_PASSWORD" -Value $gateway_password -ApiToken $api_token
  Set-SpaceSecretLogged -SpaceRepoId $space_repo_id -Key "HF_TOKEN" -Value $hf_token_for_backup -ApiToken $api_token

  if ($configure_llm -eq "yes") {
    Set-SpaceVariableLogged -SpaceRepoId $space_repo_id -Key "OPENCLAW_LLM_BASE_URL" -Value $llm_base_url -ApiToken $api_token
    Set-SpaceVariableLogged -SpaceRepoId $space_repo_id -Key "OPENCLAW_LLM_MODEL" -Value $llm_model -ApiToken $api_token
    Set-SpaceSecretLogged -SpaceRepoId $space_repo_id -Key "OPENCLAW_LLM_API_KEY" -Value $llm_api_key -ApiToken $api_token
  }

  Set-SpaceVariableLogged -SpaceRepoId $space_repo_id -Key "OPENCLAW_SSHX_AUTO_START" -Value $sshx_auto_start_value -ApiToken $api_token

  Invoke-Step -Message "Print deployment summary" -Action {
    $space_page_url = "https://huggingface.co/spaces/$space_repo_id"
    $space_host = "$($space_repo_id -replace '/', '-').hf.space"
    $app_url = "https://$space_host"
    $health_url = "$app_url/healthz"

    Write-Info ""
    Write-Info "Deployment complete."
    Write-Info "Space repo: $space_repo_id"
    Write-Info "Hugging Face Space: $space_page_url"
    Write-Info "Dataset repo: $dataset_repo_id"
    Write-Info "OPENCLAW_VERSION: $openclaw_version"
    Write-Info "Space URL: $app_url"
    Write-Info "Health URL: $health_url"

    if ($generated_gateway_token) {
      Write-Info "Generated OPENCLAW_GATEWAY_TOKEN=$gateway_token"
    }
    if ($generated_gateway_password) {
      Write-Info "Generated OPENCLAW_GATEWAY_PASSWORD=$gateway_password"
    }
  }
}

try {
  Main
}
catch {
  Write-Error $_.Exception.Message
  exit 1
}
finally {
  Restore-PreviousHfLoginIfNeeded
}