patchwarden 1.5.0 → 1.6.1

package/scripts/control/manage-patchwarden.ps1

@@ -89,6 +89,58 @@ function Read-FileLineSafe {
   }
 }
 
+function Write-JsonFileAtomic {
+  param([string]$Path, [object]$Payload)
+  $directory = Split-Path -Parent $Path
+  New-Item -ItemType Directory -Force -Path $directory | Out-Null
+  $temporary = "$Path.tmp"
+  $Payload | ConvertTo-Json -Depth 5 | Set-Content -LiteralPath $temporary -Encoding UTF8
+  Move-Item -LiteralPath $temporary -Destination $Path -Force
+}
+
+function Write-BackgroundStartingState {
+  param($Definition)
+  $statusPath = Join-Path $Definition.RuntimeDirectory "tunnel-status.json"
+  $previous = Read-JsonFileSafe -Path $statusPath
+  $payload = [ordered]@{
+    status = "starting"
+    reason_code = $null
+    ready = $false
+    attempt = 0
+    pid = $null
+    checked_at = (Get-Date).ToUniversalTime().ToString("o")
+    next_retry_at = $null
+    last_error = $null
+    last_exit_code = $null
+    stdout_tail = @()
+    stderr_tail = @()
+    stdout_log = Join-Path $Definition.RuntimeDirectory "tunnel-client.stdout.log"
+    stderr_log = Join-Path $Definition.RuntimeDirectory "tunnel-client.stderr.log"
+    server_version = if ($previous) { $previous.server_version } else { $null }
+    schema_epoch = if ($previous) { $previous.schema_epoch } else { $null }
+    tool_profile = $Definition.ToolProfile
+    tool_count = if ($previous) { $previous.tool_count } else { $null }
+    tool_names = if ($previous -and $previous.tool_names) { @($previous.tool_names) } else { @() }
+    tool_manifest_sha256 = if ($previous) { $previous.tool_manifest_sha256 } else { $null }
+    tools_ready = [bool]($previous -and $previous.tools_ready)
+    core_tools_ready = [bool]($Definition.Key -eq "core" -and $previous -and $previous.core_tools_ready)
+  }
+  Write-JsonFileAtomic -Path $statusPath -Payload $payload
+}
+
+function Write-BackgroundSupervisorState {
+  param($Definition, [string]$Status, [Nullable[int]]$ProcessId, [string]$ReasonCode = $null)
+  $payload = [ordered]@{
+    status = $Status
+    reason_code = $ReasonCode
+    pid = $ProcessId
+    checked_at = (Get-Date).ToUniversalTime().ToString("o")
+    stdout_log = Join-Path $Definition.RuntimeDirectory "supervisor.stdout.log"
+    stderr_log = Join-Path $Definition.RuntimeDirectory "supervisor.stderr.log"
+  }
+  Write-JsonFileAtomic -Path (Join-Path $Definition.RuntimeDirectory "supervisor-status.json") -Payload $payload
+}
+
 function Test-TunnelHealthEndpoint {
   param([string]$HealthUrl)
   if (-not $HealthUrl) { return $null }
@@ -522,20 +574,33 @@ function Start-Mode {
   if ($Background) {
     $launcherScript = Join-Path $PSScriptRoot "start-patchwarden-tunnel.ps1"
     if (-not (Test-Path -LiteralPath $launcherScript)) { throw "Launcher script not found: $launcherScript" }
+    $backgroundWrapper = Join-Path $PSScriptRoot "run-background-supervisor.ps1"
+    if (-not (Test-Path -LiteralPath $backgroundWrapper)) { throw "Background wrapper not found: $backgroundWrapper" }
     $healthListenAddr = ([Uri]$Definition.HealthBaseUrl).Authority
     $arguments = @(
-      "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", $launcherScript,
+      "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", $backgroundWrapper,
       "-ToolProfile", $Definition.ToolProfile,
       "-Profile", $Definition.Profile,
-      "-HealthListenAddr", $healthListenAddr,
-      "-NoTunnelWebUi"
+      "-HealthListenAddr", $healthListenAddr
     )
     if (-not $Definition.HasWatcher) { $arguments += "-SkipWatcher" }
     if ($WhatIf) {
       Write-Host "[start:$($Definition.Key)] WHAT-IF: start hidden supervisor for $($Definition.Profile)" -ForegroundColor Magenta
       return
     }
-    $process = Start-Process -FilePath "powershell.exe" -ArgumentList $arguments -WorkingDirectory $ProjectRoot -PassThru -WindowStyle Hidden
+    New-Item -ItemType Directory -Force -Path $Definition.RuntimeDirectory | Out-Null
+    $supervisorStdout = Join-Path $Definition.RuntimeDirectory "supervisor.stdout.log"
+    $supervisorStderr = Join-Path $Definition.RuntimeDirectory "supervisor.stderr.log"
+    Write-BackgroundStartingState -Definition $Definition
+    Set-Content -LiteralPath $supervisorStdout -Value "" -Encoding UTF8 -NoNewline
+    Set-Content -LiteralPath $supervisorStderr -Value "" -Encoding UTF8 -NoNewline
+    try {
+      $process = Start-Process -FilePath "powershell.exe" -ArgumentList $arguments -WorkingDirectory $ProjectRoot -PassThru -WindowStyle Hidden
+      Write-BackgroundSupervisorState -Definition $Definition -Status "running" -ProcessId $process.Id
+    } catch {
+      Write-BackgroundSupervisorState -Definition $Definition -Status "failed" -ProcessId $null -ReasonCode "supervisor_launch_failed"
+      throw
+    }
     Write-Host "[start:$($Definition.Key)] Started hidden supervisor PID $($process.Id). Logs: $($Definition.RuntimeDirectory)" -ForegroundColor Green
     return
   }

package/scripts/control/provision-patchwarden-tunnel.ps1

@@ -0,0 +1,127 @@
+[CmdletBinding()]
+param(
+  [Parameter(Mandatory = $true)]
+  [ValidateSet("core", "direct")]
+  [string]$Mode,
+  [AllowEmptyString()]
+  [string]$TunnelId = "",
+  [Parameter(Mandatory = $true)]
+  [string]$TunnelClientExe,
+  [Parameter(Mandatory = $true)]
+  [string]$ConfigPath,
+  [Parameter(Mandatory = $true)]
+  [string]$CredentialPath,
+  [ValidateSet("environment", "none", "manual")]
+  [string]$ProxyMode = "environment",
+  [AllowEmptyString()]
+  [string]$ProxyUrl = "",
+  [switch]$UseSavedCredential
+)
+
+$ErrorActionPreference = "Stop"
+$ProjectRoot = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
+$Profile = if ($Mode -eq "direct") { "patchwarden-direct" } else { "patchwarden" }
+$ToolProfile = if ($Mode -eq "direct") { "chatgpt_direct" } else { "chatgpt_core" }
+$LauncherName = if ($Mode -eq "direct") { "patchwarden-mcp-direct.cmd" } else { "patchwarden-mcp-stdio.cmd" }
+$HealthListenAddr = if ($Mode -eq "direct") { "127.0.0.1:8081" } else { "127.0.0.1:8080" }
+$ProfilePath = Join-Path $env:APPDATA "tunnel-client\$Profile.yaml"
+$McpLauncher = (Join-Path $ProjectRoot "scripts\mcp\$LauncherName") -replace "\\", "/"
+$profileBackup = "$ProfilePath.patchwarden-provision-backup-$PID"
+$hadProfile = Test-Path -LiteralPath $ProfilePath
+$runtimeKey = $null
+
+function Write-Result {
+  param([bool]$Ok, [string]$ReasonCode, [string]$NextStep)
+  [ordered]@{ ok = $Ok; reason_code = $ReasonCode; next_step = $NextStep } | ConvertTo-Json -Compress
+}
+
+function Get-DoctorReason {
+  param([string]$Text)
+  $value = [string]$Text
+  if ($value -match '(?i)unauthor|forbidden|invalid.*(?:key|token)|authentication|401|403') { return "authentication_failed" }
+  if ($value -match '(?i)proxy|ECONNREFUSED|connection refused|connect.*failed|timeout|timed out') { return "proxy_unreachable" }
+  if ($value -match '(?i)region|country|unsupported location|not available in') { return "region_unsupported" }
+  return "doctor_failed"
+}
+
+try {
+  if (-not (Test-Path -LiteralPath $TunnelClientExe -PathType Leaf)) { throw "tunnel_client_missing" }
+  if (-not (Test-Path -LiteralPath $ConfigPath -PathType Leaf)) { throw "config_missing" }
+  if (-not (Test-Path -LiteralPath ($McpLauncher -replace "/", "\") -PathType Leaf)) { throw "mcp_launcher_missing" }
+  if ($UseSavedCredential) {
+    if (-not (Test-Path -LiteralPath $ProfilePath -PathType Leaf)) { throw "tunnel_profile_missing" }
+    if (-not (Test-Path -LiteralPath $CredentialPath -PathType Leaf)) { throw "tunnel_credential_missing" }
+    $secure = ConvertTo-SecureString (Get-Content -LiteralPath $CredentialPath -Raw -Encoding UTF8)
+    $bstr = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($secure)
+    try { $runtimeKey = [Runtime.InteropServices.Marshal]::PtrToStringBSTR($bstr) }
+    finally { if ($bstr -ne [IntPtr]::Zero) { [Runtime.InteropServices.Marshal]::ZeroFreeBSTR($bstr) } }
+  } else {
+    if ([string]::IsNullOrWhiteSpace($TunnelId)) { throw "tunnel_id_missing" }
+    $runtimeKey = [Console]::In.ReadLine()
+  }
+  if ([string]::IsNullOrWhiteSpace($runtimeKey)) { throw "runtime_key_missing" }
+  $env:CONTROL_PLANE_API_KEY = $runtimeKey
+  $env:PATCHWARDEN_CONFIG = $ConfigPath
+  $env:NO_PROXY = "localhost,127.0.0.1,::1"
+
+  $useProxy = $false
+  switch ($ProxyMode) {
+    "manual" {
+      $proxyUri = $null
+      if (-not [Uri]::TryCreate($ProxyUrl, [UriKind]::Absolute, [ref]$proxyUri) -or $proxyUri.Scheme -notin @("http", "https", "socks5")) { throw "proxy_invalid" }
+      if (-not [string]::IsNullOrEmpty($proxyUri.UserInfo)) { throw "proxy_credentials_forbidden" }
+      $env:HTTP_PROXY = $ProxyUrl; $env:HTTPS_PROXY = $ProxyUrl; $env:ALL_PROXY = $ProxyUrl
+      $useProxy = $true
+    }
+    "none" { Remove-Item Env:HTTP_PROXY, Env:HTTPS_PROXY, Env:ALL_PROXY -ErrorAction SilentlyContinue }
+    "environment" { $useProxy = -not [string]::IsNullOrWhiteSpace($env:HTTPS_PROXY) }
+  }
+
+  if (-not $UseSavedCredential) {
+    New-Item -ItemType Directory -Force -Path (Split-Path -Parent $ProfilePath) | Out-Null
+    if ($hadProfile) { Copy-Item -LiteralPath $ProfilePath -Destination $profileBackup -Force }
+    & $TunnelClientExe init --sample sample_mcp_stdio_local --profile $Profile --tunnel-id $TunnelId --mcp-command $McpLauncher --force | Out-Null
+    if ($LASTEXITCODE -ne 0) { throw "profile_init_failed" }
+
+    $profileText = Get-Content -LiteralPath $ProfilePath -Raw -Encoding UTF8
+    if ($profileText -match 'listen_addr:\s*"[^"]*"') {
+      $profileText = $profileText -replace '(listen_addr:\s*)"[^"]*"', "`$1`"$HealthListenAddr`""
+    } elseif ($profileText -match '(?m)^health:') {
+      $profileText = $profileText -replace '(?m)^(health:.*)$', "`$1`n  listen_addr: `"$HealthListenAddr`""
+    } else {
+      $profileText = "$($profileText.TrimEnd())`n`nhealth:`n  listen_addr: `"$HealthListenAddr`"`n"
+    }
+    Set-Content -LiteralPath $ProfilePath -Value $profileText -Encoding UTF8 -NoNewline
+  }
+
+  $doctorArgs = @("doctor", "--profile", $Profile, "--explain", "--json")
+  if ($useProxy) { $doctorArgs += @("--http-proxy", "env:HTTPS_PROXY") }
+  $doctorOutput = (& $TunnelClientExe @doctorArgs 2>&1 | Out-String)
+  if ($LASTEXITCODE -ne 0) { throw (Get-DoctorReason -Text $doctorOutput) }
+
+  if (-not $UseSavedCredential) {
+    $secure = ConvertTo-SecureString $runtimeKey -AsPlainText -Force
+    $encrypted = ConvertFrom-SecureString $secure
+    $credentialDirectory = Split-Path -Parent $CredentialPath
+    New-Item -ItemType Directory -Force -Path $credentialDirectory | Out-Null
+    $credentialTemp = "$CredentialPath.tmp-$PID"
+    Set-Content -LiteralPath $credentialTemp -Value $encrypted -Encoding UTF8 -NoNewline
+    Move-Item -LiteralPath $credentialTemp -Destination $CredentialPath -Force
+  }
+  Remove-Item -LiteralPath $profileBackup -Force -ErrorAction SilentlyContinue
+  Write-Result -Ok $true -ReasonCode "configured" -NextStep "start_core"
+  exit 0
+} catch {
+  if ($hadProfile -and (Test-Path -LiteralPath $profileBackup)) {
+    Move-Item -LiteralPath $profileBackup -Destination $ProfilePath -Force
+  } elseif (-not $hadProfile) {
+    Remove-Item -LiteralPath $ProfilePath -Force -ErrorAction SilentlyContinue
+  }
+  $reason = [string]$_.Exception.Message
+  if ($reason -notmatch '^[a-z0-9_]+$') { $reason = "provisioning_failed" }
+  Write-Result -Ok $false -ReasonCode $reason -NextStep $(if ($reason -eq "authentication_failed") { "replace_runtime_key" } elseif ($reason -eq "proxy_unreachable") { "check_proxy" } else { "review_tunnel_setup" })
+  exit 1
+} finally {
+  $env:CONTROL_PLANE_API_KEY = $null
+  $runtimeKey = $null
+}

package/scripts/control/run-background-supervisor.ps1

@@ -0,0 +1,41 @@
+[CmdletBinding()]
+param(
+  [Parameter(Mandatory = $true)]
+  [ValidateSet("chatgpt_core", "chatgpt_direct")]
+  [string]$ToolProfile,
+
+  [Parameter(Mandatory = $true)]
+  [ValidateSet("patchwarden", "patchwarden-direct")]
+  [string]$Profile,
+
+  [Parameter(Mandatory = $true)]
+  [ValidatePattern('^127\.0\.0\.1:\d+$')]
+  [string]$HealthListenAddr,
+
+  [switch]$SkipWatcher
+)
+
+$ErrorActionPreference = "Stop"
+$launcherScript = Join-Path $PSScriptRoot "start-patchwarden-tunnel.ps1"
+$runtimeName = if ($ToolProfile -eq "chatgpt_direct") { "runtime-direct" } else { "runtime" }
+$runtimeDirectory = Join-Path $env:LOCALAPPDATA "patchwarden\$runtimeName"
+$stdout = Join-Path $runtimeDirectory "supervisor.stdout.log"
+$stderr = Join-Path $runtimeDirectory "supervisor.stderr.log"
+
+New-Item -ItemType Directory -Force -Path $runtimeDirectory | Out-Null
+$arguments = @(
+  "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", $launcherScript,
+  "-ToolProfile", $ToolProfile,
+  "-Profile", $Profile,
+  "-HealthListenAddr", $HealthListenAddr,
+  "-NoTunnelWebUi"
+)
+if ($SkipWatcher) { $arguments += "-SkipWatcher" }
+
+try {
+  & powershell.exe @arguments 1> $stdout 2> $stderr
+  exit $LASTEXITCODE
+} catch {
+  $_ | Out-String | Set-Content -LiteralPath $stderr -Encoding UTF8
+  exit 1
+}

package/scripts/control/start-patchwarden-tunnel.ps1

@@ -3,7 +3,10 @@
   [string]$Profile = "patchwarden",
   [ValidateSet("chatgpt_core", "chatgpt_direct")]
   [string]$ToolProfile = "chatgpt_core",
-  [string]$ProxyUrl = $(if ($env:HTTPS_PROXY) { $env:HTTPS_PROXY } else { "http://127.0.0.1:7892" }),
+  [ValidateSet("", "environment", "none", "manual")]
+  [string]$ProxyMode = "",
+  [AllowEmptyString()]
+  [string]$ProxyUrl = "",
   [string]$TunnelClientExe = $(if ($env:TUNNEL_CLIENT_EXE) { $env:TUNNEL_CLIENT_EXE } else { $env:PATCHWARDEN_TUNNEL_CLIENT_EXE }),
   [string]$OpencodeBin = $env:OPENCODE_BIN_DIR,
   [string]$ConfigPath = $env:PATCHWARDEN_CONFIG,
@@ -22,6 +25,47 @@
 
 $ErrorActionPreference = "Stop"
 
+if ([string]::IsNullOrWhiteSpace($ProxyMode)) {
+  $ProxyMode = if ($ToolProfile -eq "chatgpt_direct" -and $env:PATCHWARDEN_DIRECT_PROXY_MODE) {
+    $env:PATCHWARDEN_DIRECT_PROXY_MODE
+  } elseif ($env:PATCHWARDEN_TUNNEL_PROXY_MODE) {
+    $env:PATCHWARDEN_TUNNEL_PROXY_MODE
+  } else {
+    "environment"
+  }
+}
+if ([string]::IsNullOrWhiteSpace($ProxyUrl)) {
+  $ProxyUrl = if ($ToolProfile -eq "chatgpt_direct" -and $env:PATCHWARDEN_DIRECT_PROXY_URL) {
+    $env:PATCHWARDEN_DIRECT_PROXY_URL
+  } else {
+    $env:PATCHWARDEN_TUNNEL_PROXY_URL
+  }
+}
+
+$script:UseProxyArgument = $false
+switch ($ProxyMode) {
+  "manual" {
+    if ([string]::IsNullOrWhiteSpace($ProxyUrl)) { throw "Manual proxy mode requires ProxyUrl." }
+    $proxyUri = $null
+    if (-not [Uri]::TryCreate($ProxyUrl, [UriKind]::Absolute, [ref]$proxyUri) -or $proxyUri.Scheme -notin @("http", "https", "socks5")) {
+      throw "ProxyUrl must use http, https, or socks5."
+    }
+    if (-not [string]::IsNullOrEmpty($proxyUri.UserInfo)) { throw "ProxyUrl must not contain credentials." }
+    $env:HTTP_PROXY = $ProxyUrl
+    $env:HTTPS_PROXY = $ProxyUrl
+    $env:ALL_PROXY = $ProxyUrl
+    $script:UseProxyArgument = $true
+  }
+  "none" {
+    Remove-Item Env:HTTP_PROXY, Env:HTTPS_PROXY, Env:ALL_PROXY -ErrorAction SilentlyContinue
+  }
+  "environment" {
+    $script:UseProxyArgument = -not [string]::IsNullOrWhiteSpace($env:HTTPS_PROXY)
+  }
+  default { throw "Unsupported proxy mode: $ProxyMode" }
+}
+$env:NO_PROXY = "localhost,127.0.0.1,::1"
+
 if ([string]::IsNullOrWhiteSpace($HealthListenAddr)) {
   if ($Profile -eq "patchwarden-direct" -or $ToolProfile -eq "chatgpt_direct") {
     $HealthListenAddr = "127.0.0.1:8081"
@@ -58,12 +102,35 @@ $script:WatcherManaged = $false
 $script:WatcherRestartAttempts = 0
 $script:WatcherHealthySince = $null
 $script:WatcherRestartExhausted = $false
-$DefaultTunnelClientPath = "D:\ai_agent\tunnel-client-v0.0.9--context-conduit-topaz-windows-amd64\tunnel-client.exe"
-
 if ($ToolProfile -eq "chatgpt_direct") {
   $SkipWatcher = $true
 }
 
+$script:AgentEnvironmentNames = @(
+  ([string]$env:PATCHWARDEN_AGENT_ENV_ALLOWLIST -split ';') |
+    Where-Object { $_ -match '^[A-Za-z_][A-Za-z0-9_]*$' } |
+    Select-Object -Unique
+)
+
+function Suspend-AgentProviderEnvironment {
+  $saved = @{}
+  foreach ($name in $script:AgentEnvironmentNames) {
+    $item = Get-Item -LiteralPath "Env:$name" -ErrorAction SilentlyContinue
+    if ($null -ne $item) {
+      $saved[$name] = [string]$item.Value
+      Remove-Item -LiteralPath "Env:$name" -ErrorAction SilentlyContinue
+    }
+  }
+  return $saved
+}
+
+function Restore-AgentProviderEnvironment {
+  param([hashtable]$Saved)
+  foreach ($name in $Saved.Keys) {
+    Set-Item -LiteralPath "Env:$name" -Value $Saved[$name]
+  }
+}
+
 function Assert-File {
   param([string]$Path, [string]$Name)
   if (-not (Test-Path -LiteralPath $Path)) {
@@ -230,9 +297,17 @@ function Get-DiagnosticCode {
 }
 
 function Invoke-TunnelDoctor {
-  $output = (& $TunnelClientExe doctor --profile $Profile --explain --json --http-proxy env:HTTPS_PROXY 2>&1 | Out-String)
+  $doctorArguments = @("doctor", "--profile", $Profile, "--explain", "--json")
+  if ($script:UseProxyArgument) { $doctorArguments += @("--http-proxy", "env:HTTPS_PROXY") }
+  $savedAgentEnvironment = Suspend-AgentProviderEnvironment
+  try {
+    $output = (& $TunnelClientExe @doctorArguments 2>&1 | Out-String)
+    $exitCode = $LASTEXITCODE
+  } finally {
+    Restore-AgentProviderEnvironment -Saved $savedAgentEnvironment
+  }
   return [pscustomobject]@{
-    ExitCode = $LASTEXITCODE
+    ExitCode = $exitCode
     Output = $output
     ReasonCode = Get-DiagnosticCode $output
   }
@@ -306,11 +381,15 @@ function Start-OwnedWatcherProcess {
   $previousWatcherLauncherPid = $env:PATCHWARDEN_WATCHER_LAUNCHER_PID
   $previousXdgConfigHome = $env:XDG_CONFIG_HOME
   $previousPath = $env:PATH
+  $previousControlPlaneApiKey = $env:CONTROL_PLANE_API_KEY
+  $previousOwnerToken = $env:PATCHWARDEN_OWNER_TOKEN
   try {
     $env:PATCHWARDEN_WATCHER_INSTANCE_ID = $script:WatcherInstanceId
     $env:PATCHWARDEN_WATCHER_LAUNCHER_PID = [string]$PID
     $env:XDG_CONFIG_HOME = $OpencodeConfigHome
     if ($OpencodeBin) { $env:PATH = "$OpencodeBin;$env:PATH" }
+    Remove-Item Env:CONTROL_PLANE_API_KEY -ErrorAction SilentlyContinue
+    Remove-Item Env:PATCHWARDEN_OWNER_TOKEN -ErrorAction SilentlyContinue
     $script:WatcherProcess = Start-Process -FilePath $node `
       -ArgumentList @((Join-Path $ProjectRoot "dist\runner\watch.js")) `
       -WorkingDirectory $ProjectRoot -PassThru -WindowStyle Hidden `
@@ -319,6 +398,8 @@ function Start-OwnedWatcherProcess {
     if ($null -eq $previousWatcherInstanceId) { Remove-Item Env:PATCHWARDEN_WATCHER_INSTANCE_ID -ErrorAction SilentlyContinue } else { $env:PATCHWARDEN_WATCHER_INSTANCE_ID = $previousWatcherInstanceId }
     if ($null -eq $previousWatcherLauncherPid) { Remove-Item Env:PATCHWARDEN_WATCHER_LAUNCHER_PID -ErrorAction SilentlyContinue } else { $env:PATCHWARDEN_WATCHER_LAUNCHER_PID = $previousWatcherLauncherPid }
     if ($null -eq $previousXdgConfigHome) { Remove-Item Env:XDG_CONFIG_HOME -ErrorAction SilentlyContinue } else { $env:XDG_CONFIG_HOME = $previousXdgConfigHome }
+    if ($null -eq $previousControlPlaneApiKey) { Remove-Item Env:CONTROL_PLANE_API_KEY -ErrorAction SilentlyContinue } else { $env:CONTROL_PLANE_API_KEY = $previousControlPlaneApiKey }
+    if ($null -eq $previousOwnerToken) { Remove-Item Env:PATCHWARDEN_OWNER_TOKEN -ErrorAction SilentlyContinue } else { $env:PATCHWARDEN_OWNER_TOKEN = $previousOwnerToken }
     $env:PATH = $previousPath
   }
   Write-WatcherStatus -Status "starting"
@@ -368,7 +449,12 @@ function Invoke-WatcherSupervisorTick {
 
 function Get-TunnelHealth {
   if (-not (Test-Path -LiteralPath $HealthUrlFile) -or -not (Test-Path -LiteralPath $PidFile)) { return $null }
-  $output = (& $TunnelClientExe health --json --url-file $HealthUrlFile --pid-file $PidFile 2>&1 | Out-String)
+  $savedAgentEnvironment = Suspend-AgentProviderEnvironment
+  try {
+    $output = (& $TunnelClientExe health --json --url-file $HealthUrlFile --pid-file $PidFile 2>&1 | Out-String)
+  } finally {
+    Restore-AgentProviderEnvironment -Saved $savedAgentEnvironment
+  }
   try { return $output | ConvertFrom-Json } catch { return $null }
 }
 
@@ -505,8 +591,7 @@ if (-not $TunnelClientExe) {
 
 # Search common installation locations
 $commonPaths = @(
-  $DefaultTunnelClientPath
-  Join-Path $env:LOCALAPPDATA "patchwarden\tunnel-client.exe"
+  Join-Path $env:LOCALAPPDATA "PatchWarden\tunnel-client.exe"
   Join-Path $env:APPDATA "tunnel-client\tunnel-client.exe"
   Join-Path $env:USERPROFILE "tunnel-client\tunnel-client.exe"
 )
@@ -525,11 +610,8 @@ if (-not $TunnelClientExe) {
   Write-Host "[input] tunnel-client.exe not found on PATH or common locations." -ForegroundColor Yellow
   Write-Host "        Please provide the full path."
   Write-Host ""
-  Write-Host "        To search for it manually, try one of these commands:" -ForegroundColor Cyan
-  Write-Host "          Get-ChildItem -Path `$env:LOCALAPPDATA -Recurse -Filter tunnel-client.exe -ErrorAction SilentlyContinue" -ForegroundColor Gray
-  Write-Host "          Get-ChildItem -Path `$env:APPDATA -Recurse -Filter tunnel-client.exe -ErrorAction SilentlyContinue" -ForegroundColor Gray
-  Write-Host "          Get-ChildItem -Path C:\ -Recurse -Filter tunnel-client.exe -ErrorAction SilentlyContinue" -ForegroundColor Gray
-  Write-Host "        Or download it from: https://platform.openai.com/docs/guides/mcp-connector" -ForegroundColor Cyan
+  Write-Host "        Desktop users can open Settings -> MCP and tunnel -> Auto detect / Choose file." -ForegroundColor Cyan
+  Write-Host "        The desktop guide explains trusted downloads and SHA256 verification." -ForegroundColor Cyan
   Write-Host ""
   $TunnelClientExe = Read-Host "Path to tunnel-client.exe"
 }
@@ -556,7 +638,7 @@ if (-not $TunnelId -and (Test-Path -LiteralPath $ProfilePath)) {
     $profileContent = Get-Content -LiteralPath $ProfilePath -Raw -Encoding UTF8
     if ($profileContent -match 'tunnel_id:\s*"([^"]+)"') {
       $TunnelId = $matches[1]
-      Write-Host "[detect] Tunnel ID read from profile $Profile`: $TunnelId" -ForegroundColor Green
+      Write-Host "[detect] Tunnel ID read from profile $Profile." -ForegroundColor Green
     }
   } catch {
     Write-Host "[warn] Could not read Tunnel ID from $ProfilePath`: $($_.Exception.Message)" -ForegroundColor Yellow
@@ -580,8 +662,15 @@ if (-not (Test-Path -LiteralPath (Join-Path $ProjectRoot "dist\index.js"))) {
 New-Item -ItemType Directory -Force -Path $RuntimeDirectory | Out-Null
 $env:PATCHWARDEN_CONFIG = $ConfigPath
 Write-Host "[manifest] Verifying the exact $ToolProfile stdio MCP tool catalog..."
-$manifestOutput = (& node (Join-Path $ProjectRoot "scripts\checks\mcp-manifest-check.js") --profile $ToolProfile --json 2>&1 | Out-String).Trim()
-if ($LASTEXITCODE -ne 0) {
+$previousErrorActionPreference = $ErrorActionPreference
+try {
+  $ErrorActionPreference = "Continue"
+  $manifestOutput = (& node (Join-Path $ProjectRoot "scripts\checks\mcp-manifest-check.js") --profile $ToolProfile --json 2>&1 | Out-String).Trim()
+  $manifestExitCode = $LASTEXITCODE
+} finally {
+  $ErrorActionPreference = $previousErrorActionPreference
+}
+if ($manifestExitCode -ne 0) {
   Write-TunnelStatus -Status "stopped" -ReasonCode "tool_manifest_check_failed" -LastError "The tunnel MCP tool manifest preflight failed."
   throw "Tool manifest preflight failed: $manifestOutput"
 }
@@ -601,10 +690,6 @@ Write-Host "[config] health listen addr: $HealthListenAddr"
 Set-SecretEnvIfMissing
 
 $env:PATCHWARDEN_CONFIG = $ConfigPath
-$env:HTTP_PROXY = $ProxyUrl
-$env:HTTPS_PROXY = $ProxyUrl
-$env:ALL_PROXY = $ProxyUrl
-$env:NO_PROXY = "localhost,127.0.0.1,::1"
 
 $profileNeedsInit = $true
 if (Test-Path -LiteralPath $ProfilePath) {
@@ -614,12 +699,17 @@ if (Test-Path -LiteralPath $ProfilePath) {
 
 if ($profileNeedsInit) {
   Write-Host "[init] Creating tunnel-client profile: $Profile"
-  & $TunnelClientExe init `
-    --sample sample_mcp_stdio_local `
-    --profile $Profile `
-    --tunnel-id $TunnelId `
-    --mcp-command $McpStdioLauncherForTunnel `
-    --force
+  $savedAgentEnvironment = Suspend-AgentProviderEnvironment
+  try {
+    & $TunnelClientExe init `
+      --sample sample_mcp_stdio_local `
+      --profile $Profile `
+      --tunnel-id $TunnelId `
+      --mcp-command $McpStdioLauncherForTunnel `
+      --force
+  } finally {
+    Restore-AgentProviderEnvironment -Saved $savedAgentEnvironment
+  }
   Set-ProfileHealthListenAddr -ProfilePath $ProfilePath -HealthListenAddr $HealthListenAddr
 } else {
   Set-ProfileHealthListenAddr -ProfilePath $ProfilePath -HealthListenAddr $HealthListenAddr
@@ -628,7 +718,7 @@ if ($profileNeedsInit) {
 $env:PATCHWARDEN_TUNNEL_STATUS_FILE = $StatusFile
 if (-not $SkipWatcher) { Start-PatchWardenWatcher }
 
-Write-Host "[doctor] Checking tunnel-client profile through the configured proxy..."
+Write-Host "[doctor] Checking tunnel-client profile (proxy mode: $ProxyMode)..."
 $preflightAttempt = 0
 $preflightMaxRetries = 3
 $doctor = Invoke-TunnelDoctor
@@ -665,8 +755,7 @@ Write-Host "[run-config] health url file: $HealthUrlFile"
 Write-Host "[run-config] pid file: $PidFile"
 Write-Host "[run-config] stdout log: $StdoutLogFile"
 Write-Host "[run-config] stderr log: $StderrLogFile"
-Write-Host "[run-config] HTTPS_PROXY: $env:HTTPS_PROXY"
-Write-Host "[run-config] HTTP_PROXY: $env:HTTP_PROXY"
+Write-Host "[run-config] proxy mode: $ProxyMode"
 Write-Host "[run-config] CONTROL_PLANE_API_KEY: $(if ($env:CONTROL_PLANE_API_KEY) { 'set' } else { 'missing' })"
 Write-Host "[run-config] cwd: $ProjectRoot"
 Write-Host ""
@@ -681,18 +770,23 @@ try {
     Write-TunnelStatus -Status "starting" -ReasonCode $null -Ready $false -Attempt $attempt
     $runArguments = @(
       "run", "--profile", $Profile,
-      "--http-proxy", "env:HTTPS_PROXY",
       "--health.url-file", $HealthUrlFile,
       "--pid.file", $PidFile,
       "--log.format", "json"
     )
+    if ($script:UseProxyArgument) { $runArguments += @("--http-proxy", "env:HTTPS_PROXY") }
     if ($openUi) { $runArguments += "--open-web-ui"; $openUi = $false }
     $argumentLine = ($runArguments | ForEach-Object { Quote-ProcessArgument $_ }) -join " "
     Write-Host "[run-config] command: tunnel-client $($runArguments -join ' ')"
     $redirectedCommand = '""' + $TunnelClientExe + '" ' + $argumentLine + ' 1>"' + $StdoutLogFile + '" 2>"' + $StderrLogFile + '""'
     $processArgumentLine = '/d /s /c ' + $redirectedCommand
-    $script:TunnelProcess = Start-Process -FilePath $env:ComSpec -ArgumentList $processArgumentLine `
-      -WorkingDirectory $ProjectRoot -PassThru -WindowStyle Hidden
+    $savedAgentEnvironment = Suspend-AgentProviderEnvironment
+    try {
+      $script:TunnelProcess = Start-Process -FilePath $env:ComSpec -ArgumentList $processArgumentLine `
+        -WorkingDirectory $ProjectRoot -PassThru -WindowStyle Hidden
+    } finally {
+      Restore-AgentProviderEnvironment -Saved $savedAgentEnvironment
+    }
     Write-TunnelStatus -Status "connecting" -ReasonCode $null -Ready $false -Attempt $attempt -ProcessId $script:TunnelProcess.Id
     Write-Host "[run] supervised command PID $($script:TunnelProcess.Id), attempt $attempt"