fix: setup flow, connection page, and chat token bugs

Fix setup flow, connection page, and chat token bugs.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ranjeshj

src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs

@@ -36,6 +36,8 @@ public void Initialize(HubWindow hub)
         if (_connectionManager != null)
             _connectionManager.StateChanged += OnManagerStateChanged;
 
+        Unloaded += OnPageUnloaded;
+
         // Populate manual connection fields
         GatewayUrlTextBox.Text = settings.GatewayUrl ?? "";
         SshToggle.IsOn = settings.UseSshTunnel;
@@ -58,6 +60,12 @@ public void Initialize(HubWindow hub)
 
     private GatewayConnectionSnapshot? _lastSnapshot;
 
+    private void OnPageUnloaded(object sender, RoutedEventArgs e)
+    {
+        if (_connectionManager != null)
+            _connectionManager.StateChanged -= OnManagerStateChanged;
+    }
+
     private void OnManagerStateChanged(object? sender, GatewayConnectionSnapshot snapshot)
     {
         DispatcherQueue?.TryEnqueue(() =>
@@ -217,7 +225,10 @@ private void UpdatePairingGuidance(GatewayConnectionSnapshot snapshot)
                     }
                 }
             }
-            catch { }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"[ConnectionPage] Failed to read device ID from identity file: {ex.Message}");
+            }
         }
 
         if (snapshot.OperatorState == RoleConnectionState.PairingRequired)
@@ -520,29 +531,54 @@ private async void OnDirectConnect(object sender, RoutedEventArgs e)
         }
 
         url = GatewayUrlHelper.NormalizeForWebSocket(url);
+
+        // Validate SSH config upfront before mutating any state
+        var useSsh = SshToggle.IsOn;
+        SshTunnelConfig? sshConfig = null;
+        if (useSsh)
+        {
+            var sshUser = SshUserBox.Text.Trim();
+            var sshHost = SshHostBox.Text.Trim();
+            if (string.IsNullOrWhiteSpace(sshUser) || string.IsNullOrWhiteSpace(sshHost))
+            {
+                DirectConnectResultText.Text = "SSH user and host are required";
+                return;
+            }
+            if (!int.TryParse(SshRemotePortBox.Text, out var remotePort) || remotePort is < 1 or > 65535)
+            {
+                DirectConnectResultText.Text = "SSH remote port must be 1–65535";
+                return;
+            }
+            if (!int.TryParse(SshLocalPortBox.Text, out var localPort) || localPort is < 1 or > 65535)
+            {
+                DirectConnectResultText.Text = "SSH local port must be 1–65535";
+                return;
+            }
+            sshConfig = new SshTunnelConfig(sshUser, sshHost, remotePort, localPort);
+        }
+
         DirectConnectResultText.Text = "Connecting…";
 
+        // Snapshot previous state for rollback
+        var previousActiveId = _gatewayRegistry.ActiveGatewayId;
+        var previousSettings = _hub?.Settings;
+        var prevGatewayUrl = previousSettings?.GatewayUrl;
+        var prevUseSsh = previousSettings?.UseSshTunnel ?? false;
+        var prevSshUser = previousSettings?.SshTunnelUser;
+        var prevSshHost = previousSettings?.SshTunnelHost;
+        var prevSshRemotePort = previousSettings?.SshTunnelRemotePort ?? 0;
+        var prevSshLocalPort = previousSettings?.SshTunnelLocalPort ?? 0;
+
+        var existing = _gatewayRegistry.FindByUrl(url);
+        var isNewRecord = existing == null;
+        var existingRecordSnapshot = existing;
+        var recordId = existing?.Id ?? Guid.NewGuid().ToString();
+
         try
         {
             await _connectionManager.DisconnectAsync();
 
-            // Parse SSH config
-            var useSsh = SshToggle.IsOn;
-            SshTunnelConfig? sshConfig = null;
-            if (useSsh)
-            {
-                var sshUser = SshUserBox.Text.Trim();
-                var sshHost = SshHostBox.Text.Trim();
-                int.TryParse(SshRemotePortBox.Text, out var remotePort);
-                int.TryParse(SshLocalPortBox.Text, out var localPort);
-                if (remotePort <= 0) remotePort = 18789;
-                if (localPort <= 0) localPort = 18789;
-                sshConfig = new SshTunnelConfig(sshUser, sshHost, remotePort, localPort);
-            }
-
             // Create/update gateway record with shared token + SSH config
-            var existing = _gatewayRegistry.FindByUrl(url);
-            var recordId = existing?.Id ?? Guid.NewGuid().ToString();
             var record = new GatewayRecord
             {
                 Id = recordId,
@@ -576,23 +612,25 @@ private async void OnDirectConnect(object sender, RoutedEventArgs e)
                     writer.Flush();
                     System.IO.File.WriteAllBytes(keyPath, ms.ToArray());
                 }
-                catch { }
+                catch (Exception ex)
+                {
+                    System.Diagnostics.Debug.WriteLine($"[ConnectionPage] Failed to clear device tokens: {ex.Message}");
+                }
             }
 
             // Save settings (SSH config + gateway URL for legacy compat)
-            var settings = _hub?.Settings;
-            if (settings != null)
+            if (previousSettings != null)
             {
-                settings.GatewayUrl = url;
-                settings.UseSshTunnel = useSsh;
+                previousSettings.GatewayUrl = url;
+                previousSettings.UseSshTunnel = useSsh;
                 if (useSsh && sshConfig != null)
                 {
-                    settings.SshTunnelUser = sshConfig.User;
-                    settings.SshTunnelHost = sshConfig.Host;
-                    settings.SshTunnelRemotePort = sshConfig.RemotePort;
-                    settings.SshTunnelLocalPort = sshConfig.LocalPort;
+                    previousSettings.SshTunnelUser = sshConfig.User;
+                    previousSettings.SshTunnelHost = sshConfig.Host;
+                    previousSettings.SshTunnelRemotePort = sshConfig.RemotePort;
+                    previousSettings.SshTunnelLocalPort = sshConfig.LocalPort;
                 }
-                settings.Save();
+                previousSettings.Save();
             }
 
             // Start SSH tunnel if configured
@@ -604,11 +642,82 @@ private async void OnDirectConnect(object sender, RoutedEventArgs e)
             }
 
             await _connectionManager.ConnectAsync(recordId);
-            DirectConnectResultText.Text = $"✓ Connected to {GatewayUrlHelper.SanitizeForDisplay(url)}";
+
+            // Poll connection manager state — ConnectAsync fires connect asynchronously,
+            // so we need to wait for a definitive result before reporting success/failure.
+            bool connected = false;
+            bool failed = false;
+            for (int attempt = 0; attempt < 15; attempt++)
+            {
+                await Task.Delay(1000);
+                var snapshot = _connectionManager.CurrentSnapshot;
+                if (snapshot.OverallState is Services.Connection.OverallConnectionState.Connected
+                    or Services.Connection.OverallConnectionState.Ready)
+                {
+                    connected = true;
+                    break;
+                }
+                if (snapshot.OverallState is Services.Connection.OverallConnectionState.Error)
+                {
+                    failed = true;
+                    break;
+                }
+                if (snapshot.OverallState is Services.Connection.OverallConnectionState.PairingRequired)
+                {
+                    DirectConnectResultText.Text = $"⏳ Pairing required — approve on gateway";
+                    return; // don't rollback, pairing is in progress
+                }
+            }
+
+            if (connected)
+            {
+                DirectConnectResultText.Text = $"✓ Connected to {GatewayUrlHelper.SanitizeForDisplay(url)}";
+                return;
+            }
+
+            // Connection failed or timed out — rollback
+            var reason = failed ? "Connection failed" : "Connection timed out";
+            DirectConnectResultText.Text = $"✗ {reason}";
+            RollbackDirectConnect(previousActiveId, isNewRecord, recordId, existingRecordSnapshot,
+                previousSettings, prevGatewayUrl, prevUseSsh, prevSshUser, prevSshHost, prevSshRemotePort, prevSshLocalPort);
         }
         catch (Exception ex)
         {
             DirectConnectResultText.Text = $"✗ {ex.Message}";
+            RollbackDirectConnect(previousActiveId, isNewRecord, recordId, existingRecordSnapshot,
+                previousSettings, prevGatewayUrl, prevUseSsh, prevSshUser, prevSshHost, prevSshRemotePort, prevSshLocalPort);
+        }
+    }
+
+    private void RollbackDirectConnect(
+        string? previousActiveId, bool isNewRecord, string recordId,
+        GatewayRecord? existingRecordSnapshot, SettingsManager? settings,
+        string? prevGatewayUrl, bool prevUseSsh, string? prevSshUser,
+        string? prevSshHost, int prevSshRemotePort, int prevSshLocalPort)
+    {
+        if (_gatewayRegistry == null) return;
+
+        // Restore or remove the gateway record
+        if (isNewRecord)
+            _gatewayRegistry.Remove(recordId);
+        else if (existingRecordSnapshot != null)
+            _gatewayRegistry.AddOrUpdate(existingRecordSnapshot);
+
+        // Restore active gateway
+        if (previousActiveId != null)
+            _gatewayRegistry.SetActive(previousActiveId);
+        _gatewayRegistry.Save();
+
+        // Restore legacy settings
+        if (settings != null)
+        {
+            settings.GatewayUrl = prevGatewayUrl;
+            settings.UseSshTunnel = prevUseSsh;
+            settings.SshTunnelUser = prevSshUser;
+            settings.SshTunnelHost = prevSshHost;
+            settings.SshTunnelRemotePort = prevSshRemotePort;
+            settings.SshTunnelLocalPort = prevSshLocalPort;
+            settings.Save();
         }
     }
 

src/OpenClaw.Tray.WinUI/Services/Connection/GatewayConnectionManager.cs

@@ -81,6 +81,17 @@ public async Task ConnectAsync(string? gatewayId = null)
         await _transitionSemaphore.WaitAsync();
         try
         {
+            await ConnectCoreAsync(gatewayId);
+        }
+        finally
+        {
+            _transitionSemaphore.Release();
+        }
+    }
+
+    /// <summary>Core connect logic. Caller must hold <see cref="_transitionSemaphore"/>.</summary>
+    private async Task ConnectCoreAsync(string? gatewayId = null)
+    {
             var id = gatewayId ?? _registry.ActiveGatewayId;
             if (id == null)
             {
@@ -238,11 +249,6 @@ public async Task ConnectAsync(string? gatewayId = null)
                     _logger.Error($"[ConnMgr] Connect failed: {ex.Message}");
                 }
             }, ct);
-        }
-        finally
-        {
-            _transitionSemaphore.Release();
-        }
     }
 
     public async Task DisconnectAsync()
@@ -251,36 +257,66 @@ public async Task DisconnectAsync()
         await _transitionSemaphore.WaitAsync();
         try
         {
-            var prev = _stateMachine.Current.OverallState;
-            DisposeActiveClient();
-            _stateMachine.TryTransition(ConnectionTrigger.DisconnectRequested);
-            _diagnostics.RecordStateChange(prev, _stateMachine.Current.OverallState);
-            EmitStateChanged(prev);
+            DisconnectCore();
         }
         finally
         {
             _transitionSemaphore.Release();
         }
     }
 
+    /// <summary>Core disconnect logic. Caller must hold <see cref="_transitionSemaphore"/>.</summary>
+    private void DisconnectCore()
+    {
+        var prev = _stateMachine.Current.OverallState;
+        DisposeActiveClient();
+        _stateMachine.TryTransition(ConnectionTrigger.DisconnectRequested);
+        _diagnostics.RecordStateChange(prev, _stateMachine.Current.OverallState);
+        EmitStateChanged(prev);
+    }
+
     public async Task ReconnectAsync()
     {
-        await DisconnectAsync();
-        await ConnectAsync();
+        ThrowIfDisposed();
+        await _transitionSemaphore.WaitAsync();
+        try
+        {
+            DisconnectCore();
+            await ConnectCoreAsync();
+        }
+        finally
+        {
+            _transitionSemaphore.Release();
+        }
     }
 
     public async Task SwitchGatewayAsync(string gatewayId)
     {
-        await DisconnectAsync();
-        // Stop tunnel when switching gateways — the new one may not need it
-        if (_tunnelManager?.IsActive == true)
+        ThrowIfDisposed();
+        await _transitionSemaphore.WaitAsync();
+        try
+        {
+            DisconnectCore();
+            // Stop tunnel when switching gateways — the new one may not need it.
+            // Use a bounded timeout to avoid blocking all connection transitions.
+            if (_tunnelManager?.IsActive == true)
+            {
+                try
+                {
+                    var tunnelStop = _tunnelManager.StopAsync();
+                    if (await Task.WhenAny(tunnelStop, Task.Delay(TimeSpan.FromSeconds(5))) != tunnelStop)
+                        _logger.Warn("[ConnMgr] Tunnel stop timed out during gateway switch");
+                }
+                catch (Exception ex) { _logger.Warn($"[ConnMgr] Tunnel stop error on gateway switch: {ex.Message}"); }
+            }
+            _gatewayNeedsV2Signature = false; // new gateway might support v3
+            _registry.SetActive(gatewayId);
+            await ConnectCoreAsync(gatewayId);
+        }
+        finally
         {
-            try { await _tunnelManager.StopAsync(); }
-            catch (Exception ex) { _logger.Warn($"[ConnMgr] Tunnel stop error on gateway switch: {ex.Message}"); }
+            _transitionSemaphore.Release();
         }
-        _gatewayNeedsV2Signature = false; // new gateway might support v3
-        _registry.SetActive(gatewayId);
-        await ConnectAsync(gatewayId);
     }
 
     public async Task<SetupCodeResult> ApplySetupCodeAsync(string setupCode)
@@ -723,10 +759,10 @@ private void EmitStateChanged(OverallConnectionState previousOverall)
 
     private void DisposeActiveClient()
     {
-        // Disconnect node first
+        // Disconnect node first — run on threadpool to avoid sync context deadlocks
         if (_nodeConnector != null)
         {
-            try { _nodeConnector.DisconnectAsync().Wait(TimeSpan.FromSeconds(2)); }
+            try { Task.Run(() => _nodeConnector.DisconnectAsync()).Wait(TimeSpan.FromSeconds(2)); }
             catch (Exception ex) { _logger.Warn($"[ConnMgr] Node disconnect error: {ex.Message}"); }
         }
 
@@ -760,17 +796,27 @@ public void Dispose()
             _nodeConnector.StatusChanged -= OnNodeStatusChanged;
             _nodeConnector.PairingStatusChanged -= OnNodePairingStatusChanged;
         }
-        _stateMachine.TryTransition(ConnectionTrigger.Disposed);
-        DisposeActiveClient();
-        // Stop tunnel on app shutdown
-        if (_tunnelManager?.IsActive == true)
+        // Acquire semaphore briefly to ensure no in-flight reconnect/switch is mid-transition.
+        // Use a short timeout — if something is stuck, proceed with disposal anyway.
+        try { _transitionSemaphore.Wait(TimeSpan.FromSeconds(2)); } catch { }
+        try
+        {
+            _stateMachine.TryTransition(ConnectionTrigger.Disposed);
+            DisposeActiveClient();
+            // Stop tunnel on app shutdown — run on threadpool with timeout to avoid stalling exit
+            if (_tunnelManager?.IsActive == true)
+            {
+                try { Task.Run(() => _tunnelManager.StopAsync()).Wait(TimeSpan.FromSeconds(3)); }
+                catch { /* shutting down — best effort */ }
+            }
+            _operationCts?.Cancel();
+            _operationCts?.Dispose();
+        }
+        finally
         {
-            try { _tunnelManager.StopAsync().GetAwaiter().GetResult(); }
-            catch { /* shutting down — best effort */ }
+            try { _transitionSemaphore.Release(); } catch { }
+            _transitionSemaphore.Dispose();
         }
-        _operationCts?.Cancel();
-        _operationCts?.Dispose();
-        _transitionSemaphore.Dispose();
     }
 }