@plusonelabs/cue 0.0.90 → 0.0.93

package/bin/windows-bootstrap.ps1

@@ -0,0 +1,1113 @@
+param(
+  [string]$Distro = "Ubuntu",
+  [switch]$InstallCue,
+  [switch]$RequireSystemd = $true,
+  [switch]$Json,
+  [string]$RuntimeUrl = "",
+  [string]$RuntimeSha256 = ""
+)
+
+$ErrorActionPreference = "Stop"
+
+$BootstrapReport = [ordered]@{
+  ok = $false
+  distro = $Distro
+  requireSystemd = [bool]$RequireSystemd
+  installCue = [bool]$InstallCue
+  checks = @()
+  warnings = @()
+  steps = @()
+  runtime = $null
+  host = [ordered]@{
+    version = $null
+  }
+  cue = [ordered]@{
+    installed = $false
+    version = $null
+  }
+  runtimeArtifact = [ordered]@{
+    url = $null
+    sha256 = $null
+    source = $null
+    downloaded = $false
+    extractedPath = $null
+    installMode = $null
+  }
+}
+
+if ($RuntimeUrl) {
+  $BootstrapReport.runtimeArtifact.url = $RuntimeUrl
+}
+if ($RuntimeSha256) {
+  $BootstrapReport.runtimeArtifact.sha256 = $RuntimeSha256
+}
+
+function Add-Check {
+  param(
+    [Parameter(Mandatory = $true)]
+    [string]$Name,
+    [Parameter(Mandatory = $true)]
+    [ValidateSet("ok", "warn", "fail")]
+    [string]$Status,
+    [Parameter(Mandatory = $true)]
+    [string]$Message
+  )
+  $BootstrapReport.checks += [pscustomobject]@{
+    name = $Name
+    status = $Status
+    message = $Message
+  }
+}
+
+function Add-Warning {
+  param([Parameter(Mandatory = $true)][string]$Message)
+  $BootstrapReport.warnings += $Message
+}
+
+function Add-Step {
+  param([Parameter(Mandatory = $true)][string]$Message)
+  $BootstrapReport.steps += $Message
+}
+
+function Complete-Bootstrap {
+  param(
+    [int]$ExitCode = 0,
+    [bool]$Ok = $true
+  )
+  $BootstrapReport.ok = $Ok
+  if ($Json) {
+    $BootstrapReport | ConvertTo-Json -Depth 6
+  }
+  exit $ExitCode
+}
+
+function Write-Step($Message) {
+  if (-not $Json) {
+    Write-Host "==> $Message"
+  }
+}
+
+function Write-WarnMessage($Message) {
+  Add-Warning $Message
+  if (-not $Json) {
+    Write-Host "WARN: $Message" -ForegroundColor Yellow
+  }
+}
+
+function Write-Ok($Message) {
+  if (-not $Json) {
+    Write-Host "OK: $Message" -ForegroundColor Green
+  }
+}
+
+function Normalize-WslOutputLine {
+  param([string]$Value)
+  if ($null -eq $Value) {
+    return ""
+  }
+
+  $normalized = [string]$Value
+  $normalized = $normalized.Replace([string][char]0, "")
+  return $normalized.Trim()
+}
+
+function Quote-BashSingle {
+  param([string]$Value)
+  if ($null -eq $Value) {
+    return "''"
+  }
+  $bashSingleQuoteEscape = "'" + '"' + "'" + '"' + "'"
+  return "'" + ($Value -replace "'", $bashSingleQuoteEscape) + "'"
+}
+
+function Convert-WindowsPathToWslPath {
+  param([string]$WindowsPath)
+
+  if ([string]::IsNullOrWhiteSpace($WindowsPath)) {
+    return $null
+  }
+
+  $fullPath = [System.IO.Path]::GetFullPath($WindowsPath)
+  if ($fullPath -notmatch '^[A-Za-z]:\\') {
+    return $null
+  }
+
+  $drive = $fullPath.Substring(0, 1).ToLowerInvariant()
+  $rest = $fullPath.Substring(3).Replace('\', '/')
+  if ([string]::IsNullOrEmpty($rest)) {
+    return "/mnt/$drive"
+  }
+  return "/mnt/$drive/$rest"
+}
+
+function Read-FileBytesSafe {
+  param([string]$Path)
+  if (-not (Test-Path -LiteralPath $Path)) {
+    return [byte[]]@()
+  }
+  return [System.IO.File]::ReadAllBytes($Path)
+}
+
+function Get-DecodedTextScore {
+  param([string]$Text)
+  if ($null -eq $Text) {
+    return -100000
+  }
+
+  $score = 0
+  foreach ($char in $Text.ToCharArray()) {
+    $code = [int][char]$char
+
+    if ($char -eq [char]0) {
+      $score -= 8
+      continue
+    }
+
+    if ($char -eq [char]0xFFFD) {
+      $score -= 6
+      continue
+    }
+
+    if ([char]::IsControl($char)) {
+      if ($char -eq "`r" -or $char -eq "`n" -or $char -eq "`t") {
+        $score += 0
+      } else {
+        $score -= 4
+      }
+      continue
+    }
+
+    if ([char]::IsLetterOrDigit($char) -or [char]::IsWhiteSpace($char)) {
+      $score += 2
+      continue
+    }
+
+    # Allow punctuation/symbols/CJK without over-penalizing.
+    $score += 1
+  }
+
+  return $score
+}
+
+function Test-BytesLikelyUtf16Le {
+  param([byte[]]$Bytes)
+  if ($null -eq $Bytes -or $Bytes.Length -lt 4) {
+    return $false
+  }
+
+  $pairs = 0
+  $oddZero = 0
+  for ($i = 1; $i -lt $Bytes.Length; $i += 2) {
+    $pairs += 1
+    if ($Bytes[$i] -eq 0) {
+      $oddZero += 1
+    }
+  }
+
+  if ($pairs -eq 0) {
+    return $false
+  }
+
+  return (($oddZero / $pairs) -ge 0.30)
+}
+
+function Test-BytesLikelyUtf16Be {
+  param([byte[]]$Bytes)
+  if ($null -eq $Bytes -or $Bytes.Length -lt 4) {
+    return $false
+  }
+
+  $pairs = 0
+  $evenZero = 0
+  for ($i = 0; $i -lt $Bytes.Length; $i += 2) {
+    $pairs += 1
+    if ($Bytes[$i] -eq 0) {
+      $evenZero += 1
+    }
+  }
+
+  if ($pairs -eq 0) {
+    return $false
+  }
+
+  return (($evenZero / $pairs) -ge 0.30)
+}
+
+function Decode-WslOutputBytes {
+  param([byte[]]$Bytes)
+
+  if ($null -eq $Bytes -or $Bytes.Length -eq 0) {
+    return ""
+  }
+
+  # BOM handling first
+  if ($Bytes.Length -ge 3 -and $Bytes[0] -eq 0xEF -and $Bytes[1] -eq 0xBB -and $Bytes[2] -eq 0xBF) {
+    return [System.Text.Encoding]::UTF8.GetString($Bytes, 3, $Bytes.Length - 3)
+  }
+  if ($Bytes.Length -ge 2 -and $Bytes[0] -eq 0xFF -and $Bytes[1] -eq 0xFE) {
+    return [System.Text.Encoding]::Unicode.GetString($Bytes, 2, $Bytes.Length - 2)
+  }
+  if ($Bytes.Length -ge 2 -and $Bytes[0] -eq 0xFE -and $Bytes[1] -eq 0xFF) {
+    return [System.Text.Encoding]::BigEndianUnicode.GetString($Bytes, 2, $Bytes.Length - 2)
+  }
+
+  # `wsl -l -q` frequently writes UTF-16 text without BOM when redirected.
+  if (Test-BytesLikelyUtf16Le $Bytes) {
+    return [System.Text.Encoding]::Unicode.GetString($Bytes)
+  }
+  if (Test-BytesLikelyUtf16Be $Bytes) {
+    return [System.Text.Encoding]::BigEndianUnicode.GetString($Bytes)
+  }
+
+  $candidates = New-Object System.Collections.Generic.List[object]
+
+  $unicodeText = [System.Text.Encoding]::Unicode.GetString($Bytes)
+  $candidates.Add([pscustomobject]@{ Name = "utf16le"; Text = $unicodeText; Score = (Get-DecodedTextScore $unicodeText) })
+
+  $beUnicodeText = [System.Text.Encoding]::BigEndianUnicode.GetString($Bytes)
+  $candidates.Add([pscustomobject]@{ Name = "utf16be"; Text = $beUnicodeText; Score = (Get-DecodedTextScore $beUnicodeText) })
+
+  $utf8Text = [System.Text.Encoding]::UTF8.GetString($Bytes)
+  $candidates.Add([pscustomobject]@{ Name = "utf8"; Text = $utf8Text; Score = (Get-DecodedTextScore $utf8Text) })
+
+  try {
+    $consoleEncoding = [Console]::OutputEncoding
+    if ($consoleEncoding) {
+      $consoleText = $consoleEncoding.GetString($Bytes)
+      $candidates.Add([pscustomobject]@{
+        Name = "console"
+        Text = $consoleText
+        Score = (Get-DecodedTextScore $consoleText)
+      })
+    }
+  } catch {
+    # Ignore console encoding errors and fall back to other candidates.
+  }
+
+  try {
+    $ansiEncoding = [System.Text.Encoding]::GetEncoding([System.Globalization.CultureInfo]::CurrentCulture.TextInfo.ANSICodePage)
+    if ($ansiEncoding) {
+      $ansiText = $ansiEncoding.GetString($Bytes)
+      $candidates.Add([pscustomobject]@{
+        Name = "ansi"
+        Text = $ansiText
+        Score = (Get-DecodedTextScore $ansiText)
+      })
+    }
+  } catch {
+    # Ignore ANSI code page lookup errors.
+  }
+
+  $best = $candidates | Sort-Object -Property Score -Descending | Select-Object -First 1
+  if ($null -eq $best) {
+    return ""
+  }
+
+  return [string]$best.Text
+}
+
+function Invoke-WslCommandRawCapture {
+  param(
+    [Parameter(Mandatory = $true)]
+    [string[]]$Arguments
+  )
+
+  $stdoutPath = [System.IO.Path]::GetTempFileName()
+  $stderrPath = [System.IO.Path]::GetTempFileName()
+  try {
+    $process = Start-Process -FilePath "wsl.exe" `
+      -ArgumentList $Arguments `
+      -NoNewWindow `
+      -Wait `
+      -PassThru `
+      -RedirectStandardOutput $stdoutPath `
+      -RedirectStandardError $stderrPath
+    $code = $process.ExitCode
+
+    $stdoutText = Decode-WslOutputBytes (Read-FileBytesSafe $stdoutPath)
+    $stderrText = Decode-WslOutputBytes (Read-FileBytesSafe $stderrPath)
+  } finally {
+    Remove-Item -LiteralPath $stdoutPath -ErrorAction SilentlyContinue
+    Remove-Item -LiteralPath $stderrPath -ErrorAction SilentlyContinue
+  }
+
+  $lines = @()
+
+  foreach ($textBlock in @($stdoutText, $stderrText)) {
+    if ([string]::IsNullOrWhiteSpace($textBlock)) {
+      continue
+    }
+    foreach ($item in ($textBlock -split "(`r`n|`n|`r)")) {
+      $line = Normalize-WslOutputLine ([string]$item)
+      if ($line) {
+        $lines += $line
+      }
+    }
+  }
+
+  return [pscustomobject]@{
+    ExitCode = $code
+    Output = ($lines -join [Environment]::NewLine)
+  }
+}
+
+function Invoke-WslCommand {
+  param(
+    [Parameter(Mandatory = $true)]
+    [string[]]$Arguments
+  )
+
+  $previousErrorActionPreference = $ErrorActionPreference
+  $nativeCommandPreferenceVar = Get-Variable -Name PSNativeCommandUseErrorActionPreference -ErrorAction SilentlyContinue
+  $previousNativeCommandPreference = $null
+  if ($nativeCommandPreferenceVar) {
+    $previousNativeCommandPreference = [bool]$nativeCommandPreferenceVar.Value
+  }
+
+  try {
+    $ErrorActionPreference = "Continue"
+    if ($nativeCommandPreferenceVar) {
+      $script:PSNativeCommandUseErrorActionPreference = $false
+    }
+    $rawOutput = & wsl.exe @Arguments 2>&1
+    $code = $LASTEXITCODE
+  } finally {
+    $ErrorActionPreference = $previousErrorActionPreference
+    if ($nativeCommandPreferenceVar) {
+      $script:PSNativeCommandUseErrorActionPreference = $previousNativeCommandPreference
+    }
+  }
+
+  $lines = @()
+  foreach ($item in @($rawOutput)) {
+    if ($null -eq $item) {
+      continue
+    }
+    if ($item -is [System.Management.Automation.ErrorRecord]) {
+      $line = Normalize-WslOutputLine ($item.ToString())
+      if ($line) {
+        $lines += $line
+      }
+      continue
+    }
+    $line = Normalize-WslOutputLine ([string]$item)
+    if ($line) {
+      $lines += $line
+    }
+  }
+
+  return [pscustomobject]@{
+    ExitCode = $code
+    Output = ($lines -join [Environment]::NewLine)
+  }
+}
+
+function Resolve-RuntimeArtifactRoot {
+  param([Parameter(Mandatory = $true)][string]$ExtractDir)
+
+  $directBundle = Join-Path $ExtractDir "cli-release.mjs"
+  $directInstaller = Join-Path $ExtractDir "install-in-wsl-user.sh"
+  if ((Test-Path -LiteralPath $directBundle) -and (Test-Path -LiteralPath $directInstaller)) {
+    return $ExtractDir
+  }
+
+  $wslRuntimeDir = Join-Path $ExtractDir "wsl-runtime"
+  $nestedBundle = Join-Path $wslRuntimeDir "cli-release.mjs"
+  $nestedInstaller = Join-Path $wslRuntimeDir "install-in-wsl-user.sh"
+  if ((Test-Path -LiteralPath $nestedBundle) -and (Test-Path -LiteralPath $nestedInstaller)) {
+    return $wslRuntimeDir
+  }
+
+  $bundleFile = Get-ChildItem -LiteralPath $ExtractDir -Recurse -File -Filter "cli-release.mjs" -ErrorAction SilentlyContinue | Select-Object -First 1
+  if ($bundleFile) {
+    $candidateDir = $bundleFile.Directory.FullName
+    if (Test-Path -LiteralPath (Join-Path $candidateDir "install-in-wsl-user.sh")) {
+      return $candidateDir
+    }
+  }
+
+  return $null
+}
+
+function Resolve-ConfiguredRuntimeArtifactSource {
+  $envUrl = [string]$env:CUE_WSL_RUNTIME_URL
+  $envSha256 = [string]$env:CUE_WSL_RUNTIME_SHA256
+  if (-not [string]::IsNullOrWhiteSpace($envUrl)) {
+    $resolvedEnvSha256 = $null
+    if (-not [string]::IsNullOrWhiteSpace($envSha256)) {
+      $resolvedEnvSha256 = $envSha256
+    }
+    return [pscustomobject]@{
+      Url = $envUrl
+      Sha256 = $resolvedEnvSha256
+      Source = "env"
+    }
+  }
+
+  $manifestPath = Join-Path $PSScriptRoot "windows-runtime-artifact.json"
+  if (-not (Test-Path -LiteralPath $manifestPath)) {
+    return $null
+  }
+
+  try {
+    $manifestJson = Get-Content -LiteralPath $manifestPath -Raw | ConvertFrom-Json
+  } catch {
+    Add-Check -Name "runtime_artifact_source" -Status "warn" -Message "Runtime artifact manifest could not be parsed"
+    Add-Step "Verify windows-runtime-artifact.json is valid JSON or rerun bootstrap with -RuntimeUrl"
+    return $null
+  }
+
+  $entry = $null
+  if ($manifestJson.PSObject.Properties.Name -contains "runtimeArtifact") {
+    $entry = $manifestJson.runtimeArtifact
+  } else {
+    $entry = $manifestJson
+  }
+
+  if ($null -eq $entry) {
+    return $null
+  }
+
+  $manifestUrl = [string]$entry.url
+  if ([string]::IsNullOrWhiteSpace($manifestUrl)) {
+    return $null
+  }
+
+  $manifestSha256 = $null
+  if ($entry.PSObject.Properties.Name -contains "sha256") {
+    $manifestSha256 = [string]$entry.sha256
+    if ([string]::IsNullOrWhiteSpace($manifestSha256)) {
+      $manifestSha256 = $null
+    }
+  }
+
+  return [pscustomobject]@{
+    Url = $manifestUrl
+    Sha256 = $manifestSha256
+    Source = "manifest"
+  }
+}
+
+function Resolve-LocalRuntimeArtifactPath {
+  param([Parameter(Mandatory = $true)][string]$ArtifactPathOrUrl)
+
+  if ([string]::IsNullOrWhiteSpace($ArtifactPathOrUrl)) {
+    return $null
+  }
+
+  $candidates = New-Object System.Collections.Generic.List[string]
+  $candidates.Add($ArtifactPathOrUrl)
+
+  if (-not [System.IO.Path]::IsPathRooted($ArtifactPathOrUrl)) {
+    $candidates.Add((Join-Path $PSScriptRoot $ArtifactPathOrUrl))
+
+    $scriptParent = Split-Path -Parent $PSScriptRoot
+    $scriptGrandparent = Split-Path -Parent $scriptParent
+    $artifactBaseName = [System.IO.Path]::GetFileName($ArtifactPathOrUrl)
+    if (-not [string]::IsNullOrWhiteSpace($artifactBaseName)) {
+      # Fallbacks for test-kit deployments where artifacts may be copied to C:\cue-test
+      # instead of C:\cue-test\artifacts.
+      $candidates.Add((Join-Path $scriptGrandparent $artifactBaseName))
+      $candidates.Add((Join-Path (Join-Path $scriptGrandparent "artifacts") $artifactBaseName))
+    }
+  }
+
+  foreach ($candidate in $candidates) {
+    if ([string]::IsNullOrWhiteSpace($candidate)) {
+      continue
+    }
+    if (Test-Path -LiteralPath $candidate) {
+      return [System.IO.Path]::GetFullPath($candidate)
+    }
+  }
+
+  return $null
+}
+
+function Install-CueFromRuntimeArtifact {
+  param(
+    [Parameter(Mandatory = $true)][string]$DistroName,
+    [Parameter(Mandatory = $true)][string]$ArtifactUrl,
+    [string]$ExpectedSha256
+  )
+
+  $downloadDir = Join-Path ([System.IO.Path]::GetTempPath()) ("cue-wsl-runtime-" + [Guid]::NewGuid().ToString("N"))
+  New-Item -ItemType Directory -Path $downloadDir -Force | Out-Null
+  $zipPath = Join-Path $downloadDir "cue-wsl-runtime.zip"
+  $extractDir = Join-Path $downloadDir "extract"
+
+  $artifactLocalPath = $null
+  $isUriLike = ($ArtifactUrl -match '^[a-zA-Z][a-zA-Z0-9+.-]*://')
+  if (-not $isUriLike) {
+    $artifactLocalPath = Resolve-LocalRuntimeArtifactPath -ArtifactPathOrUrl $ArtifactUrl
+  }
+
+  if ($artifactLocalPath) {
+    Write-Step "Using local WSL runtime artifact"
+    Copy-Item -LiteralPath $artifactLocalPath -Destination $zipPath -Force
+    $BootstrapReport.runtimeArtifact.downloaded = $false
+    $BootstrapReport.runtimeArtifact.localPath = $artifactLocalPath
+    Add-Check -Name "runtime_artifact_source" -Status "ok" -Message "Using local WSL runtime artifact: $artifactLocalPath"
+  } else {
+    Write-Step "Downloading WSL runtime artifact"
+    try {
+      Invoke-WebRequest -Uri $ArtifactUrl -OutFile $zipPath
+    } catch {
+      Add-Check -Name "runtime_artifact_download" -Status "fail" -Message "Failed to download WSL runtime artifact"
+      $BootstrapReport.runtimeArtifact.downloadError = $_.Exception.Message
+      throw
+    }
+    $BootstrapReport.runtimeArtifact.downloaded = $true
+    Add-Check -Name "runtime_artifact_download" -Status "ok" -Message "Downloaded WSL runtime artifact"
+  }
+
+  if ($ExpectedSha256) {
+    Write-Step "Verifying WSL runtime artifact checksum"
+    $actualSha256 = (Get-FileHash -LiteralPath $zipPath -Algorithm SHA256).Hash.ToLowerInvariant()
+    $BootstrapReport.runtimeArtifact.actualSha256 = $actualSha256
+    if ($actualSha256 -ne $ExpectedSha256.ToLowerInvariant()) {
+      Add-Check -Name "runtime_artifact_sha256" -Status "fail" -Message "WSL runtime artifact SHA256 mismatch"
+      Add-Step "Re-download the runtime artifact and verify the URL/version"
+      throw "Runtime artifact SHA256 mismatch. Expected $ExpectedSha256, got $actualSha256"
+    }
+    Add-Check -Name "runtime_artifact_sha256" -Status "ok" -Message "WSL runtime artifact SHA256 verified"
+  }
+
+  Write-Step "Extracting WSL runtime artifact"
+  New-Item -ItemType Directory -Path $extractDir -Force | Out-Null
+  Expand-Archive -Path $zipPath -DestinationPath $extractDir -Force
+  $runtimeRoot = Resolve-RuntimeArtifactRoot -ExtractDir $extractDir
+  if (-not $runtimeRoot) {
+    Add-Check -Name "runtime_artifact_extract" -Status "fail" -Message "WSL runtime artifact layout not recognized"
+    Add-Step "Verify artifact contains cli-release.mjs and install-in-wsl-user.sh"
+    throw "WSL runtime artifact layout not recognized after extract."
+  }
+  $BootstrapReport.runtimeArtifact.extractedPath = $runtimeRoot
+  Add-Check -Name "runtime_artifact_extract" -Status "ok" -Message "Extracted WSL runtime artifact"
+
+  $runtimeRootWsl = Convert-WindowsPathToWslPath -WindowsPath $runtimeRoot
+  if (-not $runtimeRootWsl) {
+    Add-Check -Name "runtime_artifact_path_map" -Status "fail" -Message "Could not map runtime artifact path into WSL"
+    throw "Could not map runtime artifact path to WSL: $runtimeRoot"
+  }
+
+  Write-Step "Installing Cue runtime in WSL from artifact"
+  $quotedRoot = Quote-BashSingle $runtimeRootWsl
+  $installCmd = "cd $quotedRoot && chmod +x ./cli-release.mjs ./install-in-wsl-user.sh && ./install-in-wsl-user.sh"
+  $installResult = Invoke-WslCommand -Arguments @("-d", $DistroName, "--", "bash", "-lc", $installCmd)
+  $BootstrapReport.runtimeArtifact.installMode = "artifact-user-script"
+  if ($installResult.Output) {
+    $BootstrapReport.installOutput = $installResult.Output
+    if (-not $Json) {
+      Write-Host $installResult.Output
+    }
+  }
+  if ($installResult.ExitCode -ne 0) {
+    Add-Check -Name "cue_install_artifact" -Status "fail" -Message "Cue runtime artifact install failed in WSL"
+    Add-Step "Run the installer script manually inside WSL to inspect errors"
+    throw "Cue runtime artifact install failed in WSL."
+  }
+  Add-Check -Name "cue_install_artifact" -Status "ok" -Message "Cue runtime artifact installed in WSL"
+}
+
+function Get-WslCuePath {
+  param([Parameter(Mandatory = $true)][string]$DistroName)
+
+  $cuePathResult = Invoke-WslCommand -Arguments @(
+    "-d", $DistroName, "--", "bash", "-lc",
+    'if [ -d "$HOME/.cue/bin" ]; then export PATH="$HOME/.cue/bin:$PATH"; fi; command -v cue || true'
+  )
+
+  if ($cuePathResult.ExitCode -ne 0) {
+    return $null
+  }
+
+  $cuePath = $cuePathResult.Output.Trim()
+  if ([string]::IsNullOrWhiteSpace($cuePath)) {
+    return $null
+  }
+
+  return $cuePath
+}
+
+function Test-IsWindowsShimPath {
+  param([string]$Value)
+  if ([string]::IsNullOrWhiteSpace($Value)) {
+    return $false
+  }
+  return ($Value -match '^/mnt/' -or $Value -match '\.(exe|cmd)$')
+}
+
+function Get-WslUserCuePath {
+  return '$HOME/.cue/bin/cue'
+}
+
+function Get-HostPackageVersion {
+  $candidatePaths = @(
+    (Join-Path $PSScriptRoot "..\package.json"),
+    (Join-Path $PSScriptRoot "..\..\package.json")
+  )
+
+  foreach ($candidate in $candidatePaths) {
+    try {
+      if (-not (Test-Path -LiteralPath $candidate)) {
+        continue
+      }
+      $raw = Get-Content -LiteralPath $candidate -Raw
+      $pkg = $raw | ConvertFrom-Json
+      if ($pkg -and $pkg.version) {
+        return [string]$pkg.version
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return $null
+}
+
+function Get-CueSemver {
+  param([string]$VersionText)
+  if ([string]::IsNullOrWhiteSpace($VersionText)) {
+    return $null
+  }
+  $match = [regex]::Match($VersionText, '\b(\d+\.\d+\.\d+)\b')
+  if (-not $match.Success) {
+    return $null
+  }
+  return $match.Groups[1].Value
+}
+
+function Add-CueVersionCompatibilityChecks {
+  param(
+    [string]$HostVersionText,
+    [string]$WslCueVersionText,
+    [switch]$AfterInstall
+  )
+
+  if ([string]::IsNullOrWhiteSpace($HostVersionText)) {
+    Add-Check -Name "cue_version_compat" -Status "warn" -Message "Could not compare host/WSL versions because host package version is unavailable"
+    return
+  }
+
+  if ([string]::IsNullOrWhiteSpace($WslCueVersionText)) {
+    Add-Check -Name "cue_version_compat" -Status "warn" -Message "Could not compare host/WSL versions because WSL Cue version is unavailable"
+    return
+  }
+
+  $hostSemver = Get-CueSemver $HostVersionText
+  $wslSemver = Get-CueSemver $WslCueVersionText
+  if ([string]::IsNullOrWhiteSpace($hostSemver) -or [string]::IsNullOrWhiteSpace($wslSemver)) {
+    Add-Check -Name "cue_version_compat" -Status "warn" -Message "Could not parse host/WSL Cue versions for compatibility check"
+    return
+  }
+
+  $BootstrapReport.host.version = $HostVersionText
+  $BootstrapReport.cue.hostVersion = $HostVersionText
+  $BootstrapReport.cue.hostSemver = $hostSemver
+  $BootstrapReport.cue.wslSemver = $wslSemver
+
+  if ($hostSemver -eq $wslSemver) {
+    Add-Check -Name "cue_version_compat" -Status "ok" -Message "Host and WSL Cue versions match ($hostSemver)"
+    return
+  }
+
+  if ($AfterInstall) {
+    Add-Check -Name "cue_version_compat" -Status "warn" -Message "Host and WSL Cue versions differ after install (host $hostSemver, WSL $wslSemver)"
+    Add-Step "Rerun bootstrap with -InstallCue to refresh WSL runtime, or update the Windows host package"
+  } else {
+    Add-Check -Name "cue_version_compat" -Status "warn" -Message "Host and WSL Cue versions differ (host $hostSemver, WSL $wslSemver)"
+    Add-Step "Run 'cue --windows-bootstrap --install-cue' to align the WSL runtime with the host package"
+  }
+}
+
+Write-Step "Cue Windows (WSL2) bootstrap checks"
+
+if (-not (Get-Command wsl.exe -ErrorAction SilentlyContinue)) {
+  Add-Check -Name "wsl_exe" -Status "fail" -Message "wsl.exe not found"
+  Add-Step "Install WSL2 first, then rerun bootstrap"
+  if ($Json) { Complete-Bootstrap -ExitCode 1 -Ok $false }
+  Write-Error "wsl.exe not found. Install WSL2 first, then rerun."
+}
+Add-Check -Name "wsl_exe" -Status "ok" -Message "wsl.exe found"
+
+$wslStatus = Invoke-WslCommandRawCapture -Arguments @("--status")
+if ($wslStatus.ExitCode -ne 0) {
+  Add-Check -Name "wsl_status" -Status "warn" -Message "wsl --status returned non-zero"
+  Write-WarnMessage "wsl --status returned non-zero. Continuing with additional checks."
+} else {
+  Add-Check -Name "wsl_status" -Status "ok" -Message "wsl --status succeeded"
+}
+if ($wslStatus.Output) {
+  $BootstrapReport.wslStatus = $wslStatus.Output
+  if (-not $Json) {
+    Write-Host $wslStatus.Output
+  }
+}
+
+Write-Step "Checking WSL distros"
+$distroListResult = Invoke-WslCommandRawCapture -Arguments @("-l", "-q")
+if ($distroListResult.ExitCode -ne 0) {
+  $detail = $distroListResult.Output
+  Add-Check -Name "wsl_distro_list" -Status "fail" -Message "Failed to list WSL distros"
+  Add-Step "Run 'wsl -l -q' in PowerShell to diagnose WSL installation"
+  $BootstrapReport.wslDistroListError = $detail
+  if ($Json) { Complete-Bootstrap -ExitCode 1 -Ok $false }
+  Write-Error "Failed to list WSL distros. Output:`n$detail"
+}
+
+$distros = @()
+foreach ($line in ($distroListResult.Output -split "(`r`n|`n|`r)")) {
+  $trimmed = Normalize-WslOutputLine $line
+  if ($trimmed) {
+    $distros += $trimmed
+  }
+}
+$BootstrapReport.installedDistros = $distros
+
+if ($distros.Count -eq 0) {
+  Add-Check -Name "wsl_distro_list" -Status "fail" -Message "No WSL distro installed"
+  Write-WarnMessage "No WSL distro is installed."
+  Add-Step "Install a distro (recommended): wsl --install -d $Distro"
+  if (-not $Json) {
+    Write-Host "Install one (recommended):"
+    Write-Host "  wsl --install -d $Distro"
+  }
+  Complete-Bootstrap -ExitCode 1 -Ok $false
+}
+Add-Check -Name "wsl_distro_list" -Status "ok" -Message "Found $($distros.Count) installed distro(s)"
+
+if (-not $Json) {
+  Write-Host "Installed distros:"
+  foreach ($name in $distros) {
+    Write-Host "  - $name"
+  }
+}
+
+if (-not ($distros -contains $Distro)) {
+  Add-Check -Name "supported_distro" -Status "fail" -Message "Supported distro '$Distro' not found"
+  Write-WarnMessage "Supported distro '$Distro' not found."
+  Add-Step "Install recommended distro: wsl --install -d $Distro"
+  if (-not $Json) {
+    Write-Host "Recommended install command:"
+    Write-Host "  wsl --install -d $Distro"
+  }
+  Complete-Bootstrap -ExitCode 1 -Ok $false
+}
+Add-Check -Name "supported_distro" -Status "ok" -Message "Found supported distro: $Distro"
+Write-Ok "Found supported distro: $Distro"
+
+Write-Step "Checking bash in WSL"
+$bashCheck = Invoke-WslCommand -Arguments @("-d", $Distro, "--", "bash", "-lc", "command -v bash >/dev/null && echo bash-ok")
+if ($bashCheck.ExitCode -ne 0 -or -not ($bashCheck.Output -match "bash-ok")) {
+  Add-Check -Name "bash" -Status "fail" -Message "bash not available in WSL distro '$Distro'"
+  Add-Step "Open WSL distro '$Distro' and ensure bash is installed/runnable"
+  if ($Json) { Complete-Bootstrap -ExitCode 1 -Ok $false }
+  Write-Error "bash not available in WSL distro '$Distro'."
+}
+Add-Check -Name "bash" -Status "ok" -Message "bash available in WSL distro '$Distro'"
+Write-Ok "bash available"
+
+if ($RequireSystemd) {
+  Write-Step "Checking systemd"
+  $systemdCheck = Invoke-WslCommand -Arguments @("-d", $Distro, "--", "bash", "-lc", "test -d /run/systemd/system && echo systemd-ok")
+  if ($systemdCheck.ExitCode -ne 0 -or -not ($systemdCheck.Output -match "systemd-ok")) {
+    Add-Check -Name "systemd" -Status "warn" -Message "systemd not detected in '$Distro'"
+    Write-WarnMessage "systemd does not appear to be enabled in '$Distro'."
+    Add-Step "Enable systemd in WSL ($Distro): edit /etc/wsl.conf with [boot] systemd=true"
+    Add-Step "Run from PowerShell: wsl --shutdown"
+    Add-Step "Reopen WSL and verify: systemctl --user status"
+    if (-not $Json) {
+      Write-Host "Cue manager/service parity may be incomplete until systemd is enabled in WSL."
+      Write-Host "See docs/windows/support.md for supported environment requirements."
+    }
+  } else {
+    Add-Check -Name "systemd" -Status "ok" -Message "systemd enabled in '$Distro'"
+    Write-Ok "systemd enabled"
+  }
+}
+
+Write-Step "Checking runtime (bun or npm) in WSL"
+$nodePathCheck = Invoke-WslCommand -Arguments @("-d", $Distro, "--", "bash", "-lc", "command -v node || true")
+if ($nodePathCheck.ExitCode -ne 0) {
+  Add-Check -Name "node" -Status "fail" -Message "Failed to check node runtime in WSL distro '$Distro'"
+  Add-Step "Open WSL and verify Linux Node.js is installed"
+  if ($Json) { Complete-Bootstrap -ExitCode 1 -Ok $false }
+  Write-Error "Failed to check node runtime in WSL distro '$Distro'."
+}
+
+$nodePath = $nodePathCheck.Output.Trim()
+if ([string]::IsNullOrWhiteSpace($nodePath)) {
+  Add-Check -Name "node" -Status "fail" -Message "Linux node runtime not found in WSL"
+  Write-WarnMessage "Node.js is not installed inside WSL (Linux runtime required to run Cue)."
+  Add-Step "Install Linux Node.js/npm in Ubuntu (example): sudo apt update && sudo apt install -y nodejs npm"
+  Add-Step "Or install Bun and ensure Linux node is available before rerunning bootstrap"
+  if (-not $Json) {
+    Write-Host "Install Linux Node.js inside WSL, then rerun bootstrap."
+  }
+  Complete-Bootstrap -ExitCode 1 -Ok $false
+}
+
+if ($nodePath -match '^/mnt/' -or $nodePath -match '\.exe$') {
+  Add-Check -Name "node" -Status "fail" -Message "WSL node resolves to Windows path: $nodePath"
+  Write-WarnMessage "WSL node resolves to a Windows executable. Cue requires a Linux Node.js runtime inside WSL."
+  Add-Step "Install Linux Node.js/npm in Ubuntu (example): sudo apt update && sudo apt install -y nodejs npm"
+  Add-Step "Ensure 'command -v node' returns a Linux path (e.g. /usr/bin/node), then rerun bootstrap"
+  if (-not $Json) {
+    Write-Host "WSL node currently resolves to a Windows path:"
+    Write-Host "  $nodePath"
+  }
+  Complete-Bootstrap -ExitCode 1 -Ok $false
+}
+
+Add-Check -Name "node" -Status "ok" -Message "Linux node runtime found in WSL: $nodePath"
+Write-Ok "Linux node runtime found"
+
+$runtimeCheck = Invoke-WslCommand -Arguments @("-d", $Distro, "--", "bash", "-lc", "if command -v bun >/dev/null; then echo bun; elif command -v npm >/dev/null; then echo npm; else echo none; fi")
+if ($runtimeCheck.ExitCode -ne 0) {
+  Add-Check -Name "runtime" -Status "fail" -Message "Failed to check runtime in WSL distro '$Distro'"
+  Add-Step "Open WSL and verify Bun or Node/npm is installed"
+  if ($Json) { Complete-Bootstrap -ExitCode 1 -Ok $false }
+  Write-Error "Failed to check runtime in WSL distro '$Distro'."
+}
+
+$runtime = $runtimeCheck.Output.Trim()
+$BootstrapReport.runtime = $runtime
+if ($runtime -eq "none" -or [string]::IsNullOrWhiteSpace($runtime)) {
+  Add-Check -Name "runtime" -Status "fail" -Message "Neither bun nor npm found in WSL"
+  Write-WarnMessage "Neither bun nor npm was found in WSL."
+  Add-Step "Install Bun (recommended) or Node/npm inside WSL, then rerun bootstrap"
+  Add-Step "Bun install guide: https://bun.sh/"
+  if (-not $Json) {
+    Write-Host "Install Bun (recommended) or Node/npm inside WSL, then rerun."
+    Write-Host "  Bun: https://bun.sh/"
+  }
+  Complete-Bootstrap -ExitCode 1 -Ok $false
+}
+Add-Check -Name "runtime" -Status "ok" -Message "Found runtime in WSL: $runtime"
+Write-Ok "Found runtime in WSL: $runtime"
+
+$hostVersion = Get-HostPackageVersion
+if ($hostVersion) {
+  $BootstrapReport.host.version = $hostVersion
+  Add-Check -Name "host_version" -Status "ok" -Message "Host Cue package version: $hostVersion"
+} else {
+  Add-Check -Name "host_version" -Status "warn" -Message "Could not detect host Cue package version"
+}
+
+$resolvedRuntimeArtifact = $null
+if (-not [string]::IsNullOrWhiteSpace($RuntimeUrl)) {
+  $resolvedArgSha256 = $null
+  if (-not [string]::IsNullOrWhiteSpace($RuntimeSha256)) {
+    $resolvedArgSha256 = $RuntimeSha256
+  }
+  $resolvedRuntimeArtifact = [pscustomobject]@{
+    Url = $RuntimeUrl
+    Sha256 = $resolvedArgSha256
+    Source = "argument"
+  }
+} elseif ($InstallCue) {
+  $resolvedRuntimeArtifact = Resolve-ConfiguredRuntimeArtifactSource
+}
+
+if ($resolvedRuntimeArtifact) {
+  $RuntimeUrl = [string]$resolvedRuntimeArtifact.Url
+  if ([string]::IsNullOrWhiteSpace($RuntimeSha256) -and $resolvedRuntimeArtifact.Sha256) {
+    $RuntimeSha256 = [string]$resolvedRuntimeArtifact.Sha256
+  }
+  $BootstrapReport.runtimeArtifact.url = $RuntimeUrl
+  if ($RuntimeSha256) {
+    $BootstrapReport.runtimeArtifact.sha256 = $RuntimeSha256
+  }
+  $BootstrapReport.runtimeArtifact.source = [string]$resolvedRuntimeArtifact.Source
+  Add-Check -Name "runtime_artifact_source" -Status "ok" -Message "Resolved runtime artifact source ($($resolvedRuntimeArtifact.Source))"
+  if (-not $Json) {
+    Write-Host "Resolved runtime artifact source ($($resolvedRuntimeArtifact.Source)): $RuntimeUrl"
+  }
+}
+
+Write-Step "Checking Cue in WSL"
+$userCuePath = Get-WslUserCuePath
+$userCueVersionProbe = Invoke-WslCommand -Arguments @("-d", $Distro, "--", "bash", "-lc", 'if [ -e "$HOME/.cue/bin/cue" ]; then "$HOME/.cue/bin/cue" --version; else exit 3; fi')
+$cueUserPathRunnable = $false
+$cueVersionText = $null
+if ($userCueVersionProbe.ExitCode -eq 0) {
+  $cueUserPathRunnable = $true
+  if (-not [string]::IsNullOrWhiteSpace($userCueVersionProbe.Output)) {
+    $cueVersionText = $userCueVersionProbe.Output.Trim()
+  }
+  Add-Check -Name "cue_user_path" -Status "ok" -Message "Cue runtime found at ~/.cue/bin/cue"
+} else {
+  $userCueNodeProbe = Invoke-WslCommand -Arguments @("-d", $Distro, "--", "bash", "-lc", 'if [ -e "$HOME/.cue/bin/cue" ]; then node "$HOME/.cue/bin/cue" --version; else exit 3; fi')
+  if ($userCueNodeProbe.ExitCode -eq 0) {
+    $cueUserPathRunnable = $true
+    if (-not [string]::IsNullOrWhiteSpace($userCueNodeProbe.Output)) {
+      $cueVersionText = $userCueNodeProbe.Output.Trim()
+    }
+    Add-Check -Name "cue_user_path" -Status "ok" -Message "Cue runtime found at ~/.cue/bin/cue (node fallback)"
+  }
+}
+
+$cuePath = Get-WslCuePath -DistroName $Distro
+$cuePathIsWindowsShim = Test-IsWindowsShimPath -Value $cuePath
+if ($cuePath) {
+  if ($cuePathIsWindowsShim) {
+    Add-Check -Name "cue_path" -Status "warn" -Message "WSL cue resolves to a Windows command: $cuePath"
+    Write-WarnMessage "WSL cue resolves to a Windows command: $cuePath"
+    Add-Step "Install Linux Cue in WSL or use bootstrap runtime artifact install; prefer ~/.cue/bin on PATH"
+  } else {
+    Add-Check -Name "cue_path" -Status "ok" -Message "Linux cue found in WSL: $cuePath"
+  }
+}
+
+if ([string]::IsNullOrWhiteSpace($cueVersionText) -and $cuePath -and -not $cuePathIsWindowsShim) {
+  $cueVersion = Invoke-WslCommand -Arguments @("-d", $Distro, "--", "bash", "-lc", 'export PATH="$HOME/.cue/bin:$PATH"; cue --version')
+  if ($cueVersion.ExitCode -eq 0 -and -not [string]::IsNullOrWhiteSpace($cueVersion.Output)) {
+    $cueVersionText = $cueVersion.Output.Trim()
+  }
+}
+
+$shouldInstallFromArtifact = [bool]$InstallCue -and (-not [string]::IsNullOrWhiteSpace($RuntimeUrl))
+if ($cueUserPathRunnable -or -not [string]::IsNullOrWhiteSpace($cueVersionText)) {
+  if ($shouldInstallFromArtifact) {
+    Add-Check -Name "cue" -Status "ok" -Message "Cue already installed in WSL (will install/update from runtime artifact)"
+  } else {
+    if ([string]::IsNullOrWhiteSpace($cueVersionText)) {
+      Add-Check -Name "cue" -Status "ok" -Message "Cue already installed in WSL (version text unavailable)"
+    } else {
+      Add-Check -Name "cue" -Status "ok" -Message "Cue already installed in WSL"
+    }
+  }
+  $BootstrapReport.cue.installed = $true
+  $BootstrapReport.cue.version = $cueVersionText
+  Add-CueVersionCompatibilityChecks -HostVersionText $hostVersion -WslCueVersionText $cueVersionText
+  if ($shouldInstallFromArtifact) {
+    $BootstrapReport.cue.previousVersion = $cueVersionText
+    Write-Ok "Cue already installed in WSL (runtime artifact install/update requested)"
+    Add-Step "Proceeding with runtime artifact install/update because -InstallCue and a runtime artifact source are available"
+    if (-not $Json) {
+      Write-Host "Proceeding with runtime artifact install/update..."
+    }
+  } else {
+    Write-Ok "Cue already installed in WSL"
+  }
+  if (-not $Json -and $cueVersionText) {
+    Write-Host $cueVersionText
+  }
+  if (-not $shouldInstallFromArtifact) {
+    Complete-Bootstrap -ExitCode 0 -Ok $true
+  }
+}
+
+if (-not $InstallCue) {
+  Add-Check -Name "cue" -Status "fail" -Message "Cue not installed in WSL"
+  Write-WarnMessage "Cue is not installed in WSL yet."
+  Add-Step "Install Cue inside WSL and rerun bootstrap"
+  if ($RuntimeUrl) {
+    Add-Step "Or rerun bootstrap with -InstallCue (runtime artifact source is already configured)"
+    Add-Step "Or rerun bootstrap with -InstallCue -RuntimeUrl <artifact-url>"
+    if (-not $Json) {
+      Write-Host "Install via runtime artifact:"
+      Write-Host "  cue --windows-bootstrap --install-cue"
+      Write-Host "  # or explicit override:"
+      Write-Host "  cue --windows-bootstrap --install-cue --runtime-url <artifact-url>"
+      Write-Host ""
+    }
+  } else {
+    Add-Step "Or rerun bootstrap with -InstallCue to auto-install using the configured runtime source (if present)"
+  }
+  if ($runtime -eq "bun") {
+    $installCmd = "wsl -d $Distro -- bash -lc 'bun add -g @plusonelabs/cue'"
+  } else {
+    $installCmd = "wsl -d $Distro -- bash -lc 'npm install -g @plusonelabs/cue'"
+  }
+  Add-Step $installCmd
+  if (-not $Json) {
+    Write-Host "Install inside WSL and rerun:"
+    Write-Host "  $installCmd"
+    Write-Host ""
+    Write-Host "Or run this script with -InstallCue to install automatically."
+  }
+  Add-Step "Or rerun bootstrap with -InstallCue"
+  Complete-Bootstrap -ExitCode 1 -Ok $false
+}
+
+Write-Step "Installing Cue in WSL"
+if ($RuntimeUrl) {
+  try {
+    Install-CueFromRuntimeArtifact -DistroName $Distro -ArtifactUrl $RuntimeUrl -ExpectedSha256 $RuntimeSha256
+  } catch {
+    if (-not $Json) {
+      Write-Error $_
+    }
+    if ($Json) { Complete-Bootstrap -ExitCode 1 -Ok $false }
+    exit 1
+  }
+} else {
+  if ($runtime -eq "bun") {
+    $installResult = Invoke-WslCommand -Arguments @("-d", $Distro, "--", "bash", "-lc", "bun add -g @plusonelabs/cue")
+  } else {
+    $installResult = Invoke-WslCommand -Arguments @("-d", $Distro, "--", "bash", "-lc", "npm install -g @plusonelabs/cue")
+  }
+
+  if ($installResult.Output) {
+    $BootstrapReport.installOutput = $installResult.Output
+    if (-not $Json) {
+      Write-Host $installResult.Output
+    }
+  }
+  if ($installResult.ExitCode -ne 0) {
+    Add-Check -Name "cue_install" -Status "fail" -Message "Cue install failed in WSL"
+    Add-Step "Run the install command manually inside WSL to inspect errors"
+    if ($Json) { Complete-Bootstrap -ExitCode 1 -Ok $false }
+    Write-Error "Cue install failed in WSL."
+  }
+  Add-Check -Name "cue_install" -Status "ok" -Message "Cue install command succeeded in WSL"
+}
+
+$userCueVersionAfter = Invoke-WslCommand -Arguments @("-d", $Distro, "--", "bash", "-lc", "$userCuePath --version")
+if ($userCueVersionAfter.ExitCode -ne 0) {
+  Add-Check -Name "cue_verify_user_path" -Status "fail" -Message "Installed Cue runtime not runnable at ~/.cue/bin/cue after install"
+  Add-Step "Inspect ~/.cue/bin/cue and ~/.cue/runtime in WSL"
+  if ($Json) { Complete-Bootstrap -ExitCode 1 -Ok $false }
+  Write-Error "Installed Cue runtime not runnable at ~/.cue/bin/cue after install."
+}
+Add-Check -Name "cue_verify_user_path" -Status "ok" -Message "Installed Cue runtime runnable at ~/.cue/bin/cue"
+
+$cuePathAfter = Get-WslCuePath -DistroName $Distro
+if ([string]::IsNullOrWhiteSpace($cuePathAfter)) {
+  Add-Check -Name "cue_verify_path" -Status "warn" -Message "Cue not found on default WSL PATH after install"
+  Add-Step "Add ~/.cue/bin to PATH in WSL shell rc for direct WSL terminal usage"
+  Write-WarnMessage "Cue is installed at ~/.cue/bin/cue but not on default WSL PATH."
+} elseif (Test-IsWindowsShimPath -Value $cuePathAfter) {
+  Add-Check -Name "cue_verify_path" -Status "warn" -Message "Default WSL PATH resolves cue to Windows command: $cuePathAfter"
+  Add-Step "Add ~/.cue/bin to PATH before Windows-inherited paths in WSL for direct WSL terminal usage"
+  Add-Step "Windows wrapper still works because it prefers ~/.cue/bin automatically"
+  Write-WarnMessage "Default WSL PATH resolves cue to a Windows command after install: $cuePathAfter"
+} else {
+  Add-Check -Name "cue_verify_path" -Status "ok" -Message "Default WSL PATH resolves cue to Linux path after install: $cuePathAfter"
+}
+
+$cueVersionAfter = Invoke-WslCommand -Arguments @("-d", $Distro, "--", "bash", "-lc", 'export PATH="$HOME/.cue/bin:$PATH"; cue --version')
+if ($cueVersionAfter.ExitCode -ne 0) {
+  Add-Check -Name "cue_verify" -Status "fail" -Message "Cue not runnable in WSL after install"
+  if ($Json) { Complete-Bootstrap -ExitCode 1 -Ok $false }
+  Write-Error "Cue still not runnable in WSL after install."
+}
+
+Add-Check -Name "cue_verify" -Status "ok" -Message "Cue installed and runnable in WSL"
+$BootstrapReport.cue.installed = $true
+$resolvedInstalledCueVersion = $cueVersionAfter.Output.Trim()
+if ([string]::IsNullOrWhiteSpace($resolvedInstalledCueVersion) -and -not [string]::IsNullOrWhiteSpace($userCueVersionAfter.Output)) {
+  $resolvedInstalledCueVersion = $userCueVersionAfter.Output.Trim()
+}
+$BootstrapReport.cue.version = $resolvedInstalledCueVersion
+Add-CueVersionCompatibilityChecks -HostVersionText $hostVersion -WslCueVersionText $resolvedInstalledCueVersion -AfterInstall
+Write-Ok "Cue installed and runnable in WSL"
+Add-Step "Next: run 'cue' from Windows (wrapper) or inside WSL"
+if (-not $Json) {
+  Write-Host $cueVersionAfter.Output
+  Write-Host ""
+  Write-Host "Next: run 'cue' from Windows (wrapper) or inside WSL."
+}
+Complete-Bootstrap -ExitCode 0 -Ok $true