From 1cc74a49e414c8b7a7f9397f3fe36b9916024c02 Mon Sep 17 00:00:00 2001 From: Vitor Cepeda Lopes Date: Tue, 3 Nov 2026 14:54:31 +0000 Subject: [PATCH 1/6] feat(auth): use personal Tailscale identity in Windows Companion Verify the canonical personal profile on the current Gateway connection before enabling operator features. Keep native Dashboard proof bound to that lease, retire private browser profiles on close, and retain existing credential authentication. --- docs/CONNECTION_ARCHITECTURE.md | 30 +- docs/OPERATOR_NODE_CONCEPTS.md | 7 + .../BootstrapTokenLifecycle.cs | 5 +- src/OpenClaw.Connection/CredentialResolver.cs | 16 + .../GatewayClientFactory.cs | 3 +- ...tewayConnectionManager.PersonalIdentity.cs | 138 +++++++ .../GatewayConnectionManager.cs | 39 +- .../GatewayConnectionSnapshot.cs | 1 + .../GatewayConnectionValidator.cs | 26 +- .../GatewayPersonalAuthenticationPolicy.cs | 54 +++ src/OpenClaw.Connection/GatewayRecord.cs | 2 + .../ICredentialResolver.cs | 2 + .../IGatewayConnectionManager.cs | 4 + .../InteractiveGatewayCredentialResolver.cs | 6 + src/OpenClaw.Shared/ConnectEnvelopeBuilder.cs | 8 +- ...lawGatewayClient.PersonalAuthentication.cs | 123 ++++++ src/OpenClaw.Shared/OpenClawGatewayClient.cs | 68 ++-- .../OperatorAuthenticationMode.cs | 7 + .../PersonalTailscaleGatewayRoute.cs | 36 ++ src/OpenClaw.Shared/WebSocketClientBase.cs | 4 +- src/OpenClaw.Tray.WinUI/App.xaml.cs | 4 +- .../PersonalDashboardWindowReusePolicy.cs | 16 + .../Helpers/PersonalGatewayAuthChallenge.cs | 67 ++++ .../PersonalGatewayNativeBridgeScript.cs | 37 ++ .../Pages/ConnectionPage.xaml | 9 + .../Pages/ConnectionPage.xaml.cs | 33 +- .../Services/GatewayDashboardLauncher.cs | 11 +- .../Services/GatewayDirectConnectService.cs | 12 +- .../Services/IWindowManager.cs | 1 + .../WindowManager.PersonalDashboard.cs | 51 +++ .../Services/WindowManager.cs | 12 +- .../Strings/en-us/Resources.resw | 8 + .../Strings/fr-fr/Resources.resw | 8 + .../Strings/nl-nl/Resources.resw | 8 + .../Strings/pt-br/Resources.resw | 8 + .../Strings/zh-cn/Resources.resw | 8 + .../Strings/zh-tw/Resources.resw | 8 + .../Windows/PersonalDashboardWindow.xaml | 24 ++ .../Windows/PersonalDashboardWindow.xaml.cs | 375 ++++++++++++++++++ .../CredentialResolverTests.cs | 15 + ...yConnectionManagerPersonalIdentityTests.cs | 196 +++++++++ ...atewayPersonalAuthenticationPolicyTests.cs | 54 +++ .../PersonalTailscaleGatewayClientTests.cs | 82 ++++ .../PersonalGatewayProtocolFixture.cs | 127 ++++++ .../GatewayDirectConnectServiceTests.cs | 15 + .../OpenClaw.Tray.Tests.csproj | 4 + .../PersonalDashboardNativeBridgeTests.cs | 42 ++ ...PersonalGatewayAuthChallengeParserTests.cs | 69 ++++ .../SetupDashboardHandoffTests.cs | 20 + .../OpenClaw.Tray.UITests.csproj | 2 + .../PersonalDashboardWindowTests.cs | 119 ++++++ .../OpenClaw.Tray.UITests/UIThreadFixture.cs | 2 +- 52 files changed, 1984 insertions(+), 42 deletions(-) create mode 100644 src/OpenClaw.Connection/GatewayConnectionManager.PersonalIdentity.cs create mode 100644 src/OpenClaw.Connection/GatewayPersonalAuthenticationPolicy.cs create mode 100644 src/OpenClaw.Shared/OpenClawGatewayClient.PersonalAuthentication.cs create mode 100644 src/OpenClaw.Shared/OperatorAuthenticationMode.cs create mode 100644 src/OpenClaw.Shared/PersonalTailscaleGatewayRoute.cs create mode 100644 src/OpenClaw.Tray.WinUI/Helpers/PersonalDashboardWindowReusePolicy.cs create mode 100644 src/OpenClaw.Tray.WinUI/Helpers/PersonalGatewayAuthChallenge.cs create mode 100644 src/OpenClaw.Tray.WinUI/Helpers/PersonalGatewayNativeBridgeScript.cs create mode 100644 src/OpenClaw.Tray.WinUI/Services/WindowManager.PersonalDashboard.cs create mode 100644 src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml create mode 100644 src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml.cs create mode 100644 tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs create mode 100644 tests/OpenClaw.Connection.Tests/GatewayPersonalAuthenticationPolicyTests.cs create mode 100644 tests/OpenClaw.Shared.Tests/PersonalTailscaleGatewayClientTests.cs create mode 100644 tests/OpenClaw.TestSupport/PersonalGatewayProtocolFixture.cs create mode 100644 tests/OpenClaw.Tray.Tests/PersonalDashboardNativeBridgeTests.cs create mode 100644 tests/OpenClaw.Tray.Tests/PersonalGatewayAuthChallengeParserTests.cs create mode 100644 tests/OpenClaw.Tray.UITests/PersonalDashboardWindowTests.cs diff --git a/docs/CONNECTION_ARCHITECTURE.md b/docs/CONNECTION_ARCHITECTURE.md index b2b26331ff..19dd9537fa 100644 --- a/docs/CONNECTION_ARCHITECTURE.md +++ b/docs/CONNECTION_ARCHITECTURE.md @@ -766,7 +766,7 @@ the existing `SetupGatewaySession` reads credentials from the active registry. No browser-profile credentials are accepted by this port, and it does not change Node mode, local MCP, capability settings, or install WSL. -Credential resolution order is intentionally strict: +Credential resolution order for the default Gateway credential mode is intentionally strict: 1. **Stored device token** in the per-gateway identity directory. 2. **`GatewayRecord.SharedGatewayToken`** - shared token for HTTP/chat surfaces. @@ -793,6 +793,34 @@ URLs; remote HTTPS gateways retain proxy support. It accepts the original 200-399 response without following redirects, so a readiness check never contacts a `Location` destination. Browser navigation remains a separate step. +## Personal Tailscale operator identity + +The direct Gateway form offers **Personal Tailscale identity** as an explicit +operator authentication mode. It requires a credential-free `wss://` address +under `.ts.net`, without SSH forwarding. The hostname admits the route; it does +not prove the caller's identity. The Gateway must support personal Tailscale +authentication and a canonical `users.self` profile. + +`CredentialResolver` returns an empty personal credential without reading saved +operator tokens. The client signs an interactive `gateway-client` / `ui` connect +with empty `auth`. A current-socket hello must report `auth.method=tailscale` +and a nonempty `recoveryScope`. Application readiness follows a successful +`users.self` read on that same transport epoch. Node credential resolution and +saved shared credentials remain unchanged. Personal failures do not activate +shared-token or bootstrap recovery. + +The personal Dashboard opens in a native WebView. Each challenge rechecks +`users.self` and the exact current lease before returning a signed credentialless +response bound to the method and recovery scope. The shared Control UI must +support this native response contract. Navigation, reconnect, profile changes +and lease retirement prevent an old document from receiving a new proof. + +Each window uses its own named InPrivate browser profile. Closing or retiring +that window calls the browser's profile deletion API and closes the control. +WebView2 deletes the marked profile at browser-process exit and retries after +later starts if another process holds its files. This does not assert immediate +disk erasure. + ## Self-recovery and automatic local-gateway repair Two orthogonal self-healing behaviors keep the connection reliable without dead-ending the user: diff --git a/docs/OPERATOR_NODE_CONCEPTS.md b/docs/OPERATOR_NODE_CONCEPTS.md index 5e5054035e..0a1101a8cf 100644 --- a/docs/OPERATOR_NODE_CONCEPTS.md +++ b/docs/OPERATOR_NODE_CONCEPTS.md @@ -73,6 +73,13 @@ tokens can help the app connect for the first time, but a paired device token takes precedence after approval. This keeps long-lived operator and node identity scoped to the gateway record that issued it. +An existing Tailscale Gateway can instead use the explicit personal operator +mode. The Gateway verifies the Tailscale user, and Companion checks the current +personal profile before exposing the operator connection. This does not turn the +Windows node identity into a person or change node pairing. See +[personal Tailscale operator identity](CONNECTION_ARCHITECTURE.md#personal-tailscale-operator-identity) +for the connection and Dashboard requirements. + Some trust decisions are intentionally not automatic. Node command trust and capability reapproval stay pending until an operator explicitly approves them, so a new or changed node capability is visible before the gateway can use it. diff --git a/src/OpenClaw.Connection/BootstrapTokenLifecycle.cs b/src/OpenClaw.Connection/BootstrapTokenLifecycle.cs index 3cedf84edc..de62308ac9 100644 --- a/src/OpenClaw.Connection/BootstrapTokenLifecycle.cs +++ b/src/OpenClaw.Connection/BootstrapTokenLifecycle.cs @@ -220,7 +220,8 @@ internal OperatorCredentialSelection SelectOperatorCredential( var selected = resolved; lock (_stateLock) { - if (_forceBootstrapForGatewayRecordId == record.Id && + if (record.OperatorAuthentication == OperatorAuthenticationMode.GatewayCredential && + _forceBootstrapForGatewayRecordId == record.Id && !string.IsNullOrWhiteSpace(record.BootstrapToken)) { var credential = new GatewayCredential( @@ -382,7 +383,7 @@ attempt.GatewayRecordId is null || } var record = _registry.GetById(attempt.GatewayRecordId); - if (record is null) + if (record is null || record.OperatorAuthentication == OperatorAuthenticationMode.PersonalTailscale) return false; var hasSharedToken = !string.IsNullOrWhiteSpace(record.SharedGatewayToken); diff --git a/src/OpenClaw.Connection/CredentialResolver.cs b/src/OpenClaw.Connection/CredentialResolver.cs index 83585f4588..c026871575 100644 --- a/src/OpenClaw.Connection/CredentialResolver.cs +++ b/src/OpenClaw.Connection/CredentialResolver.cs @@ -35,6 +35,22 @@ public GatewayCredentialResolution ResolveOperatorDetailed(GatewayRecord record, { ArgumentNullException.ThrowIfNull(record); + if (record.OperatorAuthentication == OperatorAuthenticationMode.PersonalTailscale) + { + if (record.SshTunnel is not null || + !GatewayPersonalAuthenticationPolicy.TryNormalizeGatewayUrl(record.Url, out _, out var error)) + return new(null, GatewayCredentialResolutionStatus.Missing, + Detail: "Personal authentication requires a direct credential-free wss:// host.ts.net route."); + return GatewayCredentialResolution.FromLegacy(new GatewayCredential( + string.Empty, false, GatewayPersonalAuthenticationPolicy.CredentialSource) + { + OperatorAuthentication = OperatorAuthenticationMode.PersonalTailscale + }); + } + if (record.OperatorAuthentication != OperatorAuthenticationMode.GatewayCredential) + return new(null, GatewayCredentialResolutionStatus.Corrupt, + Detail: "The saved operator authentication mode is unsupported."); + return ResolveRole( _identityReader.ReadStoredDeviceToken(identityPath), SourceDeviceToken, diff --git a/src/OpenClaw.Connection/GatewayClientFactory.cs b/src/OpenClaw.Connection/GatewayClientFactory.cs index f64362da68..5bca1b45a3 100644 --- a/src/OpenClaw.Connection/GatewayClientFactory.cs +++ b/src/OpenClaw.Connection/GatewayClientFactory.cs @@ -28,7 +28,8 @@ public IGatewayClientLifecycle Create( bootstrapPairAsNode: false, identityPath: identityPath, ignoreStoredDeviceToken: credential.IsBootstrapToken, - assistantMediaAuthToken: credential.InteractiveHttpToken) + assistantMediaAuthToken: credential.InteractiveHttpToken, + operatorAuthentication: credential.OperatorAuthentication) { SupportsExecApprovals = SupportsExecApprovals, ClientIdentity = ClientIdentity, diff --git a/src/OpenClaw.Connection/GatewayConnectionManager.PersonalIdentity.cs b/src/OpenClaw.Connection/GatewayConnectionManager.PersonalIdentity.cs new file mode 100644 index 0000000000..32268a9e02 --- /dev/null +++ b/src/OpenClaw.Connection/GatewayConnectionManager.PersonalIdentity.cs @@ -0,0 +1,138 @@ +using System.Text.Json; +using OpenClaw.Shared; + +namespace OpenClaw.Connection; + +public sealed partial class GatewayConnectionManager +{ + private enum PersonalVerification { NotRequired, Verified, Stale, Rejected } + private PersonalOperatorLease? _personalOperatorLease; + + public PersonalOperatorLease? CurrentPersonalOperatorLease + { + get + { + var lease = Volatile.Read(ref _personalOperatorLease); + var client = _activeLifecycle?.DataClient; + if (lease is null || client is not { IsPersonalTailscaleAuthentication: true } || + lease.Generation != Interlocked.Read(ref _generation) || + client.SessionMutationConnectionEpoch != lease.TransportEpoch || + client.AuthenticatedSigningDeviceId != lease.DeviceId || + client.PersonalRecoveryScope != lease.RecoveryScope || + _registry.ActiveGatewayId != lease.GatewayId || + _registry.GetById(lease.GatewayId) is not { OperatorAuthentication: OperatorAuthenticationMode.PersonalTailscale } record || + record.SshTunnel is not null || + !GatewayPersonalAuthenticationPolicy.TryNormalizeGatewayUrl(record.Url, out var route, out _) || + !GatewayPersonalAuthenticationPolicy.TryNormalizeGatewayUrl(client.CurrentGatewayUrl, out var connected, out _) || + !GatewayPersonalAuthenticationPolicy.TryNormalizeGatewayUrl(lease.GatewayUrl, out var leased, out _) || + route != connected || route != leased) + return null; + return lease; + } + } + + private async Task<(PersonalVerification Disposition, PersonalOperatorLease? Lease)> VerifyPersonalOperatorAsync(long generation) + { + var client = _activeLifecycle?.DataClient; + var record = _activeGatewayRecordId is null ? null : _registry.GetById(_activeGatewayRecordId); + if (record?.OperatorAuthentication != OperatorAuthenticationMode.PersonalTailscale) + { + return (PersonalVerification.NotRequired, null); + } + + if (client is not { IsPersonalTailscaleAuthentication: true } || + client.PersonalHandshakeConnectionEpoch is not { } epoch || + client.PersonalRecoveryScope is not { } scope || + record.SshTunnel is not null || + !GatewayPersonalAuthenticationPolicy.TryNormalizeGatewayUrl(record.Url, out var route, out _) || + !GatewayPersonalAuthenticationPolicy.TryNormalizeGatewayUrl(client.CurrentGatewayUrl, out var connected, out _) || + route != connected) + return (PersonalVerification.Rejected, null); + + try + { + var self = await client.ReadPersonalIdentityAsync(epoch).ConfigureAwait(false); + if (!IsCurrent()) return (PersonalVerification.Stale, null); + if (!GatewayPersonalAuthenticationPolicy.TryGetCanonicalProfileId(self, out var profile)) + return (PersonalVerification.Rejected, null); + client.VerifyPersonalIdentity(profile, epoch); + if (!IsCurrent() || client.SessionMutationConnectionEpoch != epoch || + client.AuthenticatedSigningDeviceId is not { Length: > 0 } deviceId) + return (PersonalVerification.Stale, null); + var lease = new PersonalOperatorLease(record.Id, route, profile, scope, deviceId, generation, epoch); + return (PersonalVerification.Verified, lease); + } + catch (Exception ex) when (ex is InvalidOperationException or TimeoutException or + OperationCanceledException or JsonException) + { + if (!IsCurrent()) return (PersonalVerification.Stale, null); + _diagnostics.Record("identity", "Personal profile verification unavailable", ex.GetType().Name); + return (PersonalVerification.Rejected, null); + } + + bool IsCurrent() => + generation == Interlocked.Read(ref _generation) && + ReferenceEquals(client, _activeLifecycle?.DataClient) && + client.PersonalHandshakeConnectionEpoch == epoch && + client.PersonalRecoveryScope == scope && + _registry.ActiveGatewayId == record.Id && + _registry.GetById(record.Id) is { OperatorAuthentication: OperatorAuthenticationMode.PersonalTailscale } current && + current.SshTunnel is null && + GatewayPersonalAuthenticationPolicy.TryNormalizeGatewayUrl(current.Url, out var currentRoute, out _) && + currentRoute == route; + } + + public async Task CreatePersonalBrowserAuthResponseAsync( + string nonce, long signedAt, CancellationToken cancellationToken = default) + { + if (string.IsNullOrWhiteSpace(nonce) || System.Text.Encoding.UTF8.GetByteCount(nonce) > 512 || nonce.Contains('|') || + nonce.Any(character => char.IsControl(character) || character == '\uFEFF') || + signedAt <= 0 || Math.Abs((double)new DateTimeOffset(_clock.UtcNow).ToUnixTimeMilliseconds() - signedAt) > 300_000) + return null; + + var lease = CurrentPersonalOperatorLease; + var client = _activeLifecycle?.DataClient; + if (lease is null || client is null) return null; + try + { + var self = await client.ReadPersonalIdentityAsync(lease.TransportEpoch).ConfigureAwait(false); + if (cancellationToken.IsCancellationRequested || + !ReferenceEquals(lease, CurrentPersonalOperatorLease) || + !ReferenceEquals(client, _activeLifecycle?.DataClient)) + return null; + if (!GatewayPersonalAuthenticationPolicy.TryGetCanonicalProfileId(self, out var profile) || + profile != lease.IdentityProfileId) + { + await RevokePersonalOperatorAsync(lease).ConfigureAwait(false); + return null; + } + var response = client.CreatePersonalBrowserAuthResponse(nonce, signedAt, lease.TransportEpoch); + return ReferenceEquals(lease, CurrentPersonalOperatorLease) + ? JsonSerializer.Serialize(response) : null; + } + catch (Exception ex) when (ex is InvalidOperationException or TimeoutException or + OperationCanceledException or JsonException) + { + await RevokePersonalOperatorAsync(lease).ConfigureAwait(false); + return null; + } + } + + private async Task RevokePersonalOperatorAsync(PersonalOperatorLease expected) + { + await _transitionSemaphore.WaitAsync().ConfigureAwait(false); + try + { + if (!ReferenceEquals(expected, CurrentPersonalOperatorLease)) return; + _stateMachine.TryTransition(ConnectionTrigger.WebSocketError, + "Personal identity changed. Reconnect this Gateway."); + _stateMachine.Current = _stateMachine.Current with { PersonalIdentityProfileId = null }; + await DisposeActiveClientAsync().ConfigureAwait(false); + EmitStateChanged(); + } + finally + { + _transitionSemaphore.Release(); + } + } +} diff --git a/src/OpenClaw.Connection/GatewayConnectionManager.cs b/src/OpenClaw.Connection/GatewayConnectionManager.cs index df82239365..c4ccf4eafd 100644 --- a/src/OpenClaw.Connection/GatewayConnectionManager.cs +++ b/src/OpenClaw.Connection/GatewayConnectionManager.cs @@ -14,7 +14,7 @@ namespace OpenClaw.Connection; /// Node, bootstrap-token, and device-pair workflows are delegated to their /// dedicated connection-domain owners through typed internal ports. /// -public sealed class GatewayConnectionManager : +public sealed partial class GatewayConnectionManager : IGatewayConnectionManager, INodeLifecycleSource, INodeConnectionStateSink, @@ -2623,6 +2623,7 @@ expectedRecord.NativePackageFamilyName is not null private static bool IsSameCredentialHandoffRecord( GatewayRecord current, GatewayRecord expected) => + current.OperatorAuthentication == expected.OperatorAuthentication && string.Equals(current.Id, expected.Id, StringComparison.Ordinal) && string.Equals(current.Url, expected.Url, StringComparison.Ordinal) && string.Equals( @@ -2648,16 +2649,51 @@ private static bool IsSameCredentialHandoffRecord( private async Task HandleHandshakeSucceededAsync(long gen) { NodeAutomaticStartPlan? nodeStartPlan = null; + if (Interlocked.Read(ref _generation) != gen) return; + var personalClient = _activeLifecycle?.DataClient; + var personal = await VerifyPersonalOperatorAsync(gen).ConfigureAwait(false); await _transitionSemaphore.WaitAsync(); try { if (Interlocked.Read(ref _generation) != gen) return; + if (!ReferenceEquals(personalClient, _activeLifecycle?.DataClient)) return; + if (personal.Disposition == PersonalVerification.Stale) return; + if (personal.Disposition == PersonalVerification.Verified) + { + if (personal.Lease is not { } lease || personalClient is null || + personalClient.SessionMutationConnectionEpoch != lease.TransportEpoch || + personalClient.PersonalRecoveryScope != lease.RecoveryScope) + return; + Volatile.Write(ref _personalOperatorLease, lease); + if (CurrentPersonalOperatorLease is null) + { + Interlocked.CompareExchange(ref _personalOperatorLease, null, lease); + return; + } + } + else if (personal.Disposition == PersonalVerification.NotRequired) + { + Volatile.Write(ref _personalOperatorLease, null); + } + if (personal.Disposition == PersonalVerification.Rejected) + { + _stateMachine.TryTransition(ConnectionTrigger.AuthenticationFailed, + "Personal Tailscale identity could not be verified. Reconnect this Gateway."); + CompleteOperatorTelemetryAttempt(gen, "failure", ConnectionErrorCategory.AuthFailure); + await DisposeActiveClientAsync().ConfigureAwait(false); + EmitStateChanged(); + return; + } var prev = _stateMachine.Current.OverallState; _diagnostics.Record("state", "Handshake succeeded (hello-ok)"); _stateMachine.SetOperatorProtocolCompatibility( ReadOperatorProtocolCompatibility(gen)); _stateMachine.TryTransition(ConnectionTrigger.HandshakeSucceeded); + _stateMachine.Current = _stateMachine.Current with + { + PersonalIdentityProfileId = CurrentPersonalOperatorLease?.IdentityProfileId + }; CompleteOperatorTelemetryAttempt(gen, "success"); var nodeModeIntended = SyncNodeIntentFromSettings(); _bootstrapTokenLifecycle.ResetOperatorRecoveryAfterHandshake( @@ -3673,6 +3709,7 @@ private async Task StopNativeGatewayAsync() private async Task DisposeActiveClientAsync() { + Volatile.Write(ref _personalOperatorLease, null); await _nodeConnectionCoordinator.RetireAsync().ConfigureAwait(false); _devicePairApprovalCoordinator.Reset(); diff --git a/src/OpenClaw.Connection/GatewayConnectionSnapshot.cs b/src/OpenClaw.Connection/GatewayConnectionSnapshot.cs index 120b607c9b..68f4386ac5 100644 --- a/src/OpenClaw.Connection/GatewayConnectionSnapshot.cs +++ b/src/OpenClaw.Connection/GatewayConnectionSnapshot.cs @@ -21,6 +21,7 @@ public sealed record GatewayConnectionSnapshot public OpenClaw.Shared.GatewayErrorKind? OperatorErrorKind { get; init; } public bool OperatorPairingRequired { get; init; } public string? OperatorDeviceId { get; init; } + public string? PersonalIdentityProfileId { get; init; } public string? OperatorCredentialSource { get; init; } public GatewayCredentialResolutionStatus? OperatorCredentialStatus { get; init; } public bool OperatorCredentialFallbackUsed { get; init; } diff --git a/src/OpenClaw.Connection/GatewayConnectionValidator.cs b/src/OpenClaw.Connection/GatewayConnectionValidator.cs index 70ff3a0c2f..85f49a84fa 100644 --- a/src/OpenClaw.Connection/GatewayConnectionValidator.cs +++ b/src/OpenClaw.Connection/GatewayConnectionValidator.cs @@ -151,7 +151,8 @@ internal static OpenClawGatewayClient CreateClient( ignoreStoredDeviceToken: credential.Source != CredentialResolver.SourceDeviceToken, persistHandshakeDeviceTokens: false, ephemeralOperatorCredential: ephemeralOperatorCredential, - useBoundedBootstrapScopes: useBoundedBootstrapScopes) + useBoundedBootstrapScopes: useBoundedBootstrapScopes, + operatorAuthentication: credential.OperatorAuthentication) { UseV2Signature = record.IsLocal || record.RequiresV2Signature || credential.IsBootstrapToken }; @@ -165,8 +166,27 @@ internal static async Task RunHandshakeAsync( OpenClawGatewayClient client, CancellationToken cancellationToken) { var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - void Handshake(object? sender, EventArgs e) => - completion.TrySetResult(new(SetupCodeOutcome.Success)); + void Handshake(object? sender, EventArgs e) => _ = VerifyHandshakeAsync(); + async Task VerifyHandshakeAsync() + { + try + { + if (client.IsPersonalTailscaleAuthentication) + { + if (client.PersonalHandshakeConnectionEpoch is not { } epoch) + throw new InvalidOperationException(); + var self = await client.ReadPersonalIdentityAsync(epoch).ConfigureAwait(false); + if (!GatewayPersonalAuthenticationPolicy.TryGetCanonicalProfileId(self, out var profile)) + throw new InvalidOperationException(); + client.VerifyPersonalIdentity(profile, epoch); + } + completion.TrySetResult(new(SetupCodeOutcome.Success)); + } + catch (Exception ex) when (ex is InvalidOperationException or TimeoutException or OperationCanceledException) + { + completion.TrySetResult(AuthenticationFailure("Personal Tailscale identity could not be verified.")); + } + } void AuthenticationFailed(object? sender, string message) => completion.TrySetResult(AuthenticationFailure(message)); // Pairing is reported before the Gateway closes the socket. Preserve it as the first result. diff --git a/src/OpenClaw.Connection/GatewayPersonalAuthenticationPolicy.cs b/src/OpenClaw.Connection/GatewayPersonalAuthenticationPolicy.cs new file mode 100644 index 0000000000..f8f1372101 --- /dev/null +++ b/src/OpenClaw.Connection/GatewayPersonalAuthenticationPolicy.cs @@ -0,0 +1,54 @@ +using System.Net; + +namespace OpenClaw.Connection; + +public static class GatewayPersonalAuthenticationPolicy +{ + public const string AuthMethod = "tailscale"; + public const string CredentialSource = "auth.tailscale"; + + public static bool TryNormalizeGatewayUrl(string? value, out string normalizedUrl, out string error) => + OpenClaw.Shared.PersonalTailscaleGatewayRoute.TryNormalizeGatewayUrl(value, out normalizedUrl, out error); + + public static bool TryGetCanonicalProfileId(System.Text.Json.JsonElement response, out string profileId) + { + profileId = string.Empty; + if (response.ValueKind != System.Text.Json.JsonValueKind.Object || + !response.TryGetProperty("profile", out var profile) || + profile.ValueKind != System.Text.Json.JsonValueKind.Object || + !profile.TryGetProperty("id", out var id) || + id.ValueKind != System.Text.Json.JsonValueKind.String) + { + return false; + } + + profileId = id.GetString() ?? string.Empty; + return !string.IsNullOrWhiteSpace(profileId) && + string.Equals(profileId, profileId.Trim(), StringComparison.Ordinal); + } + + public static bool IsTrustedDashboardSource(string sourceUrl, string expectedGatewayUrl) + { + if (!TryNormalizeGatewayUrl(expectedGatewayUrl, out var route, out _) || + !Uri.TryCreate(route, UriKind.Absolute, out var expected) || + !Uri.TryCreate(sourceUrl, UriKind.Absolute, out var source)) + { + return false; + } + + return string.Equals(source.Scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) && + string.IsNullOrEmpty(source.UserInfo) && + source.Port == expected.Port && + string.Equals(source.Host, expected.Host, StringComparison.OrdinalIgnoreCase) && + !IPAddress.TryParse(source.Host, out _); + } +} + +public sealed record PersonalOperatorLease( + string GatewayId, + string GatewayUrl, + string IdentityProfileId, + string RecoveryScope, + string DeviceId, + long Generation, + long TransportEpoch); \ No newline at end of file diff --git a/src/OpenClaw.Connection/GatewayRecord.cs b/src/OpenClaw.Connection/GatewayRecord.cs index de142fc582..193902d2d0 100644 --- a/src/OpenClaw.Connection/GatewayRecord.cs +++ b/src/OpenClaw.Connection/GatewayRecord.cs @@ -6,6 +6,8 @@ namespace OpenClaw.Connection; /// public sealed record GatewayRecord { + public OpenClaw.Shared.OperatorAuthenticationMode OperatorAuthentication { get; init; } + /// Stable GUID, primary key. public string Id { get; init; } = ""; diff --git a/src/OpenClaw.Connection/ICredentialResolver.cs b/src/OpenClaw.Connection/ICredentialResolver.cs index 92fc9ef296..88d601696b 100644 --- a/src/OpenClaw.Connection/ICredentialResolver.cs +++ b/src/OpenClaw.Connection/ICredentialResolver.cs @@ -7,6 +7,8 @@ namespace OpenClaw.Connection; /// public sealed record GatewayCredential(string Token, bool IsBootstrapToken, string Source) { + public OperatorAuthenticationMode OperatorAuthentication { get; init; } + public GatewayCredentialResolutionStatus ResolutionStatus { get; init; } = GatewayCredentialResolutionStatus.Resolved; public bool FallbackUsed { get; init; } diff --git a/src/OpenClaw.Connection/IGatewayConnectionManager.cs b/src/OpenClaw.Connection/IGatewayConnectionManager.cs index 2deee61dfe..aae06c39d8 100644 --- a/src/OpenClaw.Connection/IGatewayConnectionManager.cs +++ b/src/OpenClaw.Connection/IGatewayConnectionManager.cs @@ -12,6 +12,10 @@ public interface IGatewayConnectionManager : IDisposable, IAsyncDisposable // ─── State ─── GatewayConnectionSnapshot CurrentSnapshot { get; } string? ActiveGatewayUrl { get; } + PersonalOperatorLease? CurrentPersonalOperatorLease => null; + Task CreatePersonalBrowserAuthResponseAsync( + string nonce, long signedAt, CancellationToken cancellationToken = default) => + Task.FromResult(null); // ─── Events ─── event EventHandler StateChanged; diff --git a/src/OpenClaw.Connection/InteractiveGatewayCredentialResolver.cs b/src/OpenClaw.Connection/InteractiveGatewayCredentialResolver.cs index d69fc8f740..8763579276 100644 --- a/src/OpenClaw.Connection/InteractiveGatewayCredentialResolver.cs +++ b/src/OpenClaw.Connection/InteractiveGatewayCredentialResolver.cs @@ -13,6 +13,7 @@ public static class InteractiveGatewayCredentialResolver internal static GatewayCredential? ResolveForAssistantMediaHttpSurface( GatewayRecord record, GatewayCredential? fallback) => + record.OperatorAuthentication == OperatorAuthenticationMode.PersonalTailscale ? null : !string.IsNullOrWhiteSpace(record.SharedGatewayToken) ? new GatewayCredential( record.SharedGatewayToken!, @@ -60,6 +61,11 @@ public static bool TryResolve( var active = registry?.GetActive(); if (active != null && !string.IsNullOrWhiteSpace(active.Url)) { + if (active.OperatorAuthentication != OperatorAuthenticationMode.GatewayCredential) + { + credential = null; + return false; + } if (active.NativePackageFamilyName is not null && authorizeCredential is null) { credential = null; diff --git a/src/OpenClaw.Shared/ConnectEnvelopeBuilder.cs b/src/OpenClaw.Shared/ConnectEnvelopeBuilder.cs index a1d664d6ef..4c8df4b368 100644 --- a/src/OpenClaw.Shared/ConnectEnvelopeBuilder.cs +++ b/src/OpenClaw.Shared/ConnectEnvelopeBuilder.cs @@ -19,13 +19,19 @@ protected ConnectCredential(string value) internal string Value { get; } internal abstract string FieldName { get; } - internal Dictionary ToAuthPayload() => + internal virtual Dictionary ToAuthPayload() => new() { [FieldName] = Value }; public sealed override string ToString() => $"ConnectCredential {{ Kind = {FieldName} }}"; } +internal sealed class TailscaleConnectCredential() : ConnectCredential(string.Empty) +{ + internal override string FieldName => "tailscale"; + internal override Dictionary ToAuthPayload() => []; +} + internal sealed class TokenConnectCredential(string token) : ConnectCredential(token) { diff --git a/src/OpenClaw.Shared/OpenClawGatewayClient.PersonalAuthentication.cs b/src/OpenClaw.Shared/OpenClawGatewayClient.PersonalAuthentication.cs new file mode 100644 index 0000000000..17321e736e --- /dev/null +++ b/src/OpenClaw.Shared/OpenClawGatewayClient.PersonalAuthentication.cs @@ -0,0 +1,123 @@ +using System.Text.Json; + +namespace OpenClaw.Shared; + +public partial class OpenClawGatewayClient +{ + private sealed record PersonalHandshake(long Epoch, string RecoveryScope, string? ProfileId = null); + private readonly OperatorAuthenticationMode _operatorAuthentication; + private PersonalHandshake? _personalHandshake; + + public bool IsPersonalTailscaleAuthentication => + _operatorAuthentication == OperatorAuthenticationMode.PersonalTailscale; + + public long? PersonalHandshakeConnectionEpoch => + TryGetHandshakeConnectionGeneration(out var epoch) && + Volatile.Read(ref _personalHandshake)?.Epoch == epoch ? epoch : null; + + public string? PersonalRecoveryScope => + PersonalHandshakeConnectionEpoch is { } epoch && + Volatile.Read(ref _personalHandshake) is { } handshake && handshake.Epoch == epoch + ? handshake.RecoveryScope : null; + + public string CurrentGatewayUrl => _currentGatewayUrl; + + public async Task ReadPersonalIdentityAsync(long expectedEpoch) + { + if (!IsPersonalTailscaleAuthentication || PersonalHandshakeConnectionEpoch != expectedEpoch) + throw new InvalidOperationException("The personal Gateway connection changed."); + var result = await SendResponseRequestAsync( + "users.self", new { }, 30000, expectedEpoch, allowPersonalIdentityRead: true).ConfigureAwait(false); + if (PersonalHandshakeConnectionEpoch != expectedEpoch) + throw new InvalidOperationException("The personal Gateway connection changed."); + return result; + } + + public void VerifyPersonalIdentity(string profileId, long expectedEpoch) + { + ArgumentException.ThrowIfNullOrWhiteSpace(profileId); + var handshake = Volatile.Read(ref _personalHandshake); + if (!IsPersonalTailscaleAuthentication || handshake is null || + handshake.Epoch != expectedEpoch || PersonalHandshakeConnectionEpoch != expectedEpoch) + throw new InvalidOperationException("The personal Gateway connection changed."); + var verified = handshake with { ProfileId = profileId }; + if (!ReferenceEquals(Interlocked.CompareExchange(ref _personalHandshake, verified, handshake), handshake)) + throw new InvalidOperationException("The personal Gateway connection changed."); + if (PersonalHandshakeConnectionEpoch != expectedEpoch) + { + Interlocked.CompareExchange(ref _personalHandshake, null, verified); + throw new InvalidOperationException("The personal Gateway connection changed."); + } + RequestInitialState(expectedEpoch); + } + + private void RequestInitialState(long epoch) + { + _ = Task.Run(async () => + { + await Task.Delay(500); + if (!TryGetReadyConnectionGeneration(out var current) || current != epoch) + return; + await CheckHealthAsync(); + await RequestSessionsAsync(); + await SubscribeSessionEventsAsync(); + await RequestUsageAsync(); + await RequestNodesAsync(); + await RequestAgentsListAsync(); + }); + } + + private bool HasVerifiedPersonalIdentity(long epoch) => + Volatile.Read(ref _personalHandshake) is { ProfileId: not null } handshake && handshake.Epoch == epoch; + + private bool TryAcceptPersonalHandshake(JsonElement payload, long epoch) + { + if (!payload.TryGetProperty("auth", out var auth) || + auth.ValueKind != JsonValueKind.Object || + !auth.TryGetProperty("method", out var method) || + method.ValueKind != JsonValueKind.String || method.GetString() != "tailscale" || + !auth.TryGetProperty("recoveryScope", out var scope) || + scope.ValueKind != JsonValueKind.String || string.IsNullOrWhiteSpace(scope.GetString())) + return false; + Volatile.Write(ref _personalHandshake, new PersonalHandshake(epoch, scope.GetString()!)); + return true; + } + + public object CreatePersonalBrowserAuthResponse(string nonce, long signedAt, long expectedEpoch) + { + var handshake = Volatile.Read(ref _personalHandshake); + if (string.IsNullOrWhiteSpace(nonce) || System.Text.Encoding.UTF8.GetByteCount(nonce) > 512 || + nonce.Contains('|') || nonce.Any(character => char.IsControl(character) || character == '\uFEFF') || + signedAt <= 0 || !IsPersonalTailscaleAuthentication || + !TryGetReadyConnectionGeneration(out var epoch) || epoch != expectedEpoch || + handshake is not { ProfileId: not null } || handshake.Epoch != epoch || + AuthenticatedSigningDeviceId != _deviceIdentity.DeviceId) + throw new InvalidOperationException("Personal Gateway identity is unavailable."); + + var scopes = GrantedOperatorScopes.ToArray(); + var signature = _deviceIdentity.SignConnectPayloadV3( + nonce, signedAt, "gateway-client", "ui", "operator", scopes, string.Empty, + WindowsClientMetadata.Platform, WindowsClientMetadata.DeviceFamily); + if (!TryGetReadyConnectionGeneration(out var currentEpoch) || currentEpoch != epoch || + !ReferenceEquals(handshake, Volatile.Read(ref _personalHandshake))) + throw new InvalidOperationException("The personal Gateway connection changed."); + + return new + { + client = new + { + id = "gateway-client", mode = "ui", version = AppVersionInfo.Version, + platform = WindowsClientMetadata.Platform, deviceFamily = WindowsClientMetadata.DeviceFamily + }, + scopes, + auth = new { }, + requiredAuthMethod = "tailscale", + expectedRecoveryScope = handshake.RecoveryScope, + device = new + { + id = _deviceIdentity.DeviceId, publicKey = _deviceIdentity.PublicKeyBase64Url, + signature, signedAt, nonce + } + }; + } +} diff --git a/src/OpenClaw.Shared/OpenClawGatewayClient.cs b/src/OpenClaw.Shared/OpenClawGatewayClient.cs index 5fd1f38c61..90dd54d210 100644 --- a/src/OpenClaw.Shared/OpenClawGatewayClient.cs +++ b/src/OpenClaw.Shared/OpenClawGatewayClient.cs @@ -202,6 +202,7 @@ protected override Task ProcessMessageForConnectionAsync( protected override Task OnConnectedAsync() { + Volatile.Write(ref _personalHandshake, null); CancelScheduledSessionRefresh(); lock (_sessionsLock) { @@ -234,6 +235,7 @@ protected override bool ShouldAutoReconnect() protected override void OnDisconnected() { + Volatile.Write(ref _personalHandshake, null); CancelScheduledSessionRefresh(); // Invalidate the handshake snapshot — the next hello-ok must // re-establish the canonical session key, scopes, etc. Without this, @@ -257,6 +259,7 @@ protected override void OnDisconnected() protected override void OnDisposing() { + Volatile.Write(ref _personalHandshake, null); CancelScheduledSessionRefresh(); Volatile.Write(ref _pendingSigningIdentity, null); Volatile.Write(ref _authenticatedSigningIdentity, null); @@ -377,7 +380,11 @@ public string? AuthenticatedSigningDeviceId public long ServerHandshakeGeneration => Interlocked.Read(ref _serverHandshakeGeneration); public int? LastRemoteCloseStatusCode => RemoteCloseStatusCode; - private bool TryGetReadyConnectionGeneration(out long connectionGeneration) + private bool TryGetReadyConnectionGeneration(out long connectionGeneration) => + TryGetHandshakeConnectionGeneration(out connectionGeneration) && + (!IsPersonalTailscaleAuthentication || HasVerifiedPersonalIdentity(connectionGeneration)); + + private bool TryGetHandshakeConnectionGeneration(out long connectionGeneration) { connectionGeneration = CurrentConnectionGeneration; return IsConnected && @@ -424,12 +431,20 @@ public OpenClawGatewayClient( HttpMessageHandler? assistantMediaHandler = null, DeviceTokenReceivedEventArgs? ephemeralOperatorCredential = null, bool useBoundedBootstrapScopes = false, - bool requireExistingIdentity = false) - : base(gatewayUrl, token, logger) - { + bool requireExistingIdentity = false, + OperatorAuthenticationMode operatorAuthentication = OperatorAuthenticationMode.GatewayCredential) + : base(gatewayUrl, token, logger, allowEmptyToken: operatorAuthentication == OperatorAuthenticationMode.PersonalTailscale) + { + _operatorAuthentication = operatorAuthentication; + if (IsPersonalTailscaleAuthentication && + (!string.IsNullOrEmpty(token) || !PersonalTailscaleGatewayRoute.TryNormalizeGatewayUrl(gatewayUrl, out _, out _))) + throw new ArgumentException("Personal authentication requires a credential-free managed Tailscale route.", nameof(gatewayUrl)); + if (!Enum.IsDefined(operatorAuthentication) || + IsPersonalTailscaleAuthentication && (tokenIsBootstrapToken || bootstrapPairAsNode || ephemeralOperatorCredential is not null)) + throw new ArgumentException("Personal authentication cannot use bootstrap or operator credentials.", nameof(operatorAuthentication)); _tokenIsBootstrapToken = tokenIsBootstrapToken; _bootstrapPairAsNode = bootstrapPairAsNode; - _ignoreStoredDeviceToken = ignoreStoredDeviceToken; + _ignoreStoredDeviceToken = ignoreStoredDeviceToken || IsPersonalTailscaleAuthentication; _persistHandshakeDeviceTokens = persistHandshakeDeviceTokens; if (ephemeralOperatorCredential is not null && (ephemeralOperatorCredential.Role != "operator" || string.IsNullOrWhiteSpace(ephemeralOperatorCredential.Token))) @@ -439,7 +454,7 @@ public OpenClawGatewayClient( _assistantMediaHttpClient = assistantMediaHandler is null ? new HttpClient(new HttpClientHandler { AllowAutoRedirect = false }) : new HttpClient(assistantMediaHandler, disposeHandler: true); - SetAssistantMediaAuthToken(assistantMediaAuthToken); + SetAssistantMediaAuthToken(IsPersonalTailscaleAuthentication ? null : assistantMediaAuthToken); _currentGatewayUrl = gatewayUrl; var dataPath = identityPath ?? OpenClawAppIdentity.ResolveRoamingDataDirectory( Environment.GetEnvironmentVariable); @@ -448,7 +463,8 @@ public OpenClawGatewayClient( if (requireExistingIdentity) _deviceIdentity.LoadExisting(); else _deviceIdentity.Initialize(); _connectEnvelopeSigner = new DeviceIdentityConnectEnvelopeSigner(_deviceIdentity); - _connectAuthToken = HasUsableOperatorDeviceToken ? EffectiveOperatorDeviceToken! : (_tokenIsBootstrapToken ? string.Empty : _token); + _connectAuthToken = IsPersonalTailscaleAuthentication ? string.Empty : + HasUsableOperatorDeviceToken ? EffectiveOperatorDeviceToken! : (_tokenIsBootstrapToken ? string.Empty : _token); _useV2Signature |= _tokenIsBootstrapToken && !HasUsableOperatorDeviceToken; } @@ -459,7 +475,7 @@ public OpenClawGatewayClient( public void SetAssistantMediaAuthToken(string? token) => Volatile.Write( ref _assistantMediaAuthToken, - string.IsNullOrWhiteSpace(token) ? null : token); + IsPersonalTailscaleAuthentication || string.IsNullOrWhiteSpace(token) ? null : token); public async Task DisconnectAsync() { @@ -1377,9 +1393,12 @@ public Task SendWizardRequestAsync(string method, object? parameter SendResponseRequestAsync(method, parameters, timeoutMs); private async Task SendResponseRequestAsync( - string method, object? parameters, int timeoutMs, long? expectedConnectionEpoch = null) + string method, object? parameters, int timeoutMs, long? expectedConnectionEpoch = null, + bool allowPersonalIdentityRead = false) { - var connectionGeneration = GetReadyConnectionGeneration(method); + var connectionGeneration = allowPersonalIdentityRead && method == "users.self" && + TryGetHandshakeConnectionGeneration(out var handshakeEpoch) + ? handshakeEpoch : GetReadyConnectionGeneration(method); if (expectedConnectionEpoch.HasValue && connectionGeneration != expectedConnectionEpoch.Value) throw new InvalidOperationException("The Gateway connection changed before the request could be sent."); @@ -2241,7 +2260,7 @@ private async Task SendConnectMessageAsync( _challengeTimestampMs, _useV2Signature, SupportsExecApprovals, - ClientIdentity), + IsPersonalTailscaleAuthentication ? OperatorClientIdentity.Interactive : ClientIdentity), _connectEnvelopeSigner); var signedAt = envelope.SignedAt; var connectNonce = envelope.Nonce!; @@ -2340,6 +2359,9 @@ private Dictionary BuildAuthPayload() private ConnectCredential SelectConnectCredential() { + if (IsPersonalTailscaleAuthentication) + return new TailscaleConnectCredential(); + if (HasUsableOperatorDeviceToken) return new DeviceTokenConnectCredential(EffectiveOperatorDeviceToken!); @@ -2611,6 +2633,13 @@ HandshakeAuthorizationAsync is not null && return; } + if (IsPersonalTailscaleAuthentication && !TryAcceptPersonalHandshake(payload, sourceConnectionGeneration)) + { + _authFailed = true; + RaiseAuthenticationFailed("The Gateway did not verify personal Tailscale authentication."); + return; + } + _logger.Info($"[HANDSHAKE] Received hello-ok!"); Volatile.Write(ref _pairingRequiredAwaitingApproval, false); Volatile.Write(ref _pairingRequiredRequestId, null); @@ -2653,6 +2682,8 @@ HandshakeAuthorizationAsync is not null && var persistedRoleTokens = new HashSet(StringComparer.OrdinalIgnoreCase); foreach (var roleToken in EnumerateHandshakeDeviceTokens(payload)) { + if (IsPersonalTailscaleAuthentication && roleToken.Role != "node") + continue; var stored = TryStoreHandshakeDeviceToken(roleToken.Role, roleToken.Token, roleToken.Scopes); persistedRoleTokens.Add(roleToken.Role); if (stored && roleToken.Role.Equals("node", StringComparison.OrdinalIgnoreCase)) @@ -2676,7 +2707,7 @@ HandshakeAuthorizationAsync is not null && } } - var newDeviceToken = !_bootstrapPairAsNode + var newDeviceToken = IsPersonalTailscaleAuthentication ? null : !_bootstrapPairAsNode ? (persistedRoleTokens.Contains(OperatorRole) ? null : TryGetHandshakeDeviceTokenCore(payload, preferredRole: null)) : TryGetHandshakeDeviceTokenCore(payload, OperatorRole, allowDirectDeviceTokenFallback: false); if (!string.IsNullOrWhiteSpace(newDeviceToken)) @@ -2708,17 +2739,8 @@ HandshakeAuthorizationAsync is not null && RaiseStatusChanged(ConnectionStatus.Connected); - // Request initial state after handshake - _ = Task.Run(async () => - { - await Task.Delay(500); - await CheckHealthAsync(); - await RequestSessionsAsync(); - await SubscribeSessionEventsAsync(); - await RequestUsageAsync(); - await RequestNodesAsync(); - await RequestAgentsListAsync(); - }); + if (!IsPersonalTailscaleAuthentication) + RequestInitialState(sourceConnectionGeneration); } // Handle health response — channels diff --git a/src/OpenClaw.Shared/OperatorAuthenticationMode.cs b/src/OpenClaw.Shared/OperatorAuthenticationMode.cs new file mode 100644 index 0000000000..a28bdf0578 --- /dev/null +++ b/src/OpenClaw.Shared/OperatorAuthenticationMode.cs @@ -0,0 +1,7 @@ +namespace OpenClaw.Shared; + +public enum OperatorAuthenticationMode +{ + GatewayCredential, + PersonalTailscale +} diff --git a/src/OpenClaw.Shared/PersonalTailscaleGatewayRoute.cs b/src/OpenClaw.Shared/PersonalTailscaleGatewayRoute.cs new file mode 100644 index 0000000000..110e73d10c --- /dev/null +++ b/src/OpenClaw.Shared/PersonalTailscaleGatewayRoute.cs @@ -0,0 +1,36 @@ +using System.Net; + +namespace OpenClaw.Shared; + +public static class PersonalTailscaleGatewayRoute +{ + public static bool TryNormalizeGatewayUrl(string? value, out string normalizedUrl, out string error) + { + normalizedUrl = string.Empty; + error = "Personal Tailscale authentication requires a credential-free wss:// host.ts.net URL."; + if (string.IsNullOrWhiteSpace(value) || !Uri.TryCreate(value.Trim(), UriKind.Absolute, out var uri)) + return false; + + if (!string.Equals(uri.Scheme, "wss", StringComparison.OrdinalIgnoreCase) || + !string.IsNullOrEmpty(uri.UserInfo) || + !string.IsNullOrEmpty(uri.Query) || + !string.IsNullOrEmpty(uri.Fragment) || + uri.Port < 1 || + IPAddress.TryParse(uri.Host, out _) || + uri.Host.EndsWith(".", StringComparison.Ordinal) || + !uri.Host.EndsWith(".ts.net", StringComparison.OrdinalIgnoreCase) || + uri.Host.Length <= ".ts.net".Length) + { + return false; + } + + var normalized = new UriBuilder(uri) + { + Scheme = Uri.UriSchemeWss, + Port = uri.IsDefaultPort ? -1 : uri.Port + }; + normalizedUrl = normalized.Uri.GetLeftPart(UriPartial.Path).TrimEnd('/'); + return true; + } + +} diff --git a/src/OpenClaw.Shared/WebSocketClientBase.cs b/src/OpenClaw.Shared/WebSocketClientBase.cs index e02156b6b8..3456056b13 100644 --- a/src/OpenClaw.Shared/WebSocketClientBase.cs +++ b/src/OpenClaw.Shared/WebSocketClientBase.cs @@ -213,11 +213,11 @@ protected virtual void OnDisposing() { } /// Maximum time allowed for one WebSocket HTTP upgrade attempt. protected virtual TimeSpan ConnectAttemptTimeout => DefaultConnectAttemptTimeout; - protected WebSocketClientBase(string gatewayUrl, string token, IOpenClawLogger? logger = null) + protected WebSocketClientBase(string gatewayUrl, string token, IOpenClawLogger? logger = null, bool allowEmptyToken = false) { if (string.IsNullOrEmpty(gatewayUrl)) throw new ArgumentException("Gateway URL is required.", nameof(gatewayUrl)); - if (string.IsNullOrEmpty(token)) + if (!allowEmptyToken && string.IsNullOrEmpty(token)) throw new ArgumentException("Token is required.", nameof(token)); _gatewayUrl = GatewayUrlHelper.NormalizeForWebSocket(gatewayUrl); diff --git a/src/OpenClaw.Tray.WinUI/App.xaml.cs b/src/OpenClaw.Tray.WinUI/App.xaml.cs index 1765e3f6e6..ded94a7c1e 100644 --- a/src/OpenClaw.Tray.WinUI/App.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/App.xaml.cs @@ -4041,7 +4041,9 @@ private void OpenDashboard(string? path = null) () => _windowManager?.ShowDashboardLaunchFailureAsync( () => OpenDashboard(path)) ?? Task.CompletedTask, new AppLogger(), "Dashboard launch error"), - () => _appNotificationService?.Dismiss(GatewayDashboardLauncher.FailureNotificationId)); + () => _appNotificationService?.Dismiss(GatewayDashboardLauncher.FailureNotificationId), + isPersonalMode: () => _gatewayRegistry?.GetActive()?.OperatorAuthentication == OperatorAuthenticationMode.PersonalTailscale, + openPersonalDashboard: target => _windowManager?.ShowPersonalDashboardAsync(target) ?? Task.FromResult(false)); await launcher.OpenAsync(path); }, new AppLogger(), nameof(OpenDashboard)); } diff --git a/src/OpenClaw.Tray.WinUI/Helpers/PersonalDashboardWindowReusePolicy.cs b/src/OpenClaw.Tray.WinUI/Helpers/PersonalDashboardWindowReusePolicy.cs new file mode 100644 index 0000000000..ec20e562ad --- /dev/null +++ b/src/OpenClaw.Tray.WinUI/Helpers/PersonalDashboardWindowReusePolicy.cs @@ -0,0 +1,16 @@ +using OpenClaw.Connection; + +namespace OpenClawTray.Helpers; + +internal static class PersonalDashboardWindowReusePolicy +{ + internal static bool CanReuse( + PersonalOperatorLease? currentLease, + PersonalOperatorLease windowLease, + PersonalOperatorLease requestedLease, + bool isClosed, + bool isRetired) => + !isClosed && !isRetired && + ReferenceEquals(currentLease, requestedLease) && + ReferenceEquals(windowLease, requestedLease); +} diff --git a/src/OpenClaw.Tray.WinUI/Helpers/PersonalGatewayAuthChallenge.cs b/src/OpenClaw.Tray.WinUI/Helpers/PersonalGatewayAuthChallenge.cs new file mode 100644 index 0000000000..22b2d5ab28 --- /dev/null +++ b/src/OpenClaw.Tray.WinUI/Helpers/PersonalGatewayAuthChallenge.cs @@ -0,0 +1,67 @@ +using System.Text; +using System.Text.Json; +using OpenClaw.Connection; + +namespace OpenClawTray.Helpers; + +public sealed record PersonalGatewayAuthChallenge(string Id, string Nonce, long SignedAt); + +public static class PersonalGatewayAuthChallengeParser +{ + public static bool TryParse( + string messageJson, + string sourceUrl, + string expectedGatewayUrl, + out PersonalGatewayAuthChallenge? challenge) + { + challenge = null; + if (!GatewayPersonalAuthenticationPolicy.IsTrustedDashboardSource(sourceUrl, expectedGatewayUrl)) + return false; + + try + { + using var outer = JsonDocument.Parse(messageJson); + var body = outer.RootElement; + if (body.ValueKind == JsonValueKind.String) + { + using var inner = JsonDocument.Parse(body.GetString() ?? string.Empty); + return TryReadChallenge(inner.RootElement, out challenge); + } + + return TryReadChallenge(body, out challenge); + } + catch (JsonException) + { + return false; + } + } + + private static bool TryReadChallenge(JsonElement body, out PersonalGatewayAuthChallenge? challenge) + { + challenge = null; + if (body.ValueKind != JsonValueKind.Object || body.EnumerateObject().Count() != 3 || + !body.TryGetProperty("id", out var id) || id.ValueKind != JsonValueKind.String || + !body.TryGetProperty("nonce", out var nonce) || nonce.ValueKind != JsonValueKind.String || + !body.TryGetProperty("signedAt", out var signedAt) || + signedAt.ValueKind != JsonValueKind.Number || + !signedAt.TryGetInt64(out var signedAtMs)) + { + return false; + } + + var idValue = id.GetString() ?? string.Empty; + var nonceValue = nonce.GetString() ?? string.Empty; + if (string.IsNullOrWhiteSpace(idValue) || Encoding.UTF8.GetByteCount(idValue) > 128 || + string.IsNullOrWhiteSpace(nonceValue) || Encoding.UTF8.GetByteCount(nonceValue) > 512 || + nonceValue.Contains('|') || + nonceValue.Any(character => char.IsControl(character) || character == '\uFEFF') || + !nonceValue.Any(character => !char.IsWhiteSpace(character)) || + signedAtMs <= 0 || signedAtMs > 9_007_199_254_740_991) + { + return false; + } + + challenge = new PersonalGatewayAuthChallenge(idValue, nonceValue, signedAtMs); + return true; + } +} diff --git a/src/OpenClaw.Tray.WinUI/Helpers/PersonalGatewayNativeBridgeScript.cs b/src/OpenClaw.Tray.WinUI/Helpers/PersonalGatewayNativeBridgeScript.cs new file mode 100644 index 0000000000..94e6a11d04 --- /dev/null +++ b/src/OpenClaw.Tray.WinUI/Helpers/PersonalGatewayNativeBridgeScript.cs @@ -0,0 +1,37 @@ +using System.Text.Json; + +namespace OpenClawTray.Helpers; + +internal static class PersonalGatewayNativeBridgeScript +{ + private const string BridgeScript = """ + (() => { + if (!window.chrome?.webview) return; + const bridge = window.OpenClawNativeGatewayAuth || {}; + bridge.postMessage = (message) => window.chrome.webview.postMessage( + typeof message === "string" ? message : JSON.stringify(message)); + bridge.onmessage = bridge.onmessage || null; + Object.defineProperty(window, "OpenClawNativeGatewayAuth", { + configurable: true, value: bridge + }); + window.chrome.webview.addEventListener("message", (event) => { + const handler = window.OpenClawNativeGatewayAuth; + if (typeof handler?.onmessage === "function") { + handler.onmessage({ data: typeof event.data === "string" + ? event.data : JSON.stringify(event.data) }); + } + }); + })(); + """; + + internal static string Create(string gatewayUrl) + { + var nativeControlAuth = JsonSerializer.Serialize(new + { + gatewayUrl, + nativeConnectAuth = true + }); + + return $"window.__OPENCLAW_NATIVE_CONTROL_AUTH__ = {nativeControlAuth};\n{BridgeScript}"; + } +} diff --git a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml index 1cd14f0e26..8c0626efdf 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml @@ -1007,6 +1007,15 @@ TextChanged="OnDirectInputChanged" LostFocus="OnDirectUrlLostFocus" AutomationProperties.AutomationId="AddDirectUrl"/> + + + + + @@ -2830,7 +2844,8 @@ private async Task DoDirectConnectFromAddFormAsync() if (_gatewayDirectConnectService is null) return; var url = DirectUrlBox.Text?.Trim(); - var token = DirectTokenBox.Text?.Trim(); + var personal = DirectOperatorAuthentication.SelectedIndex == 1; + var token = personal ? null : DirectTokenBox.Text?.Trim(); var friendly = DirectNameBox.Text?.Trim(); if (string.IsNullOrWhiteSpace(url)) { @@ -2838,6 +2853,11 @@ private async Task DoDirectConnectFromAddFormAsync() return; } + if (personal && !GatewayPersonalAuthenticationPolicy.TryNormalizeGatewayUrl(url, out _, out _)) + { + AddResultText.Text = LocalizationHelper.GetString("ConnectionPage_PersonalRouteRequired"); + return; + } url = GatewayUrlHelper.NormalizeForWebSocket(url); if (!TryBuildAddSshTunnelConfig(out var sshConfig, out var sshError)) @@ -2846,6 +2866,11 @@ private async Task DoDirectConnectFromAddFormAsync() return; } + if (personal && sshConfig is not null) + { + AddResultText.Text = LocalizationHelper.GetString("ConnectionPage_PersonalRouteRequired"); + return; + } AddSaveButton.IsEnabled = false; AddResultText.Text = sshConfig is null ? LocalizationHelper.GetString("ConnectionPage_Connecting") @@ -2874,14 +2899,16 @@ private async Task DoDirectConnectFromAddFormAsync() friendly, sshConfig, _editingGatewayId, - PreserveExistingSharedTokenWhenMissing: true) + PreserveExistingSharedTokenWhenMissing: true, + OperatorAuthentication: personal ? OperatorAuthenticationMode.PersonalTailscale : OperatorAuthenticationMode.GatewayCredential) : new GatewayDirectConnectRequest( url, submittedToken, friendly, sshConfig, _editingGatewayId, - PreserveExistingSharedTokenWhenMissing: false)); + PreserveExistingSharedTokenWhenMissing: personal, + OperatorAuthentication: personal ? OperatorAuthenticationMode.PersonalTailscale : OperatorAuthenticationMode.GatewayCredential)); if (result.Outcome == GatewayDirectConnectOutcome.Failed) { AddResultText.Text = $"✗ {result.Error}"; diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs index e7cfae2d37..360028688f 100644 --- a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs @@ -11,13 +11,22 @@ internal sealed class GatewayDashboardLauncher( Func resolveCredential, Func> launchBrowser, Action reportFailure, - Action? reportOpened = null) + Action? reportOpened = null, + Func? isPersonalMode = null, + Func>? openPersonalDashboard = null) { internal const string FailureNotificationId = "setup-dashboard-launch"; public async Task OpenAsync(string? path = null) { try { + if (isPersonalMode?.Invoke() == true) + { + if (openPersonalDashboard is null || !await openPersonalDashboard(path)) + throw new InvalidOperationException("Personal Gateway identity is unavailable."); + reportOpened?.Invoke(); + return true; + } if (!ensureTunnel()) throw new InvalidOperationException("The Gateway tunnel is unavailable."); var credential = resolveCredential() diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDirectConnectService.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDirectConnectService.cs index 9627697326..afe70673d7 100644 --- a/src/OpenClaw.Tray.WinUI/Services/GatewayDirectConnectService.cs +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDirectConnectService.cs @@ -18,7 +18,8 @@ internal sealed record GatewayDirectConnectRequest( string? EditingGatewayId = null, bool PreserveExistingSharedTokenWhenMissing = false, string? BootstrapToken = null, - bool NativeSetup = false); + bool NativeSetup = false, + OperatorAuthenticationMode OperatorAuthentication = OperatorAuthenticationMode.GatewayCredential); internal sealed record GatewayDirectConnectResult( GatewayDirectConnectOutcome Outcome, @@ -63,6 +64,14 @@ public async Task ConnectAsync( CancellationToken cancellationToken = default, GatewayValidationIdentity? preparedIdentity = null) { + if (!Enum.IsDefined(request.OperatorAuthentication) || + request.OperatorAuthentication == OperatorAuthenticationMode.PersonalTailscale && + (request.NativeSetup || request.SshTunnel is not null || + !string.IsNullOrWhiteSpace(request.SharedToken) || !string.IsNullOrWhiteSpace(request.BootstrapToken) || + !GatewayPersonalAuthenticationPolicy.TryNormalizeGatewayUrl(request.GatewayUrl, out _, out _))) + return Failed(GatewayConnectionSnapshot.Idle, false, + "Personal Tailscale authentication requires a direct credential-free wss:// host.ts.net route."); + if (!GatewayUrlHelper.IsValidGatewayUrl(request.GatewayUrl)) { return Failed( @@ -365,6 +374,7 @@ internal static GatewayRecord BuildCandidate( { Id = recordId, Url = request.GatewayUrl, + OperatorAuthentication = request.OperatorAuthentication, FriendlyName = string.IsNullOrWhiteSpace(request.FriendlyName) ? existing?.FriendlyName : request.FriendlyName, diff --git a/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs b/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs index 964a8a1577..6c595e8d9d 100644 --- a/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs +++ b/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs @@ -11,6 +11,7 @@ internal interface IWindowManager Window? ActiveHubWindow { get; } bool IsHubOpen { get; } bool IsChatVisible { get; } + Task ShowPersonalDashboardAsync(string? path) => Task.FromResult(false); XamlRoot? DialogXamlRoot { get; } XamlRoot? RuntimeAnchorXamlRoot { get; } XamlRoot? SetupXamlRoot { get; } diff --git a/src/OpenClaw.Tray.WinUI/Services/WindowManager.PersonalDashboard.cs b/src/OpenClaw.Tray.WinUI/Services/WindowManager.PersonalDashboard.cs new file mode 100644 index 0000000000..a763f9c235 --- /dev/null +++ b/src/OpenClaw.Tray.WinUI/Services/WindowManager.PersonalDashboard.cs @@ -0,0 +1,51 @@ +using OpenClawTray.Windows; + +namespace OpenClawTray.Services; + +internal sealed partial class WindowManager +{ + private PersonalDashboardWindow? _personalDashboardWindow; + + public async Task ShowPersonalDashboardAsync(string? path = null) + { + if (_isShuttingDown || !_dispatcherQueue.HasThreadAccess) + return false; + + var manager = _callbacks.GetConnectionManager(); + var lease = manager?.CurrentPersonalOperatorLease; + if (manager is null || lease is null) + return false; + + if (_personalDashboardWindow is not null && !_personalDashboardWindow.CanReuseFor(lease)) + { + var retiring = _personalDashboardWindow; + await retiring.CloseAsync(); + if (ReferenceEquals(_personalDashboardWindow, retiring)) + _personalDashboardWindow = null; + if (_isShuttingDown || !ReferenceEquals(lease, manager.CurrentPersonalOperatorLease)) + return false; + } + + if (_personalDashboardWindow is not null && !_personalDashboardWindow.CanReuseFor(lease)) + return false; + + if (_personalDashboardWindow is null) + { + var window = new PersonalDashboardWindow(manager, lease, path); + _personalDashboardWindow = window; + window.Closed += (_, _) => + { + if (ReferenceEquals(_personalDashboardWindow, window)) + _personalDashboardWindow = null; + }; + _callbacks.ApplyTheme(window); + } + else + { + _personalDashboardWindow.NavigateToPath(path); + } + + _personalDashboardWindow.Activate(); + return true; + } +} diff --git a/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs b/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs index f937dc8a6e..95f6b5a10a 100644 --- a/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs +++ b/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs @@ -40,7 +40,7 @@ internal sealed record WindowManagerCallbacks( Func? GetLocalAiGatewayLifecycle = null, Func? PublishNativePreparation = null); -internal sealed class WindowManager : IWindowManager +internal sealed partial class WindowManager : IWindowManager { [DllImport("user32.dll")] [return: MarshalAs(UnmanagedType.Bool)] @@ -958,6 +958,7 @@ public void ApplyThemeToOpenWindows() _callbacks.ApplyTheme(_setupWindow); _callbacks.ApplyTheme(_readyWindow); _callbacks.ApplyTheme(_restartProgressWindow); + _callbacks.ApplyTheme(_personalDashboardWindow); } public void UpdateHubTitleBarStatus( @@ -1014,6 +1015,15 @@ public Task CloseForShutdownAsync() private async Task CloseOwnedWindowsAsync() { List? failures = null; + if (_personalDashboardWindow is { } personalDashboard) + { + try { await personalDashboard.CloseAsync(); } + catch (Exception ex) + { + (failures ??= []).Add(new InvalidOperationException("Personal Dashboard shutdown failed.", ex)); + } + _personalDashboardWindow = null; + } if (_workspaceWindow is not null) { diff --git a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw index c2cfa45f81..6ed8d83c33 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw @@ -8254,4 +8254,12 @@ After enrolling, return to Settings > Windows Update and check for updates. I {2}s This question is being resolved. Refresh to check its status. Choose a valid answer for each question. + Operator authentication + Gateway credential + Personal Tailscale identity + Requires a secure Tailscale Gateway address and personal identity support on the Gateway. No shared token is sent. + Personal sign-in changed + Reconnect this Gateway in OpenClaw Companion, then reopen the Dashboard. + Personal sign-in is unavailable. Reconnect in the app. + Personal sign-in requires a secure wss:// Tailscale Gateway address ending in .ts.net, without an SSH tunnel. diff --git a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw index 6727cc2c83..5057ad9545 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw @@ -8187,4 +8187,12 @@ Après votre inscription, revenez dans Paramètres > Windows Update et recher {2} s Cette question est en cours de résolution. Actualisez pour vérifier son état. Choisissez une réponse valide pour chaque question. + Authentification de l’opérateur + Identifiant de la passerelle + Identité Tailscale personnelle + Nécessite une adresse Tailscale sécurisée et la prise en charge de l’identité personnelle par la passerelle. Aucun jeton partagé n’est envoyé. + La connexion personnelle a changé + Reconnectez cette passerelle dans OpenClaw Companion, puis rouvrez le tableau de bord. + La connexion personnelle est indisponible. Reconnectez-vous dans l’application. + La connexion personnelle nécessite une adresse Gateway Tailscale sécurisée en wss:// se terminant par .ts.net, sans tunnel SSH. diff --git a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw index ea6a3bcae0..b9343036fd 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw @@ -8188,4 +8188,12 @@ Ga na inschrijving terug naar Instellingen > Windows Update en controleer op {2} s Deze vraag wordt afgehandeld. Vernieuw om de status te controleren. Kies een geldig antwoord voor elke vraag. + Operatorverificatie + Gatewayreferentie + Persoonlijke Tailscale-identiteit + Vereist een beveiligd Tailscale Gateway-adres en ondersteuning voor persoonlijke identiteit op de Gateway. Er wordt geen gedeeld token verzonden. + Persoonlijke aanmelding gewijzigd + Verbind deze Gateway opnieuw in OpenClaw Companion en open daarna het dashboard opnieuw. + Persoonlijke aanmelding is niet beschikbaar. Verbind opnieuw in de app. + Persoonlijke aanmelding vereist een beveiligd wss:// Tailscale Gateway-adres dat eindigt op .ts.net, zonder SSH-tunnel. diff --git a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw index a5293557f6..49bc2d486d 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw @@ -8239,4 +8239,12 @@ Após a inscrição, volte para Configurações > Windows Update e verifique {2} s Esta pergunta está sendo resolvida. Atualize para verificar seu status. Escolha uma resposta válida para cada pergunta. + Autenticação do operador + Credencial do Gateway + Identidade pessoal Tailscale + Requer um endereço Tailscale seguro e suporte à identidade pessoal no Gateway. Nenhum token compartilhado é enviado. + O acesso pessoal mudou + Reconecte este Gateway no OpenClaw Companion e reabra o painel. + O acesso pessoal está indisponível. Reconecte no aplicativo. + O acesso pessoal requer um endereço seguro wss:// do Gateway Tailscale terminado em .ts.net, sem túnel SSH. diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw index ab8de3a43d..65733944cc 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw @@ -8187,4 +8187,12 @@ {2}秒 正在处理此问题。请刷新以查看其状态。 请为每个问题选择有效的答案。 + 操作员身份验证 + 网关凭据 + 个人 Tailscale 身份 + 需要安全的 Tailscale 网关地址,且网关支持个人身份。不会发送共享令牌。 + 个人登录已更改 + 请在 OpenClaw Companion 中重新连接此网关,然后重新打开仪表板。 + 个人登录不可用。请在应用中重新连接。 + 个人登录需要以 .ts.net 结尾的安全 wss:// Tailscale Gateway 地址,且不能使用 SSH 隧道。 diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw index 262a59854c..e50c5df86e 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw @@ -8187,4 +8187,12 @@ {2}秒 正在處理此問題。請重新整理以查看其狀態。 請為每個問題選擇有效的答案。 + 操作員身分驗證 + 閘道憑證 + 個人 Tailscale 身分 + 需要安全的 Tailscale 閘道位址,且閘道支援個人身分。不會傳送共用權杖。 + 個人登入已變更 + 請在 OpenClaw Companion 中重新連線此閘道,然後重新開啟儀表板。 + 個人登入無法使用。請在應用程式中重新連線。 + 個人登入需要以 .ts.net 結尾的安全 wss:// Tailscale Gateway 位址,且不能使用 SSH 通道。 diff --git a/src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml b/src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml new file mode 100644 index 0000000000..adb8bbff83 --- /dev/null +++ b/src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml @@ -0,0 +1,24 @@ + + + + + + + + + + + + diff --git a/src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml.cs b/src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml.cs new file mode 100644 index 0000000000..9bb38892b8 --- /dev/null +++ b/src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml.cs @@ -0,0 +1,375 @@ +using Microsoft.UI.Xaml; +using Microsoft.UI.Windowing; +using Microsoft.UI.Dispatching; +using Microsoft.UI.Xaml.Controls; +using Microsoft.Web.WebView2.Core; +using System.Collections.Concurrent; +using System.Text.Json; +using OpenClaw.Connection; +using OpenClaw.Shared; +using OpenClawTray.Helpers; + +namespace OpenClawTray.Windows; + +public sealed partial class PersonalDashboardWindow : Window +{ + private static string UnavailableMessage => LocalizationHelper.GetString("PersonalDashboard_Unavailable"); + private readonly IGatewayConnectionManager _manager; + private readonly PersonalOperatorLease _initialLease; + private readonly string _expectedGatewayUrl; + private readonly ConcurrentDictionary _activeRequestIds = new(StringComparer.Ordinal); + private readonly ConcurrentDictionary _seenNonces = new(StringComparer.Ordinal); + private readonly string _profileName = "personal-" + Guid.NewGuid().ToString("N"); + private CoreWebView2Profile? _ownedProfile; + private CoreWebView2? _bridgeCore; + private bool _browserClosed; + private Task? _browserRetirementTask; + private Task? _closeTask; + private bool _profileDeletionRequested; + private bool _allowNativeClose; + private bool _retired; + private bool _closed; + private bool _initialized; + private long _navigationGeneration; + private string? _path; + + public PersonalDashboardWindow( + IGatewayConnectionManager manager, + PersonalOperatorLease lease, + string? path = null) + { + _manager = manager ?? throw new ArgumentNullException(nameof(manager)); + _initialLease = lease ?? throw new ArgumentNullException(nameof(lease)); + _expectedGatewayUrl = lease.GatewayUrl; + _path = path; + InitializeComponent(); + DashboardWebView.CoreWebView2Initialized += OnCoreInitialized; + _manager.StateChanged += OnManagerStateChanged; + AppWindow.Closing += OnClosing; + Closed += OnClosed; + _ = InitializeWebViewAsync(path); + } + + private async Task InitializeWebViewAsync(string? path) + { + try + { + var environment = await CoreWebView2Environment.CreateWithOptionsAsync(null, + System.IO.Path.Combine(AppIdentity.ResolveLocalDataDirectory(), "PersonalDashboard"), null); + if (_closed || _retired) + { + await CloseOwnedBrowserAsync(); + return; + } + var options = environment.CreateCoreWebView2ControllerOptions(); + options.ProfileName = _profileName; + options.IsInPrivateModeEnabled = true; + await DashboardWebView.EnsureCoreWebView2Async(environment, options); + var core = DashboardWebView.CoreWebView2; + if (core is null) + { + if (_closed || _retired) return; + throw new InvalidOperationException("Personal browser initialization is unavailable."); + } + var profile = core.Profile; + if (!string.Equals(profile.ProfileName, _profileName, StringComparison.OrdinalIgnoreCase)) + throw new InvalidOperationException("Personal browser profile ownership changed."); + _ownedProfile = profile; + if (_closed || _retired) + { + await CloseOwnedBrowserAsync(); + return; + } + + core.Settings.IsStatusBarEnabled = false; + core.Settings.IsPasswordAutosaveEnabled = false; + core.Settings.IsGeneralAutofillEnabled = false; + core.Settings.AreDefaultContextMenusEnabled = true; + core.NavigationStarting += OnNavigationStarting; + core.NewWindowRequested += OnNewWindowRequested; + _bridgeCore = core; + core.WebMessageReceived += (_, args) => OnWebMessageReceived(core, args); + await core.AddScriptToExecuteOnDocumentCreatedAsync( + PersonalGatewayNativeBridgeScript.Create(_expectedGatewayUrl)); + _initialized = true; + + var lease = _manager.CurrentPersonalOperatorLease; + if (!ReferenceEquals(lease, _initialLease)) + { + RetireForAuthorityChange(); + return; + } + + NavigateToPath(_path); + } + catch (Exception ex) + { + new OpenClawTray.AppLogger().Warn($"Personal browser initialization failed ({ex.GetType().Name}, 0x{ex.HResult:X8})."); + _retired = true; + await CloseOwnedBrowserAsync(); + if (!_closed) ShowRecoveryPanel(); + } + } + + private void OnCoreInitialized(WebView2 sender, CoreWebView2InitializedEventArgs args) + { + try + { + var profile = sender.CoreWebView2?.Profile; + if (profile is not null && string.Equals(profile.ProfileName, _profileName, StringComparison.OrdinalIgnoreCase)) + { + _ownedProfile = profile; + if (_closed || _retired) _ = CloseOwnedBrowserAsync(); + } + } + catch (System.Runtime.InteropServices.COMException) + { + if (!_closed && !_retired) + new OpenClawTray.AppLogger().Warn("Personal browser profile ownership could not be captured."); + } + } + + public void NavigateToPath(string? path) + { + _path = path; + if (!_initialized || _retired || DashboardWebView.CoreWebView2 is null || + !ReferenceEquals(_manager.CurrentPersonalOperatorLease, _initialLease)) + { + return; + } + + var url = GatewayDashboardUrlBuilder.Build( + _expectedGatewayUrl, path, null, appendSharedGatewayToken: false); + DashboardWebView.CoreWebView2.Navigate(url); + } + + internal bool CanReuseFor(PersonalOperatorLease lease) => + PersonalDashboardWindowReusePolicy.CanReuse( + _manager.CurrentPersonalOperatorLease, _initialLease, lease, _closed, _retired); + + private void OnNavigationStarting(CoreWebView2 sender, CoreWebView2NavigationStartingEventArgs args) + { + _navigationGeneration++; + if (!GatewayPersonalAuthenticationPolicy.IsTrustedDashboardSource(args.Uri, _expectedGatewayUrl) && + !string.Equals(args.Uri, "about:blank", StringComparison.OrdinalIgnoreCase)) + args.Cancel = true; + } + + private static void OnNewWindowRequested(CoreWebView2 sender, CoreWebView2NewWindowRequestedEventArgs args) => + args.Handled = true; + + private void OnWebMessageReceived(CoreWebView2 sender, CoreWebView2WebMessageReceivedEventArgs args) => + AsyncEventHandlerGuard.Run( + () => OnWebMessageReceivedAsync(sender, args), + new OpenClawTray.AppLogger(), + nameof(OnWebMessageReceived)); + + private async Task OnWebMessageReceivedAsync(CoreWebView2 sender, CoreWebView2WebMessageReceivedEventArgs args) + { + if (_closed || _retired || !ReferenceEquals(sender, _bridgeCore) || !PersonalGatewayAuthChallengeParser.TryParse( + args.WebMessageAsJson, args.Source, _expectedGatewayUrl, out var challenge) || + challenge == null) + { + return; + } + + if (!_activeRequestIds.TryAdd(challenge.Id, 0)) + { + ReplyError(sender, challenge.Id); + return; + } + + if (!TryRegisterNonce(challenge.Nonce, challenge.SignedAt)) + { + _activeRequestIds.TryRemove(challenge.Id, out _); + ReplyError(sender, challenge.Id); + return; + } + + var navigationGeneration = _navigationGeneration; + try + { + var lease = _manager.CurrentPersonalOperatorLease; + if (!ReferenceEquals(lease, _initialLease)) + { + ReplyError(sender, challenge.Id); + RetireForAuthorityChange(); + return; + } + + var responseJson = await _manager.CreatePersonalBrowserAuthResponseAsync( + challenge.Nonce, challenge.SignedAt); + if (responseJson == null || _closed || _retired || navigationGeneration != _navigationGeneration || + !ReferenceEquals(sender, _bridgeCore) || + !GatewayPersonalAuthenticationPolicy.IsTrustedDashboardSource(sender.Source, _expectedGatewayUrl) || + !ReferenceEquals(_manager.CurrentPersonalOperatorLease, _initialLease)) + { + if (!_closed && !_retired && navigationGeneration == _navigationGeneration) + ReplyError(sender, challenge.Id); + return; + } + + using var response = JsonDocument.Parse(responseJson); + sender.PostWebMessageAsJson(JsonSerializer.Serialize(new + { + id = challenge.Id, + result = response.RootElement + })); + } + catch + { + if (!_closed && !_retired && navigationGeneration == _navigationGeneration) + ReplyError(sender, challenge.Id); + } + finally + { + _activeRequestIds.TryRemove(challenge.Id, out _); + } + } + + private bool TryRegisterNonce(string nonce, long signedAt) + { + var now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); + foreach (var entry in _seenNonces) + { + if (entry.Value < now - 300_000) + _seenNonces.TryRemove(entry.Key, out _); + } + + if (_seenNonces.Count >= 1024 || Math.Abs(now - signedAt) > 300_000) + return false; + return _seenNonces.TryAdd(nonce, signedAt); + } + + private static void ReplyError(CoreWebView2 core, string id) + { + try + { + core.PostWebMessageAsJson(JsonSerializer.Serialize(new { id, error = UnavailableMessage })); + } + catch + { + // The WebView can close while a native challenge is in flight. + } + } + + private void OnManagerStateChanged(object? sender, GatewayConnectionSnapshot snapshot) + { + if (ReferenceEquals(_manager.CurrentPersonalOperatorLease, _initialLease)) + return; + DispatcherQueue?.TryEnqueue(RetireForAuthorityChange); + } + + private void RetireForAuthorityChange() => AsyncEventHandlerGuard.Run( + RetireAsync, new OpenClawTray.AppLogger(), nameof(RetireForAuthorityChange)); + + private async Task RetireAsync() + { + if (_retired) return; + _retired = true; + await CloseOwnedBrowserAsync(); + if (!_closed) ShowRecoveryPanel(); + } + + public new void Close() => AsyncEventHandlerGuard.Run( + CloseAsync, new OpenClawTray.AppLogger(), nameof(Close)); + + internal Task CloseAsync() => _closeTask ??= CloseCoreAsync(); + + private async Task CloseCoreAsync() + { + _retired = true; + try { await CloseOwnedBrowserAsync(); } + finally + { + _allowNativeClose = true; + base.Close(); + } + } + + private Task CloseOwnedBrowserAsync() + { + if (_ownedProfile is { } profile && !_profileDeletionRequested) + { + _profileDeletionRequested = true; + return _browserRetirementTask = DeleteProfileAndCloseAsync(profile); + } + if (_browserRetirementTask is not null) return _browserRetirementTask; + CloseBrowserControl(); + return Task.CompletedTask; + } + + private async Task DeleteProfileAndCloseAsync(CoreWebView2Profile profile) + { + var deleted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + void OnDeleted(CoreWebView2Profile sender, object args) => deleted.TrySetResult(); + var subscribed = false; + try + { + // CoreWebView2Initialized precedes completion of EnsureCoreWebView2Async. + if (!_initialized) await DrainDispatcherAsync(); + profile.Deleted += OnDeleted; + subscribed = true; + profile.Delete(); + // Delete marks the profile synchronously; a missed callback must not block shutdown. + await Task.WhenAny(deleted.Task, DrainDispatcherAsync()); + } + catch (System.Runtime.InteropServices.COMException) + { + new OpenClawTray.AppLogger().Warn("Personal browser profile cleanup was unavailable."); + } + finally + { + try + { + if (subscribed) profile.Deleted -= OnDeleted; + } + catch (System.Runtime.InteropServices.COMException) + { + } + finally + { + CloseBrowserControl(); + } + } + } + + private Task DrainDispatcherAsync() + { + var drained = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + if (!DispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, () => drained.TrySetResult())) + drained.TrySetResult(); + return drained.Task; + } + + private void CloseBrowserControl() + { + if (_browserClosed) return; + _browserClosed = true; + _bridgeCore = null; + DashboardWebView.Close(); + } + + private void OnClosing(AppWindow sender, AppWindowClosingEventArgs args) + { + if (_allowNativeClose) return; + args.Cancel = true; + Close(); + } + + private void ShowRecoveryPanel() + { + DashboardWebView.Visibility = Visibility.Collapsed; + RecoveryPanel.Visibility = Visibility.Visible; + } + + private void OnClosed(object sender, WindowEventArgs args) + { + _closed = true; + _retired = true; + _manager.StateChanged -= OnManagerStateChanged; + AppWindow.Closing -= OnClosing; + _ = CloseOwnedBrowserAsync(); + } + +} diff --git a/tests/OpenClaw.Connection.Tests/CredentialResolverTests.cs b/tests/OpenClaw.Connection.Tests/CredentialResolverTests.cs index bfd708341c..211efa5756 100644 --- a/tests/OpenClaw.Connection.Tests/CredentialResolverTests.cs +++ b/tests/OpenClaw.Connection.Tests/CredentialResolverTests.cs @@ -13,6 +13,21 @@ public CredentialResolverTests() _resolver = new CredentialResolver(_mockReader); } + [Fact] + public void PersonalOperatorIgnoresStoredOperatorCredentialsAndPreservesNodeResolution() + { + var record = new GatewayRecord { Id = "personal", Url = "wss://fixture.example.ts.net", + OperatorAuthentication = OperatorAuthenticationMode.PersonalTailscale, + SharedGatewayToken = "shared", BootstrapToken = "bootstrap" }; + _mockReader.OperatorReadResult = DeviceTokenReadResult.Corrupt("must not be used"); + _mockReader.NodeToken = "node-token"; + var personal = Assert.IsType(_resolver.ResolveOperator(record, "/fixture")); + Assert.Empty(personal.Token); + Assert.Equal(OperatorAuthenticationMode.PersonalTailscale, personal.OperatorAuthentication); + Assert.Equal("node-token", _resolver.ResolveNode(record, "/fixture")!.Token); + Assert.Equal("shared", record.SharedGatewayToken); + } + // ─── Operator resolution ─── [Fact] diff --git a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs new file mode 100644 index 0000000000..f42d414dcc --- /dev/null +++ b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs @@ -0,0 +1,196 @@ +using System.Text.Json; +using OpenClaw.Shared; +using OpenClaw.TestSupport; + +namespace OpenClaw.Connection.Tests; + +public sealed class GatewayConnectionManagerPersonalIdentityTests +{ + [Fact] + public async Task PersonalConnectionPublishesOnlyAfterCurrentSocketSelfVerificationAndNeverUsesSavedToken() + { + await using var harness = new Harness(); + var peer = await harness.HelloAsync(); + var self = await peer.ReceiveAsync(); + Assert.Equal("users.self", self.GetProperty("method").GetString()); + Assert.Null(harness.Manager.CurrentPersonalOperatorLease); + Assert.NotEqual(RoleConnectionState.Connected, harness.Manager.CurrentSnapshot.OperatorState); + await peer.SelfAsync(self); + await harness.WaitAsync(RoleConnectionState.Connected); + var lease = Assert.IsType(harness.Manager.CurrentPersonalOperatorLease); + Assert.Equal("person-42", lease.IdentityProfileId); + Assert.Equal("fixture-scope", lease.RecoveryScope); + var signing = harness.Manager.CreatePersonalBrowserAuthResponseAsync("browser-nonce", DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()); + var refresh = await peer.ReceiveAsync(); + Assert.Equal("users.self", refresh.GetProperty("method").GetString()); + await peer.SelfAsync(refresh); + using var response = JsonDocument.Parse(Assert.IsType(await signing)); + Assert.Empty(response.RootElement.GetProperty("auth").EnumerateObject()); + Assert.Equal("tailscale", response.RootElement.GetProperty("requiredAuthMethod").GetString()); + Assert.Equal(lease.RecoveryScope, response.RootElement.GetProperty("expectedRecoveryScope").GetString()); + Assert.Equal(lease.DeviceId, response.RootElement.GetProperty("device").GetProperty("id").GetString()); + Assert.Equal("saved-shared", harness.Registry.GetById("personal")!.SharedGatewayToken); + await harness.Manager.DisconnectAsync(); + Assert.Null(harness.Manager.CurrentPersonalOperatorLease); + } + + [Fact] + public async Task MissingCanonicalSelfProfileRejectsPersonalConnection() + { + await using var harness = new Harness(); + var peer = await harness.HelloAsync(); + var self = await peer.ReceiveAsync(); + await peer.SelfAsync(self, null); + await harness.WaitAsync(RoleConnectionState.Error); + Assert.Null(harness.Manager.CurrentPersonalOperatorLease); + Assert.Null(harness.Manager.CurrentSnapshot.PersonalIdentityProfileId); + } + + [Fact] + public async Task PendingIdentityReadDoesNotBlockDisconnectOrPublishAnOldLease() + { + await using var harness = new Harness(); + var first = await harness.HelloAsync(); + Assert.Equal("users.self", (await first.ReceiveAsync()).GetProperty("method").GetString()); + await harness.Manager.DisconnectAsync().WaitAsync(TimeSpan.FromSeconds(5)); + Assert.Null(harness.Manager.CurrentPersonalOperatorLease); + var second = await harness.HelloAsync(); + var self = await second.ReceiveAsync(); + await second.SelfAsync(self, "replacement-person"); + await harness.WaitAsync(RoleConnectionState.Connected); + Assert.Equal("replacement-person", harness.Manager.CurrentPersonalOperatorLease!.IdentityProfileId); + } + + [Fact] + public async Task BrowserProfileChangeRetiresOnlyItsCurrentPersonalConnection() + { + await using var harness = new Harness(); + var peer = await harness.HelloAsync(); + await peer.SelfAsync(await peer.ReceiveAsync()); + await harness.WaitAsync(RoleConnectionState.Connected); + var signing = harness.Manager.CreatePersonalBrowserAuthResponseAsync("browser-nonce", DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()); + await peer.SelfAsync(await peer.ReceiveAsync(), "different-person"); + Assert.Null(await signing); + Assert.Null(harness.Manager.CurrentPersonalOperatorLease); + Assert.NotEqual(RoleConnectionState.Connected, harness.Manager.CurrentSnapshot.OperatorState); + } + + [Fact] + public async Task InvalidBrowserChallengesNeverProducePersonalProof() + { + await using var harness = new Harness(); + var peer = await harness.HelloAsync(); + await peer.SelfAsync(await peer.ReceiveAsync()); + await harness.WaitAsync(RoleConnectionState.Connected); + foreach (var nonce in new[] { "", "a|b", "a\n", "\uFEFFnonce", new string('é', 257) }) + Assert.Null(await harness.Manager.CreatePersonalBrowserAuthResponseAsync(nonce, DateTimeOffset.UtcNow.ToUnixTimeMilliseconds())); + Assert.Null(await harness.Manager.CreatePersonalBrowserAuthResponseAsync("expired", 1)); + Assert.NotNull(harness.Manager.CurrentPersonalOperatorLease); + } + + [Fact] + public async Task RetiredBrowserReadCannotRevokeReplacementLease() + { + await using var harness = new Harness(); + var first = await harness.HelloAsync(); + await first.SelfAsync(await first.ReceiveAsync()); + await harness.WaitAsync(RoleConnectionState.Connected); + var oldLease = harness.Manager.CurrentPersonalOperatorLease; + var signing = harness.Manager.CreatePersonalBrowserAuthResponseAsync("browser-nonce", DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()); + Assert.Equal("users.self", (await first.ReceiveAsync()).GetProperty("method").GetString()); + await harness.Manager.DisconnectAsync().WaitAsync(TimeSpan.FromSeconds(5)); + var replacement = await harness.HelloAsync(); + await replacement.SelfAsync(await replacement.ReceiveAsync(), "replacement-person"); + await harness.WaitAsync(RoleConnectionState.Connected); + var currentLease = harness.Manager.CurrentPersonalOperatorLease; + Assert.Null(await signing); + Assert.NotSame(oldLease, currentLease); + Assert.Same(currentLease, harness.Manager.CurrentPersonalOperatorLease); + Assert.Equal("replacement-person", currentLease!.IdentityProfileId); + } + + private sealed class Harness : IAsyncDisposable, IGatewayClientFactory + { + private readonly TempDirectory _directory = new("personal-manager-wire-"); + private readonly List _peers = []; + public GatewayRegistry Registry { get; } + public GatewayConnectionManager Manager { get; } + + public Harness() + { + Registry = new GatewayRegistry(_directory.Path); + Registry.AddOrUpdate(new GatewayRecord { Id = "personal", Url = PersonalGatewayProtocolFixture.Route, + OperatorAuthentication = OperatorAuthenticationMode.PersonalTailscale, + SharedGatewayToken = "saved-shared", BootstrapToken = "saved-bootstrap" }); + Registry.SetActive("personal"); + Manager = new GatewayConnectionManager(new CredentialResolver(new NoOperatorTokenReads()), this, Registry, NullLogger.Instance); + } + + public IGatewayClientLifecycle Create(string gatewayUrl, GatewayCredential credential, string identityPath, IOpenClawLogger logger) + { + Assert.Empty(credential.Token); + Assert.Equal(OperatorAuthenticationMode.PersonalTailscale, credential.OperatorAuthentication); + var peer = new PersonalGatewayProtocolFixture(); + _peers.Add(peer); + return new Lifecycle(peer.CreateClient(identityPath)); + } + + public async Task HelloAsync() + { + await Manager.ConnectAsync("personal"); + var peer = _peers[^1]; + await peer.ChallengeAsync(); + var connect = await peer.ReceiveAsync(); + Assert.Equal("connect", connect.GetProperty("method").GetString()); + Assert.Empty(connect.GetProperty("params").GetProperty("auth").EnumerateObject()); + await peer.HelloAsync(connect); + return peer; + } + + public async Task WaitAsync(RoleConnectionState state) + { + var changed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + void OnState(object? sender, GatewayConnectionSnapshot snapshot) + { + if (snapshot.OperatorState == state) changed.TrySetResult(); + } + Manager.StateChanged += OnState; + try + { + if (Manager.CurrentSnapshot.OperatorState == state) return; + await changed.Task.WaitAsync(TimeSpan.FromSeconds(5)); + } + finally { Manager.StateChanged -= OnState; } + } + + public async ValueTask DisposeAsync() + { + Manager.Dispose(); + foreach (var peer in _peers) await peer.DisposeAsync(); + _directory.Dispose(); + } + } + + private sealed class NoOperatorTokenReads : IDeviceIdentityReader + { + public string? TryReadStoredDeviceToken(string dataPath) => throw new InvalidOperationException("Personal mode read a saved operator token."); + public string? TryReadStoredNodeDeviceToken(string dataPath) => null; + } + + private sealed class Lifecycle(OpenClawGatewayClient client) : IGatewayClientLifecycle + { + public OpenClawGatewayClient DataClient => client; + public event EventHandler? StatusChanged + { + add => client.StatusChanged += value; + remove => client.StatusChanged -= value; + } + public event EventHandler? AuthenticationFailed + { + add => client.AuthenticationFailed += value; + remove => client.AuthenticationFailed -= value; + } + public Task ConnectAsync(CancellationToken ct) => client.ConnectAsync(); + public void Dispose() => client.Dispose(); + } +} diff --git a/tests/OpenClaw.Connection.Tests/GatewayPersonalAuthenticationPolicyTests.cs b/tests/OpenClaw.Connection.Tests/GatewayPersonalAuthenticationPolicyTests.cs new file mode 100644 index 0000000000..77f885d070 --- /dev/null +++ b/tests/OpenClaw.Connection.Tests/GatewayPersonalAuthenticationPolicyTests.cs @@ -0,0 +1,54 @@ +using System.Text.Json; + +namespace OpenClaw.Connection.Tests; + +public sealed class GatewayPersonalAuthenticationPolicyTests +{ + [Theory] + [InlineData("wss://node.example.ts.net", "wss://node.example.ts.net")] + [InlineData("wss://node.example.ts.net:443/", "wss://node.example.ts.net")] + [InlineData("wss://node.example.ts.net:9443/", "wss://node.example.ts.net:9443")] + [InlineData("wss://node.example.ts.net/gateway", "wss://node.example.ts.net/gateway")] + public void TryNormalizeGatewayUrl_AcceptsCredentialFreeTailscaleTlsRoutes(string input, string expected) + { + Assert.True(GatewayPersonalAuthenticationPolicy.TryNormalizeGatewayUrl(input, out var route, out _)); + Assert.Equal(expected, route); + } + + [Theory] + [InlineData("ws://node.example.ts.net")] + [InlineData("wss://node.example.com")] + [InlineData("wss://ts.net")] + [InlineData("wss://user:password@node.example.ts.net")] + [InlineData("wss://node.example.ts.net/?token=secret")] + [InlineData("wss://node.example.ts.net/#token=secret")] + [InlineData("wss://node.example.ts.net:0")] + public void TryNormalizeGatewayUrl_RejectsNonPersonalOrCredentialBearingRoutes(string input) + { + Assert.False(GatewayPersonalAuthenticationPolicy.TryNormalizeGatewayUrl(input, out _, out _)); + } + + [Fact] + public void TryGetCanonicalProfileId_RequiresNonemptyProfileId() + { + using var valid = JsonDocument.Parse("{\"profile\":{\"id\":\"person-42\"}}"); + using var missing = JsonDocument.Parse("{\"profile\":{\"name\":\"V\"}}"); + using var whitespace = JsonDocument.Parse("{\"profile\":{\"id\":\" \"}}"); + + Assert.True(GatewayPersonalAuthenticationPolicy.TryGetCanonicalProfileId(valid.RootElement, out var id)); + Assert.Equal("person-42", id); + Assert.False(GatewayPersonalAuthenticationPolicy.TryGetCanonicalProfileId(missing.RootElement, out _)); + Assert.False(GatewayPersonalAuthenticationPolicy.TryGetCanonicalProfileId(whitespace.RootElement, out _)); + } + + [Fact] + public void IsTrustedDashboardSource_MatchesTheConfiguredTlsPort() + { + Assert.True(GatewayPersonalAuthenticationPolicy.IsTrustedDashboardSource( + "https://node.example.ts.net:9443/chat", "wss://node.example.ts.net:9443")); + Assert.False(GatewayPersonalAuthenticationPolicy.IsTrustedDashboardSource( + "https://node.example.ts.net:9444/chat", "wss://node.example.ts.net:9443")); + Assert.False(GatewayPersonalAuthenticationPolicy.IsTrustedDashboardSource( + "https://node.example.ts.net/chat", "wss://node.example.ts.net:9443")); + } +} diff --git a/tests/OpenClaw.Shared.Tests/PersonalTailscaleGatewayClientTests.cs b/tests/OpenClaw.Shared.Tests/PersonalTailscaleGatewayClientTests.cs new file mode 100644 index 0000000000..47cd2e126d --- /dev/null +++ b/tests/OpenClaw.Shared.Tests/PersonalTailscaleGatewayClientTests.cs @@ -0,0 +1,82 @@ +using System.Text.Json; +using OpenClaw.TestSupport; +using Xunit; + +namespace OpenClaw.Shared.Tests; + +public sealed class PersonalTailscaleGatewayClientTests +{ + [Fact] + public async Task CurrentSocketRequiresPersonalHelloAndVerifiedProfileBeforeApplicationReadiness() + { + using var identity = new TempDirectory("personal-wire-"); + await using var peer = new PersonalGatewayProtocolFixture(); + using var client = peer.CreateClient(identity.Path); + var hello = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + client.HandshakeSucceeded += (_, _) => hello.TrySetResult(); + await client.ConnectAsync(); + await peer.ChallengeAsync(); + var connect = await peer.ReceiveAsync(); + Assert.Equal("connect", connect.GetProperty("method").GetString()); + var parameters = connect.GetProperty("params"); + Assert.Empty(parameters.GetProperty("auth").EnumerateObject()); + Assert.Equal("gateway-client", parameters.GetProperty("client").GetProperty("id").GetString()); + Assert.Equal("ui", parameters.GetProperty("client").GetProperty("mode").GetString()); + Assert.False(string.IsNullOrWhiteSpace(parameters.GetProperty("device").GetProperty("signature").GetString())); + await peer.HelloAsync(connect); + await hello.Task.WaitAsync(TimeSpan.FromSeconds(5)); + Assert.False(client.IsConnectedToGateway); + Assert.Null(client.SessionMutationConnectionEpoch); + var epoch = Assert.IsType(client.PersonalHandshakeConnectionEpoch); + Assert.Throws(() => client.CreatePersonalBrowserAuthResponse("nonce", 1, epoch)); + var reading = client.ReadPersonalIdentityAsync(epoch); + var self = await peer.ReceiveAsync(); + Assert.Equal("users.self", self.GetProperty("method").GetString()); + await peer.SelfAsync(self); + var profile = await reading; + client.VerifyPersonalIdentity(profile.GetProperty("profile").GetProperty("id").GetString()!, epoch); + Assert.True(client.IsConnectedToGateway); + using var signed = JsonDocument.Parse(JsonSerializer.Serialize(client.CreatePersonalBrowserAuthResponse("browser-nonce", DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(), epoch))); + Assert.Empty(signed.RootElement.GetProperty("auth").EnumerateObject()); + Assert.Equal("tailscale", signed.RootElement.GetProperty("requiredAuthMethod").GetString()); + Assert.Equal("fixture-scope", signed.RootElement.GetProperty("expectedRecoveryScope").GetString()); + Assert.Equal(client.AuthenticatedSigningDeviceId, signed.RootElement.GetProperty("device").GetProperty("id").GetString()); + await client.DisconnectAsync(); + Assert.Null(client.PersonalHandshakeConnectionEpoch); + Assert.False(client.IsConnectedToGateway); + Assert.Throws(() => client.CreatePersonalBrowserAuthResponse("late", 1, epoch)); + } + + [Theory] + [InlineData("token", "fixture-scope")] + [InlineData("tailscale", "")] + [InlineData("tailscale", " ")] + [InlineData("", "fixture-scope")] + public async Task HelloWithWrongMethodOrMissingScopeNeverPublishesPersonalReadiness(string method, string scope) + { + using var identity = new TempDirectory("personal-invalid-wire-"); + await using var peer = new PersonalGatewayProtocolFixture(); + using var client = peer.CreateClient(identity.Path); + var failed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + client.AuthenticationFailed += (_, _) => failed.TrySetResult(); + await client.ConnectAsync(); + await peer.ChallengeAsync(); + var connect = await peer.ReceiveAsync(); + await peer.HelloAsync(connect, method, scope); + await failed.Task.WaitAsync(TimeSpan.FromSeconds(5)); + Assert.Null(client.PersonalHandshakeConnectionEpoch); + Assert.False(client.IsConnectedToGateway); + } + + [Theory] + [InlineData("ws://protocol.example.ts.net", "")] + [InlineData("wss://127.0.0.1", "")] + [InlineData("wss://protocol.example.ts.net?token=private", "")] + [InlineData("wss://protocol.example.ts.net", "shared")] + public void PersonalConstructorRejectsUnsafeRoutesAndMixedCredentials(string route, string token) + { + using var identity = new TempDirectory("personal-route-"); + Assert.Throws(() => new OpenClawGatewayClient(route, token, + identityPath: identity.Path, operatorAuthentication: OperatorAuthenticationMode.PersonalTailscale)); + } +} diff --git a/tests/OpenClaw.TestSupport/PersonalGatewayProtocolFixture.cs b/tests/OpenClaw.TestSupport/PersonalGatewayProtocolFixture.cs new file mode 100644 index 0000000000..285b04e29a --- /dev/null +++ b/tests/OpenClaw.TestSupport/PersonalGatewayProtocolFixture.cs @@ -0,0 +1,127 @@ +using System.Net; +using System.Net.Sockets; +using System.Net.WebSockets; +using System.Reflection; +using System.Security.Cryptography; +using System.Text; +using System.Text.Json; +using System.Threading.Channels; +using OpenClaw.Shared; + +namespace OpenClaw.TestSupport; + +public sealed class PersonalGatewayProtocolFixture : IAsyncDisposable +{ + public const string Route = "wss://protocol.example.ts.net"; + private readonly TcpListener _listener = new(IPAddress.Loopback, 0); + private readonly CancellationTokenSource _lifetime = new(); + private readonly Task _socket; + private TcpClient? _tcp; + private Task? _pump; + private readonly Channel _frames = Channel.CreateUnbounded(); + + public PersonalGatewayProtocolFixture() + { + _listener.Start(); + _socket = AcceptAsync(); + } + + public OpenClawGatewayClient CreateClient(string identityPath) + { + var client = new OpenClawGatewayClient(Route, string.Empty, + identityPath: identityPath, operatorAuthentication: OperatorAuthenticationMode.PersonalTailscale); + typeof(WebSocketClientBase).GetField("_gatewayUrl", BindingFlags.Instance | BindingFlags.NonPublic)! + .SetValue(client, $"ws://127.0.0.1:{((IPEndPoint)_listener.LocalEndpoint).Port}/"); + return client; + } + + private async Task AcceptAsync() + { + _tcp = await _listener.AcceptTcpClientAsync(_lifetime.Token); + var stream = _tcp.GetStream(); + var header = new StringBuilder(); + var one = new byte[1]; + while (!header.ToString().EndsWith("\r\n\r\n", StringComparison.Ordinal)) + { + if (header.Length >= 16384 || await stream.ReadAsync(one, _lifetime.Token) == 0) + throw new IOException("Invalid fixture upgrade."); + header.Append((char)one[0]); + } + var key = header.ToString().Split("\r\n") + .Single(line => line.StartsWith("Sec-WebSocket-Key:", StringComparison.OrdinalIgnoreCase)).Split(':', 2)[1].Trim(); + var accept = Convert.ToBase64String(SHA1.HashData(Encoding.ASCII.GetBytes(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"))); + await stream.WriteAsync(Encoding.ASCII.GetBytes("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: " + accept + "\r\n\r\n"), _lifetime.Token); + var socket = WebSocket.CreateFromStream(stream, isServer: true, subProtocol: null, keepAliveInterval: Timeout.InfiniteTimeSpan); + _pump = PumpAsync(socket); + return socket; + } + + public async Task ChallengeAsync() => await SendAsync(new + { + type = "event", @event = "connect.challenge", payload = new { nonce = "fixture-challenge", ts = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() } + }); + + public async Task ReceiveAsync() => + await _frames.Reader.ReadAsync(_lifetime.Token).AsTask().WaitAsync(TimeSpan.FromSeconds(5)); + + private async Task PumpAsync(WebSocket socket) + { + try + { + while (!_lifetime.IsCancellationRequested) + { + using var frame = new MemoryStream(); + var buffer = new byte[8192]; + WebSocketReceiveResult result; + do + { + result = await socket.ReceiveAsync(new ArraySegment(buffer), _lifetime.Token); + if (result.MessageType == WebSocketMessageType.Close) + { + await socket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Fixture closed", _lifetime.Token); + _frames.Writer.TryComplete(); + return; + } + if (result.MessageType != WebSocketMessageType.Text) throw new IOException("Expected fixture text frame."); + frame.Write(buffer, 0, result.Count); + } while (!result.EndOfMessage); + using var json = JsonDocument.Parse(frame.ToArray()); + await _frames.Writer.WriteAsync(json.RootElement.Clone(), _lifetime.Token); + } + } + catch (Exception ex) when (ex is OperationCanceledException or ObjectDisposedException or WebSocketException or IOException) + { + _frames.Writer.TryComplete(ex); + } + } + + public async Task SendAsync(object value) + { + var socket = await _socket.WaitAsync(TimeSpan.FromSeconds(5)); + await socket.SendAsync(new ArraySegment(JsonSerializer.SerializeToUtf8Bytes(value)), WebSocketMessageType.Text, true, _lifetime.Token); + } + + public Task HelloAsync(JsonElement connect, string method = "tailscale", string scope = "fixture-scope") => SendAsync(new + { + type = "res", id = connect.GetProperty("id").GetString(), ok = true, + payload = new { type = "hello-ok", protocol = GatewayProtocolContract.CurrentVersion, + auth = new { method, recoveryScope = scope, deviceId = "fixture-operator", scopes = new[] { "operator.read", "operator.write" } } } + }); + + public Task SelfAsync(JsonElement request, string? profile = "person-42") => SendAsync(new + { + type = "res", id = request.GetProperty("id").GetString(), ok = true, + payload = new { profile = new { id = profile } } + }); + + public async ValueTask DisposeAsync() + { + _lifetime.Cancel(); + _listener.Stop(); + _tcp?.Dispose(); + try { (await _socket).Dispose(); } + catch (Exception ex) when (ex is OperationCanceledException or ObjectDisposedException or SocketException or IOException) { } + if (_pump is not null) await _pump; + _lifetime.Dispose(); + } +} diff --git a/tests/OpenClaw.Tray.Tests/GatewayDirectConnectServiceTests.cs b/tests/OpenClaw.Tray.Tests/GatewayDirectConnectServiceTests.cs index c5fe1030c5..2653f073c1 100644 --- a/tests/OpenClaw.Tray.Tests/GatewayDirectConnectServiceTests.cs +++ b/tests/OpenClaw.Tray.Tests/GatewayDirectConnectServiceTests.cs @@ -8,6 +8,21 @@ namespace OpenClaw.Tray.Tests; public sealed class GatewayDirectConnectServiceTests : IDisposable { + [Theory] + [InlineData("ws://fixture.example.ts.net", null, false)] + [InlineData("wss://fixture.example.com", null, false)] + [InlineData("wss://fixture.example.ts.net", "shared", false)] + [InlineData("wss://fixture.example.ts.net", null, true)] + public async Task InvalidPersonalRequestCannotMutateRegistryOrStartConnection(string url, string? token, bool nativeSetup) + { + var previous = AddPreviousGateway(); + var result = await CreateService().ConnectAsync(new(url, token, null, null, + NativeSetup: nativeSetup, OperatorAuthentication: OperatorAuthenticationMode.PersonalTailscale)); + Assert.False(result.GatewayCommitted); + Assert.Equal(previous.Id, _registry.ActiveGatewayId); + Assert.Equal(0, _manager.ConnectCount); + } + [Theory] [InlineData(false)] [InlineData(true)] diff --git a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj index 4d13d430af..2065540e97 100644 --- a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj +++ b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj @@ -209,6 +209,10 @@ + + + + diff --git a/tests/OpenClaw.Tray.Tests/PersonalDashboardNativeBridgeTests.cs b/tests/OpenClaw.Tray.Tests/PersonalDashboardNativeBridgeTests.cs new file mode 100644 index 0000000000..c079b282e6 --- /dev/null +++ b/tests/OpenClaw.Tray.Tests/PersonalDashboardNativeBridgeTests.cs @@ -0,0 +1,42 @@ +using System.Text.Json; +using OpenClaw.Connection; +using OpenClawTray.Helpers; + +namespace OpenClaw.Tray.Tests; + +public sealed class PersonalDashboardNativeBridgeTests +{ + [Fact] + public void NativeBridgeScriptSelectsPersonalAuthAdapterBeforeBridgeStartup() + { + const string gatewayUrl = "wss://node.example.ts.net:9443"; + var script = PersonalGatewayNativeBridgeScript.Create(gatewayUrl); + const string assignment = "window.__OPENCLAW_NATIVE_CONTROL_AUTH__ = "; + var assignmentStart = script.IndexOf(assignment, StringComparison.Ordinal); + Assert.True(assignmentStart >= 0, "The script must select native personal authentication."); + + var jsonStart = assignmentStart + assignment.Length; + var jsonEnd = script.IndexOf(';', jsonStart); + using var config = JsonDocument.Parse(script[jsonStart..jsonEnd]); + Assert.Equal(gatewayUrl, config.RootElement.GetProperty("gatewayUrl").GetString()); + Assert.True(config.RootElement.GetProperty("nativeConnectAuth").GetBoolean()); + Assert.True(script.IndexOf("window.OpenClawNativeGatewayAuth", StringComparison.Ordinal) > jsonEnd, + "Native authentication selection must precede bridge startup."); + } + + [Fact] + public void ReusePolicyRequiresTheSameCurrentLeaseAndAnActiveWindow() + { + var lease = new PersonalOperatorLease( + "gateway-1", "wss://node.example.ts.net", "person-42", "scope-9", "device-7", 3, 7); + var nextLease = lease with { Generation = 4 }; + var identicalReplacement = lease with { }; + Assert.False(PersonalDashboardWindowReusePolicy.CanReuse(identicalReplacement, lease, lease, false, false)); + + Assert.True(PersonalDashboardWindowReusePolicy.CanReuse(lease, lease, lease, false, false)); + Assert.False(PersonalDashboardWindowReusePolicy.CanReuse(lease, lease, lease, true, false)); + Assert.False(PersonalDashboardWindowReusePolicy.CanReuse(lease, lease, lease, false, true)); + Assert.False(PersonalDashboardWindowReusePolicy.CanReuse(nextLease, lease, nextLease, false, false)); + Assert.False(PersonalDashboardWindowReusePolicy.CanReuse(lease, lease, nextLease, false, false)); + } +} diff --git a/tests/OpenClaw.Tray.Tests/PersonalGatewayAuthChallengeParserTests.cs b/tests/OpenClaw.Tray.Tests/PersonalGatewayAuthChallengeParserTests.cs new file mode 100644 index 0000000000..35e072ac81 --- /dev/null +++ b/tests/OpenClaw.Tray.Tests/PersonalGatewayAuthChallengeParserTests.cs @@ -0,0 +1,69 @@ +using OpenClawTray.Helpers; + +namespace OpenClaw.Tray.Tests; + +public sealed class PersonalGatewayAuthChallengeParserTests +{ + private const string Route = "wss://node.example.ts.net"; + + [Theory] + [InlineData("{\"id\":\"challenge-1\",\"nonce\":\"nonce-123\",\"signedAt\":1793563200000}")] + [InlineData("\"{\\\"id\\\":\\\"challenge-1\\\",\\\"nonce\\\":\\\"nonce-123\\\",\\\"signedAt\\\":1793563200000}\"")] + public void TryParse_AcceptsNarrowChallengeFromCurrentTlsAuthority(string message) + { + Assert.True(PersonalGatewayAuthChallengeParser.TryParse( + message, + "https://node.example.ts.net/chat", + Route, + out var challenge)); + + Assert.NotNull(challenge); + Assert.Equal("challenge-1", challenge.Id); + Assert.Equal("nonce-123", challenge.Nonce); + Assert.Equal(1793563200000, challenge.SignedAt); + } + + [Fact] + public void TryParse_AcceptsChallengeFromMatchingCustomTlsPort() + { + Assert.True(PersonalGatewayAuthChallengeParser.TryParse( + "{\"id\":\"challenge-1\",\"nonce\":\"nonce-123\",\"signedAt\":1793563200000}", + "https://node.example.ts.net:9443/chat", + "wss://node.example.ts.net:9443", + out _)); + } + + [Fact] + public void TryParse_RejectsChallengeFromDifferentTlsPort() + { + Assert.False(PersonalGatewayAuthChallengeParser.TryParse( + "{\"id\":\"challenge-1\",\"nonce\":\"nonce-123\",\"signedAt\":1793563200000}", + "https://node.example.ts.net:9444/chat", + "wss://node.example.ts.net:9443", + out _)); + } + + [Theory] + [InlineData("https://attacker.ts.net/chat", "{\"id\":\"id\",\"nonce\":\"n\",\"signedAt\":1}")] + [InlineData("http://node.example.ts.net/chat", "{\"id\":\"id\",\"nonce\":\"n\",\"signedAt\":1}")] + [InlineData("https://node.example.ts.net/chat", "{\"id\":\"id\",\"nonce\":\"n|token\",\"signedAt\":1}")] + [InlineData("https://node.example.ts.net/chat", "{\"id\":\"id\",\"nonce\":\"n\",\"signedAt\":1,\"auth\":{\"token\":\"secret\"}}")] + public void TryParse_RejectsUntrustedOrCredentialBearingMessages(string source, string message) + { + Assert.False(PersonalGatewayAuthChallengeParser.TryParse(message, source, Route, out _)); + } + + [Theory] + [InlineData("\"1793563200000\"")] + [InlineData("null")] + [InlineData("true")] + [InlineData("{}")] + [InlineData("[]")] + public void TryParse_RejectsNonNumericSignedAtWithoutThrowing(string signedAt) + { + var message = $"{{\"id\":\"challenge-1\",\"nonce\":\"nonce-123\",\"signedAt\":{signedAt}}}"; + + Assert.False(PersonalGatewayAuthChallengeParser.TryParse( + message, "https://node.example.ts.net/chat", Route, out _)); + } +} diff --git a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs index 9d725a8f00..5b11cda631 100644 --- a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs +++ b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs @@ -165,6 +165,26 @@ public async Task Failure_IsReportedOnceWithoutAutomaticRetry(string failure) Assert.Equal(1, failures); } + [Theory] + [InlineData(true)] + [InlineData(false)] + public async Task PersonalDashboardNeverFallsBackToBrowserOrSavedCredentials(bool available) + { + var failures = 0; + var opened = 0; + string? path = null; + var launcher = new GatewayDashboardLauncher( + () => throw new InvalidOperationException("Personal mode accessed the shared tunnel route."), + () => throw new InvalidOperationException("Personal mode resolved saved credentials."), + _ => throw new InvalidOperationException("Personal mode opened the shared browser route."), + () => failures++, () => opened++, () => true, + target => { path = target; return Task.FromResult(available); }); + Assert.Equal(available, await launcher.OpenAsync("channels")); + Assert.Equal("channels", path); + Assert.Equal(available ? 0 : 1, failures); + Assert.Equal(available ? 1 : 0, opened); + } + [Fact] public void EndpointBinding_ExcludesRotatingTokensButIncludesSshRealm() { diff --git a/tests/OpenClaw.Tray.UITests/OpenClaw.Tray.UITests.csproj b/tests/OpenClaw.Tray.UITests/OpenClaw.Tray.UITests.csproj index 5d998a9c63..f0b26b6983 100644 --- a/tests/OpenClaw.Tray.UITests/OpenClaw.Tray.UITests.csproj +++ b/tests/OpenClaw.Tray.UITests/OpenClaw.Tray.UITests.csproj @@ -69,6 +69,8 @@ + WithBrowserAsync(async (window, core, manager) => + { + await core.ExecuteScriptAsync("OpenClawNativeGatewayAuth.postMessage({id:'current',nonce:'current-nonce',signedAt:Date.now()})"); + await manager.Started.Task.WaitAsync(TimeSpan.FromSeconds(10)); + manager.Response.SetResult("{\"fixture\":\"accepted\"}"); + await WaitForReplyAsync(core, "current"); + Assert.Equal("\"accepted\"", await core.ExecuteScriptAsync("fixtureReplies.find(x=>x.id==='current').result.fixture")); + + manager.PrepareRequest(); + await core.ExecuteScriptAsync("OpenClawNativeGatewayAuth.postMessage({id:'retired',nonce:'retired-nonce',signedAt:Date.now()})"); + await manager.Started.Task.WaitAsync(TimeSpan.FromSeconds(10)); + manager.Lease = manager.Lease with { Generation = manager.Lease.Generation + 1 }; + manager.Response.SetResult("{\"fixture\":\"must-not-be-delivered\"}"); + await WaitForReplyAsync(core, "retired"); + Assert.Equal("false", await core.ExecuteScriptAsync("fixtureReplies.some(x=>x.id==='retired' && x.result)")); + }); + + [Fact] + public Task CloseDeletesOwnedInPrivateProfile() => WithBrowserAsync(async (window, core, manager) => + { + Assert.True(core.Profile.IsInPrivateModeEnabled); + Assert.StartsWith("personal-", core.Profile.ProfileName); + var deleted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + core.Profile.Deleted += (_, _) => deleted.TrySetResult(); + await window.CloseAsync(); + await deleted.Task.WaitAsync(TimeSpan.FromSeconds(10)); + }); + + private Task WithBrowserAsync(Func test) => ui.RunOnUIAsync(async () => + { + using var directory = new TempDirectory("personal-browser-ui-"); + using var environment = new EnvironmentScope("OPENCLAW_TRAY_DATA_DIR", directory.Path); + var page = directory.Combine("page"); + Directory.CreateDirectory(page); + File.WriteAllText(Path.Combine(page, "index.html"), """ + Native authentication fixture + + """); + var contract = DispatchProxy.Create(); + var manager = (ManagerProxy)(object)contract; + var window = new PersonalDashboardWindow(contract, manager.Lease, "/index.html"); + var view = (WebView2)((FrameworkElement)window.Content).FindName("DashboardWebView"); + var ready = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + view.CoreWebView2Initialized += (_, _) => + { + var core = view.CoreWebView2; + if (core is null) { ready.TrySetException(new InvalidOperationException("Native Core initialization failed.")); return; } + core.SetVirtualHostNameToFolderMapping(Host, page, CoreWebView2HostResourceAccessKind.DenyCors); + core.NavigationCompleted += (_, result) => + { + if (result.IsSuccess) ready.TrySetResult(core); + else ready.TrySetException(new InvalidOperationException("Native fixture page did not load.")); + }; + }; + window.Activate(); + try + { + await test(window, await ready.Task.WaitAsync(TimeSpan.FromSeconds(15)), manager); + } + finally + { + manager.Response.TrySetResult(null); + await window.CloseAsync(); + } + }); + + private static async Task WaitForReplyAsync(CoreWebView2 core, string id) + { + var deadline = DateTime.UtcNow.AddSeconds(10); + while (await core.ExecuteScriptAsync($"fixtureReplies.some(x=>x.id==='{id}')") != "true") + { + Assert.True(DateTime.UtcNow < deadline, "Native browser reply did not arrive."); + await Task.Delay(25); + } + } + + public class ManagerProxy : DispatchProxy + { + public PersonalOperatorLease Lease { get; set; } = new("fixture", "wss://" + Host, "person", "scope", "device", 1, 1); + public TaskCompletionSource Started { get; private set; } = new(TaskCreationOptions.RunContinuationsAsynchronously); + public TaskCompletionSource Response { get; private set; } = new(TaskCreationOptions.RunContinuationsAsynchronously); + + public void PrepareRequest() + { + Started = new(TaskCreationOptions.RunContinuationsAsynchronously); + Response = new(TaskCreationOptions.RunContinuationsAsynchronously); + } + + protected override object? Invoke(MethodInfo? method, object?[]? args) + { + if (method?.Name == "get_CurrentPersonalOperatorLease") return Lease; + if (method?.Name == "CreatePersonalBrowserAuthResponseAsync") + { + Started.TrySetResult(); + return Response.Task; + } + return null; + } + } +} diff --git a/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs b/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs index e5ebf8e78d..fc61b32e67 100644 --- a/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs +++ b/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs @@ -353,7 +353,7 @@ public void Dispose() /// All UI tests share one Application/Window — declare them in this collection /// so xUnit serializes them and reuses the fixture. /// -[CollectionDefinition(Name)] +[CollectionDefinition(Name, DisableParallelization = true)] public sealed class UICollection : ICollectionFixture { public const string Name = "UI"; From e35c7a1b859a291bad4f8708a294c981d5ff7bb1 Mon Sep 17 00:00:00 2001 From: Vitor Cepeda Lopes Date: Thu, 5 Nov 2026 19:33:22 +0000 Subject: [PATCH 2/6] fix(auth): retire stale personal identity and media authority --- .../GatewayConnectionManager.cs | 4 +- .../GatewayPersonalAuthenticationPolicy.cs | 4 +- .../AssistantMediaResolution.cs | 5 +- .../OpenClawGatewayClient.AssistantMedia.cs | 17 ++- ...lawGatewayClient.PersonalAuthentication.cs | 35 ++++- src/OpenClaw.Shared/OpenClawGatewayClient.cs | 3 +- ...yConnectionManagerPersonalIdentityTests.cs | 49 ++++++- .../PersonalTailscaleMediaTests.cs | 133 ++++++++++++++++++ .../PersonalGatewayProtocolFixture.cs | 10 +- 9 files changed, 246 insertions(+), 14 deletions(-) create mode 100644 tests/OpenClaw.Shared.Tests/PersonalTailscaleMediaTests.cs diff --git a/src/OpenClaw.Connection/GatewayConnectionManager.cs b/src/OpenClaw.Connection/GatewayConnectionManager.cs index c4ccf4eafd..d48043608f 100644 --- a/src/OpenClaw.Connection/GatewayConnectionManager.cs +++ b/src/OpenClaw.Connection/GatewayConnectionManager.cs @@ -2677,8 +2677,10 @@ private async Task HandleHandshakeSucceededAsync(long gen) } if (personal.Disposition == PersonalVerification.Rejected) { - _stateMachine.TryTransition(ConnectionTrigger.AuthenticationFailed, + _stateMachine.TryTransition(_stateMachine.Current.OperatorState == RoleConnectionState.Connected + ? ConnectionTrigger.WebSocketError : ConnectionTrigger.AuthenticationFailed, "Personal Tailscale identity could not be verified. Reconnect this Gateway."); + _stateMachine.Current = _stateMachine.Current with { PersonalIdentityProfileId = null }; CompleteOperatorTelemetryAttempt(gen, "failure", ConnectionErrorCategory.AuthFailure); await DisposeActiveClientAsync().ConfigureAwait(false); EmitStateChanged(); diff --git a/src/OpenClaw.Connection/GatewayPersonalAuthenticationPolicy.cs b/src/OpenClaw.Connection/GatewayPersonalAuthenticationPolicy.cs index f8f1372101..31684fc27d 100644 --- a/src/OpenClaw.Connection/GatewayPersonalAuthenticationPolicy.cs +++ b/src/OpenClaw.Connection/GatewayPersonalAuthenticationPolicy.cs @@ -23,7 +23,7 @@ public static bool TryGetCanonicalProfileId(System.Text.Json.JsonElement respons } profileId = id.GetString() ?? string.Empty; - return !string.IsNullOrWhiteSpace(profileId) && + return profileId != "gateway-owner" && !string.IsNullOrWhiteSpace(profileId) && string.Equals(profileId, profileId.Trim(), StringComparison.Ordinal); } @@ -51,4 +51,4 @@ public sealed record PersonalOperatorLease( string RecoveryScope, string DeviceId, long Generation, - long TransportEpoch); \ No newline at end of file + long TransportEpoch); diff --git a/src/OpenClaw.Shared/AssistantMediaResolution.cs b/src/OpenClaw.Shared/AssistantMediaResolution.cs index 4a4088a20f..0a4d048e1d 100644 --- a/src/OpenClaw.Shared/AssistantMediaResolution.cs +++ b/src/OpenClaw.Shared/AssistantMediaResolution.cs @@ -36,4 +36,7 @@ public enum AssistantFileDownloadStatus internal readonly record struct GatewayConnectionLease( Guid ClientId, long Generation, - Uri HttpBaseUri); + Uri HttpBaseUri) +{ + internal object? PersonalAuthority { get; init; } +} diff --git a/src/OpenClaw.Shared/OpenClawGatewayClient.AssistantMedia.cs b/src/OpenClaw.Shared/OpenClawGatewayClient.AssistantMedia.cs index 05b55bcda0..7c8277b8a3 100644 --- a/src/OpenClaw.Shared/OpenClawGatewayClient.AssistantMedia.cs +++ b/src/OpenClaw.Shared/OpenClawGatewayClient.AssistantMedia.cs @@ -184,6 +184,9 @@ private async Task ResolveLegacyMediaAsync( if (string.IsNullOrWhiteSpace(media.GatewaySource) || !AssistantMediaDirectiveParser.IsSendableLegacySource(media.GatewaySource)) return AssistantMediaResolutionResult.Unavailable; + if (IsPersonalTailscaleAuthentication && + !await VerifyPersonalMediaIdentityAsync(lease, cancellationToken).ConfigureAwait(false)) + return AssistantMediaResolutionResult.Unavailable; var metadataUri = BuildLegacyMediaUri( lease.HttpBaseUri, @@ -249,6 +252,7 @@ private async Task DownloadMediaBytesAsync( int maximumBytes, CancellationToken cancellationToken) { + if (!IsCurrentMediaLease(lease)) return AssistantMediaResolutionResult.Unavailable; using var request = CreateAuthenticatedMediaRequest(uri, $"{MimePrefix(kind)}/*"); using var response = await _assistantMediaHttpClient.SendAsync( request, @@ -284,7 +288,12 @@ private HttpRequestMessage CreateAuthenticatedMediaRequest(Uri uri, string accep var request = new HttpRequestMessage(HttpMethod.Get, uri); request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(accept)); var authToken = Volatile.Read(ref _assistantMediaAuthToken); - if (!string.IsNullOrWhiteSpace(authToken)) + if (IsPersonalTailscaleAuthentication) + { + request.Headers.Add("Origin", uri.GetLeftPart(UriPartial.Authority)); + request.Headers.TryAddWithoutValidation("x-openclaw-scopes", string.Join(",", GrantedOperatorScopes)); + } + else if (!string.IsNullOrWhiteSpace(authToken)) request.Headers.Authorization = new AuthenticationHeaderValue( "Bearer", authToken); @@ -296,13 +305,17 @@ private bool TryCaptureMediaLease(out GatewayConnectionLease lease) lease = default; if (!IsConnectedToGateway || !TryBuildMediaHttpBaseUri(_currentGatewayUrl, out var baseUri)) return false; - lease = new GatewayConnectionLease(_mediaClientId, ConnectionGeneration, baseUri); + lease = new GatewayConnectionLease(_mediaClientId, ConnectionGeneration, baseUri) + { + PersonalAuthority = IsPersonalTailscaleAuthentication ? Volatile.Read(ref _personalHandshake) : null + }; return true; } private bool IsCurrentMediaLease(GatewayConnectionLease lease) => lease.ClientId == _mediaClientId && lease.Generation == ConnectionGeneration + && (!IsPersonalTailscaleAuthentication || ReferenceEquals(lease.PersonalAuthority, Volatile.Read(ref _personalHandshake))) && IsConnectedToGateway; internal static bool TryBuildMediaHttpBaseUri(string gatewayUrl, out Uri baseUri) diff --git a/src/OpenClaw.Shared/OpenClawGatewayClient.PersonalAuthentication.cs b/src/OpenClaw.Shared/OpenClawGatewayClient.PersonalAuthentication.cs index 17321e736e..c2664ed9ee 100644 --- a/src/OpenClaw.Shared/OpenClawGatewayClient.PersonalAuthentication.cs +++ b/src/OpenClaw.Shared/OpenClawGatewayClient.PersonalAuthentication.cs @@ -4,7 +4,7 @@ namespace OpenClaw.Shared; public partial class OpenClawGatewayClient { - private sealed record PersonalHandshake(long Epoch, string RecoveryScope, string? ProfileId = null); + private sealed record PersonalHandshake(long Epoch, string RecoveryScope, string? ProfileId = null, string? ExpectedProfileId = null); private readonly OperatorAuthenticationMode _operatorAuthentication; private PersonalHandshake? _personalHandshake; @@ -37,7 +37,8 @@ public void VerifyPersonalIdentity(string profileId, long expectedEpoch) { ArgumentException.ThrowIfNullOrWhiteSpace(profileId); var handshake = Volatile.Read(ref _personalHandshake); - if (!IsPersonalTailscaleAuthentication || handshake is null || + if (profileId == "gateway-owner" || !IsPersonalTailscaleAuthentication || handshake is null || + handshake.ExpectedProfileId is { } expectedProfile && profileId != expectedProfile || handshake.Epoch != expectedEpoch || PersonalHandshakeConnectionEpoch != expectedEpoch) throw new InvalidOperationException("The personal Gateway connection changed."); var verified = handshake with { ProfileId = profileId }; @@ -51,6 +52,36 @@ public void VerifyPersonalIdentity(string profileId, long expectedEpoch) RequestInitialState(expectedEpoch); } + private void InvalidatePersonalIdentity() + { + var handshake = Volatile.Read(ref _personalHandshake); + if (!IsPersonalTailscaleAuthentication || handshake is not { ProfileId: not null }) return; + var pending = handshake with { ProfileId = null, ExpectedProfileId = handshake.ProfileId }; + if (ReferenceEquals(Interlocked.CompareExchange(ref _personalHandshake, pending, handshake), handshake)) + HandshakeSucceeded?.Invoke(this, EventArgs.Empty); + } + + private async Task VerifyPersonalMediaIdentityAsync(GatewayConnectionLease lease, CancellationToken cancellationToken) + { + if (!IsCurrentMediaLease(lease) || lease.PersonalAuthority is not PersonalHandshake personal) return false; + try + { + var self = await ReadPersonalIdentityAsync(lease.Generation).WaitAsync(cancellationToken).ConfigureAwait(false); + if (!IsCurrentMediaLease(lease)) return false; + if (self.ValueKind == JsonValueKind.Object && self.TryGetProperty("profile", out var profile) && + profile.ValueKind == JsonValueKind.Object && profile.TryGetProperty("id", out var id) && + id.ValueKind == JsonValueKind.String && id.GetString() == personal.ProfileId) + return true; + InvalidatePersonalIdentity(); + return false; + } + catch (Exception ex) when (ex is InvalidOperationException or TimeoutException or OperationCanceledException or JsonException) + { + cancellationToken.ThrowIfCancellationRequested(); + return false; + } + } + private void RequestInitialState(long epoch) { _ = Task.Run(async () => diff --git a/src/OpenClaw.Shared/OpenClawGatewayClient.cs b/src/OpenClaw.Shared/OpenClawGatewayClient.cs index 90dd54d210..fe8a2eb40a 100644 --- a/src/OpenClaw.Shared/OpenClawGatewayClient.cs +++ b/src/OpenClaw.Shared/OpenClawGatewayClient.cs @@ -452,7 +452,7 @@ public OpenClawGatewayClient( _ephemeralOperatorCredential = ephemeralOperatorCredential; _useBoundedBootstrapScopes = useBoundedBootstrapScopes; _assistantMediaHttpClient = assistantMediaHandler is null - ? new HttpClient(new HttpClientHandler { AllowAutoRedirect = false }) + ? new HttpClient(new HttpClientHandler { AllowAutoRedirect = false, UseCookies = !IsPersonalTailscaleAuthentication }) : new HttpClient(assistantMediaHandler, disposeHandler: true); SetAssistantMediaAuthToken(IsPersonalTailscaleAuthentication ? null : assistantMediaAuthToken); _currentGatewayUrl = gatewayUrl; @@ -3684,6 +3684,7 @@ private void HandleEventForConnection( && changeReason.ValueKind == JsonValueKind.String && changeReason.GetString() == "profile-identity") { + InvalidatePersonalIdentity(); SelfProfileChanged?.Invoke(this, EventArgs.Empty); } if (sessionChange.TryGetProperty("catalogChanged", out var catalogChanged) diff --git a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs index f42d414dcc..cedcb86134 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs @@ -34,18 +34,61 @@ public async Task PersonalConnectionPublishesOnlyAfterCurrentSocketSelfVerificat Assert.Null(harness.Manager.CurrentPersonalOperatorLease); } - [Fact] - public async Task MissingCanonicalSelfProfileRejectsPersonalConnection() + [Theory] + [InlineData(null)] + [InlineData("gateway-owner")] + public async Task MissingOrSharedOwnerSelfProfileRejectsPersonalConnection(string? profile) + { + await using var harness = new Harness(); + var peer = await harness.HelloAsync(); + var self = await peer.ReceiveAsync(); + await peer.SelfAsync(self, profile); + await harness.WaitAsync(RoleConnectionState.Error); + Assert.Null(harness.Manager.CurrentPersonalOperatorLease); + Assert.Null(harness.Manager.CurrentSnapshot.PersonalIdentityProfileId); + } + + [Theory] + [InlineData("gateway-owner")] + [InlineData("different-person")] + public async Task ProfileInvalidationWithholdsOldLeaseAndRejectsChangedPerson(string profile) { await using var harness = new Harness(); var peer = await harness.HelloAsync(); + await peer.SelfAsync(await peer.ReceiveAsync()); + await harness.WaitAsync(RoleConnectionState.Connected); + await peer.ProfileChangedAsync(); var self = await peer.ReceiveAsync(); - await peer.SelfAsync(self, null); + Assert.Equal("users.self", self.GetProperty("method").GetString()); + Assert.Null(harness.Manager.CurrentPersonalOperatorLease); + await peer.SelfAsync(self, profile); await harness.WaitAsync(RoleConnectionState.Error); Assert.Null(harness.Manager.CurrentPersonalOperatorLease); Assert.Null(harness.Manager.CurrentSnapshot.PersonalIdentityProfileId); } + [Fact] + public async Task ProfileInvalidationReverifiesSamePersonBeforeReplacingLease() + { + await using var harness = new Harness(); + var peer = await harness.HelloAsync(); + await peer.SelfAsync(await peer.ReceiveAsync()); + await harness.WaitAsync(RoleConnectionState.Connected); + var previous = harness.Manager.CurrentPersonalOperatorLease; + var renewed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + harness.Manager.StateChanged += (_, _) => + { + if (harness.Manager.CurrentPersonalOperatorLease is { } lease && !ReferenceEquals(lease, previous)) + renewed.TrySetResult(lease); + }; + await peer.ProfileChangedAsync(); + var self = await peer.ReceiveAsync(); + Assert.Equal("users.self", self.GetProperty("method").GetString()); + Assert.Null(harness.Manager.CurrentPersonalOperatorLease); + await peer.SelfAsync(self); + Assert.Equal("person-42", (await renewed.Task.WaitAsync(TimeSpan.FromSeconds(5))).IdentityProfileId); + } + [Fact] public async Task PendingIdentityReadDoesNotBlockDisconnectOrPublishAnOldLease() { diff --git a/tests/OpenClaw.Shared.Tests/PersonalTailscaleMediaTests.cs b/tests/OpenClaw.Shared.Tests/PersonalTailscaleMediaTests.cs new file mode 100644 index 0000000000..02a02c0d53 --- /dev/null +++ b/tests/OpenClaw.Shared.Tests/PersonalTailscaleMediaTests.cs @@ -0,0 +1,133 @@ +using System.Net; +using System.Net.Http.Headers; +using System.Text; +using OpenClaw.TestSupport; +using Xunit; + +namespace OpenClaw.Shared.Tests; + +public sealed class PersonalTailscaleMediaTests +{ + [Theory] + [InlineData(HttpStatusCode.OK, AssistantMediaResolutionStatus.Ready, 2)] + [InlineData(HttpStatusCode.Forbidden, AssistantMediaResolutionStatus.Unavailable, 1)] + public async Task LegacyMediaUsesCurrentServeIdentityAndScopeCeilingWithoutBearerFallback( + HttpStatusCode status, AssistantMediaResolutionStatus expected, int requests) + { + using var identity = new TempDirectory("personal-media-"); + await using var peer = new PersonalGatewayProtocolFixture(); + using var handler = new MediaHandler((_, count) => Task.FromResult(count == 1 ? Metadata(status) : Image())); + using var client = peer.CreateClient(identity.Path, handler); + await ReadyAsync(peer, client); + var media = client.ResolveAssistantMediaAsync("main", Legacy()); + await SelfAsync(peer); + Assert.Equal(expected, (await media).Status); + Assert.Equal(requests, handler.Requests.Count); + Assert.All(handler.Requests, request => + { + Assert.Equal("https://protocol.example.ts.net", request.Uri.GetLeftPart(UriPartial.Authority)); + Assert.Null(request.Authorization); + Assert.Equal("https://protocol.example.ts.net", request.Origin); + Assert.Equal("operator.read,operator.write", request.Scopes); + Assert.False(request.HasAmbientCredentials); + }); + if (requests == 2) + Assert.Contains("mediaTicket=fixture-ticket", handler.Requests[1].Uri.Query, StringComparison.Ordinal); + } + + [Fact] + public async Task ChangedCanonicalPersonBeforeHttpRefusesMediaAndRetiresReadiness() + { + using var identity = new TempDirectory("personal-media-person-"); + await using var peer = new PersonalGatewayProtocolFixture(); + using var handler = new MediaHandler((_, _) => Task.FromResult(Metadata(HttpStatusCode.OK))); + using var client = peer.CreateClient(identity.Path, handler); + await ReadyAsync(peer, client); + var media = client.ResolveAssistantMediaAsync("main", Legacy()); + await SelfAsync(peer, "another-person"); + Assert.Equal(AssistantMediaResolutionStatus.Unavailable, (await media).Status); + Assert.Empty(handler.Requests); + Assert.False(client.IsConnectedToGateway); + } + + [Fact] + public async Task ProfileInvalidationDuringMetadataCannotFetchBytesWithRetiredAuthority() + { + using var identity = new TempDirectory("personal-media-retire-"); + await using var peer = new PersonalGatewayProtocolFixture(); + var entered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + using var handler = new MediaHandler(async (_, _) => + { + entered.TrySetResult(); + await release.Task; + return Metadata(HttpStatusCode.OK); + }); + using var client = peer.CreateClient(identity.Path, handler); + await ReadyAsync(peer, client); + var invalidated = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + client.SelfProfileChanged += (_, _) => invalidated.TrySetResult(); + var media = client.ResolveAssistantMediaAsync("main", Legacy()); + await SelfAsync(peer); + await entered.Task.WaitAsync(TimeSpan.FromSeconds(5)); + await peer.ProfileChangedAsync(); + await invalidated.Task.WaitAsync(TimeSpan.FromSeconds(5)); + release.TrySetResult(); + Assert.Equal(AssistantMediaResolutionStatus.Unavailable, (await media).Status); + Assert.Single(handler.Requests); + } + + private static ChatMediaContentInfo Legacy() => new() + { + Kind = ChatMediaContentKind.Image, Source = ChatMediaContentSource.LegacyDirective, + GatewaySource = "/fixture/banner.png" + }; + + private static async Task ReadyAsync(PersonalGatewayProtocolFixture peer, OpenClawGatewayClient client) + { + var hello = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + client.HandshakeSucceeded += (_, _) => hello.TrySetResult(); + await client.ConnectAsync(); + await peer.ChallengeAsync(); + await peer.HelloAsync(await peer.ReceiveAsync()); + await hello.Task.WaitAsync(TimeSpan.FromSeconds(5)); + var epoch = client.PersonalHandshakeConnectionEpoch!.Value; + var self = client.ReadPersonalIdentityAsync(epoch); + await SelfAsync(peer); + await self; + client.VerifyPersonalIdentity("person-42", epoch); + } + + private static async Task SelfAsync(PersonalGatewayProtocolFixture peer, string profile = "person-42") + { + var request = await peer.ReceiveAsync(); + Assert.Equal("users.self", request.GetProperty("method").GetString()); + await peer.SelfAsync(request, profile); + } + + private static HttpResponseMessage Metadata(HttpStatusCode status) => new(status) + { + Content = new StringContent("""{"available":true,"mimeType":"image/png","sizeBytes":3,"mediaTicket":"fixture-ticket"}""", Encoding.UTF8, "application/json") + }; + + private static HttpResponseMessage Image() + { + var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent([1, 2, 3]) }; + response.Content.Headers.ContentType = new MediaTypeHeaderValue("image/png"); + return response; + } + + private sealed record Request(Uri Uri, string? Authorization, string? Origin, string? Scopes, bool HasAmbientCredentials); + private sealed class MediaHandler(Func> respond) : HttpMessageHandler + { + public List Requests { get; } = []; + protected override Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) + { + string? Header(string name) => request.Headers.TryGetValues(name, out var values) ? string.Join(",", values) : null; + Requests.Add(new(request.RequestUri!, request.Headers.Authorization?.ToString(), Header("Origin"), Header("x-openclaw-scopes"), + request.Headers.Any(header => header.Key.StartsWith("Tailscale-", StringComparison.OrdinalIgnoreCase) || + header.Key.StartsWith("X-Forwarded-", StringComparison.OrdinalIgnoreCase) || header.Key is "Cookie" or "Sec-Fetch-Site"))); + return respond(request, Requests.Count); + } + } +} diff --git a/tests/OpenClaw.TestSupport/PersonalGatewayProtocolFixture.cs b/tests/OpenClaw.TestSupport/PersonalGatewayProtocolFixture.cs index 285b04e29a..668251b483 100644 --- a/tests/OpenClaw.TestSupport/PersonalGatewayProtocolFixture.cs +++ b/tests/OpenClaw.TestSupport/PersonalGatewayProtocolFixture.cs @@ -26,10 +26,11 @@ public PersonalGatewayProtocolFixture() _socket = AcceptAsync(); } - public OpenClawGatewayClient CreateClient(string identityPath) + public OpenClawGatewayClient CreateClient(string identityPath, HttpMessageHandler? httpHandler = null) { var client = new OpenClawGatewayClient(Route, string.Empty, - identityPath: identityPath, operatorAuthentication: OperatorAuthenticationMode.PersonalTailscale); + identityPath: identityPath, operatorAuthentication: OperatorAuthenticationMode.PersonalTailscale, + assistantMediaHandler: httpHandler); typeof(WebSocketClientBase).GetField("_gatewayUrl", BindingFlags.Instance | BindingFlags.NonPublic)! .SetValue(client, $"ws://127.0.0.1:{((IPEndPoint)_listener.LocalEndpoint).Port}/"); return client; @@ -61,6 +62,11 @@ public async Task ChallengeAsync() => await SendAsync(new type = "event", @event = "connect.challenge", payload = new { nonce = "fixture-challenge", ts = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() } }); + public Task ProfileChangedAsync() => SendAsync(new + { + type = "event", @event = "sessions.changed", payload = new { reason = "profile-identity" } + }); + public async Task ReceiveAsync() => await _frames.Reader.ReadAsync(_lifetime.Token).AsTask().WaitAsync(TimeSpan.FromSeconds(5)); From 32e59cbef166a3b2e5b8ecd8b0d889f19be5c424 Mon Sep 17 00:00:00 2001 From: Vitor Cepeda Lopes <7040636+TheAngryPit@users.noreply.github.com> Date: Wed, 11 Nov 2026 21:14:16 +0000 Subject: [PATCH 3/6] test(auth): correlate replacement-token validation with fixture --- .../GatewayConnectionManagerTests.cs | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs index 0a564cca65..973904e653 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs @@ -7,6 +7,7 @@ using OpenClaw.Connection; using OpenClaw.Connection.NativeGateway; using OpenClaw.TestSupport; +using OpenClaw.TestSupport.Gateway; namespace OpenClaw.Connection.Tests; @@ -2600,10 +2601,13 @@ public async Task StaleOldGatewayV2FallbackAfterSwitch_DoesNotMarkCurrentGateway [Fact] public async Task ConnectWithSharedTokenAsync_RevalidatesDurableTokensUnderTransitionSemaphore() { + await using var server = await FixtureGatewayServer.StartAsync( + GatewayScenario.CreateBrowse(), "valid-shared-token"); + var gatewayUrl = server.Endpoint.AbsoluteUri; _registry.AddOrUpdate(new GatewayRecord { Id = "gw-1", - Url = "ws://127.0.0.1:9", + Url = gatewayUrl, SshTunnel = new SshTunnelConfig("user", "host.example", 18789, 45678) }); _registry.SetActive("gw-1"); @@ -2618,17 +2622,23 @@ public async Task ConnectWithSharedTokenAsync_RevalidatesDurableTokensUnderTrans var connectTask = manager.ConnectAsync("gw-1"); await tunnel.Started.Task.WaitAsync(TimeSpan.FromSeconds(2)); - var replaceTask = manager.ConnectWithSharedTokenAsync("ws://127.0.0.1:9", "bad-shared-token"); + var replaceTask = manager.ConnectWithSharedTokenAsync(gatewayUrl, "bad-shared-token"); var identityDir = _registry.GetIdentityDirectory("gw-1"); var identity = new DeviceIdentity(identityDir, NullLogger.Instance); identity.Initialize(); identity.StoreDeviceTokenForRole("operator", "operator-token"); + Assert.Empty(server.Requests); tunnel.AllowStart.SetResult(true); await connectTask.WaitAsync(TimeSpan.FromSeconds(2)); - var result = await replaceTask.WaitAsync(TimeSpan.FromSeconds(10)); + var rejectionTask = server.WaitForCompletedRequestAsync("connect"); + await Task.WhenAll(replaceTask, rejectionTask).WaitAsync(TimeSpan.FromSeconds(10)); + var result = await replaceTask; Assert.Equal(SetupCodeOutcome.ConnectionFailed, result.Outcome); + var rejection = await rejectionTask; + Assert.Equal(rejection, Assert.Single(server.Requests, request => request.Method == "connect")); + Assert.Equal("error:AUTH_TOKEN_MISMATCH", rejection.Outcome); Assert.Null(_registry.GetById("gw-1")?.SharedGatewayToken); Assert.Equal("operator-token", DeviceIdentity.TryReadStoredDeviceToken(identityDir)); } From 500a5752773a2a8e20a58a08810613ea57870c8a Mon Sep 17 00:00:00 2001 From: Vitor Cepeda Lopes <7040636+TheAngryPit@users.noreply.github.com> Date: Thu, 12 Nov 2026 01:22:15 +0000 Subject: [PATCH 4/6] fix: await personal Dashboard profile deletion before closing --- .../Windows/PersonalDashboardWindow.xaml.cs | 3 +-- .../PersonalDashboardWindowTests.cs | 14 ++++++++------ 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml.cs b/src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml.cs index f774e264ec..8a1cffbec7 100644 --- a/src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/Windows/PersonalDashboardWindow.xaml.cs @@ -311,8 +311,7 @@ private async Task DeleteProfileAndCloseAsync(CoreWebView2Profile profile) profile.Deleted += OnDeleted; subscribed = true; profile.Delete(); - // Delete marks the profile synchronously; a missed callback must not block shutdown. - await Task.WhenAny(deleted.Task, DrainDispatcherAsync()); + await deleted.Task; } catch (System.Runtime.InteropServices.COMException) { diff --git a/tests/OpenClaw.Tray.UITests/PersonalDashboardWindowTests.cs b/tests/OpenClaw.Tray.UITests/PersonalDashboardWindowTests.cs index b8ec6ef161..1f4bc9bb2a 100644 --- a/tests/OpenClaw.Tray.UITests/PersonalDashboardWindowTests.cs +++ b/tests/OpenClaw.Tray.UITests/PersonalDashboardWindowTests.cs @@ -34,12 +34,14 @@ public Task NativeBridgeDeliversCurrentReplyAndRejectsLeaseRetiredDuringAwait() [Fact] public Task CloseDeletesOwnedInPrivateProfile() => WithBrowserAsync(async (window, core, manager) => { - Assert.True(core.Profile.IsInPrivateModeEnabled); - Assert.StartsWith("personal-", core.Profile.ProfileName); + var profile = core.Profile; + Assert.True(profile.IsInPrivateModeEnabled); + Assert.StartsWith("personal-", profile.ProfileName); var deleted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - core.Profile.Deleted += (_, _) => deleted.TrySetResult(); - await window.CloseAsync(); - await deleted.Task.WaitAsync(TimeSpan.FromSeconds(10)); + profile.Deleted += (_, _) => deleted.TrySetResult(); + await window.CloseAsync().WaitAsync(TimeSpan.FromSeconds(10)); + Assert.True(deleted.Task.IsCompletedSuccessfully); + GC.KeepAlive(profile); }); private Task WithBrowserAsync(Func test) => ui.RunOnUIAsync(async () => @@ -79,7 +81,7 @@ private Task WithBrowserAsync(Func Date: Thu, 12 Nov 2026 11:57:07 +0000 Subject: [PATCH 5/6] fix: localize personal Gateway identity recovery --- ...tewayConnectionManager.PersonalIdentity.cs | 1 + .../GatewayConnectionManager.cs | 3 ++ src/OpenClaw.Shared/GatewayErrorClassifier.cs | 6 +++ src/OpenClaw.Tray.WinUI/App.xaml.cs | 11 +++-- .../GatewayPersonalErrorPresentation.cs | 18 ++++++++ .../Pages/ConnectionPage.xaml.cs | 3 +- .../Pages/ConnectionPagePlan.cs | 20 +++++++++ .../Services/GatewayDirectConnectService.cs | 14 ++++-- .../Strings/en-us/Resources.resw | 4 ++ .../Strings/fr-fr/Resources.resw | 4 ++ .../Strings/nl-nl/Resources.resw | 4 ++ .../Strings/pt-br/Resources.resw | 4 ++ .../Strings/zh-cn/Resources.resw | 4 ++ .../Strings/zh-tw/Resources.resw | 4 ++ .../Windows/ConnectionStatusWindow.xaml.cs | 12 ++++-- ...yConnectionManagerPersonalIdentityTests.cs | 2 + .../ConnectionPagePersonalIdentityTests.cs | 43 +++++++++++++++++++ .../GatewayDirectConnectServiceTests.cs | 27 ++++++++++++ .../OpenClaw.Tray.Tests.csproj | 1 + .../GatewayFixtureUiTests.UsageResponsive.cs | 28 +++++++++++- 20 files changed, 200 insertions(+), 13 deletions(-) create mode 100644 src/OpenClaw.Tray.WinUI/Helpers/GatewayPersonalErrorPresentation.cs create mode 100644 tests/OpenClaw.Tray.Tests/ConnectionPagePersonalIdentityTests.cs diff --git a/src/OpenClaw.Connection/GatewayConnectionManager.PersonalIdentity.cs b/src/OpenClaw.Connection/GatewayConnectionManager.PersonalIdentity.cs index 32268a9e02..0c96e0cb9c 100644 --- a/src/OpenClaw.Connection/GatewayConnectionManager.PersonalIdentity.cs +++ b/src/OpenClaw.Connection/GatewayConnectionManager.PersonalIdentity.cs @@ -124,6 +124,7 @@ private async Task RevokePersonalOperatorAsync(PersonalOperatorLease expected) try { if (!ReferenceEquals(expected, CurrentPersonalOperatorLease)) return; + _stateMachine.SetOperatorErrorKind(GatewayErrorKind.PersonalIdentityReverificationRequired); _stateMachine.TryTransition(ConnectionTrigger.WebSocketError, "Personal identity changed. Reconnect this Gateway."); _stateMachine.Current = _stateMachine.Current with { PersonalIdentityProfileId = null }; diff --git a/src/OpenClaw.Connection/GatewayConnectionManager.cs b/src/OpenClaw.Connection/GatewayConnectionManager.cs index 70b6a6a66e..b8a0497121 100644 --- a/src/OpenClaw.Connection/GatewayConnectionManager.cs +++ b/src/OpenClaw.Connection/GatewayConnectionManager.cs @@ -2388,6 +2388,8 @@ private static ConnectionErrorCategory MapConnectionErrorCategory( errorKind switch { GatewayErrorKind.Auth or + GatewayErrorKind.PersonalIdentityUnverified or + GatewayErrorKind.PersonalIdentityReverificationRequired or GatewayErrorKind.TokenDrift or GatewayErrorKind.DeviceTokenMismatch or GatewayErrorKind.ScopeMismatch => ConnectionErrorCategory.AuthFailure, @@ -2687,6 +2689,7 @@ private async Task HandleHandshakeSucceededAsync(long gen) } if (personal.Disposition == PersonalVerification.Rejected) { + _stateMachine.SetOperatorErrorKind(GatewayErrorKind.PersonalIdentityUnverified); _stateMachine.TryTransition(_stateMachine.Current.OperatorState == RoleConnectionState.Connected ? ConnectionTrigger.WebSocketError : ConnectionTrigger.AuthenticationFailed, "Personal Tailscale identity could not be verified. Reconnect this Gateway."); diff --git a/src/OpenClaw.Shared/GatewayErrorClassifier.cs b/src/OpenClaw.Shared/GatewayErrorClassifier.cs index 2428927e38..2211a2785a 100644 --- a/src/OpenClaw.Shared/GatewayErrorClassifier.cs +++ b/src/OpenClaw.Shared/GatewayErrorClassifier.cs @@ -69,6 +69,12 @@ public enum GatewayErrorKind /// The Gateway wire protocol is incompatible with this client. ProtocolMismatch, + + /// The personal operator identity could not be verified. + PersonalIdentityUnverified, + + /// The current personal operator identity must be verified again. + PersonalIdentityReverificationRequired, } /// diff --git a/src/OpenClaw.Tray.WinUI/App.xaml.cs b/src/OpenClaw.Tray.WinUI/App.xaml.cs index 9a258353d9..7ff9a91ade 100644 --- a/src/OpenClaw.Tray.WinUI/App.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/App.xaml.cs @@ -2914,11 +2914,14 @@ private static bool TryBuildConnectionIssueNotification( { title = LocalizationHelper.GetString("AppNotification_GatewayConnectionFailed_Title"); var rawError = snapshot.OperatorError; - message = string.IsNullOrWhiteSpace(rawError) - ? LocalizationHelper.GetString("AppNotification_GatewayConnectionFailed_DefaultMessage") - : rawError; + var personalErrorKey = GatewayPersonalErrorPresentation.ResourceKey(snapshot.OperatorErrorKind); + message = personalErrorKey is not null + ? LocalizationHelper.GetString(personalErrorKey) + : string.IsNullOrWhiteSpace(rawError) + ? LocalizationHelper.GetString("AppNotification_GatewayConnectionFailed_DefaultMessage") + : rawError; severity = AppNotificationSeverity.Error; - key = $"operator-error:{rawError ?? "default"}"; + key = $"operator-error:{personalErrorKey ?? rawError ?? "default"}"; return true; } diff --git a/src/OpenClaw.Tray.WinUI/Helpers/GatewayPersonalErrorPresentation.cs b/src/OpenClaw.Tray.WinUI/Helpers/GatewayPersonalErrorPresentation.cs new file mode 100644 index 0000000000..134fca6b2f --- /dev/null +++ b/src/OpenClaw.Tray.WinUI/Helpers/GatewayPersonalErrorPresentation.cs @@ -0,0 +1,18 @@ +using OpenClaw.Shared; + +namespace OpenClawTray.Helpers; + +/// Native recovery resources for personal identity failures, without raw Gateway diagnostics. +internal static class GatewayPersonalErrorPresentation +{ + public static string? ResourceKey(GatewayErrorKind? kind, bool rollbackIncomplete = false) + { + if (kind is not (GatewayErrorKind.PersonalIdentityUnverified or GatewayErrorKind.PersonalIdentityReverificationRequired)) + return null; + if (rollbackIncomplete) + return "ConnectionPage_PersonalIdentityRecoveryIncomplete"; + return kind == GatewayErrorKind.PersonalIdentityUnverified + ? "ConnectionPage_PersonalIdentityUnverified" + : "ConnectionPage_PersonalIdentityReverificationRequired"; + } +} diff --git a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs index 663fb35493..f4af58e91e 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs @@ -2945,7 +2945,8 @@ private async Task DoDirectConnectFromAddFormAsync() OperatorAuthentication: personal ? OperatorAuthenticationMode.PersonalTailscale : OperatorAuthenticationMode.GatewayCredential)); if (result.Outcome == GatewayDirectConnectOutcome.Failed) { - AddResultText.Text = $"✗ {result.Error}"; + var errorKey = GatewayPersonalErrorPresentation.ResourceKey(result.ErrorKind, result.RollbackIncomplete); + AddResultText.Text = $"✗ {(errorKey is null ? result.Error : LocalizationHelper.GetString(errorKey))}"; return; } diff --git a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs index c7ffa2c67d..b1b6dea139 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs @@ -123,6 +123,7 @@ internal enum RecoveryCategory LocalPortConflict, /// The Gateway and Windows app do not share a supported wire protocol. ProtocolMismatch, + PersonalIdentity, } /// @@ -247,6 +248,25 @@ private static ConnectionPagePlan BuildDerived( if (snap.ProtocolCompatibility.IsMismatch) return BuildProtocolMismatchRecovery(snap, activeRecord, displayName); + if (snap.OperatorState == RoleConnectionState.Error && + OpenClawTray.Helpers.GatewayPersonalErrorPresentation.ResourceKey(snap.OperatorErrorKind) is { } personalErrorKey) + { + return new ConnectionPagePlan + { + Mode = ConnectionPageMode.Recovery, + Recovery = RecoveryCategory.PersonalIdentity, + StripGlyph = OpenClawTray.Helpers.FluentIconCatalog.StatusErr, + StripAccent = ConnectionAccent.Critical, + StripHeadlineResourceKey = "ConnectionPage_PersonalIdentityHeader", + StripSubResourceKey = personalErrorKey, + RecoveryHeaderResourceKey = "ConnectionPage_PersonalIdentityHeader", + RecoveryBulletResourceKeys = [personalErrorKey], + ActiveGatewayDisplayName = displayName, + ActiveGatewayDetailLine = ConnectionCardPlanSanitizer.SanitizeGatewayUrl(activeRecord?.Url ?? snap.GatewayUrl), + RelevantGatewayId = activeRecord?.Id, + }; + } + // ─── Derived layout ─── return snap.OverallState switch { diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDirectConnectService.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDirectConnectService.cs index afe70673d7..1e3a39a19b 100644 --- a/src/OpenClaw.Tray.WinUI/Services/GatewayDirectConnectService.cs +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDirectConnectService.cs @@ -27,7 +27,8 @@ internal sealed record GatewayDirectConnectResult( bool GatewayCommitted, string? Error = null, bool RollbackIncomplete = false, - string? EndpointBinding = null); + string? EndpointBinding = null, + GatewayErrorKind? ErrorKind = null); /// /// Owns the direct-connect commit/rollback workflow. WinUI surfaces provide input and render the @@ -114,6 +115,7 @@ previousActiveId is not null && var settingsMutated = false; var connectionAttemptStarted = false; var previousConnectionStopped = false; + GatewayErrorKind? connectionFailureKind = null; DeviceIdentityReplacementTransaction? candidateIdentityCreation = null; GatewayValidationIdentity? validationIdentity = null; DeviceIdentityReplacementTransaction? nativeIdentityRollback = null; @@ -181,6 +183,7 @@ existing is not null && !replacesCredentialRealm cancellationToken.ThrowIfCancellationRequested(); if (snapshot.OperatorState == RoleConnectionState.Error) { + connectionFailureKind = snapshot.OperatorErrorKind; throw new InvalidOperationException( snapshot.OperatorError ?? snapshot.NodeError ?? @@ -288,7 +291,8 @@ existing is not null && !replacesCredentialRealm error, rollbackIncomplete: !string.IsNullOrWhiteSpace(cleanupError) || !string.IsNullOrWhiteSpace(rollback.Error) || - !string.IsNullOrWhiteSpace(connectionRestoreError)); + !string.IsNullOrWhiteSpace(connectionRestoreError), + errorKind: connectionFailureKind); } finally { @@ -686,13 +690,15 @@ private static GatewayDirectConnectResult Failed( GatewayConnectionSnapshot snapshot, bool gatewayCommitted, string error, - bool rollbackIncomplete = false) => + bool rollbackIncomplete = false, + GatewayErrorKind? errorKind = null) => new( GatewayDirectConnectOutcome.Failed, snapshot, gatewayCommitted, error, - rollbackIncomplete); + rollbackIncomplete, + ErrorKind: errorKind); private sealed record ConnectionSettingsSnapshot( string GatewayUrl, diff --git a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw index ec60217cc9..f18d564d97 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw @@ -9985,4 +9985,8 @@ After enrolling, return to Settings > Windows Update and check for updates. I unrouted shown Archived "{0}" ({1}). Dismiss notification + Personal sign-in unavailable + Your Tailscale identity could not be verified. Reconnect this Gateway. Shared credentials will not be used. + Your Tailscale identity needs to be verified again. Reconnect this Gateway. Shared credentials will not be used. + Personal sign-in failed, and recovery did not complete. Review Connection settings before retrying. diff --git a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw index 138873c3de..99091fb4ea 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw @@ -9914,4 +9914,8 @@ Après votre inscription, revenez dans Paramètres > Windows Update et recher sessions non routées affichées « {0} » archivée ({1}). Fermer la notification + Connexion personnelle indisponible + Votre identité Tailscale n’a pas pu être vérifiée. Reconnectez cette passerelle. Les identifiants partagés ne seront pas utilisés. + Votre identité Tailscale doit être vérifiée à nouveau. Reconnectez cette passerelle. Les identifiants partagés ne seront pas utilisés. + La connexion personnelle a échoué et la récupération n’a pas abouti. Vérifiez les paramètres de connexion avant de réessayer. diff --git a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw index 8a7f453ff9..dceec2a1b3 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw @@ -9915,4 +9915,8 @@ Ga na inschrijving terug naar Instellingen > Windows Update en controleer op niet-gerouteerde sessies weergegeven "{0}" gearchiveerd ({1}). Melding sluiten + Persoonlijk aanmelden niet beschikbaar + Je Tailscale-identiteit kon niet worden geverifieerd. Maak opnieuw verbinding met deze Gateway. Gedeelde inloggegevens worden niet gebruikt. + Je Tailscale-identiteit moet opnieuw worden geverifieerd. Maak opnieuw verbinding met deze Gateway. Gedeelde inloggegevens worden niet gebruikt. + Persoonlijk aanmelden is mislukt en het herstel is niet voltooid. Controleer de verbindingsinstellingen voordat je het opnieuw probeert. diff --git a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw index 6c2ae3fd99..8c01595320 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw @@ -9967,4 +9967,8 @@ Após a inscrição, volte para Configurações > Windows Update e verifique sessões não roteadas exibidas "{0}" arquivada ({1}). Dispensar notificação + Login pessoal indisponível + Não foi possível verificar sua identidade do Tailscale. Reconecte este Gateway. As credenciais compartilhadas não serão usadas. + Sua identidade do Tailscale precisa ser verificada novamente. Reconecte este Gateway. As credenciais compartilhadas não serão usadas. + O login pessoal falhou e a recuperação não foi concluída. Revise as configurações de Conexão antes de tentar novamente. diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw index a825bcbe56..39a89dd2eb 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw @@ -9914,4 +9914,8 @@ 显示未路由会话 已归档“{0}”({1})。 关闭通知 + 个人登录不可用 + 无法验证你的 Tailscale 身份。请重新连接此网关。不会使用共享凭据。 + 需要重新验证你的 Tailscale 身份。请重新连接此网关。不会使用共享凭据。 + 个人登录失败,且恢复未完成。请先检查“连接”设置,然后重试。 diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw index b4a9b22070..8c7623ccb3 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw @@ -9914,4 +9914,8 @@ 顯示未路由的工作階段 已封存「{0}」({1})。 關閉通知 + 個人登入無法使用 + 無法驗證你的 Tailscale 身分。請重新連線至此閘道。不會使用共用認證。 + 需要重新驗證你的 Tailscale 身分。請重新連線至此閘道。不會使用共用認證。 + 個人登入失敗,且復原未完成。請先檢查「連線」設定,再重試。 diff --git a/src/OpenClaw.Tray.WinUI/Windows/ConnectionStatusWindow.xaml.cs b/src/OpenClaw.Tray.WinUI/Windows/ConnectionStatusWindow.xaml.cs index 095cf01d31..c4a0bf4b33 100644 --- a/src/OpenClaw.Tray.WinUI/Windows/ConnectionStatusWindow.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/Windows/ConnectionStatusWindow.xaml.cs @@ -115,7 +115,10 @@ private void OnManagerStateChanged(object? sender, GatewayConnectionSnapshot sna else if (snapshot.OverallState == OverallConnectionState.Error) { ConnectButton.Content = LocalizationHelper.GetString("ConnectionStatus_Connect"); - var errorText = $"✗ {snapshot.OperatorError ?? snapshot.NodeError ?? LocalizationHelper.GetString("ConnectionPage_GatewayConnectionFailed")}"; + var personalErrorKey = GatewayPersonalErrorPresentation.ResourceKey(snapshot.OperatorErrorKind); + var errorText = $"✗ {(personalErrorKey is null + ? snapshot.OperatorError ?? snapshot.NodeError ?? LocalizationHelper.GetString("ConnectionPage_GatewayConnectionFailed") + : LocalizationHelper.GetString(personalErrorKey))}"; SetupCodeResult.Text = errorText; DirectConnectResult.Text = errorText; } @@ -170,10 +173,12 @@ private void RefreshStateMachine(GatewayConnectionSnapshot snapshot) var elapsed = DateTime.Now - _lastStateChangeTime; var elapsedStr = elapsed.TotalSeconds < 60 ? $"{elapsed.TotalSeconds:F0}s" : $"{elapsed.TotalMinutes:F0}m"; + var personalErrorKey = GatewayPersonalErrorPresentation.ResourceKey(snapshot.OperatorErrorKind); + var operatorError = personalErrorKey is null ? snapshot.OperatorError : LocalizationHelper.GetString(personalErrorKey); OpDetailText.Text = snapshot.OperatorState switch { RoleConnectionState.Connected => $"✓ {elapsedStr} device={snapshot.OperatorDeviceId ?? "—"}", - RoleConnectionState.Error => $"✗ {elapsedStr}: {snapshot.OperatorError ?? "unknown"}", + RoleConnectionState.Error => $"✗ {elapsedStr}: {operatorError ?? "unknown"}", RoleConnectionState.PairingRequired => $"⏳ {LocalizationHelper.GetString("ConnectionStatus_AwaitingApproval")}", _ => elapsedStr }; @@ -463,7 +468,8 @@ private async Task OnDirectConnectAsync() if (result.Outcome == GatewayDirectConnectOutcome.Failed) { InvalidatePendingStatusMessages(); - DirectConnectResult.Text = $"✗ {result.Error}"; + var errorKey = GatewayPersonalErrorPresentation.ResourceKey(result.ErrorKind, result.RollbackIncomplete); + DirectConnectResult.Text = $"✗ {(errorKey is null ? result.Error : LocalizationHelper.GetString(errorKey))}"; return; } diff --git a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs index cedcb86134..783be800d0 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerPersonalIdentityTests.cs @@ -44,6 +44,7 @@ public async Task MissingOrSharedOwnerSelfProfileRejectsPersonalConnection(strin var self = await peer.ReceiveAsync(); await peer.SelfAsync(self, profile); await harness.WaitAsync(RoleConnectionState.Error); + Assert.Equal(GatewayErrorKind.PersonalIdentityUnverified, harness.Manager.CurrentSnapshot.OperatorErrorKind); Assert.Null(harness.Manager.CurrentPersonalOperatorLease); Assert.Null(harness.Manager.CurrentSnapshot.PersonalIdentityProfileId); } @@ -115,6 +116,7 @@ public async Task BrowserProfileChangeRetiresOnlyItsCurrentPersonalConnection() await peer.SelfAsync(await peer.ReceiveAsync(), "different-person"); Assert.Null(await signing); Assert.Null(harness.Manager.CurrentPersonalOperatorLease); + Assert.Equal(GatewayErrorKind.PersonalIdentityReverificationRequired, harness.Manager.CurrentSnapshot.OperatorErrorKind); Assert.NotEqual(RoleConnectionState.Connected, harness.Manager.CurrentSnapshot.OperatorState); } diff --git a/tests/OpenClaw.Tray.Tests/ConnectionPagePersonalIdentityTests.cs b/tests/OpenClaw.Tray.Tests/ConnectionPagePersonalIdentityTests.cs new file mode 100644 index 0000000000..69389bde08 --- /dev/null +++ b/tests/OpenClaw.Tray.Tests/ConnectionPagePersonalIdentityTests.cs @@ -0,0 +1,43 @@ +using System.Xml.Linq; +using OpenClaw.Connection; +using OpenClaw.Shared; +using OpenClawTray.Pages; + +namespace OpenClaw.Tray.Tests; + +public sealed class ConnectionPagePersonalIdentityTests +{ + [Theory] + [InlineData(GatewayErrorKind.PersonalIdentityUnverified, "ConnectionPage_PersonalIdentityUnverified", + "Votre identité Tailscale n’a pas pu être vérifiée. Reconnectez cette passerelle. Les identifiants partagés ne seront pas utilisés.")] + [InlineData(GatewayErrorKind.PersonalIdentityReverificationRequired, "ConnectionPage_PersonalIdentityReverificationRequired", + "Votre identité Tailscale doit être vérifiée à nouveau. Reconnectez cette passerelle. Les identifiants partagés ne seront pas utilisés.")] + public void PersonalFailureUsesLocalizedGuidanceInsteadOfRawDiagnostics(GatewayErrorKind kind, string detailKey, string french) + { + const string raw = "untrusted-remote-detail-314159"; + var snapshot = new GatewayConnectionSnapshot + { + OverallState = OverallConnectionState.Error, + OperatorState = RoleConnectionState.Error, + OperatorErrorKind = kind, + OperatorError = raw, + }; + var plan = ConnectionPagePlan.Build(snapshot, new GatewayRecord + { + Id = "personal", Url = "wss://personal.example.ts.net", + OperatorAuthentication = OperatorAuthenticationMode.PersonalTailscale, + }, self: null, settings: null, savedGatewayCount: 1); + + Assert.Equal(ConnectionPageMode.Recovery, plan.Mode); + Assert.Equal("ConnectionPage_PersonalIdentityHeader", plan.StripHeadlineResourceKey); + Assert.Equal(detailKey, plan.StripSubResourceKey); + Assert.Equal(detailKey, Assert.Single(plan.RecoveryBulletResourceKeys)); + Assert.DoesNotContain(raw, plan.StripSub); + Assert.Null(plan.RecoveryDetail); + Assert.DoesNotContain(plan.Recovery, new[] { RecoveryCategory.Auth, RecoveryCategory.TokenDrift, RecoveryCategory.Scope }); + var document = XDocument.Load(Path.Combine(TestRepositoryPaths.GetRepositoryRoot(), + "src", "OpenClaw.Tray.WinUI", "Strings", "fr-fr", "Resources.resw")); + Assert.Equal(french, document.Root!.Elements("data") + .Single(element => (string?)element.Attribute("name") == detailKey).Element("value")!.Value); + } +} diff --git a/tests/OpenClaw.Tray.Tests/GatewayDirectConnectServiceTests.cs b/tests/OpenClaw.Tray.Tests/GatewayDirectConnectServiceTests.cs index 2653f073c1..d2744c0fc4 100644 --- a/tests/OpenClaw.Tray.Tests/GatewayDirectConnectServiceTests.cs +++ b/tests/OpenClaw.Tray.Tests/GatewayDirectConnectServiceTests.cs @@ -8,6 +8,33 @@ namespace OpenClaw.Tray.Tests; public sealed class GatewayDirectConnectServiceTests : IDisposable { + [Theory] + [InlineData(GatewayErrorKind.PersonalIdentityUnverified, true, "ConnectionPage_PersonalIdentityUnverified")] + [InlineData(GatewayErrorKind.PersonalIdentityReverificationRequired, true, "ConnectionPage_PersonalIdentityReverificationRequired")] + [InlineData(GatewayErrorKind.PersonalIdentityUnverified, false, "ConnectionPage_PersonalIdentityRecoveryIncomplete")] + [InlineData(GatewayErrorKind.PersonalIdentityReverificationRequired, false, "ConnectionPage_PersonalIdentityRecoveryIncomplete")] + public async Task PersonalFailureKindSurvivesRestoringThePreviousConnection(GatewayErrorKind kind, bool restoreSucceeds, string resourceKey) + { + var previous = AddPreviousGateway(); + _manager.SetCurrentSnapshot(Connected(previous.Id)); + _manager.NextSnapshot = Failed(previous.Id, "untrusted-remote-detail-314159") with { OperatorErrorKind = kind }; + _manager.RestoreSnapshot = restoreSucceeds ? Connected(previous.Id) + : Failed(previous.Id, "restoration-diagnostic") with { OperatorErrorKind = GatewayErrorKind.Network }; + + var result = await CreateService().ConnectAsync(new( + "wss://personal.example.ts.net", null, null, null, + OperatorAuthentication: OperatorAuthenticationMode.PersonalTailscale)); + + Assert.Equal(GatewayDirectConnectOutcome.Failed, result.Outcome); + Assert.Equal(kind, result.ErrorKind); + Assert.Equal(previous.Id, _manager.CurrentSnapshot.GatewayId); + Assert.Equal(restoreSucceeds ? RoleConnectionState.Connected : RoleConnectionState.Error, _manager.CurrentSnapshot.OperatorState); + Assert.Equal(restoreSucceeds ? null : (GatewayErrorKind?)GatewayErrorKind.Network, _manager.CurrentSnapshot.OperatorErrorKind); + Assert.Equal(!restoreSucceeds, result.RollbackIncomplete); + Assert.Equal(resourceKey, OpenClawTray.Helpers.GatewayPersonalErrorPresentation.ResourceKey(result.ErrorKind, result.RollbackIncomplete)); + Assert.False(result.GatewayCommitted); + } + [Theory] [InlineData("ws://fixture.example.ts.net", null, false)] [InlineData("wss://fixture.example.com", null, false)] diff --git a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj index 18892f2028..389ff980ba 100644 --- a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj +++ b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj @@ -258,6 +258,7 @@ + diff --git a/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs b/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs index 1b57275397..d6644ff8b5 100644 --- a/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs +++ b/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs @@ -86,7 +86,26 @@ await WaitUiAsync(run, () => FindById(run, "SettingsPageAppTheme") is { Current. await run.InvokeAsync("app.navigate", new { page = "chat" }); await WaitUiAsync(run, () => FindById(run, "WorkspacePagesCustomize") is { Current.IsOffscreen: false }, "Chat pin customization"); - var window = FindHub(run); + AutomationElement window; + try { window = FindHub(run); } + catch (InvalidOperationException error) + { + string diagnostic; + try + { + diagnostic = JsonSerializer.Serialize(AppWindows(run).Select(candidate => new + { + window = Describe(candidate), + hasComposer = candidate.FindFirst(TreeScope.Descendants, + new PropertyCondition(AutomationElement.AutomationIdProperty, "ChatComposerInput")) is not null, + hasCustomizer = candidate.FindFirst(TreeScope.Descendants, + new PropertyCondition(AutomationElement.AutomationIdProperty, "WorkspacePagesCustomize")) is not null, + }).ToArray()); + } + catch (Exception diagnosticError) { diagnostic = diagnosticError.ToString(); } + throw new InvalidOperationException( + $"Pinned Usage {theme}: owned chat-window lookup failed after the customize control became visible. Owned-window observations: {diagnostic}", error); + } var handle = new IntPtr(window.Current.NativeWindowHandle); await NativeKeyboardProof.ActivateAsync(handle); var scale = UsageGetDpiForWindow(handle) / 96d; @@ -626,6 +645,13 @@ await run.WaitForAsync(async () => return true; } } + if (candidate is null && FindById(run, "UsageSessionsShowAll") is { Current.IsOffscreen: false } more) + { + Invoke(more); + requestedPercent = 0; + scroll.SetScrollPercent(ScrollPattern.NoScroll, requestedPercent); + return false; + } Assert.True(requestedPercent < 100 && position.VerticalViewSize is > 0 and < 100, "Main Usage session header has no visible measured geometry at the end of the page."); // Overlapping half-viewport steps reveal the intended row, not a calendar-dependent offset. From c43d070bea087ef940d40571855e41715b0d3aac Mon Sep 17 00:00:00 2001 From: Vitor Cepeda Lopes <7040636+TheAngryPit@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:59:09 +0000 Subject: [PATCH 6/6] docs: document personal recovery resource usage --- .../Helpers/GatewayPersonalErrorPresentation.cs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/OpenClaw.Tray.WinUI/Helpers/GatewayPersonalErrorPresentation.cs b/src/OpenClaw.Tray.WinUI/Helpers/GatewayPersonalErrorPresentation.cs index 134fca6b2f..3a4cde31c1 100644 --- a/src/OpenClaw.Tray.WinUI/Helpers/GatewayPersonalErrorPresentation.cs +++ b/src/OpenClaw.Tray.WinUI/Helpers/GatewayPersonalErrorPresentation.cs @@ -1,10 +1,16 @@ +// Maps personal identity failures to native recovery resources. using OpenClaw.Shared; namespace OpenClawTray.Helpers; /// Native recovery resources for personal identity failures, without raw Gateway diagnostics. +/// +/// Resolve ResourceKey(result.ErrorKind, result.RollbackIncomplete) through native localization; +/// a null result leaves non-personal error presentation with its existing owner. +/// internal static class GatewayPersonalErrorPresentation { + /// Returns the recovery resource for a personal failure, or null for other error kinds. public static string? ResourceKey(GatewayErrorKind? kind, bool rollbackIncomplete = false) { if (kind is not (GatewayErrorKind.PersonalIdentityUnverified or GatewayErrorKind.PersonalIdentityReverificationRequired))