From bd8ab21e0a31af98b8fcd3e45dc38bb4d65ef4e7 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Tue, 18 Aug 2026 04:23:19 +0100 Subject: [PATCH 01/38] fix(companion): require live Tailscale readiness for dashboard auth --- .../GatewayConnectionManager.cs | 59 ++ src/OpenClaw.Connection/GatewayRecord.cs | 8 + .../GatewayTailscaleAuthUpgrade.cs | 539 ++++++++++++ .../IGatewayConnectionManager.cs | 9 + src/OpenClaw.SetupEngine/PairOperatorStep.cs | 12 + .../TailscaleSetupSteps.cs | 18 +- .../Capabilities/AppCapability.cs | 11 +- src/OpenClaw.Shared/ChannelsSnapshot.cs | 7 + src/OpenClaw.Shared/IOperatorGatewayClient.cs | 2 + src/OpenClaw.Shared/OpenClawGatewayClient.cs | 16 +- .../TailscaleServeStatusPolicy.cs | 209 +++++ .../App.CapabilityHandlers.cs | 31 +- src/OpenClaw.Tray.WinUI/App.xaml.cs | 70 +- .../Helpers/GatewayDashboardUrlBuilder.cs | 13 +- .../Pages/ConnectionPage.xaml.cs | 81 +- .../GatewayTailscaleAuthLiveVerifierTests.cs | 431 ++++++++++ .../GatewayTailscaleAuthUpgradeTests.cs | 780 ++++++++++++++++++ .../Setup/SetupAndConnectTests.cs | 11 +- .../SetupStepsTests.cs | 69 ++ .../AppCapabilityTests.cs | 39 + .../OpenClawGatewayClientTests.cs | 86 +- .../AppRefactorContractTests.cs | 27 + .../ConnectionPageTailscaleRecoveryTests.cs | 47 ++ .../GatewayDashboardUrlBuilderTests.cs | 17 + 24 files changed, 2563 insertions(+), 29 deletions(-) create mode 100644 src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs create mode 100644 src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs create mode 100644 tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs create mode 100644 tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs diff --git a/src/OpenClaw.Connection/GatewayConnectionManager.cs b/src/OpenClaw.Connection/GatewayConnectionManager.cs index f2c57556a0..8f49e95fd5 100644 --- a/src/OpenClaw.Connection/GatewayConnectionManager.cs +++ b/src/OpenClaw.Connection/GatewayConnectionManager.cs @@ -56,6 +56,7 @@ public sealed class GatewayConnectionManager : private readonly ICredentialResolver _credentialResolver; private readonly IGatewayClientFactory _clientFactory; private readonly GatewayRegistry _registry; + private readonly IGatewayTailscaleAuthLiveVerifier _tailscaleAuthLiveVerifier; private readonly IOpenClawLogger _logger; private readonly IDeviceIdentityStore? _identityStore; private readonly INodeConnector? _nodeConnector; @@ -132,6 +133,8 @@ public GatewayConnectionManager( _clientFactory = clientFactory ?? throw new ArgumentNullException(nameof(clientFactory)); _registry = registry ?? throw new ArgumentNullException(nameof(registry)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + _tailscaleAuthLiveVerifier = new GatewayTailscaleAuthLiveVerifier( + new WslExeCommandRunner(_logger)); _identityStore = identityStore; _nodeConnector = nodeConnector; _tunnelManager = tunnelManager; @@ -203,6 +206,62 @@ public GatewayConnectionManager( public IOperatorGatewayClient? OperatorClient => _activeLifecycle?.DataClient; /// Internal access to the concrete client for auto-approve and other manager-internal operations. internal OpenClawGatewayClient? ConcreteOperatorClient => _activeLifecycle?.DataClient; + + public async Task EnableTailscaleDashboardAuthAsync( + string gatewayId, + CancellationToken cancellationToken = default) + { + await _transitionSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false); + try + { + if (!string.Equals(_activeGatewayRecordId, gatewayId, StringComparison.Ordinal)) + return new(GatewayTailscaleAuthUpgradeOutcome.NotActive); + + var client = OperatorClient; + if (client is null) + return new(GatewayTailscaleAuthUpgradeOutcome.NotConnected); + + var service = new GatewayTailscaleAuthUpgradeService(_registry); + return await service.EnableAsync( + gatewayId, + new GatewayTailscaleAuthConfigClientAdapter(client), + cancellationToken) + .ConfigureAwait(false); + } + finally + { + _transitionSemaphore.Release(); + } + } + + public async Task RevalidateTailscaleDashboardAuthAsync( + string gatewayId, + CancellationToken cancellationToken = default) + { + await _transitionSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false); + try + { + if (!string.Equals(_activeGatewayRecordId, gatewayId, StringComparison.Ordinal)) + return false; + + var client = OperatorClient; + if (client is null) + return false; + + var service = new GatewayTailscaleAuthUpgradeService( + _registry, + _tailscaleAuthLiveVerifier); + return await service.RevalidateAsync( + gatewayId, + new GatewayTailscaleAuthConfigClientAdapter(client), + cancellationToken) + .ConfigureAwait(false); + } + finally + { + _transitionSemaphore.Release(); + } + } public ConnectionDiagnostics Diagnostics => _diagnostics; // ─── Lifecycle ─── diff --git a/src/OpenClaw.Connection/GatewayRecord.cs b/src/OpenClaw.Connection/GatewayRecord.cs index 379bd3424c..5be315505d 100644 --- a/src/OpenClaw.Connection/GatewayRecord.cs +++ b/src/OpenClaw.Connection/GatewayRecord.cs @@ -33,6 +33,12 @@ public sealed record GatewayRecord /// WSL distro name for gateway records provisioned by SetupEngine. public string? SetupManagedDistroName { get; init; } + /// + /// True when setup or an explicit upgrade granted this managed gateway's + /// Dashboard access to verified Tailscale identity authentication. + /// + public bool TrustTailscaleAuth { get; init; } + /// Per-gateway SSH tunnel configuration. Null if no tunnel needed. public SshTunnelConfig? SshTunnel { get; init; } @@ -95,6 +101,7 @@ rebuilt.SshTunnel is null && // Migrate legacy "Local ()" ownership to the explicit durable marker. SetupManagedDistroName = managedDistroName, RequiresV2Signature = rebuilt.RequiresV2Signature || existing.RequiresV2Signature, + TrustTailscaleAuth = rebuilt.TrustTailscaleAuth || existing.TrustTailscaleAuth, }; } else if (existingManagedDistroName is not null) @@ -104,6 +111,7 @@ rebuilt.SshTunnel is null && IsLocal = OpenClaw.Shared.LocalGatewayUrlClassifier.IsLocalGatewayUrl(rebuilt.Url), SetupManagedDistroName = null, RequiresV2Signature = false, + TrustTailscaleAuth = false, FriendlyName = ParseLegacyManagedDistroName(result.FriendlyName) is not null ? null : result.FriendlyName, diff --git a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs new file mode 100644 index 0000000000..283af7b491 --- /dev/null +++ b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs @@ -0,0 +1,539 @@ +using System.Security.Cryptography; +using System.Text; +using System.Text.Json; +using OpenClaw.Shared; + +namespace OpenClaw.Connection; + +public enum GatewayTailscaleAuthUpgradeOutcome +{ + Succeeded, + AlreadyEnabled, + Ineligible, + NotActive, + NotConnected, + MissingConfigScope, + ConfigUnavailable, + PatchRejected, + PersistenceFailed, +} + +public sealed record GatewayTailscaleAuthUpgradeResult( + GatewayTailscaleAuthUpgradeOutcome Outcome, + string? Error = null) +{ + public bool IsSuccess => Outcome is + GatewayTailscaleAuthUpgradeOutcome.Succeeded or + GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled; +} + +public static class GatewayTailscaleAuthUpgradePolicy +{ + public static bool IsEligible(GatewayRecord? record) + { + if (record is null || + !record.IsLocal || + record.SshTunnel is not null || + GatewayRecordEditing.ResolveManagedDistroName(record) is null) + { + return false; + } + + // Topology only limits where the opt-in is offered; confirmation and a successful Core patch grant trust. + return GatewayTopologyClassifier.Classify(record.Url, useSshTunnel: false).DetectedKind == + GatewayKind.Tailscale; + } + + public static bool CanOffer(GatewayRecord? record) => + record?.TrustTailscaleAuth != true && IsEligible(record); +} + +internal interface IGatewayTailscaleAuthConfigClient +{ + IReadOnlyList GrantedOperatorScopes { get; } + bool IsConnectedToGateway { get; } + Task RequestConfigDetailedAsync(int timeoutMs = 15000); + Task PatchConfigDetailedAsync( + JsonElement fullConfig, + string? baseHash, + int timeoutMs = 15000); +} + +internal sealed class GatewayTailscaleAuthConfigClientAdapter(IOperatorGatewayClient client) + : IGatewayTailscaleAuthConfigClient +{ + public IReadOnlyList GrantedOperatorScopes => client.GrantedOperatorScopes; + public bool IsConnectedToGateway => client.IsConnectedToGateway; + public Task RequestConfigDetailedAsync(int timeoutMs = 15000) => + client.RequestConfigDetailedAsync(timeoutMs); + public Task PatchConfigDetailedAsync( + JsonElement fullConfig, + string? baseHash, + int timeoutMs = 15000) => + client.PatchConfigDetailedAsync(fullConfig, baseHash, timeoutMs); +} + +internal enum GatewayTailscaleAuthLiveState +{ + Ready, + NotReady, + Unavailable, +} + +internal interface IGatewayTailscaleAuthLiveVerifier +{ + Task VerifyAsync( + GatewayRecord record, + int gatewayPort, + CancellationToken cancellationToken); +} + +internal sealed class GatewayTailscaleAuthLiveVerifier : IGatewayTailscaleAuthLiveVerifier +{ + private static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(5); + private static readonly IReadOnlyList StatusCommand = + ["/usr/bin/tailscale", "status", "--json"]; + private static readonly IReadOnlyList ServeStatusCommand = + ["/usr/bin/tailscale", "serve", "status", "--json"]; + + private readonly IWslCommandRunner _commandRunner; + private readonly TimeSpan _timeout; + + public GatewayTailscaleAuthLiveVerifier( + IWslCommandRunner commandRunner, + TimeSpan? timeout = null) + { + _commandRunner = commandRunner ?? throw new ArgumentNullException(nameof(commandRunner)); + _timeout = timeout ?? DefaultTimeout; + } + + public async Task VerifyAsync( + GatewayRecord record, + int gatewayPort, + CancellationToken cancellationToken) + { + if (GatewayRecordEditing.ResolveManagedDistroName(record) is not { } distroName || + !Uri.TryCreate(record.Url, UriKind.Absolute, out var gatewayUri) || + gatewayPort is <= 0 or > 65535) + { + return GatewayTailscaleAuthLiveState.Unavailable; + } + + using var timeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); + timeout.CancelAfter(_timeout); + + WslCommandResult statusResult; + try + { + statusResult = await _commandRunner.RunAsync( + BuildRootProbeArguments(distroName, StatusCommand), + timeout.Token) + .ConfigureAwait(false); + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + throw; + } + catch + { + return GatewayTailscaleAuthLiveState.Unavailable; + } + + if (!statusResult.Success) + return GatewayTailscaleAuthLiveState.Unavailable; + + string dnsName; + try + { + using var status = JsonDocument.Parse(statusResult.StandardOutput); + var root = status.RootElement; + var backendRunning = + root.ValueKind == JsonValueKind.Object && + root.TryGetProperty("BackendState", out var backendState) && + backendState.ValueKind == JsonValueKind.String && + string.Equals(backendState.GetString(), "Running", StringComparison.Ordinal); + dnsName = + root.ValueKind == JsonValueKind.Object && + root.TryGetProperty("Self", out var self) && + self.ValueKind == JsonValueKind.Object && + self.TryGetProperty("DNSName", out var dnsNameElement) && + dnsNameElement.ValueKind == JsonValueKind.String && + !string.IsNullOrWhiteSpace(dnsNameElement.GetString()) + ? dnsNameElement.GetString()!.Trim().TrimEnd('.') + : string.Empty; + + if (!backendRunning || + !string.Equals(dnsName, gatewayUri.Host.TrimEnd('.'), StringComparison.OrdinalIgnoreCase)) + { + return GatewayTailscaleAuthLiveState.NotReady; + } + } + catch (JsonException) + { + return GatewayTailscaleAuthLiveState.Unavailable; + } + + WslCommandResult serveResult; + try + { + serveResult = await _commandRunner.RunAsync( + BuildRootProbeArguments(distroName, ServeStatusCommand), + timeout.Token) + .ConfigureAwait(false); + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + throw; + } + catch + { + return GatewayTailscaleAuthLiveState.Unavailable; + } + + if (!serveResult.Success || + !TailscaleServeStatusPolicy.TryParse( + serveResult.StandardOutput, + gatewayPort, + gatewayUri, + out var serveStatus)) + { + return GatewayTailscaleAuthLiveState.Unavailable; + } + + return serveStatus.RoutesToGateway && !serveStatus.FunnelEnabled + ? GatewayTailscaleAuthLiveState.Ready + : GatewayTailscaleAuthLiveState.NotReady; + } + + private static IReadOnlyList BuildRootProbeArguments( + string distroName, + IReadOnlyList command) => + ["-d", distroName, "--user", "root", "--", .. command]; +} + +internal sealed class GatewayTailscaleAuthUpgradeService +{ + private static readonly TimeSpan ConfigTimeout = TimeSpan.FromSeconds(15); + private readonly GatewayRegistry _registry; + private readonly IGatewayTailscaleAuthLiveVerifier? _liveVerifier; + + public GatewayTailscaleAuthUpgradeService(GatewayRegistry registry) + : this(registry, liveVerifier: null) + { + } + + public GatewayTailscaleAuthUpgradeService( + GatewayRegistry registry, + IGatewayTailscaleAuthLiveVerifier? liveVerifier) + { + _registry = registry ?? throw new ArgumentNullException(nameof(registry)); + _liveVerifier = liveVerifier; + } + + public async Task EnableAsync( + string gatewayId, + IGatewayTailscaleAuthConfigClient client, + CancellationToken cancellationToken) + { + var record = _registry.GetById(gatewayId); + if (!GatewayTailscaleAuthUpgradePolicy.IsEligible(record)) + return new(GatewayTailscaleAuthUpgradeOutcome.Ineligible); + + if (!string.Equals(_registry.ActiveGatewayId, gatewayId, StringComparison.Ordinal)) + return new(GatewayTailscaleAuthUpgradeOutcome.NotActive); + + if (!client.IsConnectedToGateway) + return new(GatewayTailscaleAuthUpgradeOutcome.NotConnected); + + if (!OperatorScopeHelper.CanReadConfig(client.GrantedOperatorScopes) || + !OperatorScopeHelper.CanWriteConfig(client.GrantedOperatorScopes)) + { + return new(GatewayTailscaleAuthUpgradeOutcome.MissingConfigScope); + } + + ConfigSnapshot snapshot; + try + { + snapshot = await ReadConfigAsync(client, cancellationToken).ConfigureAwait(false); + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + throw; + } + catch (Exception ex) + { + return new(GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable, ex.Message); + } + + cancellationToken.ThrowIfCancellationRequested(); + + if (record!.TrustTailscaleAuth && AllowsTailscaleAuth(snapshot.Root)) + return new(GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled); + + if (string.IsNullOrWhiteSpace(snapshot.BaseHash)) + { + return new(GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable, "Config base hash is unavailable."); + } + + var previousValue = false; + var changed = false; + if (!record.TrustTailscaleAuth) + { + _registry.Update(gatewayId, current => + { + if (!GatewayTailscaleAuthUpgradePolicy.CanOffer(current)) + return current; + + previousValue = current.TrustTailscaleAuth; + changed = true; + return current with { TrustTailscaleAuth = true }; + }); + + if (!changed) + return new(GatewayTailscaleAuthUpgradeOutcome.NotActive); + + try + { + _registry.Save(); + } + catch (Exception ex) + { + _registry.Update(gatewayId, current => current with { TrustTailscaleAuth = previousValue }); + return new(GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, ex.Message); + } + } + + if (cancellationToken.IsCancellationRequested) + { + var rollback = RollBackMarkerAfterRejectedPatch( + gatewayId, + changed, + previousValue, + patchError: null); + if (rollback.Outcome == GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed) + return rollback; + cancellationToken.ThrowIfCancellationRequested(); + } + + // Core beta.7 and current main define config.patch as JSON Merge Patch. + // Send only the intended leaf: replaying the full snapshot would turn + // unrelated null values into deletion markers. + var configPatch = CreateAllowTailscalePatch(); + ConfigPatchResult patch; + Task? patchTask = null; + try + { + patchTask = client.PatchConfigDetailedAsync(configPatch, snapshot.BaseHash); + patch = await patchTask.WaitAsync(cancellationToken) + .ConfigureAwait(false); + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + // Dispatch cannot be canceled at the client boundary. Observe its bounded + // result before returning so callers never proceed beside an in-flight + // mutation. Roll back only a definitive gateway rejection; otherwise the + // marker remains for the next trust-aware live revalidation. + try + { + var completedPatch = await patchTask!.ConfigureAwait(false); + if (!completedPatch.Ok && completedPatch.IsGatewayRejection) + { + var rollback = RollBackMarkerAfterRejectedPatch( + gatewayId, + changed, + previousValue, + completedPatch.Error); + if (rollback.Outcome == GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed) + return rollback; + } + } + catch + { + // A transport failure is ambiguous: Core may have committed. + } + throw; + } + catch (Exception ex) + { + // The response can be lost after Core commits the patch. Keep the marker so + // the next trust-aware launch revalidates the authoritative Core state. + return new(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, ex.Message); + } + + if (!patch.Ok && patch.IsGatewayRejection) + return RollBackMarkerAfterRejectedPatch(gatewayId, changed, previousValue, patch.Error); + + if (!patch.Ok) + { + // The request may have committed before its response was lost. Preserve + // the marker so the next trust-aware launch revalidates Core state. + return new(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, patch.Error); + } + + return new(GatewayTailscaleAuthUpgradeOutcome.Succeeded); + } + + public async Task RevalidateAsync( + string gatewayId, + IGatewayTailscaleAuthConfigClient client, + CancellationToken cancellationToken) + { + var record = _registry.GetById(gatewayId); + if (record?.TrustTailscaleAuth != true || + !GatewayTailscaleAuthUpgradePolicy.IsEligible(record) || + !string.Equals(_registry.ActiveGatewayId, gatewayId, StringComparison.Ordinal) || + !client.IsConnectedToGateway || + !OperatorScopeHelper.CanReadConfig(client.GrantedOperatorScopes)) + { + return false; + } + + ConfigSnapshot snapshot; + try + { + snapshot = await ReadConfigAsync(client, cancellationToken).ConfigureAwait(false); + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + throw; + } + catch + { + return false; + } + + if (AllowsTailscaleAuth(snapshot.Root)) + { + if (_liveVerifier is null || !TryGetGatewayPort(snapshot.Root, out var gatewayPort)) + return false; + + try + { + return await _liveVerifier.VerifyAsync(record, gatewayPort, cancellationToken).ConfigureAwait(false) == + GatewayTailscaleAuthLiveState.Ready; + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + throw; + } + catch + { + return false; + } + } + + _registry.Update(gatewayId, current => current with { TrustTailscaleAuth = false }); + try + { + _registry.Save(); + } + catch + { + _registry.Update(gatewayId, current => current with { TrustTailscaleAuth = true }); + } + return false; + } + + private static async Task ReadConfigAsync( + IGatewayTailscaleAuthConfigClient client, + CancellationToken cancellationToken) + { + var timeoutMs = checked((int)ConfigTimeout.TotalMilliseconds); + var response = await client.RequestConfigDetailedAsync(timeoutMs) + .WaitAsync(cancellationToken) + .ConfigureAwait(false); + return CaptureSnapshot(response); + } + + private static ConfigSnapshot CaptureSnapshot(JsonElement response) + { + var root = response.TryGetProperty("parsed", out var parsed) + ? parsed + : response.TryGetProperty("config", out var config) + ? config + : response; + var baseHash = response.TryGetProperty("baseHash", out var baseHashElement) && + baseHashElement.ValueKind == JsonValueKind.String + ? baseHashElement.GetString() + : response.TryGetProperty("hash", out var hashElement) && + hashElement.ValueKind == JsonValueKind.String + ? hashElement.GetString() + : null; + if (baseHash is null && + response.TryGetProperty("raw", out var rawElement) && + rawElement.ValueKind == JsonValueKind.String && + rawElement.GetString() is { } raw) + { + baseHash = Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(raw))); + } + + return new(root.Clone(), baseHash); + } + + private static JsonElement CreateAllowTailscalePatch() + { + using var document = JsonDocument.Parse(""" + { "gateway": { "auth": { "allowTailscale": true } } } + """); + return document.RootElement.Clone(); + } + + private GatewayTailscaleAuthUpgradeResult RollBackMarkerAfterRejectedPatch( + string gatewayId, + bool changed, + bool previousValue, + string? patchError) + { + if (!changed) + return new(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, patchError); + + _registry.Update(gatewayId, current => current with { TrustTailscaleAuth = previousValue }); + try + { + _registry.Save(); + return new(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, patchError); + } + catch (Exception ex) + { + return new( + GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, + $"Local Tailscale trust-marker rollback failed: {ex.Message}"); + } + } + + // A true marker is issued only after this service or setup explicitly writes + // allowTailscale=true. Omission therefore means that grant drifted or was revoked; + // do not duplicate Core's environment-sensitive implicit auth resolver here. + private static bool AllowsTailscaleAuth(JsonElement config) => + config.ValueKind == JsonValueKind.Object && + config.TryGetProperty("gateway", out var gateway) && + gateway.ValueKind == JsonValueKind.Object && + gateway.TryGetProperty("auth", out var auth) && + auth.ValueKind == JsonValueKind.Object && + auth.TryGetProperty("allowTailscale", out var allowTailscale) && + allowTailscale.ValueKind is JsonValueKind.True; + + private static bool TryGetGatewayPort(JsonElement config, out int port) + { + const int defaultGatewayPort = 18789; + port = 0; + if (config.ValueKind != JsonValueKind.Object || + !config.TryGetProperty("gateway", out var gateway) || + gateway.ValueKind != JsonValueKind.Object) + { + return false; + } + + if (!gateway.TryGetProperty("port", out var gatewayPort)) + { + port = defaultGatewayPort; + return true; + } + + return gatewayPort.ValueKind == JsonValueKind.Number && + gatewayPort.TryGetInt32(out port) && + port is > 0 and <= 65535; + } + + private sealed record ConfigSnapshot(JsonElement Root, string? BaseHash); +} diff --git a/src/OpenClaw.Connection/IGatewayConnectionManager.cs b/src/OpenClaw.Connection/IGatewayConnectionManager.cs index 0dc94a65ff..eab1c1632c 100644 --- a/src/OpenClaw.Connection/IGatewayConnectionManager.cs +++ b/src/OpenClaw.Connection/IGatewayConnectionManager.cs @@ -29,6 +29,15 @@ public interface IGatewayConnectionManager : IDisposable, IAsyncDisposable Task RestartSshTunnelAsync(CancellationToken cancellationToken = default) => Task.FromResult(false); Task SwitchGatewayAsync(string gatewayId); + Task EnableTailscaleDashboardAuthAsync( + string gatewayId, + CancellationToken cancellationToken = default) => + Task.FromResult(new GatewayTailscaleAuthUpgradeResult( + GatewayTailscaleAuthUpgradeOutcome.NotConnected)); + Task RevalidateTailscaleDashboardAuthAsync( + string gatewayId, + CancellationToken cancellationToken = default) => + Task.FromResult(false); void SetGatewayConnectionIntent(string gatewayId, bool shouldBeConnected); bool IsAutomaticReconnectAllowed(string gatewayId); diff --git a/src/OpenClaw.SetupEngine/PairOperatorStep.cs b/src/OpenClaw.SetupEngine/PairOperatorStep.cs index 9a30951df7..f2bf76840e 100644 --- a/src/OpenClaw.SetupEngine/PairOperatorStep.cs +++ b/src/OpenClaw.SetupEngine/PairOperatorStep.cs @@ -12,6 +12,8 @@ namespace OpenClaw.SetupEngine; public sealed class PairOperatorStep : SetupStep { + private const string AllowTailscaleConfigKey = "gateway.auth.allowTailscale"; + public override string Id => "pair-operator"; public override string DisplayName => "Pair operator connection"; public override RetryPolicy Retry => new(MaxAttempts: 3, InitialDelay: TimeSpan.FromSeconds(3)); @@ -50,6 +52,7 @@ public override async Task ExecuteAsync(SetupContext ctx, Cancellati BootstrapToken = ctx.BootstrapToken, IsLocal = true, SetupManagedDistroName = ctx.DistroName, + TrustTailscaleAuth = ResolveEffectiveTailscaleAuthTrust(ctx.Config), LastConnected = DateTime.UtcNow }; @@ -166,6 +169,15 @@ record = registry.AddOrUpdate(record); } } + private static bool ResolveEffectiveTailscaleAuthTrust(SetupConfig config) + { + if (!config.Tailscale.Enabled || !config.Tailscale.TrustTailscaleAuth) + return false; + + return config.Gateway.ExtraConfig?.TryGetValue(AllowTailscaleConfigKey, out var value) != true || + bool.TryParse(value, out var enabled) && enabled; + } + internal static async Task EnsurePairingEndpointTrustedAsync( SetupContext ctx, CancellationToken cancellationToken, diff --git a/src/OpenClaw.SetupEngine/TailscaleSetupSteps.cs b/src/OpenClaw.SetupEngine/TailscaleSetupSteps.cs index cf8c6eb99c..9817f7e186 100644 --- a/src/OpenClaw.SetupEngine/TailscaleSetupSteps.cs +++ b/src/OpenClaw.SetupEngine/TailscaleSetupSteps.cs @@ -139,15 +139,21 @@ private static bool HasGatewayWebProxy(JsonElement root, int port) foreach (var webEndpoint in web.EnumerateObject()) { - if (!webEndpoint.Value.TryGetProperty("Handlers", out var handlers) || handlers.ValueKind != JsonValueKind.Object) + if (webEndpoint.Value.ValueKind != JsonValueKind.Object || + !webEndpoint.Value.TryGetProperty("Handlers", out var handlers) || + handlers.ValueKind != JsonValueKind.Object) + { continue; + } foreach (var handler in handlers.EnumerateObject()) { if (handler.Value.ValueKind != JsonValueKind.Object || !handler.Value.TryGetProperty("Proxy", out var proxy) || proxy.ValueKind != JsonValueKind.String) + { continue; + } if (IsLoopbackGatewayProxy(proxy.GetString(), port)) return true; @@ -157,9 +163,6 @@ private static bool HasGatewayWebProxy(JsonElement root, int port) return false; } - // Serve status represents Funnel as AllowFunnel on current Tailscale - // versions. Accept the legacy Funnel spelling too so a version change - // cannot silently turn a public endpoint into an accepted setup state. private static bool HasEnabledFunnel(JsonElement root) { foreach (var property in root.EnumerateObject()) @@ -176,11 +179,10 @@ private static bool HasEnabledFunnel(JsonElement root) JsonValueKind.True => true, JsonValueKind.False or JsonValueKind.Null or JsonValueKind.Undefined => false, JsonValueKind.Array => value.EnumerateArray().Any(ContainsEnabledFunnelValue), - JsonValueKind.Object => value.EnumerateObject().Any(property => ContainsEnabledFunnelValue(property.Value)), - // A non-empty string is a configured public endpoint in older status - // documents. Be conservative: setup must never accept it as private. + JsonValueKind.Object => value.EnumerateObject().Any(property => + ContainsEnabledFunnelValue(property.Value)), JsonValueKind.String => !string.IsNullOrWhiteSpace(value.GetString()), - _ => false + _ => false, }; private static bool IsLoopbackGatewayProxy(string? proxy, int port) => diff --git a/src/OpenClaw.Shared/Capabilities/AppCapability.cs b/src/OpenClaw.Shared/Capabilities/AppCapability.cs index 5faac7ccc2..cbc4fe948d 100644 --- a/src/OpenClaw.Shared/Capabilities/AppCapability.cs +++ b/src/OpenClaw.Shared/Capabilities/AppCapability.cs @@ -46,7 +46,7 @@ public class AppCapability : NodeCapabilityBase public Func? SettingsSetHandler; public Func? MenuHandler; public Func? SearchHandler; - public Func? DashboardUrlHandler; + public Func>? DashboardUrlHandler; public Func>? ChatSnapshotHandler; public Func>? ChatSendHandler; public Func>? ChatResetHandler; @@ -69,7 +69,7 @@ public override async Task ExecuteAsync(NodeInvokeRequest re "app.settings.set" => HandleSettingsSet(request), "app.menu" => HandleMenu(), "app.search" => HandleSearch(request), - "app.dashboard.url" => HandleDashboardUrl(request), + "app.dashboard.url" => await HandleDashboardUrl(request), "app.chat.snapshot" => await HandleChatSnapshot(request), "app.chat.send" => await HandleChatSend(request), "app.chat.reset" => await HandleChatReset(request), @@ -197,11 +197,14 @@ private NodeInvokeResponse HandleSearch(NodeInvokeRequest request) return Success(SearchHandler(query)); } - private NodeInvokeResponse HandleDashboardUrl(NodeInvokeRequest request) + private async Task HandleDashboardUrl(NodeInvokeRequest request) { if (DashboardUrlHandler == null) return Error("Dashboard URL handler not registered"); - return Success(DashboardUrlHandler(GetStringArg(request.Args, "path"))); + var result = await DashboardUrlHandler(GetStringArg(request.Args, "path")); + if (TryGetErrorPayload(result, out var error)) + return Error(error); + return Success(result); } private async Task HandleChatSnapshot(NodeInvokeRequest request) diff --git a/src/OpenClaw.Shared/ChannelsSnapshot.cs b/src/OpenClaw.Shared/ChannelsSnapshot.cs index 123f8dffb7..03c32027c7 100644 --- a/src/OpenClaw.Shared/ChannelsSnapshot.cs +++ b/src/OpenClaw.Shared/ChannelsSnapshot.cs @@ -357,6 +357,13 @@ public sealed class ConfigPatchResult /// Raw JSON of the gateway response (or stringified exception). For diagnostic disclosure. public string? RawResponse { get; init; } + /// + /// True only when the gateway returned an explicit pre-commit rejection. + /// Transport failures, timeouts, and post-commit runtime errors leave the + /// commit outcome unknown and must not be treated as authoritative. + /// + public bool IsGatewayRejection { get; init; } + /// /// True when the gateway rejected the patch because our baseHash was /// stale (someone else changed the config out from under us). Pages diff --git a/src/OpenClaw.Shared/IOperatorGatewayClient.cs b/src/OpenClaw.Shared/IOperatorGatewayClient.cs index 6c93e99c26..1860b22677 100644 --- a/src/OpenClaw.Shared/IOperatorGatewayClient.cs +++ b/src/OpenClaw.Shared/IOperatorGatewayClient.cs @@ -115,6 +115,8 @@ async Task RunCronJobDetailedAsync(string jobId, bool forc Task InstallSkillAsync(string skillId); Task SetSkillEnabledAsync(string skillKey, bool enabled); Task RequestConfigAsync(); + Task RequestConfigDetailedAsync(int timeoutMs = 15000) => + Task.FromException(new NotSupportedException("Response-aware config.get is not supported by this client.")); Task RequestConfigSchemaAsync(); Task SetConfigAsync(string path, object value); Task PatchConfigAsync(JsonElement fullConfig, string? baseHash); diff --git a/src/OpenClaw.Shared/OpenClawGatewayClient.cs b/src/OpenClaw.Shared/OpenClawGatewayClient.cs index e929b07273..ed12a35360 100644 --- a/src/OpenClaw.Shared/OpenClawGatewayClient.cs +++ b/src/OpenClaw.Shared/OpenClawGatewayClient.cs @@ -12,6 +12,11 @@ namespace OpenClaw.Shared; +internal sealed class GatewayRequestRejectedException(string message, string? code) : InvalidOperationException(message) +{ + public string? Code { get; } = code; +} + public partial class OpenClawGatewayClient : WebSocketClientBase, IOperatorGatewayClient { private const string OperatorClientId = "cli"; @@ -1226,6 +1231,9 @@ public async Task RequestConfigAsync() await SendTrackedRequestAsync("config.get"); } + public Task RequestConfigDetailedAsync(int timeoutMs = 15000) => + SendWizardRequestAsync("config.get", timeoutMs: timeoutMs); + public async Task RequestConfigSchemaAsync() { await SendTrackedRequestAsync("config.schema"); @@ -1283,6 +1291,10 @@ public async Task PatchConfigDetailedAsync(JsonElement fullCo Ok = false, Error = ex.Message, RawResponse = ex.ToString(), + IsGatewayRejection = ex is GatewayRequestRejectedException + { + Code: "INVALID_REQUEST", + }, }; } } @@ -1988,7 +2000,9 @@ private void HandleResponseForConnection( okWiz.ValueKind == JsonValueKind.False) { var message = TryGetErrorMessage(root) ?? "wizard request failed"; - wizardCompletion.TryFault(new InvalidOperationException(message)); + wizardCompletion.TryFault(new GatewayRequestRejectedException( + message, + TryGetErrorTopLevelCode(root))); } else if (root.TryGetProperty("payload", out var wizPayload)) { diff --git a/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs b/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs new file mode 100644 index 0000000000..0f5fedb8f3 --- /dev/null +++ b/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs @@ -0,0 +1,209 @@ +using System.Text.Json; + +namespace OpenClaw.Shared; + +public sealed record TailscaleServeStatusResult(bool RoutesToGateway, bool FunnelEnabled); + +public static class TailscaleServeStatusPolicy +{ + public static bool TryParse( + string status, + int port, + Uri? expectedEndpoint, + out TailscaleServeStatusResult parsed) + { + parsed = new TailscaleServeStatusResult(false, false); + if (port is <= 0 or > 65535) + return false; + + try + { + using var document = JsonDocument.Parse(status); + var root = document.RootElement; + if (root.ValueKind != JsonValueKind.Object || + !HasValidWebShape(root) || + !TryReadFunnelState(root, out var funnelEnabled)) + { + return false; + } + + parsed = new TailscaleServeStatusResult( + RoutesToGateway: HasGatewayWebProxy(root, port, expectedEndpoint), + FunnelEnabled: funnelEnabled); + return true; + } + catch (JsonException) + { + return false; + } + } + + private static bool HasValidWebShape(JsonElement root) + { + if (!root.TryGetProperty("Web", out var web)) + return true; + if (web.ValueKind != JsonValueKind.Object) + return false; + + foreach (var endpoint in web.EnumerateObject()) + { + if (endpoint.Value.ValueKind != JsonValueKind.Object) + return false; + if (endpoint.Value.TryGetProperty("Handlers", out var handlers) && + handlers.ValueKind != JsonValueKind.Object) + { + return false; + } + + if (endpoint.Value.TryGetProperty("Handlers", out handlers)) + { + foreach (var handler in handlers.EnumerateObject()) + { + if (handler.Value.ValueKind != JsonValueKind.Object || + (handler.Value.TryGetProperty("Proxy", out var proxy) && + proxy.ValueKind != JsonValueKind.String)) + { + return false; + } + } + } + } + + return true; + } + + private static bool HasGatewayWebProxy(JsonElement root, int port, Uri? expectedEndpoint) + { + if (!root.TryGetProperty("Web", out var web) || web.ValueKind != JsonValueKind.Object) + return false; + + foreach (var webEndpoint in web.EnumerateObject()) + { + if (!EndpointMatches(webEndpoint.Name, expectedEndpoint) || + webEndpoint.Value.ValueKind != JsonValueKind.Object || + !webEndpoint.Value.TryGetProperty("Handlers", out var handlers) || + handlers.ValueKind != JsonValueKind.Object || + !handlers.TryGetProperty("/", out var rootHandler) || + rootHandler.ValueKind != JsonValueKind.Object || + !rootHandler.TryGetProperty("Proxy", out var proxy) || + proxy.ValueKind != JsonValueKind.String) + { + continue; + } + + if (IsLoopbackGatewayProxy(proxy.GetString(), port)) + return true; + } + + return false; + } + + private static bool EndpointMatches(string endpoint, Uri? expectedEndpoint) + { + if (expectedEndpoint is null) + return true; + + var candidate = endpoint.Contains("://", StringComparison.Ordinal) + ? endpoint + : $"https://{endpoint}"; + return Uri.TryCreate(candidate, UriKind.Absolute, out var uri) && + uri.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) && + !HasUserInfoDelimiter(candidate) && + string.IsNullOrEmpty(uri.UserInfo) && + HasCanonicalRootPathAndNoSuffix(candidate) && + string.IsNullOrEmpty(uri.Query) && + string.IsNullOrEmpty(uri.Fragment) && + string.Equals( + uri.Host.TrimEnd('.'), + expectedEndpoint.Host.TrimEnd('.'), + StringComparison.OrdinalIgnoreCase) && + uri.Port == expectedEndpoint.Port; + } + + private static bool TryReadFunnelState(JsonElement root, out bool enabled) + { + enabled = false; + foreach (var property in root.EnumerateObject()) + { + if (!property.NameEquals("AllowFunnel") && !property.NameEquals("Funnel")) + continue; + if (!TryContainsEnabledFunnelValue(property.Value, out var propertyEnabled)) + return false; + enabled |= propertyEnabled; + } + + return true; + } + + private static bool TryContainsEnabledFunnelValue(JsonElement value, out bool enabled) + { + enabled = false; + switch (value.ValueKind) + { + case JsonValueKind.True: + enabled = true; + return true; + case JsonValueKind.False: + case JsonValueKind.Null: + return true; + case JsonValueKind.String: + enabled = !string.IsNullOrWhiteSpace(value.GetString()); + return true; + case JsonValueKind.Array: + foreach (var item in value.EnumerateArray()) + { + if (!TryContainsEnabledFunnelValue(item, out var itemEnabled)) + return false; + enabled |= itemEnabled; + } + return true; + case JsonValueKind.Object: + foreach (var property in value.EnumerateObject()) + { + if (!TryContainsEnabledFunnelValue(property.Value, out var propertyEnabled)) + return false; + enabled |= propertyEnabled; + } + return true; + default: + return false; + } + } + + private static bool IsLoopbackGatewayProxy(string? proxy, int port) => + proxy is not null && + Uri.TryCreate(proxy, UriKind.Absolute, out var uri) && + uri.Scheme.Equals(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) && + uri.Port == port && + HasCanonicalRootPathAndNoSuffix(proxy) && + !HasUserInfoDelimiter(proxy) && + string.IsNullOrEmpty(uri.UserInfo) && + string.IsNullOrEmpty(uri.Query) && + string.IsNullOrEmpty(uri.Fragment) && + (uri.Host.Equals("127.0.0.1", StringComparison.OrdinalIgnoreCase) || + uri.Host.Equals("localhost", StringComparison.OrdinalIgnoreCase)); + + private static bool HasUserInfoDelimiter(string value) + { + var authorityStart = value.IndexOf("://", StringComparison.Ordinal); + if (authorityStart < 0) + return false; + authorityStart += 3; + + var authorityEnd = value.IndexOfAny(['/', '?', '#'], authorityStart); + if (authorityEnd < 0) + authorityEnd = value.Length; + return value.AsSpan(authorityStart, authorityEnd - authorityStart).Contains('@'); + } + + private static bool HasCanonicalRootPathAndNoSuffix(string value) + { + var authorityStart = value.IndexOf("://", StringComparison.Ordinal); + if (authorityStart < 0) + return false; + authorityStart += 3; + + var suffixStart = value.IndexOfAny(['/', '\\', '?', '#'], authorityStart); + return suffixStart < 0 || value.AsSpan(suffixStart).SequenceEqual("/"); + } +} diff --git a/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs b/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs index 8e93ebbe9e..da0afc3ddf 100644 --- a/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs +++ b/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs @@ -224,16 +224,39 @@ private void WireAppCapabilityHandlers() return matches; }; - app.DashboardUrlHandler = (path) => + app.DashboardUrlHandler = async (path) => { - if (!TryResolveChatCredentials(out var gatewayUrl, out var token, out var credentialSource, out var isBootstrapToken)) + if (!TryResolveChatCredentials(out var gatewayUrl, out var dashboardCredential, out var credentialSource, out var isBootstrapToken)) return new { error = "Gateway URL or credential is not configured" }; + var active = _gatewayRegistry?.GetActive(); + var activeMatches = active is not null && + string.Equals(active.Url, gatewayUrl, StringComparison.OrdinalIgnoreCase); + var trustTailscaleAuth = false; + if (active?.TrustTailscaleAuth == true && + activeMatches && + _connectionManager is not null) + { + trustTailscaleAuth = await _connectionManager + .RevalidateTailscaleDashboardAuthAsync(active.Id); + } + + var usesSharedCredential = + !isBootstrapToken && credentialSource == CredentialResolver.SourceSharedGatewayToken; + + if (!GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential( + trustTailscaleAuth, + usesSharedCredential)) + { + return new { error = GatewayDashboardUrlBuilder.NoBrowserCompatibleCredentialError }; + } + var url = GatewayDashboardUrlBuilder.Build( gatewayUrl, path, - token, - !isBootstrapToken && credentialSource == CredentialResolver.SourceSharedGatewayToken); + dashboardCredential, + usesSharedCredential, + trustTailscaleAuth); return new { diff --git a/src/OpenClaw.Tray.WinUI/App.xaml.cs b/src/OpenClaw.Tray.WinUI/App.xaml.cs index a57b2c8c1e..a56ff2434b 100644 --- a/src/OpenClaw.Tray.WinUI/App.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/App.xaml.cs @@ -3812,11 +3812,77 @@ private void OpenDashboard(string? path = null) return; } - var url = GatewayDashboardUrlBuilder.Build( + var appendBrowserCredential = + !isBootstrapToken && credentialSource == CredentialResolver.SourceSharedGatewayToken; + var active = _gatewayRegistry?.GetActive(); + if (active?.TrustTailscaleAuth == true && + string.Equals(active.Url, gatewayUrl, StringComparison.OrdinalIgnoreCase) && + _connectionManager is not null) + { + _ = OpenDashboardAfterTailscaleAuthRevalidationAsync( + active.Id, + gatewayUrl, + path, + token, + appendBrowserCredential); + return; + } + + if (!GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential( + trustTailscaleAuth: false, + usesSharedGatewayToken: appendBrowserCredential)) + { + ShowConnectionSettingsForPairingIssue( + "Dashboard", + "Tailscale authentication is unavailable and no approved browser credential is available"); + return; + } + + LaunchDashboardUrl(GatewayDashboardUrlBuilder.Build( gatewayUrl, path, token, - !isBootstrapToken && credentialSource == CredentialResolver.SourceSharedGatewayToken); + appendBrowserCredential)); + } + + private async Task OpenDashboardAfterTailscaleAuthRevalidationAsync( + string gatewayId, + string gatewayUrl, + string? path, + string? browserCredential, + bool appendBrowserCredential) + { + var trustTailscaleAuth = false; + try + { + trustTailscaleAuth = await _connectionManager! + .RevalidateTailscaleDashboardAuthAsync(gatewayId); + } + catch (Exception ex) + { + Logger.Warn($"Failed to revalidate Tailscale dashboard auth: {ex.Message}"); + } + + if (!GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential( + trustTailscaleAuth, + appendBrowserCredential)) + { + ShowConnectionSettingsForPairingIssue( + "Dashboard", + "Tailscale authentication is unavailable and no approved browser credential is available"); + return; + } + + LaunchDashboardUrl(GatewayDashboardUrlBuilder.Build( + gatewayUrl, + path, + browserCredential, + appendBrowserCredential && !trustTailscaleAuth, + trustTailscaleAuth)); + } + + private static void LaunchDashboardUrl(string url) + { try { diff --git a/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs b/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs index 60391616ab..61dff64255 100644 --- a/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs +++ b/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs @@ -2,11 +2,20 @@ namespace OpenClawTray.Helpers; public static class GatewayDashboardUrlBuilder { + public const string NoBrowserCompatibleCredentialError = + "No browser-compatible gateway credential is available"; + + public static bool HasBrowserCompatibleCredential( + bool trustTailscaleAuth, + bool usesSharedGatewayToken) => + trustTailscaleAuth || usesSharedGatewayToken; + public static string Build( string gatewayUrl, string? path, string? sharedGatewayToken, - bool appendSharedGatewayToken) + bool appendSharedGatewayToken, + bool trustTailscaleAuth = false) { ArgumentException.ThrowIfNullOrWhiteSpace(gatewayUrl); @@ -19,7 +28,7 @@ public static string Build( ? baseUrl : $"{baseUrl}/{path.TrimStart('/')}"; - if (appendSharedGatewayToken && !string.IsNullOrEmpty(sharedGatewayToken)) + if (appendSharedGatewayToken && !trustTailscaleAuth && !string.IsNullOrEmpty(sharedGatewayToken)) { var separator = url.Contains('#') ? "&" : "#"; url = $"{url}{separator}token={Uri.EscapeDataString(sharedGatewayToken)}"; diff --git a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs index 7800cd7092..b2845bcdac 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs @@ -1797,6 +1797,17 @@ private Border BuildSavedGatewayRowControl(SavedGatewayRow row) var openDashboard = new MenuFlyoutItem { Text = LocalizationHelper.GetString("ConnectionPage_OpenDashboard"), Tag = row.Id }; openDashboard.Click += OnSavedRowOpenDashboard; flyout.Items.Add(openDashboard); + var gatewayRecord = _gatewayRegistry?.GetById(row.Id); + if (row.IsActive && GatewayTailscaleAuthUpgradePolicy.CanOffer(gatewayRecord)) + { + var enableTailscaleAuth = new MenuFlyoutItem + { + Text = "Use Tailscale identity for dashboard", + Tag = row.Id, + }; + enableTailscaleAuth.Click += OnEnableTailscaleDashboardAuth; + flyout.Items.Add(enableTailscaleAuth); + } if (row.HasHostTerminal) { var openTerminal = new MenuFlyoutItem { Text = row.HostTerminalLabel, Tag = row.Id }; @@ -2520,7 +2531,23 @@ private async Task OnSavedRowOpenDashboardAsync(object sender) if (rec == null) return; try { - if (!string.IsNullOrWhiteSpace(rec.SharedGatewayToken)) + var trustTailscaleAuth = rec.TrustTailscaleAuth && + _connectionManager is not null && + await _connectionManager.RevalidateTailscaleDashboardAuthAsync(rec.Id); + if (trustTailscaleAuth) + { + var tailscaleUrl = GatewayDashboardUrlBuilder.Build( + rec.Url, + path: null, + rec.SharedGatewayToken, + appendSharedGatewayToken: false, + trustTailscaleAuth: true); + await global::Windows.System.Launcher.LaunchUriAsync(new Uri(tailscaleUrl)); + return; + } + + var usesSharedGatewayToken = !string.IsNullOrWhiteSpace(rec.SharedGatewayToken); + if (usesSharedGatewayToken) { var provenanceService = CurrentApp.ManagedLocalPortProvenance; if (provenanceService is null) @@ -2538,11 +2565,20 @@ private async Task OnSavedRowOpenDashboardAsync(object sender) } } + if (!GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential( + trustTailscaleAuth, + usesSharedGatewayToken)) + { + CurrentApp.ShowTransientConnectionError( + "Tailscale authentication is unavailable and no approved browser credential is available"); + return; + } + var url = GatewayDashboardUrlBuilder.Build( rec.Url, path: null, rec.SharedGatewayToken, - appendSharedGatewayToken: !string.IsNullOrWhiteSpace(rec.SharedGatewayToken)); + appendSharedGatewayToken: usesSharedGatewayToken); await global::Windows.System.Launcher.LaunchUriAsync(new Uri(url)); } catch (Exception ex) @@ -2551,6 +2587,47 @@ private async Task OnSavedRowOpenDashboardAsync(object sender) } } + private void OnEnableTailscaleDashboardAuth(object sender, RoutedEventArgs e) => + AsyncEventHandlerGuard.Run( + () => OnEnableTailscaleDashboardAuthAsync(sender), + new AppLogger(), + nameof(OnEnableTailscaleDashboardAuth)); + + private async Task OnEnableTailscaleDashboardAuthAsync(object sender) + { + if (sender is not MenuFlyoutItem item || + item.Tag is not string gatewayId || + _connectionManager is null) + { + return; + } + + var dialog = new ContentDialog + { + Title = "Use Tailscale identity for dashboard?", + Content = "This enables verified Tailscale identity authentication on this managed gateway. Your saved token, device identity, WSL distro, and pairing remain unchanged.", + PrimaryButtonText = "Enable", + CloseButtonText = LocalizationHelper.GetString("ConnectionPage_CancelAction"), + DefaultButton = ContentDialogButton.Close, + XamlRoot = XamlRoot, + }; + if (await dialog.ShowAsync() != ContentDialogResult.Primary) + return; + + var result = await _connectionManager.EnableTailscaleDashboardAuthAsync(gatewayId); + if (result.IsSuccess) + { + SetGatewayHostActionStatus("Tailscale dashboard identity enabled."); + LoadSavedGateways(); + return; + } + + var detail = string.IsNullOrWhiteSpace(result.Error) + ? result.Outcome.ToString() + : result.Error; + SetGatewayHostActionStatus($"Could not enable Tailscale dashboard identity: {detail}", isError: true); + } + private void OnSavedRowEdit(object sender, RoutedEventArgs e) { if (sender is not MenuFlyoutItem item || item.Tag is not string gwId) return; diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs new file mode 100644 index 0000000000..30637d6fad --- /dev/null +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -0,0 +1,431 @@ +using System.Text.Json; + +namespace OpenClaw.Connection.Tests; + +public sealed class GatewayTailscaleAuthLiveVerifierTests +{ + [Fact] + public void ConnectionManager_WiresWslLiveVerifierIntoDashboardRevalidation() + { + var source = File.ReadAllText(Path.Combine( + GetRepositoryRoot(), + "src", + "OpenClaw.Connection", + "GatewayConnectionManager.cs")); + var revalidationStart = source.IndexOf( + "public async Task RevalidateTailscaleDashboardAuthAsync(", + StringComparison.Ordinal); + var diagnosticsStart = source.IndexOf( + "public ConnectionDiagnostics Diagnostics", + revalidationStart, + StringComparison.Ordinal); + + Assert.True(revalidationStart >= 0); + Assert.True(diagnosticsStart > revalidationStart); + Assert.Contains( + "new GatewayTailscaleAuthLiveVerifier(\n new WslExeCommandRunner(_logger))", + source.Replace("\r\n", "\n", StringComparison.Ordinal)); + var revalidation = source[revalidationStart..diagnosticsStart] + .Replace("\r\n", "\n", StringComparison.Ordinal); + Assert.Contains( + "new GatewayTailscaleAuthUpgradeService(\n" + + " _registry,\n" + + " _tailscaleAuthLiveVerifier);", + revalidation); + } + + [Theory] + [MemberData(nameof(StatusResults))] + public async Task VerifyAsync_ClassifiesStatusResult( + WslCommandResult commandResult, + string expected) + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ServeStatus() + : commandResult)); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(expected, result.ToString()); + Assert.Equal("OpenClawGateway", runner.DistroName); + Assert.Equal(["/usr/bin/tailscale", "status", "--json"], runner.Commands[0]); + Assert.Equal( + ["-d", "OpenClawGateway", "--user", "root", "--", "/usr/bin/tailscale", "status", "--json"], + runner.HostArguments[0]); + Assert.Equal(expected == "Ready" ? 2 : 1, runner.ProbeCalls); + if (expected == "Ready") + { + Assert.Equal(["/usr/bin/tailscale", "serve", "status", "--json"], runner.Commands[1]); + Assert.Equal( + ["-d", "OpenClawGateway", "--user", "root", "--", "/usr/bin/tailscale", "serve", "status", "--json"], + runner.HostArguments[1]); + } + } + + [Fact] + public async Task VerifyAsync_RecordWithoutManagedDistroIsUnavailableWithoutCommand() + { + var runner = new FakeWslCommandRunner((_, _, _) => + Task.FromResult(RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync( + ManagedRecord() with { SetupManagedDistroName = null, FriendlyName = null }, + 18789, + CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.Unavailable, result); + Assert.Equal(0, runner.ProbeCalls); + } + + [Fact] + public async Task VerifyAsync_RunnerFailureIsUnavailable() + { + var runner = new FakeWslCommandRunner((_, _, _) => + Task.FromException(new InvalidOperationException("wsl unavailable"))); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.Unavailable, result); + } + + [Fact] + public async Task VerifyAsync_TimeoutIsUnavailable() + { + var runner = new FakeWslCommandRunner(async (_, _, cancellationToken) => + { + await Task.Delay(Timeout.InfiniteTimeSpan, cancellationToken); + throw new InvalidOperationException("unreachable"); + }); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromMilliseconds(20)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.Unavailable, result); + } + + [Fact] + public async Task VerifyAsync_CallerCancellationPropagates() + { + var runner = new FakeWslCommandRunner(async (_, _, cancellationToken) => + { + await Task.Delay(Timeout.InfiniteTimeSpan, cancellationToken); + throw new InvalidOperationException("unreachable"); + }); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + using var cancellation = new CancellationTokenSource(); + cancellation.Cancel(); + + await Assert.ThrowsAnyAsync(() => + verifier.VerifyAsync(ManagedRecord(), 18789, cancellation.Token)); + } + + [Theory] + [InlineData("other.tail.example.", 18789, false, "NotReady")] + [InlineData("host.tail.example.", 19999, false, "NotReady")] + [InlineData("host.tail.example.", 18789, true, "NotReady")] + public async Task VerifyAsync_FailsClosedWhenEndpointOrServeRouteDoesNotMatch( + string dnsName, + int proxyPort, + bool funnelEnabled, + string expected) + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ServeStatus(proxyPort: proxyPort, funnelEnabled: funnelEnabled) + : Status("Running", dnsName))); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(expected, result.ToString()); + } + + [Fact] + public async Task VerifyAsync_UnrelatedServeHostIsNotReady() + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ServeStatus(host: "other.tail.example") + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.NotReady, result); + } + + [Theory] + [InlineData(8443, "", "NotReady")] + [InlineData(443, "/unrelated", "NotReady")] + [InlineData(443, "/app/..", "NotReady")] + [InlineData(443, "\\backend", "NotReady")] + [InlineData(443, "?target=other", "NotReady")] + [InlineData(443, "#fragment", "NotReady")] + public async Task VerifyAsync_RequiresExactPublicEndpointAndCoreRootProxy( + int endpointPort, + string proxySuffix, + string expected) + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ServeStatus(endpointPort: endpointPort, proxySuffix: proxySuffix) + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(expected, result.ToString()); + } + + [Theory] + [InlineData("user:password@")] + [InlineData("@")] + public async Task VerifyAsync_RejectsProxyUserInfo(string proxyUserInfo) + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ServeStatus(proxyUserInfo: proxyUserInfo) + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.NotReady, result); + } + + [Theory] + [InlineData("http://host.tail.example:443")] + [InlineData("https://user@host.tail.example:443")] + [InlineData("https://@host.tail.example:443")] + [InlineData("https://host.tail.example:443/path")] + [InlineData("https://host.tail.example:443/app/..")] + [InlineData("https://host.tail.example:443\\app")] + [InlineData("https://host.tail.example:443?query=1")] + [InlineData("https://host.tail.example:443#fragment")] + public async Task VerifyAsync_RejectsNonCanonicalServeEndpoint(string endpoint) + { + var endpointJson = JsonSerializer.Serialize(endpoint); + var serveJson = $$""" + { + "Web": { + {{endpointJson}}: { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:18789" } } + } + } + } + """; + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? new WslCommandResult(0, serveJson, "") + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.NotReady, result); + } + + [Theory] + [InlineData("[]")] + [InlineData("null")] + [InlineData("{\"Web\":[]}")] + [InlineData("{\"Web\":{\"host.tail.example:443\":[]}}")] + public async Task VerifyAsync_StructurallyUnexpectedServeStatusIsUnavailable(string serveJson) + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? new WslCommandResult(0, serveJson, "") + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.Unavailable, result); + } + + [Theory] + [InlineData("[]")] + [InlineData("42")] + [InlineData("{\"Proxy\":42}")] + public async Task VerifyAsync_MalformedSiblingHandlerIsUnavailable(string malformedHandler) + { + var serveJson = $$""" + { + "Web": { + "host.tail.example:443": { + "Handlers": { + "/": { "Proxy": "http://127.0.0.1:18789" }, + "/bad": {{malformedHandler}} + } + } + } + } + """; + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? new WslCommandResult(0, serveJson, "") + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.Unavailable, result); + } + + [Theory] + [InlineData("\"AllowFunnel\": false, \"Funnel\": true", "NotReady")] + [InlineData("\"AllowFunnel\": 42", "Unavailable")] + [InlineData("\"Funnel\": [false, {\"legacy\": true}]", "NotReady")] + public async Task VerifyAsync_EvaluatesEveryFunnelAliasAndRejectsUnknownShapes( + string funnelProperties, + string expected) + { + var serveJson = $$""" + { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:18789" } } + } + }, + {{funnelProperties}} + } + """; + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? new WslCommandResult(0, serveJson, "") + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(expected, result.ToString()); + } + + public static TheoryData StatusResults => new() + { + { RunningStatus(), "Ready" }, + { Status("NeedsLogin", "host.tail.example."), "NotReady" }, + { Status("Stopped", "host.tail.example."), "NotReady" }, + { Status("Running", ""), "NotReady" }, + { new WslCommandResult(0, "{}", ""), "NotReady" }, + { new WslCommandResult(0, "not-json", ""), "Unavailable" }, + { new WslCommandResult(1, "", "tailscaled unavailable"), "Unavailable" }, + }; + + private static WslCommandResult RunningStatus() => Status("Running", "host.tail.example."); + + private static WslCommandResult ServeStatus( + string host = "host.tail.example", + int endpointPort = 443, + int proxyPort = 18789, + string proxySuffix = "", + string proxyUserInfo = "", + bool funnelEnabled = false) + { + var proxyJson = JsonSerializer.Serialize( + $"http://{proxyUserInfo}127.0.0.1:{proxyPort}{proxySuffix}"); + return new( + 0, + $$""" + { + "Web": { + "{{host}}:{{endpointPort}}": { + "Handlers": { "/": { "Proxy": {{proxyJson}} } } + } + }, + "AllowFunnel": { "{{host}}:{{endpointPort}}": {{funnelEnabled.ToString().ToLowerInvariant()}} } + } + """, + ""); + } + + private static string GetRepositoryRoot() + { + var current = new DirectoryInfo(AppContext.BaseDirectory); + while (current is not null) + { + if ((Directory.Exists(Path.Combine(current.FullName, ".git")) || + File.Exists(Path.Combine(current.FullName, ".git"))) && + File.Exists(Path.Combine( + current.FullName, + "src", + "OpenClaw.Connection", + "GatewayConnectionManager.cs"))) + { + return current.FullName; + } + + current = current.Parent; + } + + throw new InvalidOperationException("Could not find repository root."); + } + + private static WslCommandResult Status(string backendState, string dnsName) => + new( + 0, + $"{{\"BackendState\":\"{backendState}\",\"Self\":{{\"DNSName\":\"{dnsName}\"}}}}", + ""); + + private static GatewayRecord ManagedRecord() => new() + { + Id = "gateway-1", + Url = "wss://host.tail.example", + IsLocal = true, + SetupManagedDistroName = "OpenClawGateway", + TrustTailscaleAuth = true, + }; + + private sealed class FakeWslCommandRunner( + Func, CancellationToken, Task> runInDistro) + : IWslCommandRunner + { + public int ProbeCalls { get; private set; } + public string? DistroName { get; private set; } + public List> Commands { get; } = []; + public List> HostArguments { get; } = []; + + public Task RunInDistroAsync( + string name, + IReadOnlyList command, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) + => throw new NotSupportedException(); + + public Task RunAsync( + IReadOnlyList arguments, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) + { + HostArguments.Add(arguments); + Assert.True(arguments.Count >= 6); + Assert.Equal("-d", arguments[0]); + Assert.Equal("--user", arguments[2]); + Assert.Equal("root", arguments[3]); + Assert.Equal("--", arguments[4]); + ProbeCalls++; + DistroName = arguments[1]; + var command = arguments.Skip(5).ToArray(); + Commands.Add(command); + return runInDistro(DistroName, command, cancellationToken); + } + + public Task> ListDistrosAsync( + CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public Task TerminateDistroAsync( + string name, + CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public Task UnregisterDistroAsync( + string name, + CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + } +} diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs new file mode 100644 index 0000000000..ad57425d96 --- /dev/null +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs @@ -0,0 +1,780 @@ +using System.Text.Json; +using OpenClaw.Shared; +using OpenClaw.TestSupport; + +namespace OpenClaw.Connection.Tests; + +public sealed class GatewayTailscaleAuthUpgradeTests : IDisposable +{ + private readonly TempDirectory _temp = new(); + + [Fact] + public async Task EnableAsync_PersistsRecordBeforePatchingCore() + { + var registry = CreateRegistry(); + var client = new FakeConfigClient(Config(allowTailscale: false)); + client.BeforePatch = () => Assert.True(registry.GetActive()!.TrustTailscaleAuth); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.Succeeded, result.Outcome); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); + Assert.Equal(1, client.PatchCalls); + Assert.Equal("base-1", client.PatchBaseHash); + Assert.True(client.PatchedConfig!.Value + .GetProperty("gateway") + .GetProperty("auth") + .GetProperty("allowTailscale") + .GetBoolean()); + Assert.False(client.PatchedConfig.Value.TryGetProperty("unrelated", out _)); + + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", reloaded.GetActive()!.SharedGatewayToken); + } + + [Fact] + public async Task EnableAsync_CoreAlreadyEnabled_RequiresAcceptedIdempotentPatch() + { + var registry = CreateRegistry(); + var client = new FakeConfigClient(Config(allowTailscale: true)); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.Succeeded, result.Outcome); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(1, client.PatchCalls); + } + + [Fact] + public async Task EnableAsync_PersistedMarkerRevalidatesLiveCoreState() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: false)); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.Succeeded, result.Outcome); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(1, client.ConfigRequests); + Assert.Equal(1, client.PatchCalls); + } + + [Fact] + public async Task EnableAsync_PersistedMarkerAndLiveCoreStateReturnAlreadyEnabled() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: true)); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled, result.Outcome); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(1, client.ConfigRequests); + Assert.Equal(0, client.PatchCalls); + } + + [Fact] + public async Task EnableAsync_PersistedMarkerDoesNotRequirePatchHashWhenCoreAllowsTailscale() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: true, includeBaseHash: false)); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled, result.Outcome); + Assert.Equal(0, client.PatchCalls); + } + + [Fact] + public async Task EnableAsync_MissingBaseHash_FailsClosedBeforePatch() + { + var registry = CreateRegistry(); + var client = new FakeConfigClient(Config(allowTailscale: false, includeBaseHash: false)); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable, result.Outcome); + Assert.Equal(0, client.PatchCalls); + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + } + + [Fact] + public async Task EnableAsync_PatchRejected_LeavesRecordAndCredentialsUntouched() + { + var registry = CreateRegistry(); + var client = new FakeConfigClient(Config(allowTailscale: false)) + { + PatchResult = new ConfigPatchResult + { + Ok = false, + Error = "rejected", + IsGatewayRejection = true, + }, + }; + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, result.Outcome); + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); + } + + [Fact] + public async Task EnableAsync_AmbiguousPatchFailure_PreservesMarkerForRevalidation() + { + var registry = CreateRegistry(); + var client = new FakeConfigClient(Config(allowTailscale: false)) + { + PatchResult = new ConfigPatchResult { Ok = false, Error = "request timed out" }, + }; + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, result.Outcome); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); + } + + [Fact] + public async Task EnableAsync_MissingScopes_DoesNotRequestOrMutateConfig() + { + var registry = CreateRegistry(); + var client = new FakeConfigClient(Config(allowTailscale: false)) + { + Scopes = ["operator.read"], + }; + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.MissingConfigScope, result.Outcome); + Assert.Equal(0, client.ConfigRequests); + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + } + + [Fact] + public async Task EnableAsync_SaveFailure_RestoresInMemoryMarker() + { + var registry = CreateRegistry(new FailingWriteFileSystem()); + var client = new FakeConfigClient(Config(allowTailscale: true)); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, result.Outcome); + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); + Assert.Equal(0, client.PatchCalls); + } + + [Fact] + public async Task RevalidateAsync_CoreStillAllowsTailscale_KeepsMarkerAndReturnsTrue() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: true)); + var liveVerifier = new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready); + var service = new GatewayTailscaleAuthUpgradeService(registry, liveVerifier); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.True(trusted); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(1, client.ConfigRequests); + Assert.Equal(0, client.PatchCalls); + Assert.Equal(1, liveVerifier.Calls); + Assert.Equal(18789, liveVerifier.LastGatewayPort); + } + + [Fact] + public async Task RevalidateAsync_OmittedGatewayPort_UsesCoreDefault() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: true, includeGatewayPort: false)); + var liveVerifier = new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready); + var service = new GatewayTailscaleAuthUpgradeService(registry, liveVerifier); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.True(trusted); + Assert.Equal(18789, liveVerifier.LastGatewayPort); + } + + [Theory] + [InlineData("0")] + [InlineData("65536")] + [InlineData("\"18789\"")] + public async Task RevalidateAsync_InvalidExplicitGatewayPort_FailsClosed(string gatewayPort) + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(ConfigWithGatewayPort(gatewayPort)); + var liveVerifier = new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready); + var service = new GatewayTailscaleAuthUpgradeService(registry, liveVerifier); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(trusted); + Assert.Equal(0, liveVerifier.Calls); + } + + [Fact] + public async Task RevalidateAsync_CoreAllowsWithoutLiveVerifier_PreservesMarkerAndTokenAndReturnsFalse() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: true)); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(trusted); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); + Assert.Equal(1, client.ConfigRequests); + + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", reloaded.GetActive()!.SharedGatewayToken); + } + + [Fact] + public async Task RevalidateAsync_CoreAllowsButLiveForwardedIdentityIsUnavailable_KeepsMarkerAndReturnsFalse() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: true)); + var liveVerifier = new FakeLiveVerifier(GatewayTailscaleAuthLiveState.NotReady); + var service = new GatewayTailscaleAuthUpgradeService(registry, liveVerifier); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(trusted); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(1, client.ConfigRequests); + Assert.Equal(1, liveVerifier.Calls); + + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + } + + [Fact] + public async Task RevalidateAsync_LiveVerifierFailure_KeepsMarkerAndReturnsFalse() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: true)); + var liveVerifier = new FakeLiveVerifier(new InvalidOperationException("live probe unavailable")); + var service = new GatewayTailscaleAuthUpgradeService(registry, liveVerifier); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(trusted); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(1, liveVerifier.Calls); + } + + [Fact] + public async Task RevalidateAsync_LiveVerifierRecovery_ReturnsTrueWithoutReissuingMarker() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: true)); + var liveVerifier = new FakeLiveVerifier( + GatewayTailscaleAuthLiveState.Unavailable, + GatewayTailscaleAuthLiveState.Ready); + var service = new GatewayTailscaleAuthUpgradeService(registry, liveVerifier); + + var unavailable = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + var recovered = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(unavailable); + Assert.True(recovered); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(2, client.ConfigRequests); + Assert.Equal(2, liveVerifier.Calls); + } + + [Fact] + public async Task RevalidateAsync_ConfigFailurePreservesMarkerAndSkipsLiveVerifier() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: true)) + { + ConfigError = new InvalidOperationException("config unavailable"), + }; + var liveVerifier = new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready); + var service = new GatewayTailscaleAuthUpgradeService(registry, liveVerifier); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(trusted); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(1, client.ConfigRequests); + Assert.Equal(0, liveVerifier.Calls); + } + + [Fact] + public async Task RevalidateAsync_OmittedExplicitGrantClearsMarker() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(ImplicitServeConfig()); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(trusted); + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(1, client.ConfigRequests); + Assert.Equal(0, client.PatchCalls); + } + + [Fact] + public async Task RevalidateAsync_CoreDisablesTailscale_ClearsPersistedMarkerAndReturnsFalse() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: false)); + var liveVerifier = new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready); + var service = new GatewayTailscaleAuthUpgradeService(registry, liveVerifier); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(trusted); + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); + Assert.Equal(0, client.PatchCalls); + Assert.Equal(0, liveVerifier.Calls); + + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.False(reloaded.GetActive()!.TrustTailscaleAuth); + } + + [Fact] + public async Task RevalidateAsync_CallerCancellationRemainsCancellation() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + var client = new FakeConfigClient(Config(allowTailscale: true)) { EmitConfig = false }; + var service = new GatewayTailscaleAuthUpgradeService(registry); + using var cancellation = new CancellationTokenSource(); + cancellation.Cancel(); + + await Assert.ThrowsAnyAsync(() => + service.RevalidateAsync("gateway-1", client, cancellation.Token)); + } + + [Fact] + public async Task EnableAsync_CancellationAfterConfigReadDoesNotMutateOrPatch() + { + using var cancellation = new CancellationTokenSource(); + var registry = CreateRegistry(); + var client = new FakeConfigClient(Config(allowTailscale: false)) + { + AfterConfig = cancellation.Cancel, + }; + var service = new GatewayTailscaleAuthUpgradeService(registry); + + await Assert.ThrowsAnyAsync(() => + service.EnableAsync("gateway-1", client, cancellation.Token)); + + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(0, client.PatchCalls); + } + + [Fact] + public async Task EnableAsync_CancellationAfterMarkerPersistenceRollsBackBeforeDispatch() + { + using var cancellation = new CancellationTokenSource(); + var registry = CreateRegistry(new CancelOnFirstWriteFileSystem(cancellation)); + var client = new FakeConfigClient(Config(allowTailscale: false)); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + await Assert.ThrowsAnyAsync(() => + service.EnableAsync("gateway-1", client, cancellation.Token)); + + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(0, client.PatchCalls); + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.False(reloaded.GetActive()!.TrustTailscaleAuth); + } + + [Fact] + public async Task EnableAsync_CancellationBeforeDispatchSurfacesRollbackPersistenceFailure() + { + using var cancellation = new CancellationTokenSource(); + var registry = CreateRegistry(new CancelThenFailRollbackFileSystem(cancellation)); + var client = new FakeConfigClient(Config(allowTailscale: false)); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, cancellation.Token); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, result.Outcome); + Assert.Contains("trust-marker rollback failed", result.Error); + Assert.DoesNotContain("Core rejected", result.Error); + Assert.Equal(0, client.PatchCalls); + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + } + + [Fact] + public async Task EnableAsync_CancellationDuringPatchPreservesMarkerForRevalidation() + { + using var cancellation = new CancellationTokenSource(); + var registry = CreateRegistry(); + var patchCompletion = new TaskCompletionSource( + TaskCreationOptions.RunContinuationsAsynchronously); + var client = new FakeConfigClient(Config(allowTailscale: false)) + { + PatchCompletion = patchCompletion, + }; + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var enableTask = service.EnableAsync("gateway-1", client, cancellation.Token); + await client.PatchStarted.Task.WaitAsync(TimeSpan.FromSeconds(1)); + cancellation.Cancel(); + + Assert.False(enableTask.IsCompleted); + patchCompletion.SetResult(new ConfigPatchResult { Ok = true }); + await Assert.ThrowsAnyAsync(() => enableTask); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(1, client.PatchCalls); + } + + [Fact] + public async Task EnableAsync_CancellationDuringPatchRollsBackDefinitiveGatewayRejection() + { + using var cancellation = new CancellationTokenSource(); + var registry = CreateRegistry(); + var patchCompletion = new TaskCompletionSource( + TaskCreationOptions.RunContinuationsAsynchronously); + var client = new FakeConfigClient(Config(allowTailscale: false)) + { + PatchCompletion = patchCompletion, + }; + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var enableTask = service.EnableAsync("gateway-1", client, cancellation.Token); + await client.PatchStarted.Task.WaitAsync(TimeSpan.FromSeconds(1)); + cancellation.Cancel(); + patchCompletion.SetResult(new ConfigPatchResult + { + Ok = false, + Error = "base hash mismatch", + IsGatewayRejection = true, + }); + + await Assert.ThrowsAnyAsync(() => enableTask); + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + } + + [Fact] + public async Task EnableAsync_CancellationDuringPatchSurfacesRollbackPersistenceFailure() + { + using var cancellation = new CancellationTokenSource(); + var registry = CreateRegistry(new FailOnSecondWriteFileSystem()); + var patchCompletion = new TaskCompletionSource( + TaskCreationOptions.RunContinuationsAsynchronously); + var client = new FakeConfigClient(Config(allowTailscale: false)) + { + PatchCompletion = patchCompletion, + }; + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var enableTask = service.EnableAsync("gateway-1", client, cancellation.Token); + await client.PatchStarted.Task.WaitAsync(TimeSpan.FromSeconds(1)); + cancellation.Cancel(); + patchCompletion.SetResult(new ConfigPatchResult + { + Ok = false, + Error = "base hash mismatch", + IsGatewayRejection = true, + }); + + var result = await enableTask; + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, result.Outcome); + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + } + + [Fact] + public async Task RevalidateAsync_EditedNonTailscaleEndpointDoesNotTrustMarker() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with + { + Url = "wss://gateway.example.test", + TrustTailscaleAuth = true, + }); + var client = new FakeConfigClient(Config(allowTailscale: true)); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(trusted); + Assert.Equal(0, client.ConfigRequests); + } + + [Theory] + [MemberData(nameof(IneligibleRecords))] + public void CanOffer_RejectsRecordsOutsideManagedTailnetBoundary(GatewayRecord record) => + Assert.False(GatewayTailscaleAuthUpgradePolicy.CanOffer(record)); + + public static TheoryData IneligibleRecords => new() + { + ManagedRecord() with { IsLocal = false }, + ManagedRecord() with { SetupManagedDistroName = null }, + ManagedRecord() with { SshTunnel = new SshTunnelConfig("user", "host", 18789, 18789) }, + ManagedRecord() with { Url = "ws://127.0.0.1:18789" }, + ManagedRecord() with { Url = "wss://gateway.example.test" }, + }; + + public void Dispose() => _temp.Dispose(); + + private GatewayRegistry CreateRegistry(IFileSystem? fileSystem = null) + { + var registry = new GatewayRegistry(_temp.Path, fileSystem); + registry.AddOrUpdate(ManagedRecord()); + registry.SetActive("gateway-1"); + return registry; + } + + private static GatewayRecord ManagedRecord() => new() + { + Id = "gateway-1", + Url = "wss://openclaw-host.tail1234.ts.net", + IsLocal = true, + SetupManagedDistroName = "OpenClawGateway", + SharedGatewayToken = "test-token-placeholder", + }; + + private static JsonElement Config( + bool allowTailscale, + bool includeBaseHash = true, + bool includeGatewayPort = true) + { + using var document = JsonDocument.Parse($$""" + { + "parsed": { + "gateway": { + {{(includeGatewayPort ? "\"port\": 18789," : "")}} + "auth": { "allowTailscale": {{allowTailscale.ToString().ToLowerInvariant()}} } + }, + "unrelated": "keep" + }{{(includeBaseHash ? ",\n \"baseHash\": \"base-1\"" : "")}} + } + """); + return document.RootElement.Clone(); + } + + private static JsonElement ConfigWithGatewayPort(string gatewayPort) + { + using var document = JsonDocument.Parse($$""" + { + "parsed": { + "gateway": { + "port": {{gatewayPort}}, + "auth": { "allowTailscale": true } + } + } + } + """); + return document.RootElement.Clone(); + } + + private static JsonElement ImplicitServeConfig() + { + using var document = JsonDocument.Parse(""" + { + "parsed": { + "gateway": { + "auth": { "mode": "token" }, + "tailscale": { "mode": "serve" } + } + }, + "baseHash": "base-1" + } + """); + return document.RootElement.Clone(); + } + + private sealed class FakeConfigClient(JsonElement config) : IGatewayTailscaleAuthConfigClient + { + public IReadOnlyList Scopes { get; set; } = ["operator.read", "operator.write"]; + public IReadOnlyList GrantedOperatorScopes => Scopes; + public bool IsConnectedToGateway { get; set; } = true; + public int ConfigRequests { get; private set; } + public int PatchCalls { get; private set; } + public string? PatchBaseHash { get; private set; } + public JsonElement? PatchedConfig { get; private set; } + public ConfigPatchResult PatchResult { get; set; } = new() { Ok = true }; + public Exception? ConfigError { get; set; } + public bool EmitConfig { get; set; } = true; + public Action? AfterConfig { get; set; } + public Action? BeforePatch { get; set; } + public TaskCompletionSource? PatchCompletion { get; set; } + public TaskCompletionSource PatchStarted { get; } = new( + TaskCreationOptions.RunContinuationsAsynchronously); + + public Task RequestConfigDetailedAsync(int timeoutMs = 15000) + { + ConfigRequests++; + if (ConfigError is not null) + return Task.FromException(ConfigError); + + var result = EmitConfig + ? Task.FromResult(config.Clone()) + : new TaskCompletionSource().Task; + AfterConfig?.Invoke(); + return result; + } + + public Task PatchConfigDetailedAsync( + JsonElement fullConfig, + string? baseHash, + int timeoutMs = 15000) + { + BeforePatch?.Invoke(); + PatchCalls++; + PatchBaseHash = baseHash; + PatchedConfig = fullConfig.Clone(); + PatchStarted.TrySetResult(); + return PatchCompletion?.Task ?? Task.FromResult(PatchResult); + } + } + + private sealed class CancelOnFirstWriteFileSystem(CancellationTokenSource cancellation) : IFileSystem + { + private readonly RealFileSystem _inner = new(); + private int _writes; + + public bool FileExists(string path) => _inner.FileExists(path); + public string ReadAllText(string path) => _inner.ReadAllText(path); + public void WriteAllText(string path, string content) + { + _inner.WriteAllText(path, content); + if (Interlocked.Increment(ref _writes) == 1) + cancellation.Cancel(); + } + public void CreateDirectory(string path) => _inner.CreateDirectory(path); + public bool DirectoryExists(string path) => _inner.DirectoryExists(path); + public void CopyFile(string source, string destination, bool overwrite) => + _inner.CopyFile(source, destination, overwrite); + public void DeleteFile(string path) => _inner.DeleteFile(path); + } + + private sealed class CancelThenFailRollbackFileSystem(CancellationTokenSource cancellation) : IFileSystem + { + private readonly RealFileSystem _inner = new(); + private int _writes; + + public bool FileExists(string path) => _inner.FileExists(path); + public string ReadAllText(string path) => _inner.ReadAllText(path); + public void WriteAllText(string path, string content) + { + if (Interlocked.Increment(ref _writes) == 2) + throw new IOException("rollback write failed"); + _inner.WriteAllText(path, content); + cancellation.Cancel(); + } + public void CreateDirectory(string path) => _inner.CreateDirectory(path); + public bool DirectoryExists(string path) => _inner.DirectoryExists(path); + public void CopyFile(string source, string destination, bool overwrite) => + _inner.CopyFile(source, destination, overwrite); + public void DeleteFile(string path) => _inner.DeleteFile(path); + } + + private sealed class FailOnSecondWriteFileSystem : IFileSystem + { + private readonly RealFileSystem _inner = new(); + private int _writes; + + public bool FileExists(string path) => _inner.FileExists(path); + public string ReadAllText(string path) => _inner.ReadAllText(path); + public void WriteAllText(string path, string content) + { + if (Interlocked.Increment(ref _writes) == 2) + throw new IOException("rollback write failed"); + _inner.WriteAllText(path, content); + } + public void CreateDirectory(string path) => _inner.CreateDirectory(path); + public bool DirectoryExists(string path) => _inner.DirectoryExists(path); + public void CopyFile(string source, string destination, bool overwrite) => + _inner.CopyFile(source, destination, overwrite); + public void DeleteFile(string path) => _inner.DeleteFile(path); + } + + private sealed class FailingWriteFileSystem : IFileSystem + { + public bool FileExists(string path) => false; + public string ReadAllText(string path) => throw new NotSupportedException(); + public void WriteAllText(string path, string content) => throw new IOException("write failed"); + public void CreateDirectory(string path) { } + public bool DirectoryExists(string path) => true; + public void CopyFile(string source, string destination, bool overwrite) => throw new NotSupportedException(); + public void DeleteFile(string path) { } + } + + private sealed class FakeLiveVerifier : IGatewayTailscaleAuthLiveVerifier + { + private readonly Queue _results; + + public FakeLiveVerifier(params object[] results) => _results = new Queue(results); + + public int Calls { get; private set; } + public int? LastGatewayPort { get; private set; } + + public Task VerifyAsync( + GatewayRecord record, + int gatewayPort, + CancellationToken cancellationToken) + { + Calls++; + LastGatewayPort = gatewayPort; + cancellationToken.ThrowIfCancellationRequested(); + var result = _results.Count > 1 ? _results.Dequeue() : _results.Peek(); + return result switch + { + GatewayTailscaleAuthLiveState state => Task.FromResult(state), + Exception error => Task.FromException(error), + _ => throw new InvalidOperationException("Unsupported fake live-verifier result."), + }; + } + } +} diff --git a/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs b/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs index 55d5607c20..7b1b84fcf9 100644 --- a/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs +++ b/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs @@ -439,11 +439,12 @@ public async Task ExternalLike_QrOnlyFreshTray_RequiresExplicitDeviceApproval() var requestId = await WaitForFirstPendingDeviceRequestIdAsync(pendingBefore); Assert.False(string.IsNullOrWhiteSpace(requestId)); - using var dashboardDoc = await externalTray.Client.CallToolExpectSuccessAsync("app.dashboard.url"); - var dashboard = dashboardDoc.RootElement; - Assert.Equal("record.BootstrapToken", dashboard.GetProperty("credentialSource").GetString()); - Assert.False(dashboard.GetProperty("usesSharedGatewayToken").GetBoolean()); - Assert.False(dashboard.GetProperty("hasTokenQuery").GetBoolean()); + using var dashboardDoc = await externalTray.Client.CallToolAsync("app.dashboard.url"); + var dashboardResult = dashboardDoc.RootElement.GetProperty("result"); + Assert.True(dashboardResult.GetProperty("isError").GetBoolean()); + Assert.Equal( + "No browser-compatible gateway credential is available", + dashboardResult.GetProperty("content")[0].GetProperty("text").GetString()); using var rejectDoc = await RejectDevicePairingFromConnectionPageAsync(requestId); handledDeviceRequestIds.Add(requestId); diff --git a/tests/OpenClaw.SetupEngine.Tests/SetupStepsTests.cs b/tests/OpenClaw.SetupEngine.Tests/SetupStepsTests.cs index 299c85c362..1e3db3c50c 100644 --- a/tests/OpenClaw.SetupEngine.Tests/SetupStepsTests.cs +++ b/tests/OpenClaw.SetupEngine.Tests/SetupStepsTests.cs @@ -2603,11 +2603,23 @@ public void TailscalePolicy_ParsesAuthorizationUrlsAndOnlyAcceptsGatewayServePro } } """; + const string legacyAnyHandlerStatus = """ + { + "Web": { + "openclaw.example.ts.net:443": { + "Handlers": { + "/app": { "Proxy": "http://127.0.0.1:18789/backend" } + } + } + } + } + """; Assert.Equal("https://login.tailscale.com/a/abc_123-now", url!.AbsoluteUri); Assert.True(TailscaleSetupPolicy.ServeStatusRoutesToPort(expectedServeStatus, 18789)); Assert.False(TailscaleSetupPolicy.ServeStatusRoutesToPort(wrongBackendStatus, 18789)); Assert.False(TailscaleSetupPolicy.ServeStatusRoutesToPort(unrelatedPortStatus, 18789)); + Assert.True(TailscaleSetupPolicy.ServeStatusRoutesToPort(legacyAnyHandlerStatus, 18789)); Assert.False(TailscaleSetupPolicy.ServeStatusEnablesFunnel(expectedServeStatus, 18789)); Assert.True(TailscaleSetupPolicy.ServeStatusEnablesFunnel(funnelStatus, 18789)); } @@ -3130,6 +3142,63 @@ public async Task PairOperatorStep_FailsWhenGatewayNotReachableFromWindows() Assert.Contains("not reachable", result.Message, StringComparison.OrdinalIgnoreCase); } + [Fact] + public async Task PairOperatorStep_PersistsExplicitTailscaleIdentityTrust() + { + var config = new SetupConfig + { + GatewayPort = GetFreeTcpPort(), + Tailscale = new TailscaleConfig + { + Enabled = true, + TrustTailscaleAuth = true, + }, + }; + var context = CreateContext(config); + context.GatewayUrl = "wss://gateway.tailnet.ts.net"; + context.SharedGatewayToken = "gateway-token"; + context.DistroName = "OpenClawGateway"; + + var result = await new PairOperatorStep().ExecuteAsync(context, CancellationToken.None); + + Assert.Equal(StepOutcome.Failed, result.Outcome); + var registry = new GatewayRegistry(_tempDir); + registry.Load(); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + } + + [Fact] + public async Task PairOperatorStep_ExtraConfigOverrideDisablesTailscaleIdentityTrust() + { + var config = new SetupConfig + { + GatewayPort = GetFreeTcpPort(), + Tailscale = new TailscaleConfig + { + Enabled = true, + TrustTailscaleAuth = true, + }, + Gateway = new GatewayConfig + { + ExtraConfig = new Dictionary + { + ["gateway.auth.allowTailscale"] = "false", + }, + }, + }; + var context = CreateContext(config); + context.GatewayUrl = "wss://gateway.tailnet.ts.net"; + context.SharedGatewayToken = "gateway-token"; + context.DistroName = "OpenClawGateway"; + + var result = await new PairOperatorStep().ExecuteAsync(context, CancellationToken.None); + + Assert.Equal(StepOutcome.Failed, result.Outcome); + var registry = new GatewayRegistry(_tempDir); + registry.Load(); + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + } + [Fact] public async Task PairOperatorStep_WhenSavedIdentityIsCorrupt_ReturnsTerminalWithoutMutation() { diff --git a/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs b/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs index 1c71bf5874..496be14f22 100644 --- a/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs +++ b/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs @@ -124,6 +124,45 @@ public async Task SettingsSet_WithHandlerSuccessPayload_ReturnsData() Assert.True(res.Ok); } + [Fact] + public async Task DashboardUrl_AwaitsAsyncHandler() + { + var cap = new AppCapability(NullLogger.Instance) + { + DashboardUrlHandler = path => Task.FromResult(new { url = $"https://gateway.test/{path}" }) + }; + var req = new NodeInvokeRequest + { + Id = "1", + Command = "app.dashboard.url", + Args = ParseArgs("{\"path\":\"settings\"}") + }; + + var res = await cap.ExecuteAsync(req); + + Assert.True(res.Ok); + } + + [Fact] + public async Task DashboardUrl_PropagatesHandlerError() + { + var cap = new AppCapability(NullLogger.Instance) + { + DashboardUrlHandler = _ => Task.FromResult(new { error = "credential unavailable" }) + }; + var req = new NodeInvokeRequest + { + Id = "1", + Command = "app.dashboard.url", + Args = ParseArgs("{}") + }; + + var res = await cap.ExecuteAsync(req); + + Assert.False(res.Ok); + Assert.Equal("credential unavailable", res.Error); + } + [Fact] public async Task UnknownCommand_ReturnsError() { diff --git a/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs b/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs index e42f3591ec..ce69f73549 100644 --- a/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs +++ b/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs @@ -613,13 +613,97 @@ await server.SendTextAsync( error = new { message = "wizard rejected" } })); - var exception = await Assert.ThrowsAsync( + var exception = await Assert.ThrowsAsync( async () => await responseTask.WaitAsync(TimeSpan.FromSeconds(2))); Assert.Equal("wizard rejected", exception.Message); Assert.Equal(0, helper.GetPendingRequestCount()); } + [Fact] + public async Task PatchConfigDetailedAsync_ClassifiesGatewayRejectionAsAuthoritative() + { + using var server = new LoopbackWebSocketServer(); + using var identity = new TempDirectory("config-patch-rejection-"); + await server.StartAsync(); + var helper = new GatewayClientTestHelper( + gatewayUrl: server.WebSocketUrl, + identityPath: identity.Path); + using var client = helper.Client; + await client.ConnectAsync(); + using var config = JsonDocument.Parse("{}"); + + var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 10_000); + var request = await server.ReceiveTextAsync().WaitAsync(TimeSpan.FromSeconds(2)); + var requestId = ReadRequestId(request); + await server.SendTextAsync(JsonSerializer.Serialize(new + { + type = "res", + id = requestId, + ok = false, + error = new { code = "INVALID_REQUEST", message = "patch rejected" }, + })); + + var result = await responseTask.WaitAsync(TimeSpan.FromSeconds(2)); + + Assert.False(result.Ok); + Assert.True(result.IsGatewayRejection); + Assert.Equal("patch rejected", result.Error); + } + + [Fact] + public async Task PatchConfigDetailedAsync_DoesNotClassifyUnavailableAsAuthoritative() + { + using var server = new LoopbackWebSocketServer(); + using var identity = new TempDirectory("config-patch-unavailable-"); + await server.StartAsync(); + var helper = new GatewayClientTestHelper( + gatewayUrl: server.WebSocketUrl, + identityPath: identity.Path); + using var client = helper.Client; + await client.ConnectAsync(); + using var config = JsonDocument.Parse("{}"); + + var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 10_000); + var request = await server.ReceiveTextAsync().WaitAsync(TimeSpan.FromSeconds(2)); + var requestId = ReadRequestId(request); + await server.SendTextAsync(JsonSerializer.Serialize(new + { + type = "res", + id = requestId, + ok = false, + error = new { code = "UNAVAILABLE", message = "runtime activation failed" }, + })); + + var result = await responseTask.WaitAsync(TimeSpan.FromSeconds(2)); + + Assert.False(result.Ok); + Assert.False(result.IsGatewayRejection); + Assert.Equal("runtime activation failed", result.Error); + } + + [Fact] + public async Task PatchConfigDetailedAsync_DoesNotClassifyTimeoutAsGatewayRejection() + { + using var server = new LoopbackWebSocketServer(); + using var identity = new TempDirectory("config-patch-timeout-"); + await server.StartAsync(); + var helper = new GatewayClientTestHelper( + gatewayUrl: server.WebSocketUrl, + identityPath: identity.Path); + using var client = helper.Client; + await client.ConnectAsync(); + using var config = JsonDocument.Parse("{}"); + + var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 250); + await server.ReceiveTextAsync().WaitAsync(TimeSpan.FromSeconds(2)); + var result = await responseTask.WaitAsync(TimeSpan.FromSeconds(2)); + + Assert.False(result.Ok); + Assert.False(result.IsGatewayRejection); + Assert.Contains("Timed out waiting", result.Error); + } + [Fact] public async Task SendWizardRequestAsync_DeadlineExpires_ThrowsTimeoutAndCleansTracking() { diff --git a/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs b/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs index b442dc582f..9978090151 100644 --- a/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs +++ b/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs @@ -451,6 +451,33 @@ public void Dashboard_SurfacesSshTunnelConfigurationFailure() Assert.Contains("Check SSH tunnel settings and logs.", method); } + [Fact] + public void DashboardLaunches_UseSharedBrowserCredentialPolicy() + { + var source = ReadAppSources(); + var direct = ExtractMethod(source, "OpenDashboard"); + var revalidated = ExtractMethod(source, "OpenDashboardAfterTailscaleAuthRevalidationAsync"); + + AssertInOrder( + direct, + "if (active?.TrustTailscaleAuth == true", + "OpenDashboardAfterTailscaleAuthRevalidationAsync(", + "return;", + "GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential(", + "trustTailscaleAuth: false", + "usesSharedGatewayToken: appendBrowserCredential", + "return;", + "LaunchDashboardUrl("); + AssertInOrder( + revalidated, + "trustTailscaleAuth = await", + "GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential(", + "trustTailscaleAuth,", + "appendBrowserCredential", + "return;", + "LaunchDashboardUrl("); + } + [Fact] public void SshTunnelExit_RecoversActiveRegistryGatewayThroughConnectionManager() { diff --git a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs index e791458de4..5551fcde09 100644 --- a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs +++ b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs @@ -5,6 +5,42 @@ namespace OpenClaw.Tray.Tests; public sealed class ConnectionPageTailscaleRecoveryTests { + [Fact] + public void SavedDashboardLaunch_UsesSharedBrowserCredentialPolicy() + { + var source = File.ReadAllText(Path.Combine( + TestRepositoryPaths.GetRepositoryRoot(), + "src", + "OpenClaw.Tray.WinUI", + "Pages", + "ConnectionPage.xaml.cs")); + var methodStart = source.IndexOf( + "private async Task OnSavedRowOpenDashboardAsync(object sender)", + StringComparison.Ordinal); + var methodEnd = source.IndexOf( + "private void OnEnableTailscaleDashboardAuth(object sender, RoutedEventArgs e)", + methodStart, + StringComparison.Ordinal); + Assert.True(methodStart >= 0 && methodEnd > methodStart); + var method = source[methodStart..methodEnd]; + + AssertInOrder( + method, + "var trustTailscaleAuth = rec.TrustTailscaleAuth &&", + "await _connectionManager.RevalidateTailscaleDashboardAuthAsync(rec.Id)", + "if (trustTailscaleAuth)", + "trustTailscaleAuth: true", + "LaunchUriAsync(", + "return;", + "var usesSharedGatewayToken =", + "GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential(", + "trustTailscaleAuth,", + "usesSharedGatewayToken", + "return;", + "appendSharedGatewayToken: usesSharedGatewayToken", + "LaunchUriAsync("); + } + [Fact] public void NetworkFailure_ForManagedTailscaleGateway_UsesDedicatedRecoveryPlan() { @@ -64,4 +100,15 @@ public void NetworkFailure_ForUnmanagedTailscaleGateway_UsesOrdinaryNetworkRecov Assert.Equal(RecoveryCategory.Network, plan.Recovery); Assert.NotEqual("Tailscale gateway unavailable", plan.StripHeadline); } + + private static void AssertInOrder(string source, params string[] markers) + { + var current = -1; + foreach (var marker in markers) + { + var next = source.IndexOf(marker, current + 1, StringComparison.Ordinal); + Assert.True(next >= 0, $"Could not find marker after index {current}: {marker}"); + current = next; + } + } } diff --git a/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs b/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs index 367c8c2fff..019b2bb595 100644 --- a/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs +++ b/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs @@ -4,6 +4,23 @@ namespace OpenClaw.Tray.Tests; public sealed class GatewayDashboardUrlBuilderTests { + [Theory] + [InlineData(false, false, false)] + [InlineData(false, true, true)] + [InlineData(true, false, true)] + [InlineData(true, true, true)] + public void HasBrowserCompatibleCredential_RequiresTailscaleOrSharedToken( + bool trustTailscaleAuth, + bool usesSharedGatewayToken, + bool expected) + { + Assert.Equal( + expected, + GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential( + trustTailscaleAuth, + usesSharedGatewayToken)); + } + [Fact] public void Build_AppendsSharedTokenToDashboardRoot() { From bac278abc92033c02f2bbf827c231de68e607691 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Wed, 19 Aug 2026 19:19:39 +0100 Subject: [PATCH 02/38] fix(tray): centralize dashboard link policy --- docs/ARCHITECTURE.md | 2 + .../App.AppShutdownCoordinator.cs | 1 + .../App.CapabilityHandlers.cs | 30 ++-- src/OpenClaw.Tray.WinUI/App.xaml.cs | 77 ++++------ .../Helpers/GatewayDashboardUrlBuilder.cs | 8 -- .../Pages/ConnectionPage.xaml.cs | 96 ++++++------- .../Services/GatewayDashboardLinkService.cs | 88 ++++++++++++ .../Strings/en-us/Resources.resw | 18 +++ .../Strings/fr-fr/Resources.resw | 18 +++ .../Strings/nl-nl/Resources.resw | 18 +++ .../Strings/zh-cn/Resources.resw | 18 +++ .../Strings/zh-tw/Resources.resw | 18 +++ .../AppRefactorContractTests.cs | 26 +--- .../ConnectionPageTailscaleRecoveryTests.cs | 65 +++++---- .../GatewayDashboardLinkServiceTests.cs | 135 ++++++++++++++++++ .../GatewayDashboardUrlBuilderTests.cs | 17 --- .../OpenClaw.Tray.Tests.csproj | 1 + 17 files changed, 447 insertions(+), 189 deletions(-) create mode 100644 src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs create mode 100644 tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index fb18bbeda5..b690e2a581 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -73,6 +73,7 @@ These are the canonical homes. Do not reintroduce private copies elsewhere. | Hub navigation tags, page mapping, command catalog/search, and gateway-page classification | `HubPageRegistry` | authoritative | | Hub notification banner severity and action projection | `AppNotificationInfoBarPresenter` | authoritative | | Tray-menu semantic composition and connection-toggle state | `TrayMenuPresenter` + `ConnectionTogglePresenter` | authoritative | +| Dashboard link Tailscale revalidation, browser-credential fallback, and fail-closed URL policy | `GatewayDashboardLinkService` | authoritative | | App-owned non-tray window creation, reuse, focus, theme, and lifetime | `IWindowManager` + `WindowManager` | authoritative | | Tray icon, popup coordination, live status, and callback lifetime | `ITrayController` + `TrayController` | authoritative | | Deep-link/protocol/toast/forwarded activation normalization, current-user IPC, and semantic activation plans | `ActivationRouter` | authoritative | @@ -169,6 +170,7 @@ leading and trailing pipe. Columns, in order: | app-window-surface-ownership-closed | closed | src/OpenClaw.Tray.WinUI/App.xaml.cs | concrete non-tray window fields, constructors, show/hide/focus/theme/close mechanics, and window event lifetime | IWindowManager + WindowManager | interface forwarding, immutable request construction, route and policy callbacks, and setup restart dialog policy only | App cannot regain a parallel Hub, Chat, status, setup, canvas-request, or runtime-anchor owner | AppSurfaceOwnershipContractTests.App_DelegatesConcreteTrayAndWindowOwnership | source-shape | when App is replaced as the WinUI composition root | | app-tray-controller | authoritative | src/OpenClaw.Tray.WinUI/App.xaml.cs | tray icon creation, tray popup coordination, click routing, tooltip and live-toggle refresh, theme, callbacks, and disposal | ITrayController + TrayController | App captures immutable snapshots, implements semantic action callbacks, triggers refresh from authoritative state, preserves startup construction order, and constructs shutdown-plan callbacks | one tray icon and root menu are reused; A1 presenters retain semantics; TrayMenuWindow retains native popup mechanics; callbacks detach and resources dispose once | TrayControllerTests.Dispose_UnsubscribesAndDisposesEachResourceOnce | source-shape | when the WinUI tray surface is replaced | | app-tray-surface-ownership-closed | closed | src/OpenClaw.Tray.WinUI/App.xaml.cs | concrete tray icon, root menu, weak live-control state, event subscriptions, popup build coordination, and resource disposal | ITrayController + TrayController | immutable snapshot and action callbacks plus state-change triggers only | App cannot regain tray controls or popup lifetime and TrayController cannot duplicate A1 semantic projection or TrayMenuWindow native mechanics | AppSurfaceOwnershipContractTests.App_DelegatesConcreteTrayAndWindowOwnership | source-shape | when the WinUI tray surface is replaced | +| dashboard-link-policy | authoritative | src/OpenClaw.Tray.WinUI/App.xaml.cs + App.CapabilityHandlers.cs + Pages/ConnectionPage.xaml.cs | duplicated Tailscale revalidation, browser-credential fallback, and dashboard URL policy | GatewayDashboardLinkService | callers retain UI launch, error, provenance, and MCP response side effects | trusted Tailscale links omit shared credentials; degraded revalidation falls back only to an approved shared browser credential; bootstrap-only and no-credential states fail closed | AppRefactorContractTests.DashboardLinkPolicy_StaysDelegatedToFocusedService | source-shape | when App, ConnectionPage, and local MCP no longer own dashboard-link entrypoints | | native-tool-projector | authoritative | src/OpenClaw.Tray.WinUI/Chat/OpenClawChatDataProvider.cs | pure native tool identity, allowlisted display arguments, payload extraction, and flattened-history detection/classification/summary | NativeToolProjector | ChatEventMapper and ChatHistoryLoader call the projector; ChatConversationState supplies scoped correlation plans and ChatMetadataStore owns persistence | unknown identities remain truthful Tool; title aliases are strict; display arguments are allowlisted, redacted, and bounded; live/history projection stays consistent | NativeToolProjectorTests.ExtractToolIdentity_TitleRequiresExactTrustedAlias | behavioral | - | | provider-native-tool-projection-closed | closed | src/OpenClaw.Tray.WinUI/Chat/OpenClawChatDataProvider.cs | private static copies of native tool identity, display argument, payload, flattened-history projection, and scoped metadata upsert | NativeToolProjector + ChatEventMapper + ChatHistoryLoader + ChatConversationState + ChatMetadataStore | provider forwards typed tool metadata writes while retaining bridge IO, telemetry, and event publication only | provider does not regain native tool JSON projection, identity policy, timeline correlation, or metadata persistence | review-only: pure projection, atomic correlation, and persistence are delegated to focused owners while the provider remains the IO facade | review-only | when OpenClawChatDataProvider is retired | | chat-conversation-state | authoritative | src/OpenClaw.Tray.WinUI/Chat/OpenClawChatDataProvider.cs | provider-owned runtime gate and cross-domain state transactions | ChatConversationState | sole lock, timeline and entry metadata, connection/disposal flags, and typed orchestration across lock-free substates; provider supplies bridge context and coordinates IO, telemetry, and events | one authoritative lock atomically commits reset, reconnect, dispose, queue, history, and event transitions without duplicate shared versions | ChatRuntimeOwnershipContractTests.Root_CoordinatesCrossDomainCommitsUnderSoleGate | source-shape | when the chat runtime is replaced by a different atomic transaction boundary | diff --git a/src/OpenClaw.Tray.WinUI/App.AppShutdownCoordinator.cs b/src/OpenClaw.Tray.WinUI/App.AppShutdownCoordinator.cs index 9f35e1fc69..192cf9808f 100644 --- a/src/OpenClaw.Tray.WinUI/App.AppShutdownCoordinator.cs +++ b/src/OpenClaw.Tray.WinUI/App.AppShutdownCoordinator.cs @@ -81,6 +81,7 @@ private AppShutdownPlan BuildShutdownPlan() } var connectionManager = _connectionManager; + _gatewayDashboardLinkService = null; if (connectionManager is not null) { steps.Add(new AppShutdownStep("gateway client", async () => diff --git a/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs b/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs index da0afc3ddf..d3467f8b78 100644 --- a/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs +++ b/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs @@ -232,31 +232,25 @@ private void WireAppCapabilityHandlers() var active = _gatewayRegistry?.GetActive(); var activeMatches = active is not null && string.Equals(active.Url, gatewayUrl, StringComparison.OrdinalIgnoreCase); - var trustTailscaleAuth = false; - if (active?.TrustTailscaleAuth == true && - activeMatches && - _connectionManager is not null) - { - trustTailscaleAuth = await _connectionManager - .RevalidateTailscaleDashboardAuthAsync(active.Id); - } - var usesSharedCredential = !isBootstrapToken && credentialSource == CredentialResolver.SourceSharedGatewayToken; + var tailscaleGatewayId = active?.TrustTailscaleAuth == true && activeMatches + ? active.Id + : null; + var service = _gatewayDashboardLinkService; + if (service is null) + return new { error = "Connection manager is not initialized" }; - if (!GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential( - trustTailscaleAuth, - usesSharedCredential)) - { - return new { error = GatewayDashboardUrlBuilder.NoBrowserCompatibleCredentialError }; - } - - var url = GatewayDashboardUrlBuilder.Build( + var result = await service.BuildAsync(new GatewayDashboardLinkRequest( gatewayUrl, path, dashboardCredential, usesSharedCredential, - trustTailscaleAuth); + tailscaleGatewayId)); + if (!result.Success) + return new { error = result.Error }; + + var url = result.Url!; return new { diff --git a/src/OpenClaw.Tray.WinUI/App.xaml.cs b/src/OpenClaw.Tray.WinUI/App.xaml.cs index a56ff2434b..80bb12205a 100644 --- a/src/OpenClaw.Tray.WinUI/App.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/App.xaml.cs @@ -52,6 +52,7 @@ public partial class App : Application, OpenClawTray.Services.IAppCommands, IPer private IWindowManager? _windowManager; private GatewayConnectionManager? _connectionManager; private GatewayDirectConnectService? _gatewayDirectConnectService; + private GatewayDashboardLinkService? _gatewayDashboardLinkService; private GatewayRegistry? _gatewayRegistry; private OpenClawTray.Services.ManagedLocalGatewayAutoRepairMonitor? _managedLocalAutoRepairMonitor; private ManagedLocalGatewayPortProvenanceService? _managedLocalPortProvenance; @@ -799,6 +800,10 @@ _dispatcherQueue is null tunnelManager: _sshTunnelService, endpointProvenanceProbe: managedLocalPortProvenance.InspectAsync, validationTunnelFactory: () => new SshTunnelService(appLogger)); + _gatewayDashboardLinkService = new GatewayDashboardLinkService( + (gatewayId, cancellationToken) => _connectionManager.RevalidateTailscaleDashboardAuthAsync( + gatewayId, + cancellationToken)); _connectionManager.OperatorClientChanged += OnOperatorClientChanged; _connectionManager.StateChanged += OnManagerStateChanged; _gatewayDirectConnectService = new GatewayDirectConnectService( @@ -3815,70 +3820,50 @@ private void OpenDashboard(string? path = null) var appendBrowserCredential = !isBootstrapToken && credentialSource == CredentialResolver.SourceSharedGatewayToken; var active = _gatewayRegistry?.GetActive(); - if (active?.TrustTailscaleAuth == true && - string.Equals(active.Url, gatewayUrl, StringComparison.OrdinalIgnoreCase) && - _connectionManager is not null) - { - _ = OpenDashboardAfterTailscaleAuthRevalidationAsync( - active.Id, - gatewayUrl, - path, - token, - appendBrowserCredential); - return; - } - - if (!GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential( - trustTailscaleAuth: false, - usesSharedGatewayToken: appendBrowserCredential)) - { - ShowConnectionSettingsForPairingIssue( - "Dashboard", - "Tailscale authentication is unavailable and no approved browser credential is available"); - return; - } + var tailscaleGatewayId = active?.TrustTailscaleAuth == true && + string.Equals(active.Url, gatewayUrl, StringComparison.OrdinalIgnoreCase) + ? active.Id + : null; - LaunchDashboardUrl(GatewayDashboardUrlBuilder.Build( + _ = OpenDashboardFromLinkServiceAsync(new GatewayDashboardLinkRequest( gatewayUrl, path, token, - appendBrowserCredential)); + appendBrowserCredential, + tailscaleGatewayId)); } - private async Task OpenDashboardAfterTailscaleAuthRevalidationAsync( - string gatewayId, - string gatewayUrl, - string? path, - string? browserCredential, - bool appendBrowserCredential) + internal async Task OpenDashboardFromLinkServiceAsync( + GatewayDashboardLinkRequest request, + Func>? validateBeforeLaunch = null) { - var trustTailscaleAuth = false; - try + var service = _gatewayDashboardLinkService; + if (service is null) { - trustTailscaleAuth = await _connectionManager! - .RevalidateTailscaleDashboardAuthAsync(gatewayId); + ShowConnectionSettingsForPairingIssue("Dashboard", "Connection manager is not initialized"); + return; } - catch (Exception ex) + + var result = await service.BuildAsync(request); + if (result.RevalidationError is not null) { - Logger.Warn($"Failed to revalidate Tailscale dashboard auth: {ex.Message}"); + Logger.Warn(result.RevalidationError); } - if (!GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential( - trustTailscaleAuth, - appendBrowserCredential)) + if (!result.Success) { ShowConnectionSettingsForPairingIssue( "Dashboard", - "Tailscale authentication is unavailable and no approved browser credential is available"); + result.Error ?? "Dashboard URL is unavailable"); return; } - LaunchDashboardUrl(GatewayDashboardUrlBuilder.Build( - gatewayUrl, - path, - browserCredential, - appendBrowserCredential && !trustTailscaleAuth, - trustTailscaleAuth)); + if (validateBeforeLaunch is not null && !await validateBeforeLaunch(result)) + { + return; + } + + LaunchDashboardUrl(result.Url!); } private static void LaunchDashboardUrl(string url) diff --git a/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs b/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs index 61dff64255..a3c43151d6 100644 --- a/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs +++ b/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs @@ -2,14 +2,6 @@ namespace OpenClawTray.Helpers; public static class GatewayDashboardUrlBuilder { - public const string NoBrowserCompatibleCredentialError = - "No browser-compatible gateway credential is available"; - - public static bool HasBrowserCompatibleCredential( - bool trustTailscaleAuth, - bool usesSharedGatewayToken) => - trustTailscaleAuth || usesSharedGatewayToken; - public static string Build( string gatewayUrl, string? path, diff --git a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs index b2845bcdac..1e7fb995f9 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs @@ -1802,7 +1802,7 @@ private Border BuildSavedGatewayRowControl(SavedGatewayRow row) { var enableTailscaleAuth = new MenuFlyoutItem { - Text = "Use Tailscale identity for dashboard", + Text = LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthMenu"), Tag = row.Id, }; enableTailscaleAuth.Click += OnEnableTailscaleDashboardAuth; @@ -2531,55 +2531,13 @@ private async Task OnSavedRowOpenDashboardAsync(object sender) if (rec == null) return; try { - var trustTailscaleAuth = rec.TrustTailscaleAuth && - _connectionManager is not null && - await _connectionManager.RevalidateTailscaleDashboardAuthAsync(rec.Id); - if (trustTailscaleAuth) - { - var tailscaleUrl = GatewayDashboardUrlBuilder.Build( - rec.Url, - path: null, - rec.SharedGatewayToken, - appendSharedGatewayToken: false, - trustTailscaleAuth: true); - await global::Windows.System.Launcher.LaunchUriAsync(new Uri(tailscaleUrl)); - return; - } - - var usesSharedGatewayToken = !string.IsNullOrWhiteSpace(rec.SharedGatewayToken); - if (usesSharedGatewayToken) - { - var provenanceService = CurrentApp.ManagedLocalPortProvenance; - if (provenanceService is null) - return; - _ = await provenanceService.InspectAsync(rec); - var candidate = new GatewayCredential( - rec.SharedGatewayToken!, - IsBootstrapToken: false, - CredentialResolver.SourceSharedGatewayToken); - if (!provenanceService.IsStrongCredentialAllowed(rec, candidate)) - { - CurrentApp.ShowTransientConnectionError( - "Dashboard blocked because the saved gateway address is not owned by the verified managed gateway."); - return; - } - } - - if (!GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential( - trustTailscaleAuth, - usesSharedGatewayToken)) - { - CurrentApp.ShowTransientConnectionError( - "Tailscale authentication is unavailable and no approved browser credential is available"); - return; - } - - var url = GatewayDashboardUrlBuilder.Build( + await CurrentApp.OpenDashboardFromLinkServiceAsync(new GatewayDashboardLinkRequest( rec.Url, - path: null, + null, rec.SharedGatewayToken, - appendSharedGatewayToken: usesSharedGatewayToken); - await global::Windows.System.Launcher.LaunchUriAsync(new Uri(url)); + !string.IsNullOrWhiteSpace(rec.SharedGatewayToken), + rec.TrustTailscaleAuth ? rec.Id : null), + result => ValidateSavedDashboardFallbackAsync(rec, result)); } catch (Exception ex) { @@ -2587,6 +2545,36 @@ _connectionManager is not null && } } + private async Task ValidateSavedDashboardFallbackAsync( + GatewayRecord record, + GatewayDashboardLinkResult result) + { + if (result.TrustTailscaleAuth) + { + return true; + } + + var provenanceService = CurrentApp.ManagedLocalPortProvenance; + if (provenanceService is null || string.IsNullOrWhiteSpace(record.SharedGatewayToken)) + { + return false; + } + + _ = await provenanceService.InspectAsync(record); + var candidate = new GatewayCredential( + record.SharedGatewayToken, + IsBootstrapToken: false, + CredentialResolver.SourceSharedGatewayToken); + if (provenanceService.IsStrongCredentialAllowed(record, candidate)) + { + return true; + } + + CurrentApp.ShowTransientConnectionError( + "Dashboard blocked because the saved gateway address is not owned by the verified managed gateway."); + return false; + } + private void OnEnableTailscaleDashboardAuth(object sender, RoutedEventArgs e) => AsyncEventHandlerGuard.Run( () => OnEnableTailscaleDashboardAuthAsync(sender), @@ -2604,9 +2592,9 @@ item.Tag is not string gatewayId || var dialog = new ContentDialog { - Title = "Use Tailscale identity for dashboard?", - Content = "This enables verified Tailscale identity authentication on this managed gateway. Your saved token, device identity, WSL distro, and pairing remain unchanged.", - PrimaryButtonText = "Enable", + Title = LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthTitle"), + Content = LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthBody"), + PrimaryButtonText = LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthEnable"), CloseButtonText = LocalizationHelper.GetString("ConnectionPage_CancelAction"), DefaultButton = ContentDialogButton.Close, XamlRoot = XamlRoot, @@ -2617,7 +2605,7 @@ item.Tag is not string gatewayId || var result = await _connectionManager.EnableTailscaleDashboardAuthAsync(gatewayId); if (result.IsSuccess) { - SetGatewayHostActionStatus("Tailscale dashboard identity enabled."); + SetGatewayHostActionStatus(LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthEnabled")); LoadSavedGateways(); return; } @@ -2625,7 +2613,9 @@ item.Tag is not string gatewayId || var detail = string.IsNullOrWhiteSpace(result.Error) ? result.Outcome.ToString() : result.Error; - SetGatewayHostActionStatus($"Could not enable Tailscale dashboard identity: {detail}", isError: true); + SetGatewayHostActionStatus( + string.Format(LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthFailedFormat"), detail), + isError: true); } private void OnSavedRowEdit(object sender, RoutedEventArgs e) diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs new file mode 100644 index 0000000000..384826c670 --- /dev/null +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs @@ -0,0 +1,88 @@ +using OpenClawTray.Helpers; + +namespace OpenClawTray.Services; + +public sealed record GatewayDashboardLinkRequest( + string GatewayUrl, + string? Path, + string? BrowserCredential, + bool AppendBrowserCredential, + string? TailscaleGatewayId = null); + +public sealed record GatewayDashboardLinkResult( + string? Url, + bool TrustTailscaleAuth, + string? Error = null, + string? RevalidationError = null) +{ + public bool Success => Url is not null && Error is null; +} + +/// +/// Owns dashboard-link authentication policy while callers retain UI and MCP side effects. +/// +public sealed class GatewayDashboardLinkService +{ + internal const string NoBrowserCompatibleCredential = + "No browser-compatible gateway credential is available"; + internal const string RevalidationFailed = + "Tailscale dashboard authentication revalidation failed"; + + private readonly Func> _revalidateTailscaleAuth; + + public GatewayDashboardLinkService( + Func> revalidateTailscaleAuth) + { + _revalidateTailscaleAuth = revalidateTailscaleAuth + ?? throw new ArgumentNullException(nameof(revalidateTailscaleAuth)); + } + + public async Task BuildAsync( + GatewayDashboardLinkRequest request, + CancellationToken cancellationToken = default) + { + var trustTailscaleAuth = false; + string? revalidationError = null; + + if (!string.IsNullOrWhiteSpace(request.TailscaleGatewayId)) + { + try + { + trustTailscaleAuth = await _revalidateTailscaleAuth( + request.TailscaleGatewayId, + cancellationToken) + .ConfigureAwait(false); + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + throw; + } + catch (Exception) + { + revalidationError = RevalidationFailed; + } + } + + if (!trustTailscaleAuth && + (!request.AppendBrowserCredential || string.IsNullOrWhiteSpace(request.BrowserCredential))) + { + return new GatewayDashboardLinkResult( + Url: null, + TrustTailscaleAuth: false, + Error: NoBrowserCompatibleCredential, + RevalidationError: revalidationError); + } + + var url = GatewayDashboardUrlBuilder.Build( + request.GatewayUrl, + request.Path, + request.BrowserCredential, + request.AppendBrowserCredential && !trustTailscaleAuth, + trustTailscaleAuth); + + return new GatewayDashboardLinkResult( + url, + trustTailscaleAuth, + RevalidationError: revalidationError); + } +} diff --git a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw index 02c2920726..e8527a623d 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw @@ -5467,6 +5467,24 @@ Make sure the gateway is running. Open dashboard + + Use Tailscale identity for dashboard + + + Use Tailscale identity for dashboard? + + + This enables verified Tailscale identity authentication on this managed gateway. Your saved token, device identity, WSL distro, and pairing remain unchanged. + + + Enable + + + Tailscale dashboard identity enabled. + + + Could not enable Tailscale dashboard identity: {0} + Options for {0} diff --git a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw index 60e556866a..ab436d79f4 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw @@ -5463,6 +5463,24 @@ Assurez-vous que la passerelle est en cours d'exécution. Ouvrir le tableau de bord + + Utiliser l’identité Tailscale pour le tableau de bord + + + Utiliser l’identité Tailscale pour le tableau de bord ? + + + Cela active l’authentification vérifiée par identité Tailscale sur cette passerelle gérée. Votre jeton enregistré, l’identité de l’appareil, la distribution WSL et l’association restent inchangés. + + + Activer + + + L’identité Tailscale est activée pour le tableau de bord. + + + Impossible d’activer l’identité Tailscale pour le tableau de bord : {0} + Options pour {0} diff --git a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw index cbb9ea5f26..c1c064a02a 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw @@ -5464,6 +5464,24 @@ Controleer of de gateway actief is. Dashboard openen + + Tailscale-identiteit gebruiken voor het dashboard + + + Tailscale-identiteit gebruiken voor het dashboard? + + + Hiermee wordt verificatie via Tailscale-identiteit ingeschakeld op deze beheerde gateway. Uw opgeslagen token, apparaatidentiteit, WSL-distributie en koppeling blijven ongewijzigd. + + + Inschakelen + + + Tailscale-identiteit voor het dashboard is ingeschakeld. + + + Kan Tailscale-identiteit voor het dashboard niet inschakelen: {0} + Opties voor {0} diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw index bf824cb7ab..d149a59556 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw @@ -5463,6 +5463,24 @@ 打开仪表板 + + 使用 Tailscale 身份访问仪表板 + + + 使用 Tailscale 身份访问仪表板? + + + 这将在此托管网关上启用经过验证的 Tailscale 身份认证。已保存的令牌、设备身份、WSL 发行版和配对信息均保持不变。 + + + 启用 + + + 已启用仪表板的 Tailscale 身份认证。 + + + 无法启用仪表板的 Tailscale 身份认证:{0} + {0} 的选项 diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw index 58acfbc957..540db16fab 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw @@ -5463,6 +5463,24 @@ 開啟儀表板 + + 使用 Tailscale 身分存取儀表板 + + + 使用 Tailscale 身分存取儀表板? + + + 這會在此受管理的閘道上啟用經過驗證的 Tailscale 身分驗證。已儲存的權杖、裝置身分、WSL 發行版本和配對資訊均維持不變。 + + + 啟用 + + + 已啟用儀表板的 Tailscale 身分驗證。 + + + 無法啟用儀表板的 Tailscale 身分驗證:{0} + {0} 的選項 diff --git a/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs b/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs index 9978090151..5f7ed5a5ca 100644 --- a/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs +++ b/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs @@ -452,30 +452,14 @@ public void Dashboard_SurfacesSshTunnelConfigurationFailure() } [Fact] - public void DashboardLaunches_UseSharedBrowserCredentialPolicy() + public void DashboardLinkPolicy_StaysDelegatedToFocusedService() { var source = ReadAppSources(); - var direct = ExtractMethod(source, "OpenDashboard"); - var revalidated = ExtractMethod(source, "OpenDashboardAfterTailscaleAuthRevalidationAsync"); - AssertInOrder( - direct, - "if (active?.TrustTailscaleAuth == true", - "OpenDashboardAfterTailscaleAuthRevalidationAsync(", - "return;", - "GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential(", - "trustTailscaleAuth: false", - "usesSharedGatewayToken: appendBrowserCredential", - "return;", - "LaunchDashboardUrl("); - AssertInOrder( - revalidated, - "trustTailscaleAuth = await", - "GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential(", - "trustTailscaleAuth,", - "appendBrowserCredential", - "return;", - "LaunchDashboardUrl("); + Assert.Contains("GatewayDashboardLinkService", source); + Assert.DoesNotContain("OpenDashboardAfterTailscaleAuthRevalidationAsync", source); + Assert.DoesNotContain(".RevalidateTailscaleDashboardAuthAsync(active.Id)", source); + Assert.DoesNotContain("GatewayDashboardUrlBuilder.Build(", source); } [Fact] diff --git a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs index 5551fcde09..91dfa5451c 100644 --- a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs +++ b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs @@ -6,7 +6,7 @@ namespace OpenClaw.Tray.Tests; public sealed class ConnectionPageTailscaleRecoveryTests { [Fact] - public void SavedDashboardLaunch_UsesSharedBrowserCredentialPolicy() + public void SavedDashboardLaunch_DelegatesToSharedDashboardLinkService() { var source = File.ReadAllText(Path.Combine( TestRepositoryPaths.GetRepositoryRoot(), @@ -24,21 +24,44 @@ public void SavedDashboardLaunch_UsesSharedBrowserCredentialPolicy() Assert.True(methodStart >= 0 && methodEnd > methodStart); var method = source[methodStart..methodEnd]; - AssertInOrder( - method, - "var trustTailscaleAuth = rec.TrustTailscaleAuth &&", - "await _connectionManager.RevalidateTailscaleDashboardAuthAsync(rec.Id)", - "if (trustTailscaleAuth)", - "trustTailscaleAuth: true", - "LaunchUriAsync(", - "return;", - "var usesSharedGatewayToken =", - "GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential(", - "trustTailscaleAuth,", - "usesSharedGatewayToken", - "return;", - "appendSharedGatewayToken: usesSharedGatewayToken", - "LaunchUriAsync("); + Assert.Contains("OpenDashboardFromLinkServiceAsync", method); + Assert.Contains("new GatewayDashboardLinkRequest(", method); + Assert.Contains("ValidateSavedDashboardFallbackAsync", method); + Assert.DoesNotContain("RevalidateTailscaleDashboardAuthAsync", method); + Assert.DoesNotContain("GatewayDashboardUrlBuilder.Build(", method); + + var validationStart = source.IndexOf( + "private async Task ValidateSavedDashboardFallbackAsync(", + methodStart, + StringComparison.Ordinal); + Assert.True(validationStart > methodStart); + var validationEnd = source.IndexOf( + "private void OnEnableTailscaleDashboardAuth(object sender, RoutedEventArgs e)", + validationStart, + StringComparison.Ordinal); + Assert.True(validationEnd > validationStart); + var validation = source[validationStart..validationEnd]; + + var tailscaleBypass = validation.IndexOf( + "if (result.TrustTailscaleAuth)", + StringComparison.Ordinal); + var bypassReturn = validation.IndexOf( + "return true;", + tailscaleBypass, + StringComparison.Ordinal); + var provenanceLookup = validation.IndexOf( + "ManagedLocalPortProvenance", + bypassReturn, + StringComparison.Ordinal); + var credentialAuthorization = validation.IndexOf( + "IsStrongCredentialAllowed", + provenanceLookup, + StringComparison.Ordinal); + + Assert.True(tailscaleBypass >= 0); + Assert.True(bypassReturn > tailscaleBypass); + Assert.True(provenanceLookup > bypassReturn); + Assert.True(credentialAuthorization > provenanceLookup); } [Fact] @@ -101,14 +124,4 @@ public void NetworkFailure_ForUnmanagedTailscaleGateway_UsesOrdinaryNetworkRecov Assert.NotEqual("Tailscale gateway unavailable", plan.StripHeadline); } - private static void AssertInOrder(string source, params string[] markers) - { - var current = -1; - foreach (var marker in markers) - { - var next = source.IndexOf(marker, current + 1, StringComparison.Ordinal); - Assert.True(next >= 0, $"Could not find marker after index {current}: {marker}"); - current = next; - } - } } diff --git a/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs new file mode 100644 index 0000000000..f732e538d7 --- /dev/null +++ b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs @@ -0,0 +1,135 @@ +using OpenClawTray.Services; + +namespace OpenClaw.Tray.Tests; + +public sealed class GatewayDashboardLinkServiceTests +{ + [Fact] + public async Task BuildAsync_SharedCredential_AppendsCredentialWithoutRevalidation() + { + var revalidationCalls = 0; + var service = CreateService((_, _) => + { + revalidationCalls++; + return Task.FromResult(true); + }); + + var result = await service.BuildAsync(Request()); + + Assert.True(result.Success); + Assert.Contains("token=shared-token", result.Url); + Assert.Equal(0, revalidationCalls); + } + + [Fact] + public async Task BuildAsync_TrustedTailscaleGateway_OmitsSharedCredential() + { + var service = CreateService((_, _) => Task.FromResult(true)); + + var result = await service.BuildAsync(Request(tailscaleGatewayId: "gateway-1")); + + Assert.True(result.Success); + Assert.True(result.TrustTailscaleAuth); + Assert.DoesNotContain("token=", result.Url); + } + + [Fact] + public async Task BuildAsync_FailedRevalidation_FallsBackToSharedCredential() + { + var service = CreateService((_, _) => Task.FromResult(false)); + + var result = await service.BuildAsync(Request(tailscaleGatewayId: "gateway-1")); + + Assert.True(result.Success); + Assert.False(result.TrustTailscaleAuth); + Assert.Contains("token=shared-token", result.Url); + } + + [Theory] + [InlineData(null)] + [InlineData("gateway-1")] + public async Task BuildAsync_WithoutApprovedBrowserCredential_FailsClosed( + string? tailscaleGatewayId) + { + var service = CreateService((_, _) => Task.FromResult(false)); + + var result = await service.BuildAsync(Request( + appendBrowserCredential: false, + tailscaleGatewayId: tailscaleGatewayId)); + + Assert.False(result.Success); + Assert.Null(result.Url); + Assert.Equal(GatewayDashboardLinkService.NoBrowserCompatibleCredential, result.Error); + } + + [Fact] + public async Task BuildAsync_RevalidationException_PreservesFallbackAndSanitizesDiagnostic() + { + var service = CreateService((_, _) => + throw new InvalidOperationException("sensitive probe detail")); + + var result = await service.BuildAsync(Request(tailscaleGatewayId: "gateway-1")); + + Assert.True(result.Success); + Assert.Contains("token=shared-token", result.Url); + Assert.Equal(GatewayDashboardLinkService.RevalidationFailed, result.RevalidationError); + Assert.DoesNotContain("sensitive", result.RevalidationError); + } + + [Theory] + [InlineData(null)] + [InlineData("")] + [InlineData(" ")] + public async Task BuildAsync_AppendRequestedWithoutCredential_FailsClosed( + string? browserCredential) + { + var service = CreateService((_, _) => Task.FromResult(false)); + + var result = await service.BuildAsync(Request( + browserCredential: browserCredential, + tailscaleGatewayId: "gateway-1")); + + Assert.False(result.Success); + Assert.Null(result.Url); + Assert.Equal(GatewayDashboardLinkService.NoBrowserCompatibleCredential, result.Error); + } + + [Fact] + public async Task BuildAsync_CallerCancellation_PropagatesWithoutFallback() + { + using var cts = new CancellationTokenSource(); + cts.Cancel(); + var service = CreateService((_, cancellationToken) => + Task.FromCanceled(cancellationToken)); + + await Assert.ThrowsAnyAsync(() => + service.BuildAsync(Request(tailscaleGatewayId: "gateway-1"), cts.Token)); + } + + [Fact] + public async Task BuildAsync_NonCallerCancellation_PreservesFallbackAndSanitizesDiagnostic() + { + var service = CreateService((_, _) => + Task.FromException(new OperationCanceledException("sensitive probe detail"))); + + var result = await service.BuildAsync(Request(tailscaleGatewayId: "gateway-1")); + + Assert.True(result.Success); + Assert.Contains("token=shared-token", result.Url); + Assert.Equal(GatewayDashboardLinkService.RevalidationFailed, result.RevalidationError); + Assert.DoesNotContain("sensitive", result.RevalidationError); + } + + private static GatewayDashboardLinkService CreateService( + Func> revalidate) => new(revalidate); + + private static GatewayDashboardLinkRequest Request( + bool appendBrowserCredential = true, + string? browserCredential = "shared-token", + string? tailscaleGatewayId = null) => new( + "https://gateway.example.test", + "/settings/profile", + browserCredential, + appendBrowserCredential, + tailscaleGatewayId); +} diff --git a/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs b/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs index 019b2bb595..367c8c2fff 100644 --- a/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs +++ b/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs @@ -4,23 +4,6 @@ namespace OpenClaw.Tray.Tests; public sealed class GatewayDashboardUrlBuilderTests { - [Theory] - [InlineData(false, false, false)] - [InlineData(false, true, true)] - [InlineData(true, false, true)] - [InlineData(true, true, true)] - public void HasBrowserCompatibleCredential_RequiresTailscaleOrSharedToken( - bool trustTailscaleAuth, - bool usesSharedGatewayToken, - bool expected) - { - Assert.Equal( - expected, - GatewayDashboardUrlBuilder.HasBrowserCompatibleCredential( - trustTailscaleAuth, - usesSharedGatewayToken)); - } - [Fact] public void Build_AppendsSharedTokenToDashboardRoot() { diff --git a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj index cacaa30454..36947cdbb2 100644 --- a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj +++ b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj @@ -115,6 +115,7 @@ + From 1ebebfa81e3c547c5fe33030b8f210cfd8efc1ac Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Fri, 21 Aug 2026 21:57:04 +0100 Subject: [PATCH 03/38] fix(tray): preserve bootstrap dashboard links --- docs/ARCHITECTURE.md | 2 +- src/OpenClaw.Tray.WinUI/App.xaml.cs | 3 +- .../Services/GatewayDashboardLinkService.cs | 20 ++++++----- .../Strings/en-us/Resources.resw | 6 ++++ .../Strings/fr-fr/Resources.resw | 6 ++++ .../Strings/nl-nl/Resources.resw | 6 ++++ .../Strings/zh-cn/Resources.resw | 6 ++++ .../Strings/zh-tw/Resources.resw | 6 ++++ .../Setup/SetupAndConnectTests.cs | 13 +++---- .../GatewayDashboardLinkServiceTests.cs | 34 +++++++++++++------ 10 files changed, 75 insertions(+), 27 deletions(-) diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index b690e2a581..21da067dc4 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -170,7 +170,7 @@ leading and trailing pipe. Columns, in order: | app-window-surface-ownership-closed | closed | src/OpenClaw.Tray.WinUI/App.xaml.cs | concrete non-tray window fields, constructors, show/hide/focus/theme/close mechanics, and window event lifetime | IWindowManager + WindowManager | interface forwarding, immutable request construction, route and policy callbacks, and setup restart dialog policy only | App cannot regain a parallel Hub, Chat, status, setup, canvas-request, or runtime-anchor owner | AppSurfaceOwnershipContractTests.App_DelegatesConcreteTrayAndWindowOwnership | source-shape | when App is replaced as the WinUI composition root | | app-tray-controller | authoritative | src/OpenClaw.Tray.WinUI/App.xaml.cs | tray icon creation, tray popup coordination, click routing, tooltip and live-toggle refresh, theme, callbacks, and disposal | ITrayController + TrayController | App captures immutable snapshots, implements semantic action callbacks, triggers refresh from authoritative state, preserves startup construction order, and constructs shutdown-plan callbacks | one tray icon and root menu are reused; A1 presenters retain semantics; TrayMenuWindow retains native popup mechanics; callbacks detach and resources dispose once | TrayControllerTests.Dispose_UnsubscribesAndDisposesEachResourceOnce | source-shape | when the WinUI tray surface is replaced | | app-tray-surface-ownership-closed | closed | src/OpenClaw.Tray.WinUI/App.xaml.cs | concrete tray icon, root menu, weak live-control state, event subscriptions, popup build coordination, and resource disposal | ITrayController + TrayController | immutable snapshot and action callbacks plus state-change triggers only | App cannot regain tray controls or popup lifetime and TrayController cannot duplicate A1 semantic projection or TrayMenuWindow native mechanics | AppSurfaceOwnershipContractTests.App_DelegatesConcreteTrayAndWindowOwnership | source-shape | when the WinUI tray surface is replaced | -| dashboard-link-policy | authoritative | src/OpenClaw.Tray.WinUI/App.xaml.cs + App.CapabilityHandlers.cs + Pages/ConnectionPage.xaml.cs | duplicated Tailscale revalidation, browser-credential fallback, and dashboard URL policy | GatewayDashboardLinkService | callers retain UI launch, error, provenance, and MCP response side effects | trusted Tailscale links omit shared credentials; degraded revalidation falls back only to an approved shared browser credential; bootstrap-only and no-credential states fail closed | AppRefactorContractTests.DashboardLinkPolicy_StaysDelegatedToFocusedService | source-shape | when App, ConnectionPage, and local MCP no longer own dashboard-link entrypoints | +| dashboard-link-policy | authoritative | src/OpenClaw.Tray.WinUI/App.xaml.cs + App.CapabilityHandlers.cs + Pages/ConnectionPage.xaml.cs | duplicated Tailscale revalidation, browser-credential fallback, and dashboard URL policy | GatewayDashboardLinkService | callers retain UI launch, error, provenance, and MCP response side effects | trusted Tailscale links omit shared credentials; degraded Tailscale revalidation falls back only to an approved shared browser credential and otherwise fails closed; non-Tailscale QR/bootstrap requests preserve the existing token-free dashboard URL | AppRefactorContractTests.DashboardLinkPolicy_StaysDelegatedToFocusedService | source-shape | when App, ConnectionPage, and local MCP no longer own dashboard-link entrypoints | | native-tool-projector | authoritative | src/OpenClaw.Tray.WinUI/Chat/OpenClawChatDataProvider.cs | pure native tool identity, allowlisted display arguments, payload extraction, and flattened-history detection/classification/summary | NativeToolProjector | ChatEventMapper and ChatHistoryLoader call the projector; ChatConversationState supplies scoped correlation plans and ChatMetadataStore owns persistence | unknown identities remain truthful Tool; title aliases are strict; display arguments are allowlisted, redacted, and bounded; live/history projection stays consistent | NativeToolProjectorTests.ExtractToolIdentity_TitleRequiresExactTrustedAlias | behavioral | - | | provider-native-tool-projection-closed | closed | src/OpenClaw.Tray.WinUI/Chat/OpenClawChatDataProvider.cs | private static copies of native tool identity, display argument, payload, flattened-history projection, and scoped metadata upsert | NativeToolProjector + ChatEventMapper + ChatHistoryLoader + ChatConversationState + ChatMetadataStore | provider forwards typed tool metadata writes while retaining bridge IO, telemetry, and event publication only | provider does not regain native tool JSON projection, identity policy, timeline correlation, or metadata persistence | review-only: pure projection, atomic correlation, and persistence are delegated to focused owners while the provider remains the IO facade | review-only | when OpenClawChatDataProvider is retired | | chat-conversation-state | authoritative | src/OpenClaw.Tray.WinUI/Chat/OpenClawChatDataProvider.cs | provider-owned runtime gate and cross-domain state transactions | ChatConversationState | sole lock, timeline and entry metadata, connection/disposal flags, and typed orchestration across lock-free substates; provider supplies bridge context and coordinates IO, telemetry, and events | one authoritative lock atomically commits reset, reconnect, dispose, queue, history, and event transitions without duplicate shared versions | ChatRuntimeOwnershipContractTests.Root_CoordinatesCrossDomainCommitsUnderSoleGate | source-shape | when the chat runtime is replaced by a different atomic transaction boundary | diff --git a/src/OpenClaw.Tray.WinUI/App.xaml.cs b/src/OpenClaw.Tray.WinUI/App.xaml.cs index 80bb12205a..5b3d3cb2f6 100644 --- a/src/OpenClaw.Tray.WinUI/App.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/App.xaml.cs @@ -803,7 +803,8 @@ _dispatcherQueue is null _gatewayDashboardLinkService = new GatewayDashboardLinkService( (gatewayId, cancellationToken) => _connectionManager.RevalidateTailscaleDashboardAuthAsync( gatewayId, - cancellationToken)); + cancellationToken), + LocalizationHelper.GetString); _connectionManager.OperatorClientChanged += OnOperatorClientChanged; _connectionManager.StateChanged += OnManagerStateChanged; _gatewayDirectConnectService = new GatewayDirectConnectService( diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs index 384826c670..e009614f9b 100644 --- a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs @@ -23,18 +23,21 @@ public sealed record GatewayDashboardLinkResult( /// public sealed class GatewayDashboardLinkService { - internal const string NoBrowserCompatibleCredential = - "No browser-compatible gateway credential is available"; - internal const string RevalidationFailed = - "Tailscale dashboard authentication revalidation failed"; + internal const string NoBrowserCompatibleCredentialKey = + "DashboardLink_NoBrowserCompatibleCredential"; + internal const string RevalidationFailedKey = + "DashboardLink_TailscaleRevalidationFailed"; private readonly Func> _revalidateTailscaleAuth; + private readonly Func _localize; public GatewayDashboardLinkService( - Func> revalidateTailscaleAuth) + Func> revalidateTailscaleAuth, + Func localize) { _revalidateTailscaleAuth = revalidateTailscaleAuth ?? throw new ArgumentNullException(nameof(revalidateTailscaleAuth)); + _localize = localize ?? throw new ArgumentNullException(nameof(localize)); } public async Task BuildAsync( @@ -59,17 +62,18 @@ public async Task BuildAsync( } catch (Exception) { - revalidationError = RevalidationFailed; + revalidationError = _localize(RevalidationFailedKey); } } - if (!trustTailscaleAuth && + if (!string.IsNullOrWhiteSpace(request.TailscaleGatewayId) && + !trustTailscaleAuth && (!request.AppendBrowserCredential || string.IsNullOrWhiteSpace(request.BrowserCredential))) { return new GatewayDashboardLinkResult( Url: null, TrustTailscaleAuth: false, - Error: NoBrowserCompatibleCredential, + Error: _localize(NoBrowserCompatibleCredentialKey), RevalidationError: revalidationError); } diff --git a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw index e8527a623d..1d5fd715c7 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw @@ -5485,6 +5485,12 @@ Make sure the gateway is running. Could not enable Tailscale dashboard identity: {0} + + No browser-compatible gateway credential is available + + + Tailscale dashboard authentication revalidation failed + Options for {0} diff --git a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw index ab436d79f4..946dea0bfa 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw @@ -5481,6 +5481,12 @@ Assurez-vous que la passerelle est en cours d'exécution. Impossible d’activer l’identité Tailscale pour le tableau de bord : {0} + + Aucun identifiant de passerelle compatible avec le navigateur n’est disponible + + + La revalidation de l’authentification Tailscale du tableau de bord a échoué + Options pour {0} diff --git a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw index c1c064a02a..44611089fd 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw @@ -5482,6 +5482,12 @@ Controleer of de gateway actief is. Kan Tailscale-identiteit voor het dashboard niet inschakelen: {0} + + Er is geen gatewayreferentie beschikbaar die geschikt is voor de browser + + + Herverificatie van Tailscale-authenticatie voor het dashboard is mislukt + Opties voor {0} diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw index d149a59556..436bc0e324 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw @@ -5481,6 +5481,12 @@ 无法启用仪表板的 Tailscale 身份认证:{0} + + 没有可供浏览器使用的网关凭据 + + + 重新验证仪表板的 Tailscale 身份认证失败 + {0} 的选项 diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw index 540db16fab..bf51c059d9 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw @@ -5481,6 +5481,12 @@ 無法啟用儀表板的 Tailscale 身分驗證:{0} + + 沒有可供瀏覽器使用的閘道認證 + + + 重新驗證儀表板的 Tailscale 身分驗證失敗 + {0} 的選項 diff --git a/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs b/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs index 7b1b84fcf9..c89b5def4b 100644 --- a/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs +++ b/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs @@ -439,12 +439,13 @@ public async Task ExternalLike_QrOnlyFreshTray_RequiresExplicitDeviceApproval() var requestId = await WaitForFirstPendingDeviceRequestIdAsync(pendingBefore); Assert.False(string.IsNullOrWhiteSpace(requestId)); - using var dashboardDoc = await externalTray.Client.CallToolAsync("app.dashboard.url"); - var dashboardResult = dashboardDoc.RootElement.GetProperty("result"); - Assert.True(dashboardResult.GetProperty("isError").GetBoolean()); - Assert.Equal( - "No browser-compatible gateway credential is available", - dashboardResult.GetProperty("content")[0].GetProperty("text").GetString()); + using var dashboardDoc = await externalTray.Client.CallToolExpectSuccessAsync("app.dashboard.url"); + var dashboard = dashboardDoc.RootElement; + var dashboardUrl = dashboard.GetProperty("url").GetString(); + Assert.NotNull(dashboardUrl); + Assert.False(dashboard.GetProperty("usesSharedGatewayToken").GetBoolean()); + Assert.False(dashboard.GetProperty("hasTokenQuery").GetBoolean()); + Assert.DoesNotContain("token=", dashboardUrl, StringComparison.OrdinalIgnoreCase); using var rejectDoc = await RejectDevicePairingFromConnectionPageAsync(requestId); handledDeviceRequestIds.Add(requestId); diff --git a/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs index f732e538d7..9551f4f277 100644 --- a/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs +++ b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs @@ -45,21 +45,32 @@ public async Task BuildAsync_FailedRevalidation_FallsBackToSharedCredential() Assert.Contains("token=shared-token", result.Url); } - [Theory] - [InlineData(null)] - [InlineData("gateway-1")] - public async Task BuildAsync_WithoutApprovedBrowserCredential_FailsClosed( - string? tailscaleGatewayId) + [Fact] + public async Task BuildAsync_TokenFreeBootstrapRequest_PreservesDashboardUrl() { var service = CreateService((_, _) => Task.FromResult(false)); var result = await service.BuildAsync(Request( appendBrowserCredential: false, - tailscaleGatewayId: tailscaleGatewayId)); + tailscaleGatewayId: null)); + + Assert.True(result.Success); + Assert.NotNull(result.Url); + Assert.DoesNotContain("token=", result.Url); + } + + [Fact] + public async Task BuildAsync_TailscaleRequestWithoutApprovedBrowserCredential_FailsClosed() + { + var service = CreateService((_, _) => Task.FromResult(false)); + + var result = await service.BuildAsync(Request( + appendBrowserCredential: false, + tailscaleGatewayId: "gateway-1")); Assert.False(result.Success); Assert.Null(result.Url); - Assert.Equal(GatewayDashboardLinkService.NoBrowserCompatibleCredential, result.Error); + Assert.Equal("localized:DashboardLink_NoBrowserCompatibleCredential", result.Error); } [Fact] @@ -72,7 +83,7 @@ public async Task BuildAsync_RevalidationException_PreservesFallbackAndSanitizes Assert.True(result.Success); Assert.Contains("token=shared-token", result.Url); - Assert.Equal(GatewayDashboardLinkService.RevalidationFailed, result.RevalidationError); + Assert.Equal("localized:DashboardLink_TailscaleRevalidationFailed", result.RevalidationError); Assert.DoesNotContain("sensitive", result.RevalidationError); } @@ -91,7 +102,7 @@ public async Task BuildAsync_AppendRequestedWithoutCredential_FailsClosed( Assert.False(result.Success); Assert.Null(result.Url); - Assert.Equal(GatewayDashboardLinkService.NoBrowserCompatibleCredential, result.Error); + Assert.Equal("localized:DashboardLink_NoBrowserCompatibleCredential", result.Error); } [Fact] @@ -116,12 +127,13 @@ public async Task BuildAsync_NonCallerCancellation_PreservesFallbackAndSanitizes Assert.True(result.Success); Assert.Contains("token=shared-token", result.Url); - Assert.Equal(GatewayDashboardLinkService.RevalidationFailed, result.RevalidationError); + Assert.Equal("localized:DashboardLink_TailscaleRevalidationFailed", result.RevalidationError); Assert.DoesNotContain("sensitive", result.RevalidationError); } private static GatewayDashboardLinkService CreateService( - Func> revalidate) => new(revalidate); + Func> revalidate) => + new(revalidate, key => $"localized:{key}"); private static GatewayDashboardLinkRequest Request( bool appendBrowserCredential = true, From b66e945c33210f677a21ddc6da91d5a46ec0fc8c Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Sat, 22 Aug 2026 09:37:44 +0100 Subject: [PATCH 04/38] fix(connection): parse foreground tailscale serve status --- .../TailscaleServeStatusPolicy.cs | 51 ++++++++- .../GatewayTailscaleAuthLiveVerifierTests.cs | 101 ++++++++++++++++++ 2 files changed, 149 insertions(+), 3 deletions(-) diff --git a/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs b/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs index 0f5fedb8f3..e5308e97be 100644 --- a/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs +++ b/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs @@ -21,14 +21,27 @@ public static bool TryParse( using var document = JsonDocument.Parse(status); var root = document.RootElement; if (root.ValueKind != JsonValueKind.Object || - !HasValidWebShape(root) || - !TryReadFunnelState(root, out var funnelEnabled)) + !TryCollectServeConfigs(root, out var configs)) { return false; } + var routesToGateway = false; + var funnelEnabled = false; + foreach (var config in configs) + { + if (!HasValidWebShape(config) || + !TryReadFunnelState(config, out var configFunnelEnabled)) + { + return false; + } + + routesToGateway |= HasGatewayWebProxy(config, port, expectedEndpoint); + funnelEnabled |= configFunnelEnabled; + } + parsed = new TailscaleServeStatusResult( - RoutesToGateway: HasGatewayWebProxy(root, port, expectedEndpoint), + RoutesToGateway: routesToGateway, FunnelEnabled: funnelEnabled); return true; } @@ -38,6 +51,38 @@ public static bool TryParse( } } + private static bool TryCollectServeConfigs( + JsonElement root, + out IReadOnlyList configs) + { + var collected = new List { root }; + if (!root.TryGetProperty("Foreground", out var foreground)) + { + configs = collected; + return true; + } + + if (foreground.ValueKind != JsonValueKind.Object) + { + configs = []; + return false; + } + + foreach (var entry in foreground.EnumerateObject()) + { + if (entry.Value.ValueKind != JsonValueKind.Object) + { + configs = []; + return false; + } + + collected.Add(entry.Value); + } + + configs = collected; + return true; + } + private static bool HasValidWebShape(JsonElement root) { if (!root.TryGetProperty("Web", out var web)) diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs index 30637d6fad..578027b094 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -158,6 +158,37 @@ public async Task VerifyAsync_UnrelatedServeHostIsNotReady() Assert.Equal(GatewayTailscaleAuthLiveState.NotReady, result); } + [Fact] + public async Task VerifyAsync_AcceptsCurrentForegroundServeStatusShape() + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ForegroundServeStatus() + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.Ready, result); + } + + [Theory] + [MemberData(nameof(UnsafeForegroundServeStatuses))] + public async Task VerifyAsync_FailsClosedForUnsafeForegroundServeStatus( + string foreground, + string expected) + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? new WslCommandResult(0, $"{{\"Foreground\":{foreground}}}", "") + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(expected, result.ToString()); + } + [Theory] [InlineData(8443, "", "NotReady")] [InlineData(443, "/unrelated", "NotReady")] @@ -316,6 +347,57 @@ public async Task VerifyAsync_EvaluatesEveryFunnelAliasAndRejectsUnknownShapes( { new WslCommandResult(1, "", "tailscaled unavailable"), "Unavailable" }, }; + public static TheoryData UnsafeForegroundServeStatuses => new() + { + { "[]", "Unavailable" }, + { "{\"config-id\":[]}", "Unavailable" }, + { + """ + { + "config-id": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:18789" } } + } + }, + "AllowFunnel": true + } + } + """, + "NotReady" + }, + { + """ + { + "gateway": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:18789" } } + } + } + }, + "funnel": { "AllowFunnel": true } + } + """, + "NotReady" + }, + { + """ + { + "gateway": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:18789" } } + } + } + }, + "malformed": [] + } + """, + "Unavailable" + }, + }; + private static WslCommandResult RunningStatus() => Status("Running", "host.tail.example."); private static WslCommandResult ServeStatus( @@ -343,6 +425,25 @@ private static WslCommandResult ServeStatus( ""); } + private static WslCommandResult ForegroundServeStatus() => + new( + 0, + """ + { + "Foreground": { + "75980230dda8b0e0": { + "TCP": { "443": { "HTTPS": true } }, + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:18789" } } + } + } + } + } + } + """, + ""); + private static string GetRepositoryRoot() { var current = new DirectoryInfo(AppContext.BaseDirectory); From 4006f6bd52b64cd9a98b6429315a001a09c60a02 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Sat, 22 Aug 2026 10:23:59 +0100 Subject: [PATCH 05/38] fix(connection): verify core-managed tailscale ingress --- .../GatewayTailscaleAuthUpgrade.cs | 128 +++++++++- .../TailscaleServeStatusPolicy.cs | 143 ++++++++--- .../GatewayTailscaleAuthLiveVerifierTests.cs | 226 +++++++++++++++++- 3 files changed, 460 insertions(+), 37 deletions(-) diff --git a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs index 283af7b491..0e7d99129f 100644 --- a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs +++ b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs @@ -200,15 +200,137 @@ public async Task VerifyAsync( return GatewayTailscaleAuthLiveState.Unavailable; } - return serveStatus.RoutesToGateway && !serveStatus.FunnelEnabled - ? GatewayTailscaleAuthLiveState.Ready - : GatewayTailscaleAuthLiveState.NotReady; + if (serveStatus.FunnelEnabled) + return GatewayTailscaleAuthLiveState.NotReady; + if (serveStatus.ForegroundProxyPort is not { } managedIngressPort) + { + return serveStatus.RoutesToGateway + ? GatewayTailscaleAuthLiveState.Ready + : GatewayTailscaleAuthLiveState.NotReady; + } + + WslCommandResult ownershipResult; + try + { + ownershipResult = await _commandRunner.RunInDistroAsync( + distroName, + BuildManagedIngressOwnershipCommand(gatewayPort, managedIngressPort), + timeout.Token) + .ConfigureAwait(false); + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + throw; + } + catch + { + return GatewayTailscaleAuthLiveState.Unavailable; + } + + if (!ownershipResult.Success) + return GatewayTailscaleAuthLiveState.Unavailable; + + return ownershipResult.StandardOutput.Trim() switch + { + "owned" => GatewayTailscaleAuthLiveState.Ready, + "not-owned" => GatewayTailscaleAuthLiveState.NotReady, + _ => GatewayTailscaleAuthLiveState.Unavailable, + }; } private static IReadOnlyList BuildRootProbeArguments( string distroName, IReadOnlyList command) => ["-d", distroName, "--user", "root", "--", .. command]; + + private static IReadOnlyList BuildManagedIngressOwnershipCommand( + int gatewayPort, + int managedIngressPort) + { + var script = $$""" + pid_before=$(/usr/bin/systemctl --user show openclaw-gateway -p MainPID --value 2>/dev/null) + case "$pid_before" in ''|*[!0-9]*) /usr/bin/printf unavailable; exit 0;; esac + test "$pid_before" -gt 0 || { /usr/bin/printf unavailable; exit 0; } + main_cgroup=$(/usr/bin/awk -F: '$1 == "0" { print $3 }' "/proc/$pid_before/cgroup" 2>/dev/null) + main_start_before=$(/usr/bin/awk '{ print $22 }' "/proc/$pid_before/stat" 2>/dev/null) + main_exe=$(/usr/bin/readlink -f "/proc/$pid_before/exe" 2>/dev/null) + test -n "$main_cgroup" && test -n "$main_start_before" && test -n "$main_exe" || { /usr/bin/printf unavailable; exit 0; } + listener_pattern='(^|[[:space:]])127\.0\.0\.1:({{gatewayPort}}|{{managedIngressPort}})([[:space:]]|$)' + listeners_raw_before=$(/usr/bin/ss -H -ltnp 2>/dev/null) || { /usr/bin/printf unavailable; exit 0; } + listeners_before=$(/usr/bin/printf '%s\n' "$listeners_raw_before" | /usr/bin/grep -E "$listener_pattern" || true) + candidate_count=0 + matched_pid='' + matched_start='' + matched_parent='' + matched_parent_start='' + matched_worker='' + matched_worker_start='' + for proc in /proc/[0-9]*; do + unset argv + declare -a argv=() + while IFS= read -r -d '' arg; do argv+=("$arg"); done < "$proc/cmdline" 2>/dev/null + test "${#argv[@]}" -eq 5 || continue + test "${argv[0]}" = /usr/bin/tailscale && test "${argv[1]}" = serve && test "${argv[2]}" = --yes && test "${argv[3]}" = --bg=false && test "${argv[4]}" = {{managedIngressPort}} || continue + candidate_pid=${proc##*/} + candidate_exe=$(/usr/bin/readlink -f "$proc/exe" 2>/dev/null) + candidate_cgroup=$(/usr/bin/awk -F: '$1 == "0" { print $3 }' "$proc/cgroup" 2>/dev/null) + candidate_start=$(/usr/bin/awk '{ print $22 }' "$proc/stat" 2>/dev/null) + candidate_parent=$(/usr/bin/awk '/^PPid:/ { print $2 }' "$proc/status" 2>/dev/null) + test "$candidate_exe" = /usr/bin/tailscale && test "$candidate_cgroup" = "$main_cgroup" && test -n "$candidate_start" || continue + route_owner=$candidate_parent + parent_exe=$(/usr/bin/readlink -f "/proc/$candidate_parent/exe" 2>/dev/null) + if test "$parent_exe" = /usr/bin/sudo; then + unset sudo_argv + declare -a sudo_argv=() + while IFS= read -r -d '' arg; do sudo_argv+=("$arg"); done < "/proc/$candidate_parent/cmdline" 2>/dev/null + test "${#sudo_argv[@]}" -eq 7 && test "${sudo_argv[0]}" = sudo && test "${sudo_argv[1]}" = -n && test "${sudo_argv[2]}" = /usr/bin/tailscale && test "${sudo_argv[3]}" = serve && test "${sudo_argv[4]}" = --yes && test "${sudo_argv[5]}" = --bg=false && test "${sudo_argv[6]}" = {{managedIngressPort}} || continue + parent_cgroup=$(/usr/bin/awk -F: '$1 == "0" { print $3 }' "/proc/$candidate_parent/cgroup" 2>/dev/null) + test "$parent_cgroup" = "$main_cgroup" || continue + route_owner=$(/usr/bin/awk '/^PPid:/ { print $2 }' "/proc/$candidate_parent/status" 2>/dev/null) + fi + worker_exe=$(/usr/bin/readlink -f "/proc/$route_owner/exe" 2>/dev/null) + worker_cgroup=$(/usr/bin/awk -F: '$1 == "0" { print $3 }' "/proc/$route_owner/cgroup" 2>/dev/null) + worker_parent=$(/usr/bin/awk '/^PPid:/ { print $2 }' "/proc/$route_owner/status" 2>/dev/null) + worker_start=$(/usr/bin/awk '{ print $22 }' "/proc/$route_owner/stat" 2>/dev/null) + test "$worker_exe" = "$main_exe" && test "$worker_cgroup" = "$main_cgroup" && test "$worker_parent" = "$pid_before" && test -n "$worker_start" || continue + unset worker_argv + declare -a worker_argv=() + while IFS= read -r -d '' arg; do worker_argv+=("$arg"); done < "/proc/$route_owner/cmdline" 2>/dev/null + test "${#worker_argv[@]}" -eq 4 || continue + case "${worker_argv[1]}" in */dist/infra/tailscale-route-owner.worker.js) ;; *) continue;; esac + test "${worker_argv[2]}" = --openclaw-tailscale-route-owner || continue + expected_direct='{"argv":["/usr/bin/tailscale","serve","--yes","--bg=false","{{managedIngressPort}}"]}' + expected_sudo='{"argv":["sudo","-n","/usr/bin/tailscale","serve","--yes","--bg=false","{{managedIngressPort}}"]}' + test "${worker_argv[3]}" = "$expected_direct" || test "${worker_argv[3]}" = "$expected_sudo" || continue + candidate_count=$((candidate_count + 1)) + matched_pid=$candidate_pid + matched_start=$candidate_start + matched_parent=$candidate_parent + matched_parent_start=$(/usr/bin/awk '{ print $22 }' "/proc/$candidate_parent/stat" 2>/dev/null) + matched_worker=$route_owner + matched_worker_start=$worker_start + done + pid_after=$(/usr/bin/systemctl --user show openclaw-gateway -p MainPID --value 2>/dev/null) + main_start_after=$(/usr/bin/awk '{ print $22 }' "/proc/$pid_before/stat" 2>/dev/null) + main_exe_after=$(/usr/bin/readlink -f "/proc/$pid_before/exe" 2>/dev/null) + listeners_raw_after=$(/usr/bin/ss -H -ltnp 2>/dev/null) || { /usr/bin/printf unavailable; exit 0; } + listeners_after=$(/usr/bin/printf '%s\n' "$listeners_raw_after" | /usr/bin/grep -E "$listener_pattern" || true) + test "$pid_before" = "$pid_after" && test "$main_start_before" = "$main_start_after" && test "$main_exe" = "$main_exe_after" && test "$listeners_before" = "$listeners_after" || { /usr/bin/printf unavailable; exit 0; } + gateway_owner=$(/usr/bin/printf '%s\n' "$listeners_after" | /usr/bin/grep -E '(^|[[:space:]])127\.0\.0\.1:{{gatewayPort}}([[:space:]]|$)' | /usr/bin/grep -F "pid=$pid_before,") + ingress_owner=$(/usr/bin/printf '%s\n' "$listeners_after" | /usr/bin/grep -E '(^|[[:space:]])127\.0\.0\.1:{{managedIngressPort}}([[:space:]]|$)' | /usr/bin/grep -F "pid=$pid_before,") + candidate_start_after=$(/usr/bin/awk '{ print $22 }' "/proc/$matched_pid/stat" 2>/dev/null) + candidate_parent_after=$(/usr/bin/awk '/^PPid:/ { print $2 }' "/proc/$matched_pid/status" 2>/dev/null) + parent_start_after=$(/usr/bin/awk '{ print $22 }' "/proc/$matched_parent/stat" 2>/dev/null) + worker_start_after=$(/usr/bin/awk '{ print $22 }' "/proc/$matched_worker/stat" 2>/dev/null) + worker_parent_after=$(/usr/bin/awk '/^PPid:/ { print $2 }' "/proc/$matched_worker/status" 2>/dev/null) + if test -n "$gateway_owner" && test -n "$ingress_owner" && test "$candidate_count" -eq 1 && test "$matched_start" = "$candidate_start_after" && test "$matched_parent" = "$candidate_parent_after" && test "$matched_parent_start" = "$parent_start_after" && test "$matched_worker_start" = "$worker_start_after" && test "$worker_parent_after" = "$pid_before"; then + /usr/bin/printf owned + else + /usr/bin/printf not-owned + fi + """; + return ["/bin/bash", "-lc", script]; + } } internal sealed class GatewayTailscaleAuthUpgradeService diff --git a/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs b/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs index e5308e97be..4b06b0e7f7 100644 --- a/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs +++ b/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs @@ -2,7 +2,10 @@ namespace OpenClaw.Shared; -public sealed record TailscaleServeStatusResult(bool RoutesToGateway, bool FunnelEnabled); +public sealed record TailscaleServeStatusResult( + bool RoutesToGateway, + bool FunnelEnabled, + int? ForegroundProxyPort = null); public static class TailscaleServeStatusPolicy { @@ -28,21 +31,65 @@ public static bool TryParse( var routesToGateway = false; var funnelEnabled = false; + int? matchedProxyPort = null; + int? foregroundProxyPort = null; + var foregroundMatchCount = 0; + var unsafeMatchingRoute = false; foreach (var config in configs) { - if (!HasValidWebShape(config) || - !TryReadFunnelState(config, out var configFunnelEnabled)) + if (!HasValidWebShape(config.Value) || + !TryReadFunnelState(config.Value, out var configFunnelEnabled)) { return false; } - - routesToGateway |= HasGatewayWebProxy(config, port, expectedEndpoint); funnelEnabled |= configFunnelEnabled; + + var routeMatch = TryGetGatewayWebProxyPort( + config.Value, + expectedEndpoint, + out var proxyPort, + out var isLiteralIpv4Loopback); + if (routeMatch == GatewayWebProxyMatch.Invalid) + { + unsafeMatchingRoute = true; + continue; + } + + if (routeMatch == GatewayWebProxyMatch.Valid && + config.IsForeground && + !isLiteralIpv4Loopback) + { + unsafeMatchingRoute = true; + continue; + } + + if (routeMatch == GatewayWebProxyMatch.Valid) + { + if (matchedProxyPort is { } existingPort && existingPort != proxyPort) + return false; + + matchedProxyPort = proxyPort; + routesToGateway |= proxyPort == port; + if (config.IsForeground) + { + foregroundMatchCount++; + if (foregroundMatchCount > 1) + return false; + foregroundProxyPort = proxyPort; + } + } + } + + if (unsafeMatchingRoute) + { + routesToGateway = false; + foregroundProxyPort = null; } parsed = new TailscaleServeStatusResult( RoutesToGateway: routesToGateway, - FunnelEnabled: funnelEnabled); + FunnelEnabled: funnelEnabled, + ForegroundProxyPort: foregroundProxyPort); return true; } catch (JsonException) @@ -53,9 +100,9 @@ public static bool TryParse( private static bool TryCollectServeConfigs( JsonElement root, - out IReadOnlyList configs) + out IReadOnlyList configs) { - var collected = new List { root }; + var collected = new List { new(root, IsForeground: false) }; if (!root.TryGetProperty("Foreground", out var foreground)) { configs = collected; @@ -76,7 +123,7 @@ private static bool TryCollectServeConfigs( return false; } - collected.Add(entry.Value); + collected.Add(new ServeConfig(entry.Value, IsForeground: true)); } configs = collected; @@ -117,14 +164,24 @@ private static bool HasValidWebShape(JsonElement root) return true; } - private static bool HasGatewayWebProxy(JsonElement root, int port, Uri? expectedEndpoint) + private static GatewayWebProxyMatch TryGetGatewayWebProxyPort( + JsonElement root, + Uri? expectedEndpoint, + out int proxyPort, + out bool isLiteralIpv4Loopback) { + proxyPort = 0; + isLiteralIpv4Loopback = false; if (!root.TryGetProperty("Web", out var web) || web.ValueKind != JsonValueKind.Object) - return false; + return GatewayWebProxyMatch.None; + var found = false; foreach (var webEndpoint in web.EnumerateObject()) { - if (!EndpointMatches(webEndpoint.Name, expectedEndpoint) || + if (!EndpointMatches(webEndpoint.Name, expectedEndpoint)) + continue; + + if (found || webEndpoint.Value.ValueKind != JsonValueKind.Object || !webEndpoint.Value.TryGetProperty("Handlers", out var handlers) || handlers.ValueKind != JsonValueKind.Object || @@ -133,14 +190,21 @@ private static bool HasGatewayWebProxy(JsonElement root, int port, Uri? expected !rootHandler.TryGetProperty("Proxy", out var proxy) || proxy.ValueKind != JsonValueKind.String) { - continue; + return GatewayWebProxyMatch.Invalid; } - if (IsLoopbackGatewayProxy(proxy.GetString(), port)) - return true; + if (!TryReadLoopbackGatewayProxyPort( + proxy.GetString(), + out proxyPort, + out isLiteralIpv4Loopback)) + { + return GatewayWebProxyMatch.Invalid; + } + + found = true; } - return false; + return found ? GatewayWebProxyMatch.Valid : GatewayWebProxyMatch.None; } private static bool EndpointMatches(string endpoint, Uri? expectedEndpoint) @@ -215,18 +279,41 @@ private static bool TryContainsEnabledFunnelValue(JsonElement value, out bool en } } - private static bool IsLoopbackGatewayProxy(string? proxy, int port) => - proxy is not null && - Uri.TryCreate(proxy, UriKind.Absolute, out var uri) && - uri.Scheme.Equals(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) && - uri.Port == port && - HasCanonicalRootPathAndNoSuffix(proxy) && - !HasUserInfoDelimiter(proxy) && - string.IsNullOrEmpty(uri.UserInfo) && - string.IsNullOrEmpty(uri.Query) && - string.IsNullOrEmpty(uri.Fragment) && - (uri.Host.Equals("127.0.0.1", StringComparison.OrdinalIgnoreCase) || - uri.Host.Equals("localhost", StringComparison.OrdinalIgnoreCase)); + private static bool TryReadLoopbackGatewayProxyPort( + string? proxy, + out int port, + out bool isLiteralIpv4Loopback) + { + port = 0; + isLiteralIpv4Loopback = false; + if (proxy is null || + !Uri.TryCreate(proxy, UriKind.Absolute, out var uri) || + !uri.Scheme.Equals(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) || + uri.Port is <= 0 or > 65535 || + !HasCanonicalRootPathAndNoSuffix(proxy) || + HasUserInfoDelimiter(proxy) || + !string.IsNullOrEmpty(uri.UserInfo) || + !string.IsNullOrEmpty(uri.Query) || + !string.IsNullOrEmpty(uri.Fragment) || + (!uri.Host.Equals("127.0.0.1", StringComparison.OrdinalIgnoreCase) && + !uri.Host.Equals("localhost", StringComparison.OrdinalIgnoreCase))) + { + return false; + } + + port = uri.Port; + isLiteralIpv4Loopback = uri.Host.Equals("127.0.0.1", StringComparison.OrdinalIgnoreCase); + return true; + } + + private readonly record struct ServeConfig(JsonElement Value, bool IsForeground); + + private enum GatewayWebProxyMatch + { + None, + Valid, + Invalid, + } private static bool HasUserInfoDelimiter(string value) { diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs index 578027b094..29e97ce1ab 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -164,12 +164,111 @@ public async Task VerifyAsync_AcceptsCurrentForegroundServeStatusShape() var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( command.Contains("serve", StringComparer.Ordinal) ? ForegroundServeStatus() - : RunningStatus())); + : command.FirstOrDefault() == "/bin/bash" + ? new WslCommandResult(0, "owned", "") + : RunningStatus())); var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); Assert.Equal(GatewayTailscaleAuthLiveState.Ready, result); + Assert.Equal(3, runner.ProbeCalls); + } + + [Fact] + public async Task VerifyAsync_AcceptsManagedForegroundIngressOwnedByGatewayService() + { + const int managedIngressPort = 35225; + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ForegroundServeStatus(proxyPort: managedIngressPort) + : command.FirstOrDefault() == "/bin/bash" + ? new WslCommandResult(0, "owned", "") + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.Ready, result); + Assert.Equal(3, runner.ProbeCalls); + Assert.Equal("/bin/bash", runner.Commands[2][0]); + Assert.Contains("systemctl --user show openclaw-gateway", runner.Commands[2][2], StringComparison.Ordinal); + Assert.Equal(2, runner.Commands[2][2].Split("systemctl", StringSplitOptions.None).Length - 1); + Assert.Contains(":18789", runner.Commands[2][2], StringComparison.Ordinal); + Assert.Contains(":35225", runner.Commands[2][2], StringComparison.Ordinal); + Assert.Contains("/proc/$pid_before/cgroup", runner.Commands[2][2], StringComparison.Ordinal); + Assert.Contains("--bg=false", runner.Commands[2][2], StringComparison.Ordinal); + Assert.Contains("tailscale-route-owner.worker.js", runner.Commands[2][2], StringComparison.Ordinal); + Assert.Contains("--openclaw-tailscale-route-owner", runner.Commands[2][2], StringComparison.Ordinal); + Assert.Contains("/proc/$matched_pid/stat", runner.Commands[2][2], StringComparison.Ordinal); + Assert.Contains("candidate_count\" -eq 1", runner.Commands[2][2], StringComparison.Ordinal); + } + + [Fact] + public async Task VerifyAsync_RejectsForegroundIngressNotOwnedByGatewayService() + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ForegroundServeStatus(proxyPort: 35225) + : command.FirstOrDefault() == "/bin/bash" + ? new WslCommandResult(0, "not-owned", "") + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.NotReady, result); + } + + [Theory] + [InlineData(0, "unavailable")] + [InlineData(0, "unexpected")] + [InlineData(1, "")] + public async Task VerifyAsync_FailsClosedWhenManagedIngressOwnershipIsUnavailable( + int exitCode, + string output) + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ForegroundServeStatus(proxyPort: 35225) + : command.FirstOrDefault() == "/bin/bash" + ? new WslCommandResult(exitCode, output, "") + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.Unavailable, result); + } + + [Fact] + public async Task VerifyAsync_RejectsManagedForegroundIngressWhenFunnelIsEnabled() + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ForegroundServeStatus(proxyPort: 35225, funnelEnabled: true) + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.NotReady, result); + Assert.Equal(2, runner.ProbeCalls); + } + + [Fact] + public async Task VerifyAsync_RejectsForegroundLocalhostProxyOutsideCoreContract() + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ForegroundServeStatus(proxyPort: 35225, proxyHost: "localhost") + : RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, TimeSpan.FromSeconds(1)); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.NotReady, result); + Assert.Equal(2, runner.ProbeCalls); } [Theory] @@ -187,6 +286,7 @@ public async Task VerifyAsync_FailsClosedForUnsafeForegroundServeStatus( var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); Assert.Equal(expected, result.ToString()); + Assert.Equal(2, runner.ProbeCalls); } [Theory] @@ -396,6 +496,111 @@ public async Task VerifyAsync_EvaluatesEveryFunnelAliasAndRejectsUnknownShapes( """, "Unavailable" }, + { + """ + { + "first": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:35225" } } + } + } + }, + "second": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:35225" } } + } + } + } + } + """, + "Unavailable" + }, + { + """ + { + "first": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:35225" } } + } + } + }, + "second": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:35226" } } + } + } + } + } + """, + "Unavailable" + }, + { + """ + { + "first": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:35225" } } + } + } + }, + "second": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://10.0.0.1:35226" } } + } + } + } + } + """, + "NotReady" + }, + { + """ + { + "literal": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:35225" } } + } + } + }, + "localhost": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://localhost:35225" } } + } + } + } + } + """, + "NotReady" + }, + { + """ + { + "literal": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://127.0.0.1:35225" } } + } + } + }, + "localhost": { + "Web": { + "host.tail.example:443": { + "Handlers": { "/": { "Proxy": "http://localhost:35226" } } + } + } + } + } + """, + "NotReady" + }, }; private static WslCommandResult RunningStatus() => Status("Running", "host.tail.example."); @@ -425,19 +630,23 @@ private static WslCommandResult ServeStatus( ""); } - private static WslCommandResult ForegroundServeStatus() => + private static WslCommandResult ForegroundServeStatus( + int proxyPort = 18789, + bool funnelEnabled = false, + string proxyHost = "127.0.0.1") => new( 0, - """ + $$""" { "Foreground": { "75980230dda8b0e0": { "TCP": { "443": { "HTTPS": true } }, "Web": { "host.tail.example:443": { - "Handlers": { "/": { "Proxy": "http://127.0.0.1:18789" } } + "Handlers": { "/": { "Proxy": "http://{{proxyHost}}:{{proxyPort}}" } } } - } + }, + "AllowFunnel": {{funnelEnabled.ToString().ToLowerInvariant()}} } } } @@ -495,7 +704,12 @@ public Task RunInDistroAsync( IReadOnlyList command, CancellationToken cancellationToken = default, IReadOnlyDictionary? environment = null) - => throw new NotSupportedException(); + { + ProbeCalls++; + DistroName = name; + Commands.Add(command); + return runInDistro(name, command, cancellationToken); + } public Task RunAsync( IReadOnlyList arguments, From b139798bd2bed572448447884746b81796418ffa Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Sat, 22 Aug 2026 10:54:44 +0100 Subject: [PATCH 06/38] fix(connection): stream WSL ownership probe via stdin --- .../GatewayTailscaleAuthUpgrade.cs | 13 ++- src/OpenClaw.Connection/WslCommandRunner.cs | 72 ++++++++++++++++- .../GatewayTailscaleAuthLiveVerifierTests.cs | 81 ++++++++++++++++--- 3 files changed, 149 insertions(+), 17 deletions(-) diff --git a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs index 0e7d99129f..cc104d0fbc 100644 --- a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs +++ b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs @@ -212,9 +212,14 @@ public async Task VerifyAsync( WslCommandResult ownershipResult; try { - ownershipResult = await _commandRunner.RunInDistroAsync( + var ownershipScript = BuildManagedIngressOwnershipScript( + gatewayPort, + managedIngressPort) + .Replace("\r", string.Empty, StringComparison.Ordinal); + ownershipResult = await _commandRunner.RunInDistroWithStandardInputAsync( distroName, - BuildManagedIngressOwnershipCommand(gatewayPort, managedIngressPort), + ["/bin/bash", "-s"], + ownershipScript, timeout.Token) .ConfigureAwait(false); } @@ -243,7 +248,7 @@ private static IReadOnlyList BuildRootProbeArguments( IReadOnlyList command) => ["-d", distroName, "--user", "root", "--", .. command]; - private static IReadOnlyList BuildManagedIngressOwnershipCommand( + private static string BuildManagedIngressOwnershipScript( int gatewayPort, int managedIngressPort) { @@ -329,7 +334,7 @@ unset worker_argv /usr/bin/printf not-owned fi """; - return ["/bin/bash", "-lc", script]; + return script; } } diff --git a/src/OpenClaw.Connection/WslCommandRunner.cs b/src/OpenClaw.Connection/WslCommandRunner.cs index 8dfd3ef50c..2eacf5f31d 100644 --- a/src/OpenClaw.Connection/WslCommandRunner.cs +++ b/src/OpenClaw.Connection/WslCommandRunner.cs @@ -29,6 +29,19 @@ Task RunInDistroAsync( string name, IReadOnlyList command, CancellationToken cancellationToken = default, IReadOnlyDictionary? environment = null); + + Task RunInDistroWithStandardInputAsync( + string name, + IReadOnlyList command, + string standardInput, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) => + cancellationToken.IsCancellationRequested + ? Task.FromCanceled(cancellationToken) + : Task.FromResult(new WslCommandResult( + -1, + string.Empty, + "This WSL command runner does not support standard input.")); } /// @@ -70,6 +83,23 @@ public Task RunInDistroAsync( return RunAsync(args, cancellationToken, environment); } + public Task RunInDistroWithStandardInputAsync( + string name, + IReadOnlyList command, + string standardInput, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) + { + var args = new List { "-d", name, "--" }; + args.AddRange(command); + return RunProcessAsync( + "wsl.exe", + args, + cancellationToken, + environment, + standardInput); + } + public Task TerminateDistroAsync(string name, CancellationToken cancellationToken = default) => RunAsync(["--terminate", name], cancellationToken); @@ -108,13 +138,15 @@ private async Task RunProcessAsync( string fileName, IReadOnlyList arguments, CancellationToken cancellationToken, - IReadOnlyDictionary? environment) + IReadOnlyDictionary? environment, + string? standardInput = null) { var psi = new ProcessStartInfo { FileName = fileName, RedirectStandardOutput = true, RedirectStandardError = true, + RedirectStandardInput = standardInput is not null, UseShellExecute = false, CreateNoWindow = true, StandardOutputEncoding = Encoding.UTF8, @@ -147,8 +179,12 @@ private async Task RunProcessAsync( var stdoutTask = process.StandardOutput.ReadToEndAsync(timeoutCts.Token); var stderrTask = process.StandardError.ReadToEndAsync(timeoutCts.Token); + var stdinTask = standardInput is null + ? Task.CompletedTask + : WriteStandardInputAsync(process, standardInput, timeoutCts.Token); bool timedOut = false; + OperationCanceledException? cancellationException = null; try { await process.WaitForExitAsync(timeoutCts.Token); @@ -159,19 +195,49 @@ private async Task RunProcessAsync( // slopwatch-ignore: SW003 Shutdown cancellation or disposal is expected and the caller already preserves the safe state. try { process.Kill(entireProcessTree: true); } catch { } } - catch (OperationCanceledException) + catch (OperationCanceledException ex) { // slopwatch-ignore: SW003 Shutdown cancellation or disposal is expected and the caller already preserves the safe state. try { process.Kill(entireProcessTree: true); } catch { } - throw; + cancellationException = ex; + } + + if (timedOut || cancellationException is not null) + { + using var exitCts = new CancellationTokenSource(TimeSpan.FromSeconds(5)); + try { await process.WaitForExitAsync(exitCts.Token).ConfigureAwait(false); } catch { } } + Exception? stdinFailure = null; string stdout, stderr; + try { await stdinTask; } catch (Exception ex) { stdinFailure = ex; } try { stdout = await stdoutTask; } catch { stdout = string.Empty; } try { stderr = await stderrTask; } catch { stderr = string.Empty; } + cancellationToken.ThrowIfCancellationRequested(); + if (cancellationException is not null) + throw cancellationException; + if (!timedOut && stdinFailure is not null) + return new WslCommandResult(-1, stdout, "wsl.exe failed to receive standard input"); + return timedOut ? new WslCommandResult(-1, stdout, "wsl.exe timed out") : new WslCommandResult(process.ExitCode, stdout, stderr); } + + private static async Task WriteStandardInputAsync( + Process process, + string standardInput, + CancellationToken cancellationToken) + { + try + { + await process.StandardInput.WriteAsync(standardInput.AsMemory(), cancellationToken); + await process.StandardInput.FlushAsync(cancellationToken); + } + finally + { + process.StandardInput.Close(); + } + } } diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs index 29e97ce1ab..998ff9bbfb 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -123,6 +123,21 @@ await Assert.ThrowsAnyAsync(() => verifier.VerifyAsync(ManagedRecord(), 18789, cancellation.Token)); } + [Fact] + public async Task StandardInputCompatibilityDefault_PropagatesPreCancellation() + { + IWslCommandRunner runner = new LegacyWslCommandRunner(); + using var cancellation = new CancellationTokenSource(); + cancellation.Cancel(); + + await Assert.ThrowsAnyAsync(() => + runner.RunInDistroWithStandardInputAsync( + "OpenClawGateway", + ["/bin/bash", "-s"], + "exit 0", + cancellation.Token)); + } + [Theory] [InlineData("other.tail.example.", 18789, false, "NotReady")] [InlineData("host.tail.example.", 19999, false, "NotReady")] @@ -192,16 +207,20 @@ public async Task VerifyAsync_AcceptsManagedForegroundIngressOwnedByGatewayServi Assert.Equal(GatewayTailscaleAuthLiveState.Ready, result); Assert.Equal(3, runner.ProbeCalls); Assert.Equal("/bin/bash", runner.Commands[2][0]); - Assert.Contains("systemctl --user show openclaw-gateway", runner.Commands[2][2], StringComparison.Ordinal); - Assert.Equal(2, runner.Commands[2][2].Split("systemctl", StringSplitOptions.None).Length - 1); - Assert.Contains(":18789", runner.Commands[2][2], StringComparison.Ordinal); - Assert.Contains(":35225", runner.Commands[2][2], StringComparison.Ordinal); - Assert.Contains("/proc/$pid_before/cgroup", runner.Commands[2][2], StringComparison.Ordinal); - Assert.Contains("--bg=false", runner.Commands[2][2], StringComparison.Ordinal); - Assert.Contains("tailscale-route-owner.worker.js", runner.Commands[2][2], StringComparison.Ordinal); - Assert.Contains("--openclaw-tailscale-route-owner", runner.Commands[2][2], StringComparison.Ordinal); - Assert.Contains("/proc/$matched_pid/stat", runner.Commands[2][2], StringComparison.Ordinal); - Assert.Contains("candidate_count\" -eq 1", runner.Commands[2][2], StringComparison.Ordinal); + Assert.Equal("-s", runner.Commands[2][1]); + Assert.Single(runner.StandardInputs); + var script = runner.StandardInputs[0]; + Assert.DoesNotContain('\r', script); + Assert.Contains("systemctl --user show openclaw-gateway", script, StringComparison.Ordinal); + Assert.Equal(2, script.Split("systemctl", StringSplitOptions.None).Length - 1); + Assert.Contains(":18789", script, StringComparison.Ordinal); + Assert.Contains(":35225", script, StringComparison.Ordinal); + Assert.Contains("/proc/$pid_before/cgroup", script, StringComparison.Ordinal); + Assert.Contains("--bg=false", script, StringComparison.Ordinal); + Assert.Contains("tailscale-route-owner.worker.js", script, StringComparison.Ordinal); + Assert.Contains("--openclaw-tailscale-route-owner", script, StringComparison.Ordinal); + Assert.Contains("/proc/$matched_pid/stat", script, StringComparison.Ordinal); + Assert.Contains("candidate_count\" -eq 1", script, StringComparison.Ordinal); } [Fact] @@ -698,6 +717,7 @@ private sealed class FakeWslCommandRunner( public string? DistroName { get; private set; } public List> Commands { get; } = []; public List> HostArguments { get; } = []; + public List StandardInputs { get; } = []; public Task RunInDistroAsync( string name, @@ -711,6 +731,17 @@ public Task RunInDistroAsync( return runInDistro(name, command, cancellationToken); } + public Task RunInDistroWithStandardInputAsync( + string name, + IReadOnlyList command, + string standardInput, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) + { + StandardInputs.Add(standardInput); + return RunInDistroAsync(name, command, cancellationToken, environment); + } + public Task RunAsync( IReadOnlyList arguments, CancellationToken cancellationToken = default, @@ -743,4 +774,34 @@ public Task UnregisterDistroAsync( CancellationToken cancellationToken = default) => throw new NotSupportedException(); } + + private sealed class LegacyWslCommandRunner : IWslCommandRunner + { + public Task RunAsync( + IReadOnlyList arguments, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) => + throw new NotSupportedException(); + + public Task> ListDistrosAsync( + CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public Task TerminateDistroAsync( + string name, + CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public Task UnregisterDistroAsync( + string name, + CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public Task RunInDistroAsync( + string name, + IReadOnlyList command, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) => + throw new NotSupportedException(); + } } From 2581f4b601c64f68c624ab1cba5fcb120f59bdfb Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Sat, 10 Oct 2026 01:32:59 +0100 Subject: [PATCH 07/38] test: reproduce credential-free saved dashboard rejection --- .../SetupDashboardHandoffTests.cs | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs index ce186b5064..c860c9e37d 100644 --- a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs +++ b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs @@ -142,6 +142,29 @@ public async Task DeviceAndBootstrapTokens_NeverEnterBrowserUrl(string source, b Assert.Equal("https://gateway.example/control", launched); } + [Fact] + public async Task SavedDashboard_WithoutBrowserCredential_BypassesCredentialFallbackValidation() + { + string? launched = null; + var validationCalls = 0; + var service = new GatewayDashboardLinkService((_, _) => Task.FromResult(false), key => key); + var launcher = new GatewayDashboardLauncher( + () => throw new InvalidOperationException("Saved rows do not require an active tunnel."), + _ => null, + service, + url => { launched = url; return Task.FromResult(true); }, + _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), + () => throw new InvalidOperationException("Unexpected launch failure")); + + var opened = await launcher.OpenSavedAsync( + new GatewayDashboardLinkRequest(Gateway.Url, null, null, AppendBrowserCredential: false), + _ => { validationCalls++; return Task.FromResult(false); }); + + Assert.True(opened); + Assert.Equal(0, validationCalls); + Assert.Equal("https://gateway.example/control", launched); + } + [Theory] [InlineData("tunnel")] [InlineData("credential")] From 63e546f452b5e6e90d1af2c7dcbdeddf92e586e9 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Sat, 10 Oct 2026 02:14:44 +0100 Subject: [PATCH 08/38] fix: allow credential-free saved dashboard links --- .../Pages/ConnectionPage.xaml.cs | 2 +- .../Services/GatewayDashboardLauncher.cs | 22 ++++-- .../Services/GatewayDashboardLinkService.cs | 10 ++- .../Strings/pt-br/Resources.resw | 24 ++++++ .../ConnectionPageTailscaleRecoveryTests.cs | 16 ++-- .../ConnectionRegressionSourceTests.cs | 6 +- .../GatewayDashboardLinkServiceTests.cs | 4 + .../SetupDashboardHandoffTests.cs | 78 +++++++++++++++++++ 8 files changed, 145 insertions(+), 17 deletions(-) diff --git a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs index fa9e65caf7..83fb366b71 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs @@ -2604,7 +2604,7 @@ private async Task ValidateSavedDashboardFallbackAsync( GatewayRecord record, GatewayDashboardLinkResult result) { - if (result.TrustTailscaleAuth) + if (!result.BrowserCredentialIncluded) { return true; } diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs index 478c55e237..765aa7c9cf 100644 --- a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs @@ -16,8 +16,9 @@ internal sealed class GatewayDashboardLauncher( { internal const string FailureNotificationId = "setup-dashboard-launch"; - public async Task OpenAsync(string? path = null) + public async Task OpenAsync(string? path = null, CancellationToken cancellationToken = default) { + cancellationToken.ThrowIfCancellationRequested(); GatewayDashboardLinkRequest? request; try { @@ -37,23 +38,27 @@ public async Task OpenAsync(string? path = null) return false; } - return await PrepareAndLaunchAsync(request, validateBeforeLaunch: null); + return await PrepareAndLaunchAsync(request, validateBeforeLaunch: null, cancellationToken: cancellationToken); } internal Task OpenSavedAsync( GatewayDashboardLinkRequest request, - Func> validateBeforeLaunch) + Func> validateBeforeLaunch, + CancellationToken cancellationToken = default) { ArgumentNullException.ThrowIfNull(request); ArgumentNullException.ThrowIfNull(validateBeforeLaunch); - return PrepareAndLaunchAsync(request, validateBeforeLaunch); + return PrepareAndLaunchAsync(request, validateBeforeLaunch, cancellationToken); } private async Task PrepareAndLaunchAsync( GatewayDashboardLinkRequest request, - Func>? validateBeforeLaunch) + Func>? validateBeforeLaunch, + CancellationToken cancellationToken) { - var result = await linkService.BuildAsync(request); + cancellationToken.ThrowIfCancellationRequested(); + var result = await linkService.BuildAsync(request, cancellationToken); + cancellationToken.ThrowIfCancellationRequested(); if (result.RevalidationError is not null) reportRevalidationWarning?.Invoke(result.RevalidationError); @@ -63,8 +68,11 @@ private async Task PrepareAndLaunchAsync( return false; } - if (validateBeforeLaunch is not null && !await validateBeforeLaunch(result)) + cancellationToken.ThrowIfCancellationRequested(); + if (result.BrowserCredentialIncluded && validateBeforeLaunch is not null && + !await validateBeforeLaunch(result)) return false; + cancellationToken.ThrowIfCancellationRequested(); try { diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs index e009614f9b..51a29370fb 100644 --- a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs @@ -13,7 +13,8 @@ public sealed record GatewayDashboardLinkResult( string? Url, bool TrustTailscaleAuth, string? Error = null, - string? RevalidationError = null) + string? RevalidationError = null, + bool BrowserCredentialIncluded = false) { public bool Success => Url is not null && Error is null; } @@ -77,6 +78,10 @@ public async Task BuildAsync( RevalidationError: revalidationError); } + // Match the URL builder's exact append predicate so only credential-bearing URLs need authorization. + var browserCredentialIncluded = request.AppendBrowserCredential && + !trustTailscaleAuth && + !string.IsNullOrEmpty(request.BrowserCredential); var url = GatewayDashboardUrlBuilder.Build( request.GatewayUrl, request.Path, @@ -87,6 +92,7 @@ public async Task BuildAsync( return new GatewayDashboardLinkResult( url, trustTailscaleAuth, - RevalidationError: revalidationError); + RevalidationError: revalidationError, + BrowserCredentialIncluded: browserCredentialIncluded); } } diff --git a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw index 49430bd91c..23a8252dc1 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw @@ -5516,6 +5516,30 @@ Certifique-se de que o Gateway está em execução. Abrir painel + + Usar identidade Tailscale para o painel + + + Usar a identidade do Tailscale no painel? + + + Isso habilita a autenticação verificada pela identidade do Tailscale neste gateway gerenciado. O token salvo, a identidade do dispositivo, a distribuição WSL e o pareamento permanecem inalterados. + + + Ativar + + + Identidade do Tailscale para o painel ativada. + + + Não foi possível ativar a identidade do Tailscale para o painel: {0} + + + Nenhuma credencial de gateway compatível com o navegador está disponível + + + Falha na revalidação da autenticação do painel pelo Tailscale + Opções de {0} diff --git a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs index 91dfa5451c..4fbc9f65a1 100644 --- a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs +++ b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs @@ -27,6 +27,8 @@ public void SavedDashboardLaunch_DelegatesToSharedDashboardLinkService() Assert.Contains("OpenDashboardFromLinkServiceAsync", method); Assert.Contains("new GatewayDashboardLinkRequest(", method); Assert.Contains("ValidateSavedDashboardFallbackAsync", method); + Assert.Contains("var recordSnapshot = rec with { }", method); + Assert.Contains("OnSavedRowOpenDashboardAsync(sender)", method); Assert.DoesNotContain("RevalidateTailscaleDashboardAuthAsync", method); Assert.DoesNotContain("GatewayDashboardUrlBuilder.Build(", method); @@ -42,26 +44,28 @@ public void SavedDashboardLaunch_DelegatesToSharedDashboardLinkService() Assert.True(validationEnd > validationStart); var validation = source[validationStart..validationEnd]; - var tailscaleBypass = validation.IndexOf( - "if (result.TrustTailscaleAuth)", + var credentialExportGuard = validation.IndexOf( + "if (!result.BrowserCredentialIncluded)", StringComparison.Ordinal); var bypassReturn = validation.IndexOf( "return true;", - tailscaleBypass, + credentialExportGuard, StringComparison.Ordinal); var provenanceLookup = validation.IndexOf( "ManagedLocalPortProvenance", bypassReturn, StringComparison.Ordinal); var credentialAuthorization = validation.IndexOf( - "IsStrongCredentialAllowed", + "InteractiveEndpointAuthorizer?.IsCredentialAllowed", provenanceLookup, StringComparison.Ordinal); - Assert.True(tailscaleBypass >= 0); - Assert.True(bypassReturn > tailscaleBypass); + Assert.True(credentialExportGuard >= 0); + Assert.True(bypassReturn > credentialExportGuard); Assert.True(provenanceLookup > bypassReturn); Assert.True(credentialAuthorization > provenanceLookup); + Assert.DoesNotContain("result.TrustTailscaleAuth", validation); + Assert.DoesNotContain("IsStrongCredentialAllowed", validation); } [Fact] diff --git a/tests/OpenClaw.Tray.Tests/ConnectionRegressionSourceTests.cs b/tests/OpenClaw.Tray.Tests/ConnectionRegressionSourceTests.cs index d69fc39139..77565c5f0c 100644 --- a/tests/OpenClaw.Tray.Tests/ConnectionRegressionSourceTests.cs +++ b/tests/OpenClaw.Tray.Tests/ConnectionRegressionSourceTests.cs @@ -5,9 +5,13 @@ public sealed class ConnectionRegressionSourceTests [Fact] public void Dashboard_TokenQuery_IsLimitedToSharedGatewayToken() { + var appSource = ReadSource("src", "OpenClaw.Tray.WinUI", "App.xaml.cs"); + var linkServiceSource = ReadSource("src", "OpenClaw.Tray.WinUI", "Services", "GatewayDashboardLinkService.cs"); var launcherSource = ReadSource("src", "OpenClaw.Tray.WinUI", "Services", "GatewayDashboardLauncher.cs"); - Assert.Contains("!credential.IsBootstrapToken && credential.Source == CredentialResolver.SourceSharedGatewayToken", launcherSource); + Assert.Contains("!isBootstrapToken && credentialSource == CredentialResolver.SourceSharedGatewayToken", appSource); + Assert.Contains("request.AppendBrowserCredential && !trustTailscaleAuth", linkServiceSource); + Assert.DoesNotContain("GatewayDashboardUrlBuilder.Build", launcherSource); Assert.DoesNotContain("if (!isBootstrapToken && !string.IsNullOrEmpty(token))", launcherSource); } diff --git a/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs index 9551f4f277..5ca9e2f94c 100644 --- a/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs +++ b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs @@ -17,6 +17,7 @@ public async Task BuildAsync_SharedCredential_AppendsCredentialWithoutRevalidati var result = await service.BuildAsync(Request()); Assert.True(result.Success); + Assert.True(result.BrowserCredentialIncluded); Assert.Contains("token=shared-token", result.Url); Assert.Equal(0, revalidationCalls); } @@ -30,6 +31,7 @@ public async Task BuildAsync_TrustedTailscaleGateway_OmitsSharedCredential() Assert.True(result.Success); Assert.True(result.TrustTailscaleAuth); + Assert.False(result.BrowserCredentialIncluded); Assert.DoesNotContain("token=", result.Url); } @@ -42,6 +44,7 @@ public async Task BuildAsync_FailedRevalidation_FallsBackToSharedCredential() Assert.True(result.Success); Assert.False(result.TrustTailscaleAuth); + Assert.True(result.BrowserCredentialIncluded); Assert.Contains("token=shared-token", result.Url); } @@ -55,6 +58,7 @@ public async Task BuildAsync_TokenFreeBootstrapRequest_PreservesDashboardUrl() tailscaleGatewayId: null)); Assert.True(result.Success); + Assert.False(result.BrowserCredentialIncluded); Assert.NotNull(result.Url); Assert.DoesNotContain("token=", result.Url); } diff --git a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs index c860c9e37d..29cca5a220 100644 --- a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs +++ b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs @@ -165,6 +165,84 @@ public async Task SavedDashboard_WithoutBrowserCredential_BypassesCredentialFall Assert.Equal("https://gateway.example/control", launched); } + [Fact] + public async Task SavedDashboard_SharedCredentialStillRequiresEndpointAuthorization() + { + var launches = 0; + var validationCalls = 0; + var service = new GatewayDashboardLinkService((_, _) => Task.FromResult(false), key => key); + var launcher = new GatewayDashboardLauncher( + () => throw new InvalidOperationException("Saved rows do not require an active tunnel."), + _ => null, + service, + _ => { launches++; return Task.FromResult(true); }, + _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), + () => throw new InvalidOperationException("Unexpected launch failure")); + + var opened = await launcher.OpenSavedAsync( + new GatewayDashboardLinkRequest(Gateway.Url, null, "shared-token", AppendBrowserCredential: true), + result => + { + Assert.True(result.BrowserCredentialIncluded); + validationCalls++; + return Task.FromResult(false); + }); + + Assert.False(opened); + Assert.Equal(1, validationCalls); + Assert.Equal(0, launches); + } + + [Fact] + public async Task SavedDashboard_CancellationAfterLinkPreparationSkipsAuthorizationAndLaunch() + { + using var cancellation = new CancellationTokenSource(); + var validationCalls = 0; + var launches = 0; + var service = new GatewayDashboardLinkService((_, _) => + { + cancellation.Cancel(); + return Task.FromResult(false); + }, key => key); + var launcher = new GatewayDashboardLauncher( + () => throw new InvalidOperationException("Saved rows do not require an active tunnel."), + _ => null, + service, + _ => { launches++; return Task.FromResult(true); }, + _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), + () => throw new InvalidOperationException("Unexpected launch failure")); + + await Assert.ThrowsAnyAsync(() => launcher.OpenSavedAsync( + new GatewayDashboardLinkRequest(Gateway.Url, null, "shared-token", true, "gateway-a"), + _ => { validationCalls++; return Task.FromResult(true); }, + cancellation.Token)); + + Assert.Equal(0, validationCalls); + Assert.Equal(0, launches); + } + + [Fact] + public async Task SavedDashboard_CancellationAfterAuthorizationSkipsBrowserDispatch() + { + using var cancellation = new CancellationTokenSource(); + var launches = 0; + var service = new GatewayDashboardLinkService((_, _) => Task.FromResult(false), key => key); + var launcher = new GatewayDashboardLauncher( + () => throw new InvalidOperationException("Saved rows do not require an active tunnel."), + _ => null, + service, + _ => { launches++; return Task.FromResult(true); }, + _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), + () => throw new InvalidOperationException("Unexpected launch failure")); + + await Assert.ThrowsAnyAsync(() => launcher.OpenSavedAsync( + new GatewayDashboardLinkRequest(Gateway.Url, null, "shared-token", true), + _ => { cancellation.Cancel(); return Task.FromResult(true); }, + cancellation.Token)); + + Assert.Equal(0, launches); + } + [Theory] [InlineData("tunnel")] [InlineData("credential")] From 8e487d7be323eab22ec2ed32e56cacfbc3e3ca4d Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Sat, 10 Oct 2026 02:14:58 +0100 Subject: [PATCH 09/38] test: align gateway assertions with rejection subtype --- .../GatewayFixtureProtocolTests.cs | 12 ++++++------ .../GatewayProtocolLiveRoundTripTests.cs | 2 +- .../OpenClawGatewayClientTests.cs | 5 ++++- 3 files changed, 11 insertions(+), 8 deletions(-) diff --git a/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs index c5b4574ff9..55542f19aa 100644 --- a/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs +++ b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs @@ -35,7 +35,7 @@ public async Task SessionMutations_AuthenticatedAcceptanceIsOptInAndResponseBoun server.ReleaseSessionMutations(); if (!allow) { - await Assert.ThrowsAsync(() => patch); + await Assert.ThrowsAnyAsync(() => patch); return; } await patch.WaitAsync(Deadline); @@ -46,7 +46,7 @@ public async Task SessionMutations_AuthenticatedAcceptanceIsOptInAndResponseBoun Assert.Equal(GatewayScenario.OtherSessionKey, Assert.Single(archived.Sessions).Key); await client.DeleteSessionConfirmedAsync(GatewayScenario.OtherSessionKey, epoch); Assert.Empty((await client.ListArchivedSessionsAsync()).Sessions); - await Assert.ThrowsAsync(() => client.DeleteSessionConfirmedAsync(GatewayScenario.MainSessionKey, epoch)); + await Assert.ThrowsAnyAsync(() => client.DeleteSessionConfirmedAsync(GatewayScenario.MainSessionKey, epoch)); Assert.Empty(server.UnexpectedRequests); } @@ -262,7 +262,7 @@ public async Task RealClient_InvalidOrUnknownParametersFailExplicitly(string met await using var server = await FixtureGatewayServer.StartAsync(GatewayScenario.CreateBrowse(), token); await using var connected = await ConnectedClient.OpenAsync(server, token); using var parameters = JsonDocument.Parse(json); - var error = await Assert.ThrowsAsync( + var error = await Assert.ThrowsAnyAsync( () => connected.Client.SendWizardRequestAsync(method, parameters.RootElement)); Assert.Contains(message, error.Message); Assert.Contains(server.Requests, request => request.Method == method && request.Outcome == "error:INVALID_PARAMS"); @@ -283,7 +283,7 @@ public async Task RealClient_WritesAreRejectedWithoutChangingScenario(string met await using var server = await FixtureGatewayServer.StartAsync(GatewayScenario.CreateBrowse(), token); await using var connected = await ConnectedClient.OpenAsync(server, token); var before = await connected.Client.SendWizardRequestAsync("config.get"); - var error = await Assert.ThrowsAsync( + var error = await Assert.ThrowsAnyAsync( () => method == "chat.send" ? connected.Client.SendChatMessageForRunAsync("Synthetic write attempt.", GatewayScenario.MainSessionKey) : (Task)connected.Client.SendWizardRequestAsync(method, new { sessionKey = GatewayScenario.MainSessionKey, message = "Synthetic write attempt." })); @@ -329,7 +329,7 @@ public async Task RealClient_ApprovalResolveInvalidDecisionDoesNotConsumeIssuedI command = "echo fixture", }); - var error = await Assert.ThrowsAsync(() => + var error = await Assert.ThrowsAnyAsync(() => connected.Client.SendWizardRequestAsync( "exec.approval.resolve", new { id = "fixture-approval-invalid", decision = "approve" })); @@ -416,7 +416,7 @@ public async Task RealClient_UnknownMethodIsRecordedAndNeverReturnsFallbackSucce var token = CreateToken(); await using var server = await FixtureGatewayServer.StartAsync(GatewayScenario.CreateBrowse(), token); await using var connected = await ConnectedClient.OpenAsync(server, token); - var error = await Assert.ThrowsAsync( + var error = await Assert.ThrowsAnyAsync( () => connected.Client.SendWizardRequestAsync("surprise.read", new { token, body = "PRIVATE-REQUEST-BODY" })); Assert.Contains("Unknown fixture Gateway method", error.Message); Assert.Equal("surprise.read", Assert.Single(server.UnexpectedRequests).Method); diff --git a/tests/OpenClaw.Shared.Tests/GatewayProtocolLiveRoundTripTests.cs b/tests/OpenClaw.Shared.Tests/GatewayProtocolLiveRoundTripTests.cs index 2c05852dd8..dade28e378 100644 --- a/tests/OpenClaw.Shared.Tests/GatewayProtocolLiveRoundTripTests.cs +++ b/tests/OpenClaw.Shared.Tests/GatewayProtocolLiveRoundTripTests.cs @@ -244,7 +244,7 @@ public async Task UpdateStatus_GatewayError_PropagatesForCallerFailOpen() { await ConnectAndWaitAsync(client, server); - var exception = await Assert.ThrowsAsync( + var exception = await Assert.ThrowsAnyAsync( () => client.GetUpdateStatusAsync(timeoutMs: 20_000)); Assert.Contains("unauthorized update.status", exception.Message); diff --git a/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs b/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs index cd988d6dd0..d1d6f42617 100644 --- a/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs +++ b/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs @@ -658,7 +658,7 @@ await server.SendTextAsync(JsonSerializer.Serialize(new error = new { message = "permission denied" }, payload = new { ok = false, reason = "permission denied" } })); - var error = await Assert.ThrowsAsync(() => task); + var error = await Assert.ThrowsAnyAsync(() => task); Assert.Equal("permission denied", error.Message); Assert.Equal(0, helper.GetPendingRequestCount()); } @@ -778,6 +778,7 @@ public async Task PatchConfigDetailedAsync_ClassifiesGatewayRejectionAsAuthorita identityPath: identity.Path); using var client = helper.Client; await client.ConnectAsync(); + helper.MarkHandshakeReady(); using var config = JsonDocument.Parse("{}"); var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 10_000); @@ -809,6 +810,7 @@ public async Task PatchConfigDetailedAsync_DoesNotClassifyUnavailableAsAuthorita identityPath: identity.Path); using var client = helper.Client; await client.ConnectAsync(); + helper.MarkHandshakeReady(); using var config = JsonDocument.Parse("{}"); var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 10_000); @@ -840,6 +842,7 @@ public async Task PatchConfigDetailedAsync_DoesNotClassifyTimeoutAsGatewayReject identityPath: identity.Path); using var client = helper.Client; await client.ConnectAsync(); + helper.MarkHandshakeReady(); using var config = JsonDocument.Parse("{}"); var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 250); From 54186599b8d23eded662e85a02f81a35ce078c34 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Sat, 10 Oct 2026 02:15:14 +0100 Subject: [PATCH 10/38] test: update connection runner fakes and deadline --- .../GatewayConnectionManagerTests.cs | 2 +- .../GatewayTailscaleAuthLiveVerifierTests.cs | 11 +++++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs index 08de274a97..99803f3f33 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs @@ -2606,7 +2606,7 @@ public async Task ConnectWithSharedTokenAsync_RevalidatesDurableTokensUnderTrans tunnel.AllowStart.SetResult(true); await connectTask.WaitAsync(TimeSpan.FromSeconds(2)); - var result = await replaceTask.WaitAsync(TimeSpan.FromSeconds(10)); + var result = await replaceTask.WaitAsync(TimeSpan.FromSeconds(20)); Assert.Equal(SetupCodeOutcome.ConnectionFailed, result.Outcome); Assert.Null(_registry.GetById("gw-1")?.SharedGatewayToken); diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs index 998ff9bbfb..7cbdc1bab2 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -723,8 +723,11 @@ public Task RunInDistroAsync( string name, IReadOnlyList command, CancellationToken cancellationToken = default, - IReadOnlyDictionary? environment = null) + IReadOnlyDictionary? environment = null, + string? standardInput = null) { + if (standardInput is not null) + StandardInputs.Add(standardInput); ProbeCalls++; DistroName = name; Commands.Add(command); @@ -738,8 +741,7 @@ public Task RunInDistroWithStandardInputAsync( CancellationToken cancellationToken = default, IReadOnlyDictionary? environment = null) { - StandardInputs.Add(standardInput); - return RunInDistroAsync(name, command, cancellationToken, environment); + return RunInDistroAsync(name, command, cancellationToken, environment, standardInput); } public Task RunAsync( @@ -801,7 +803,8 @@ public Task RunInDistroAsync( string name, IReadOnlyList command, CancellationToken cancellationToken = default, - IReadOnlyDictionary? environment = null) => + IReadOnlyDictionary? environment = null, + string? standardInput = null) => throw new NotSupportedException(); } } From 40f9787839963a792fb4db98340b279d5a17627f Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Sat, 10 Oct 2026 02:44:31 +0100 Subject: [PATCH 11/38] test: cover dashboard bearer fragments --- .../GatewayDashboardLinkServiceTests.cs | 37 ++++++++++++++++++- .../GatewayDashboardUrlBuilderTests.cs | 12 ++++++ .../SetupDashboardHandoffTests.cs | 32 ++++++++++++++++ 3 files changed, 79 insertions(+), 2 deletions(-) diff --git a/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs index 5ca9e2f94c..1e2e5ba09a 100644 --- a/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs +++ b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs @@ -63,6 +63,38 @@ public async Task BuildAsync_TokenFreeBootstrapRequest_PreservesDashboardUrl() Assert.DoesNotContain("token=", result.Url); } + [Fact] + public async Task BuildAsync_TrustedTailscaleAuthStripsEmbeddedTokenFragment() + { + var service = CreateService((_, _) => Task.FromResult(true)); + + var result = await service.BuildAsync(Request( + appendBrowserCredential: false, + browserCredential: null, + tailscaleGatewayId: "gateway-1", + gatewayUrl: "wss://gateway.example.test/mount/#token=stale&view=compact")); + + Assert.True(result.Success); + Assert.True(result.TrustTailscaleAuth); + Assert.False(result.BrowserCredentialIncluded); + Assert.Equal("https://gateway.example.test/mount/settings/profile#view=compact", result.Url); + } + + [Fact] + public async Task BuildAsync_ExistingTokenFragmentCountsAsBrowserCredential() + { + var service = CreateService((_, _) => Task.FromResult(false)); + + var result = await service.BuildAsync(Request( + appendBrowserCredential: false, + browserCredential: null, + gatewayUrl: "wss://gateway.example.test/mount/#token=stale&view=compact")); + + Assert.True(result.Success); + Assert.True(result.BrowserCredentialIncluded); + Assert.Equal("https://gateway.example.test/mount/settings/profile#token=stale&view=compact", result.Url); + } + [Fact] public async Task BuildAsync_TailscaleRequestWithoutApprovedBrowserCredential_FailsClosed() { @@ -142,8 +174,9 @@ private static GatewayDashboardLinkService CreateService( private static GatewayDashboardLinkRequest Request( bool appendBrowserCredential = true, string? browserCredential = "shared-token", - string? tailscaleGatewayId = null) => new( - "https://gateway.example.test", + string? tailscaleGatewayId = null, + string? gatewayUrl = null) => new( + gatewayUrl ?? "https://gateway.example.test", "/settings/profile", browserCredential, appendBrowserCredential, diff --git a/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs b/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs index 3e020a50fe..11dd24b6e5 100644 --- a/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs +++ b/tests/OpenClaw.Tray.Tests/GatewayDashboardUrlBuilderTests.cs @@ -21,6 +21,18 @@ public void Build_RotatedSharedTokenReplacesOldFragmentTokenWithoutQueryExport() "custodian?onboarding=1", "current", true)); } + [Fact] + public void Build_TrustedTailscaleAuthRemovesTokenFragmentAndPreservesOtherFields() + { + Assert.Equal("https://gateway.example/mount#view=compact&route=health", + GatewayDashboardUrlBuilder.Build( + "wss://gateway.example/mount/#token=old-token&view=compact&route=health", + null, + "unused", + appendSharedGatewayToken: true, + trustTailscaleAuth: true)); + } + [Fact] public void Build_AppendsSharedTokenToDashboardRoot() { diff --git a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs index 29cca5a220..d5c52ff2b1 100644 --- a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs +++ b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs @@ -193,6 +193,38 @@ public async Task SavedDashboard_SharedCredentialStillRequiresEndpointAuthorizat Assert.Equal(0, launches); } + [Fact] + public async Task SavedDashboard_EmbeddedTokenStillRequiresEndpointAuthorization() + { + var launches = 0; + var validationCalls = 0; + var service = new GatewayDashboardLinkService((_, _) => Task.FromResult(false), key => key); + var launcher = new GatewayDashboardLauncher( + () => throw new InvalidOperationException("Saved rows do not require an active tunnel."), + _ => null, + service, + _ => { launches++; return Task.FromResult(true); }, + _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), + () => throw new InvalidOperationException("Unexpected launch failure")); + + var opened = await launcher.OpenSavedAsync( + new GatewayDashboardLinkRequest( + "wss://gateway.example/control/#token=stale&view=compact", + null, + null, + AppendBrowserCredential: false), + result => + { + Assert.True(result.BrowserCredentialIncluded); + validationCalls++; + return Task.FromResult(false); + }); + + Assert.False(opened); + Assert.Equal(1, validationCalls); + Assert.Equal(0, launches); + } + [Fact] public async Task SavedDashboard_CancellationAfterLinkPreparationSkipsAuthorizationAndLaunch() { From 540dd9093566ad1c9396ac7d2fefc510c3c30ceb Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Sat, 10 Oct 2026 02:44:53 +0100 Subject: [PATCH 12/38] fix: enforce dashboard token fragment policy --- .../Helpers/GatewayDashboardUrlBuilder.cs | 36 ++++++++++++++++--- .../Services/GatewayDashboardLinkService.cs | 9 ++--- 2 files changed, 37 insertions(+), 8 deletions(-) diff --git a/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs b/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs index c6ec381aff..c17a887679 100644 --- a/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs +++ b/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs @@ -23,14 +23,42 @@ public static string Build( : $"{baseUrl}/{path.TrimStart('/')}"; var fragment = endpoint.Fragment; - if (appendSharedGatewayToken && !trustTailscaleAuth && !string.IsNullOrEmpty(sharedGatewayToken)) + if (trustTailscaleAuth) { - var fields = fragment.TrimStart('#').Split('&', StringSplitOptions.RemoveEmptyEntries) - .Where(field => !Uri.UnescapeDataString(field.Split('=', 2)[0]) - .Equals("token", StringComparison.OrdinalIgnoreCase)); + fragment = RemoveSharedTokenFields(fragment); + } + else if (appendSharedGatewayToken && !string.IsNullOrEmpty(sharedGatewayToken)) + { + var fields = GetFragmentFields(fragment) + .Where(field => !IsSharedTokenField(field)); fragment = "#" + string.Join("&", fields.Append("token=" + Uri.EscapeDataString(sharedGatewayToken))); } return url + fragment; } + + internal static bool HasSharedTokenFragment(string gatewayUrl) + { + ArgumentException.ThrowIfNullOrWhiteSpace(gatewayUrl); + var endpoint = new Uri(gatewayUrl + .Replace("ws://", "http://", StringComparison.OrdinalIgnoreCase) + .Replace("wss://", "https://", StringComparison.OrdinalIgnoreCase), UriKind.Absolute); + return GetFragmentFields(endpoint.Fragment).Any(IsSharedTokenField); + } + + private static string RemoveSharedTokenFields(string fragment) + { + var fields = GetFragmentFields(fragment).Where(field => !IsSharedTokenField(field)).ToArray(); + return fields.Length == 0 ? string.Empty : "#" + string.Join("&", fields); + } + + private static IEnumerable GetFragmentFields(string fragment) => + fragment.TrimStart('#').Split('&', StringSplitOptions.RemoveEmptyEntries); + + private static bool IsSharedTokenField(string field) + { + var separator = field.IndexOf('='); + var key = separator < 0 ? field : field[..separator]; + return Uri.UnescapeDataString(key).Equals("token", StringComparison.OrdinalIgnoreCase); + } } diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs index 51a29370fb..b8d20d0a33 100644 --- a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs @@ -78,10 +78,11 @@ public async Task BuildAsync( RevalidationError: revalidationError); } - // Match the URL builder's exact append predicate so only credential-bearing URLs need authorization. - var browserCredentialIncluded = request.AppendBrowserCredential && - !trustTailscaleAuth && - !string.IsNullOrEmpty(request.BrowserCredential); + // The emitted link can carry a shared token already embedded in its endpoint fragment. + // Keep saved-link authorization aligned with the URL, not just the append request. + var browserCredentialIncluded = !trustTailscaleAuth && + ((request.AppendBrowserCredential && !string.IsNullOrEmpty(request.BrowserCredential)) || + GatewayDashboardUrlBuilder.HasSharedTokenFragment(request.GatewayUrl)); var url = GatewayDashboardUrlBuilder.Build( request.GatewayUrl, request.Path, From 6b1675c90cce54deefc8d0cb4a503e58bdfc2c70 Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Sun, 11 Oct 2026 13:08:43 +0100 Subject: [PATCH 13/38] fix: provide actionable Tailscale adoption recovery --- .../Pages/ConnectionPage.xaml.cs | 8 +--- .../Pages/ConnectionPagePlan.cs | 13 +++++++ .../Strings/en-us/Resources.resw | 25 +++++++++++- .../Strings/fr-fr/Resources.resw | 25 +++++++++++- .../Strings/nl-nl/Resources.resw | 25 +++++++++++- .../Strings/pt-br/Resources.resw | 25 +++++++++++- .../Strings/zh-cn/Resources.resw | 25 +++++++++++- .../Strings/zh-tw/Resources.resw | 25 +++++++++++- .../AppCapabilityTests.cs | 19 +++++++++- .../ConnectionPageTailscaleRecoveryTests.cs | 38 +++++++++++++++++++ 10 files changed, 208 insertions(+), 20 deletions(-) diff --git a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs index 83fb366b71..c003bd3ed9 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs @@ -2665,12 +2665,8 @@ item.Tag is not string gatewayId || return; } - var detail = string.IsNullOrWhiteSpace(result.Error) - ? result.Outcome.ToString() - : result.Error; - SetGatewayHostActionStatus( - string.Format(LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthFailedFormat"), detail), - isError: true); + var messageKey = ConnectionPagePlan.TailscaleAuthFailureMessageResourceKey(result.Outcome); + SetGatewayHostActionStatus(LocalizationHelper.GetString(messageKey), isError: true); } private void OnSavedRowEdit(object sender, RoutedEventArgs e) diff --git a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs index bd338a91d8..78b7e6d25f 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs @@ -131,6 +131,19 @@ internal enum RecoveryCategory /// internal sealed record ConnectionPagePlan { + public static string TailscaleAuthFailureMessageResourceKey( + GatewayTailscaleAuthUpgradeOutcome outcome) => outcome switch + { + GatewayTailscaleAuthUpgradeOutcome.Ineligible => "ConnectionPage_TailscaleDashboardAuthFailureIneligible", + GatewayTailscaleAuthUpgradeOutcome.NotActive => "ConnectionPage_TailscaleDashboardAuthFailureNotActive", + GatewayTailscaleAuthUpgradeOutcome.NotConnected => "ConnectionPage_TailscaleDashboardAuthFailureNotConnected", + GatewayTailscaleAuthUpgradeOutcome.MissingConfigScope => "ConnectionPage_TailscaleDashboardAuthFailureMissingConfigScope", + GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable => "ConnectionPage_TailscaleDashboardAuthFailureConfigUnavailable", + GatewayTailscaleAuthUpgradeOutcome.PatchRejected => "ConnectionPage_TailscaleDashboardAuthFailurePatchRejected", + GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed => "ConnectionPage_TailscaleDashboardAuthFailurePersistenceFailed", + _ => "ConnectionPage_TailscaleDashboardAuthFailureGeneric", + }; + public ConnectionPageMode Mode { get; init; } = ConnectionPageMode.Welcome; // ─── Status strip ─── diff --git a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw index f4e618d08b..e7b6ec7384 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw @@ -5557,8 +5557,29 @@ Make sure the gateway is running. Tailscale dashboard identity enabled. - - Could not enable Tailscale dashboard identity: {0} + + This gateway is no longer a managed Tailscale gateway. Refresh the gateway list and try again. + + + Select this gateway as active, then try again. + + + Connect to this gateway, then try again. + + + Reconnect with operator.read and operator.write access. Ask the gateway administrator if those permissions are unavailable. + + + The gateway configuration could not be read. Reconnect to the gateway and try again. + + + The gateway did not confirm the change. Reconnect and check whether Tailscale identity is enabled before retrying. + + + The local Tailscale trust setting could not be saved. Check access to the OpenClaw Tray data folder, then retry. + + + Tailscale dashboard identity could not be enabled. Reconnect to the gateway and try again. No browser-compatible gateway credential is available diff --git a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw index 5b550753eb..74120cebee 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw @@ -5553,8 +5553,29 @@ Assurez-vous que la passerelle est en cours d'exécution. L’identité Tailscale est activée pour le tableau de bord. - - Impossible d’activer l’identité Tailscale pour le tableau de bord : {0} + + Cette passerelle n’est plus une passerelle Tailscale gérée. Actualisez la liste des passerelles et réessayez. + + + Sélectionnez cette passerelle comme passerelle active, puis réessayez. + + + Connectez-vous à cette passerelle, puis réessayez. + + + Reconnectez-vous avec les autorisations operator.read et operator.write. Demandez-les à l’administrateur de la passerelle si elles ne sont pas disponibles. + + + Impossible de lire la configuration de la passerelle. Reconnectez-vous à la passerelle et réessayez. + + + La passerelle n’a pas confirmé la modification. Reconnectez-vous et vérifiez si l’identité Tailscale est activée avant de réessayer. + + + Impossible d’enregistrer localement le paramètre de confiance Tailscale. Vérifiez l’accès au dossier de données OpenClaw Tray, puis réessayez. + + + Impossible d’activer l’identité Tailscale pour le tableau de bord. Reconnectez-vous à la passerelle et réessayez. Aucun identifiant de passerelle compatible avec le navigateur n’est disponible diff --git a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw index db083cd555..79c1afd86f 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw @@ -5554,8 +5554,29 @@ Controleer of de gateway actief is. Tailscale-identiteit voor het dashboard is ingeschakeld. - - Kan Tailscale-identiteit voor het dashboard niet inschakelen: {0} + + Deze gateway is niet langer een beheerde Tailscale-gateway. Vernieuw de gatewaylijst en probeer het opnieuw. + + + Stel deze gateway in als actief en probeer het opnieuw. + + + Maak verbinding met deze gateway en probeer het opnieuw. + + + Maak opnieuw verbinding met de machtigingen operator.read en operator.write. Vraag de gatewaybeheerder om deze toe te kennen als ze ontbreken. + + + De gatewayconfiguratie kon niet worden gelezen. Maak opnieuw verbinding met de gateway en probeer het opnieuw. + + + De gateway heeft de wijziging niet bevestigd. Maak opnieuw verbinding en controleer of Tailscale-identiteit is ingeschakeld voordat u het opnieuw probeert. + + + De lokale instelling voor Tailscale-vertrouwen kon niet worden opgeslagen. Controleer de toegang tot de gegevensmap van OpenClaw Tray en probeer het opnieuw. + + + Tailscale-identiteit kon niet worden ingeschakeld. Maak opnieuw verbinding met de gateway en probeer het opnieuw. Er is geen gatewayreferentie beschikbaar die geschikt is voor de browser diff --git a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw index 23a8252dc1..ab351abcdc 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw @@ -5531,8 +5531,29 @@ Certifique-se de que o Gateway está em execução. Identidade do Tailscale para o painel ativada. - - Não foi possível ativar a identidade do Tailscale para o painel: {0} + + Este gateway não é mais um gateway Tailscale gerenciado. Atualize a lista de gateways e tente novamente. + + + Defina este gateway como ativo e tente novamente. + + + Conecte-se a este gateway e tente novamente. + + + Reconecte-se com as permissões operator.read e operator.write. Se elas não estiverem disponíveis, peça ao administrador do gateway que as conceda. + + + Não foi possível ler a configuração do gateway. Reconecte-se ao gateway e tente novamente. + + + O gateway não confirmou a alteração. Reconecte-se e verifique se a identidade Tailscale está habilitada antes de tentar novamente. + + + Não foi possível salvar localmente a configuração de confiança do Tailscale. Verifique o acesso à pasta de dados do OpenClaw Tray e tente novamente. + + + Não foi possível habilitar a identidade Tailscale. Reconecte-se ao gateway e tente novamente. Nenhuma credencial de gateway compatível com o navegador está disponível diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw index 0e9c0182c9..93562e5cca 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw @@ -5553,8 +5553,29 @@ 已启用仪表板的 Tailscale 身份认证。 - - 无法启用仪表板的 Tailscale 身份认证:{0} + + 此网关已不再是受管理的 Tailscale 网关。请刷新网关列表后重试。 + + + 请将此网关设为当前活动网关后重试。 + + + 请先连接到此网关,然后重试。 + + + 请使用具有 operator.read 和 operator.write 权限的连接重新连接。若无法获得这些权限,请联系网关管理员。 + + + 无法读取网关配置。请重新连接网关后重试。 + + + 网关未确认此更改。请重新连接,并在重试前检查是否已启用 Tailscale 身份认证。 + + + 无法在本地保存 Tailscale 信任设置。请检查 OpenClaw Tray 数据文件夹的访问权限后重试。 + + + 无法启用 Tailscale 仪表板身份认证。请重新连接网关后重试。 没有可供浏览器使用的网关凭据 diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw index 00eff237a1..5f957ed790 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw @@ -5553,8 +5553,29 @@ 已啟用儀表板的 Tailscale 身分驗證。 - - 無法啟用儀表板的 Tailscale 身分驗證:{0} + + 此閘道已不再是受管理的 Tailscale 閘道。請重新整理閘道清單後再試一次。 + + + 請將此閘道設為目前作用中的閘道,然後再試一次。 + + + 請先連線到此閘道,然後再試一次。 + + + 請使用具備 operator.read 與 operator.write 權限的連線重新連線。若無法取得這些權限,請聯絡閘道管理員。 + + + 無法讀取閘道設定。請重新連線至閘道後再試一次。 + + + 閘道未確認這項變更。請重新連線,並在重試前確認是否已啟用 Tailscale 身分驗證。 + + + 無法在本機儲存 Tailscale 信任設定。請檢查 OpenClaw Tray 資料資料夾的存取權限後再試一次。 + + + 無法啟用 Tailscale 儀表板身分驗證。請重新連線至閘道後再試一次。 沒有可供瀏覽器使用的閘道認證 diff --git a/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs b/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs index d5b238c25d..980e5d93bd 100644 --- a/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs +++ b/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs @@ -159,9 +159,16 @@ public async Task SettingsSet_WithHandlerSuccessPayload_ReturnsData() [Fact] public async Task DashboardUrl_AwaitsAsyncHandler() { + const string expectedUrl = "https://gateway.test:8443/prefix/settings?view=compact#token=opaque"; + var handlerStarted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var handlerResult = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); var cap = new AppCapability(NullLogger.Instance) { - DashboardUrlHandler = path => Task.FromResult(new { url = $"https://gateway.test/{path}" }) + DashboardUrlHandler = path => + { + handlerStarted.TrySetResult(path); + return handlerResult.Task; + } }; var req = new NodeInvokeRequest { @@ -170,9 +177,17 @@ public async Task DashboardUrl_AwaitsAsyncHandler() Args = ParseArgs("{\"path\":\"settings\"}") }; - var res = await cap.ExecuteAsync(req); + var responseTask = cap.ExecuteAsync(req); + Assert.Equal("settings", await handlerStarted.Task.WaitAsync(TimeSpan.FromSeconds(5))); + Assert.False(responseTask.IsCompleted); + + handlerResult.SetResult(new { url = expectedUrl }); + var res = await responseTask; Assert.True(res.Ok); + Assert.Equal( + expectedUrl, + JsonSerializer.SerializeToElement(res.Payload).GetProperty("url").GetString()); } [Fact] diff --git a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs index 4fbc9f65a1..071a673f09 100644 --- a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs +++ b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs @@ -5,6 +5,44 @@ namespace OpenClaw.Tray.Tests; public sealed class ConnectionPageTailscaleRecoveryTests { + [Fact] + public void FailedDashboardAuth_UsesLocalizedRecoveryOutcomeInsteadOfRawDetails() + { + var source = File.ReadAllText(Path.Combine( + TestRepositoryPaths.GetRepositoryRoot(), + "src", + "OpenClaw.Tray.WinUI", + "Pages", + "ConnectionPage.xaml.cs")); + var methodStart = source.IndexOf( + "private async Task OnEnableTailscaleDashboardAuthAsync(object sender)", + StringComparison.Ordinal); + var methodEnd = source.IndexOf( + "private void OnSavedRowEdit(object sender, RoutedEventArgs e)", + methodStart, + StringComparison.Ordinal); + Assert.True(methodStart >= 0 && methodEnd > methodStart); + var method = source[methodStart..methodEnd]; + + Assert.Contains("ConnectionPagePlan.TailscaleAuthFailureMessageResourceKey(result.Outcome)", method); + Assert.DoesNotContain("result.Error", method); + Assert.DoesNotContain("result.Outcome.ToString()", method); + } + + [Theory] + [InlineData(GatewayTailscaleAuthUpgradeOutcome.Ineligible, "ConnectionPage_TailscaleDashboardAuthFailureIneligible")] + [InlineData(GatewayTailscaleAuthUpgradeOutcome.NotActive, "ConnectionPage_TailscaleDashboardAuthFailureNotActive")] + [InlineData(GatewayTailscaleAuthUpgradeOutcome.NotConnected, "ConnectionPage_TailscaleDashboardAuthFailureNotConnected")] + [InlineData(GatewayTailscaleAuthUpgradeOutcome.MissingConfigScope, "ConnectionPage_TailscaleDashboardAuthFailureMissingConfigScope")] + [InlineData(GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable, "ConnectionPage_TailscaleDashboardAuthFailureConfigUnavailable")] + [InlineData(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, "ConnectionPage_TailscaleDashboardAuthFailurePatchRejected")] + [InlineData(GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, "ConnectionPage_TailscaleDashboardAuthFailurePersistenceFailed")] + [InlineData(GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled, "ConnectionPage_TailscaleDashboardAuthFailureGeneric")] + public void TailscaleDashboardAuthFailure_MapsOutcomeToLocalizedRecoveryMessage( + GatewayTailscaleAuthUpgradeOutcome outcome, + string expectedResourceKey) => + Assert.Equal(expectedResourceKey, ConnectionPagePlan.TailscaleAuthFailureMessageResourceKey(outcome)); + [Fact] public void SavedDashboardLaunch_DelegatesToSharedDashboardLinkService() { From ff543be7dbfcf072f92800d4d2268abeb333eebb Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Sun, 11 Oct 2026 20:24:32 +0100 Subject: [PATCH 14/38] test: separate handshake event readiness from timeout --- tests/OpenClaw.Connection.Tests/OperatorScopeHelperTests.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/OpenClaw.Connection.Tests/OperatorScopeHelperTests.cs b/tests/OpenClaw.Connection.Tests/OperatorScopeHelperTests.cs index f66811f976..ed333ac104 100644 --- a/tests/OpenClaw.Connection.Tests/OperatorScopeHelperTests.cs +++ b/tests/OpenClaw.Connection.Tests/OperatorScopeHelperTests.cs @@ -115,10 +115,10 @@ public async Task WaitForOperatorHandshakeAsync_ReturnsTrue_WhenStateEventFires( { var mgr = new StubConnectionManager(RoleConnectionState.Connecting); - var waitTask = ChatNavigationReadiness.WaitForOperatorHandshakeAsync(mgr, TimeSpan.FromMilliseconds(500)); + var waitTask = ChatNavigationReadiness.WaitForOperatorHandshakeAsync(mgr, Timeout.InfiniteTimeSpan); mgr.SimulateConnected(); - var result = await waitTask; + var result = await waitTask.WaitAsync(TimeSpan.FromSeconds(10)); Assert.True(result); } From 6484664e118fdec2e157c51183fc4797b03700c7 Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Sun, 11 Oct 2026 20:37:25 +0100 Subject: [PATCH 15/38] fix: require Core admin scope for configuration writes --- .../OperatorScopeHelper.cs | 4 +- .../Strings/en-us/Resources.resw | 2 +- .../Strings/fr-fr/Resources.resw | 2 +- .../Strings/nl-nl/Resources.resw | 2 +- .../Strings/pt-br/Resources.resw | 2 +- .../Strings/zh-cn/Resources.resw | 2 +- .../Strings/zh-tw/Resources.resw | 2 +- .../GatewayTailscaleAuthLiveVerifierTests.cs | 52 ------------------- .../GatewayTailscaleAuthUpgradeTests.cs | 16 ++++-- .../OperatorScopeHelperTests.cs | 5 +- 10 files changed, 22 insertions(+), 67 deletions(-) diff --git a/src/OpenClaw.Connection/OperatorScopeHelper.cs b/src/OpenClaw.Connection/OperatorScopeHelper.cs index 8fe2dda323..e06beefb45 100644 --- a/src/OpenClaw.Connection/OperatorScopeHelper.cs +++ b/src/OpenClaw.Connection/OperatorScopeHelper.cs @@ -5,7 +5,6 @@ public static class OperatorScopeHelper private const string AdminScope = "operator.admin"; private const string PairingScope = "operator.pairing"; private const string ReadScope = "operator.read"; - private const string WriteScope = "operator.write"; public static bool CanApproveDevices(IReadOnlyList grantedScopes) => HasAdminScope(grantedScopes) || @@ -16,8 +15,7 @@ public static bool CanReadConfig(IReadOnlyList grantedScopes) => HasScope(grantedScopes, ReadScope); public static bool CanWriteConfig(IReadOnlyList grantedScopes) => - HasAdminScope(grantedScopes) || - HasScope(grantedScopes, WriteScope); + HasAdminScope(grantedScopes); public static bool HasAdminScope(IReadOnlyList grantedScopes) => HasScope(grantedScopes, AdminScope); diff --git a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw index e7b6ec7384..47b99c010b 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw @@ -5567,7 +5567,7 @@ Make sure the gateway is running. Connect to this gateway, then try again. - Reconnect with operator.read and operator.write access. Ask the gateway administrator if those permissions are unavailable. + Reconnect with operator.admin access. Ask the gateway administrator if that permission is unavailable. The gateway configuration could not be read. Reconnect to the gateway and try again. diff --git a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw index 74120cebee..1a8be0cab2 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw @@ -5563,7 +5563,7 @@ Assurez-vous que la passerelle est en cours d'exécution. Connectez-vous à cette passerelle, puis réessayez. - Reconnectez-vous avec les autorisations operator.read et operator.write. Demandez-les à l’administrateur de la passerelle si elles ne sont pas disponibles. + Reconnectez-vous avec l’autorisation operator.admin. Demandez-la à l’administrateur de la passerelle si elle n’est pas disponible. Impossible de lire la configuration de la passerelle. Reconnectez-vous à la passerelle et réessayez. diff --git a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw index 79c1afd86f..ba1b128ce8 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw @@ -5564,7 +5564,7 @@ Controleer of de gateway actief is. Maak verbinding met deze gateway en probeer het opnieuw. - Maak opnieuw verbinding met de machtigingen operator.read en operator.write. Vraag de gatewaybeheerder om deze toe te kennen als ze ontbreken. + Maak opnieuw verbinding met de machtiging operator.admin. Vraag de gatewaybeheerder om deze toe te kennen als deze ontbreekt. De gatewayconfiguratie kon niet worden gelezen. Maak opnieuw verbinding met de gateway en probeer het opnieuw. diff --git a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw index ab351abcdc..443fde7741 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw @@ -5541,7 +5541,7 @@ Certifique-se de que o Gateway está em execução. Conecte-se a este gateway e tente novamente. - Reconecte-se com as permissões operator.read e operator.write. Se elas não estiverem disponíveis, peça ao administrador do gateway que as conceda. + Reconecte-se com a permissão operator.admin. Se ela não estiver disponível, peça ao administrador do gateway que a conceda. Não foi possível ler a configuração do gateway. Reconecte-se ao gateway e tente novamente. diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw index 93562e5cca..a6006bcc84 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw @@ -5563,7 +5563,7 @@ 请先连接到此网关,然后重试。 - 请使用具有 operator.read 和 operator.write 权限的连接重新连接。若无法获得这些权限,请联系网关管理员。 + 请使用具有 operator.admin 权限的连接重新连接。若无法获得此权限,请联系网关管理员。 无法读取网关配置。请重新连接网关后重试。 diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw index 5f957ed790..838da8d9b6 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw @@ -5563,7 +5563,7 @@ 請先連線到此閘道,然後再試一次。 - 請使用具備 operator.read 與 operator.write 權限的連線重新連線。若無法取得這些權限,請聯絡閘道管理員。 + 請使用具備 operator.admin 權限的連線重新連線。若無法取得此權限,請聯絡閘道管理員。 無法讀取閘道設定。請重新連線至閘道後再試一次。 diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs index 7cbdc1bab2..813a29a4e8 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -4,36 +4,6 @@ namespace OpenClaw.Connection.Tests; public sealed class GatewayTailscaleAuthLiveVerifierTests { - [Fact] - public void ConnectionManager_WiresWslLiveVerifierIntoDashboardRevalidation() - { - var source = File.ReadAllText(Path.Combine( - GetRepositoryRoot(), - "src", - "OpenClaw.Connection", - "GatewayConnectionManager.cs")); - var revalidationStart = source.IndexOf( - "public async Task RevalidateTailscaleDashboardAuthAsync(", - StringComparison.Ordinal); - var diagnosticsStart = source.IndexOf( - "public ConnectionDiagnostics Diagnostics", - revalidationStart, - StringComparison.Ordinal); - - Assert.True(revalidationStart >= 0); - Assert.True(diagnosticsStart > revalidationStart); - Assert.Contains( - "new GatewayTailscaleAuthLiveVerifier(\n new WslExeCommandRunner(_logger))", - source.Replace("\r\n", "\n", StringComparison.Ordinal)); - var revalidation = source[revalidationStart..diagnosticsStart] - .Replace("\r\n", "\n", StringComparison.Ordinal); - Assert.Contains( - "new GatewayTailscaleAuthUpgradeService(\n" + - " _registry,\n" + - " _tailscaleAuthLiveVerifier);", - revalidation); - } - [Theory] [MemberData(nameof(StatusResults))] public async Task VerifyAsync_ClassifiesStatusResult( @@ -672,28 +642,6 @@ private static WslCommandResult ForegroundServeStatus( """, ""); - private static string GetRepositoryRoot() - { - var current = new DirectoryInfo(AppContext.BaseDirectory); - while (current is not null) - { - if ((Directory.Exists(Path.Combine(current.FullName, ".git")) || - File.Exists(Path.Combine(current.FullName, ".git"))) && - File.Exists(Path.Combine( - current.FullName, - "src", - "OpenClaw.Connection", - "GatewayConnectionManager.cs"))) - { - return current.FullName; - } - - current = current.Parent; - } - - throw new InvalidOperationException("Could not find repository root."); - } - private static WslCommandResult Status(string backendState, string dnsName) => new( 0, diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs index ad57425d96..4de51179e7 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs @@ -152,13 +152,16 @@ public async Task EnableAsync_AmbiguousPatchFailure_PreservesMarkerForRevalidati Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); } - [Fact] - public async Task EnableAsync_MissingScopes_DoesNotRequestOrMutateConfig() + [Theory] + [InlineData(false)] + [InlineData(true)] + public async Task EnableAsync_WithoutAdminScope_DoesNotRequestPatchOrPersistMarker(bool hasWriteScope) { var registry = CreateRegistry(); + registry.Save(); var client = new FakeConfigClient(Config(allowTailscale: false)) { - Scopes = ["operator.read"], + Scopes = hasWriteScope ? ["operator.read", "operator.write"] : ["operator.read"], }; var service = new GatewayTailscaleAuthUpgradeService(registry); @@ -166,7 +169,12 @@ public async Task EnableAsync_MissingScopes_DoesNotRequestOrMutateConfig() Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.MissingConfigScope, result.Outcome); Assert.Equal(0, client.ConfigRequests); + Assert.Equal(0, client.PatchCalls); Assert.False(registry.GetActive()!.TrustTailscaleAuth); + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.False(reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", reloaded.GetActive()!.SharedGatewayToken); } [Fact] @@ -636,7 +644,7 @@ private static JsonElement ImplicitServeConfig() private sealed class FakeConfigClient(JsonElement config) : IGatewayTailscaleAuthConfigClient { - public IReadOnlyList Scopes { get; set; } = ["operator.read", "operator.write"]; + public IReadOnlyList Scopes { get; set; } = ["operator.admin"]; public IReadOnlyList GrantedOperatorScopes => Scopes; public bool IsConnectedToGateway { get; set; } = true; public int ConfigRequests { get; private set; } diff --git a/tests/OpenClaw.Tray.Tests/OperatorScopeHelperTests.cs b/tests/OpenClaw.Tray.Tests/OperatorScopeHelperTests.cs index 3a3956856f..4a97211a8f 100644 --- a/tests/OpenClaw.Tray.Tests/OperatorScopeHelperTests.cs +++ b/tests/OpenClaw.Tray.Tests/OperatorScopeHelperTests.cs @@ -14,10 +14,11 @@ public void CanReadConfig_AllowsAdminOrReadScope() } [Fact] - public void CanWriteConfig_AllowsAdminOrWriteScope() + public void CanWriteConfig_RequiresAdminScope() { Assert.True(OperatorScopeHelper.CanWriteConfig(["operator.admin"])); - Assert.True(OperatorScopeHelper.CanWriteConfig(["operator.write"])); + Assert.False(OperatorScopeHelper.CanWriteConfig(["operator.write"])); + Assert.False(OperatorScopeHelper.CanWriteConfig(["operator.read", "operator.write"])); Assert.False(OperatorScopeHelper.CanWriteConfig(["operator.read"])); Assert.False(OperatorScopeHelper.CanWriteConfig([])); } From 3c893ec04b4ab507a583bcb42294959fa6bef447 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Mon, 12 Oct 2026 18:02:06 +0100 Subject: [PATCH 16/38] test: reproduce unapplied Tailscale configuration trust --- .../GatewayTailscaleAuthUpgradeTests.cs | 122 +++++++++++++++++- 1 file changed, 117 insertions(+), 5 deletions(-) diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs index 4de51179e7..817cc8a63c 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs @@ -99,6 +99,25 @@ public async Task EnableAsync_PersistedMarkerDoesNotRequirePatchHashWhenCoreAllo Assert.Equal(0, client.PatchCalls); } + [Fact] + public async Task EnableAsync_PersistedButUnappliedGrant_DoesNotReportAlreadyEnabled() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: true, appliedRevision: "revision-old")) + { + PatchResult = new ConfigPatchResult { Ok = false, Error = "application pending" }, + }; + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, result.Outcome); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); + } + [Fact] public async Task EnableAsync_MissingBaseHash_FailsClosedBeforePatch() { @@ -228,6 +247,91 @@ public async Task RevalidateAsync_OmittedGatewayPort_UsesCoreDefault() Assert.Equal(18789, liveVerifier.LastGatewayPort); } + [Theory] + [InlineData("parsed", "\"configRevisionHash\":\"revision-new\",\"appliedConfigHash\":\"revision-old\"")] + [InlineData("config", "\"configRevisionHash\":\"revision-new\",\"appliedConfigHash\":\"revision-old\"")] + [InlineData("parsed", "\"configRevisionHash\":\"revision-new\",\"appliedConfigHash\":null")] + [InlineData("parsed", "\"configRevisionHash\":null,\"appliedConfigHash\":null")] + [InlineData("parsed", "\"configRevisionHash\":\"revision-new\"")] + [InlineData("parsed", "\"appliedConfigHash\":\"revision-new\"")] + [InlineData("parsed", "\"configRevisionHash\":\"\",\"appliedConfigHash\":\"\"")] + [InlineData("parsed", "\"configRevisionHash\":true,\"appliedConfigHash\":true")] + [InlineData("parsed", "\"configRevisionHash\":\"revision-new\",\"appliedConfigHash\":\"REVISION-NEW\"")] + [InlineData("parsed", "\"hash\":\"revision-new\",\"appliedConfigHash\":\"revision-new\"")] + public async Task RevalidateAsync_UnprovenAppliedRevision_PreservesMarkerAndCredential( + string documentProperty, + string revisionProperties) + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + using var response = JsonDocument.Parse($$""" + { + "{{documentProperty}}": { "gateway": { "auth": { "allowTailscale": true } } }, + {{revisionProperties}} + } + """); + var client = new FakeConfigClient(response.RootElement.Clone()); + var service = new GatewayTailscaleAuthUpgradeService( + registry, new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready)); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(trusted); + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", reloaded.GetActive()!.SharedGatewayToken); + } + + [Fact] + public async Task RevalidateAsync_AmbiguousAdoptionTrustsOnlyAfterAppliedRevisionConverges() + { + var registry = CreateRegistry(); + var client = new FakeConfigClient(Config(allowTailscale: false)) + { + PatchResult = new ConfigPatchResult { Ok = false, Error = "response lost" }, + }; + var service = new GatewayTailscaleAuthUpgradeService(registry); + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, result.Outcome); + + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + service = new GatewayTailscaleAuthUpgradeService( + reloaded, new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready)); + client.ConfigResponse = Config(allowTailscale: true, appliedRevision: "revision-old"); + var pending = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + client.ConfigResponse = Config(allowTailscale: true); + var applied = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(pending); + Assert.True(applied); + Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", reloaded.GetActive()!.SharedGatewayToken); + Assert.Equal(1, client.PatchCalls); + } + + [Fact] + public async Task RevalidateAsync_UnappliedDisableRetainsMarkerUntilApplied() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: false, appliedRevision: "revision-old")); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + Assert.False(await service.RevalidateAsync("gateway-1", client, CancellationToken.None)); + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + client.ConfigResponse = Config(allowTailscale: false); + Assert.False(await service.RevalidateAsync("gateway-1", client, CancellationToken.None)); + reloaded.Load(); + Assert.False(reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", reloaded.GetActive()!.SharedGatewayToken); + } + [Theory] [InlineData("0")] [InlineData("65536")] @@ -595,7 +699,8 @@ private GatewayRegistry CreateRegistry(IFileSystem? fileSystem = null) private static JsonElement Config( bool allowTailscale, bool includeBaseHash = true, - bool includeGatewayPort = true) + bool includeGatewayPort = true, + string appliedRevision = "revision-new") { using var document = JsonDocument.Parse($$""" { @@ -605,7 +710,9 @@ private static JsonElement Config( "auth": { "allowTailscale": {{allowTailscale.ToString().ToLowerInvariant()}} } }, "unrelated": "keep" - }{{(includeBaseHash ? ",\n \"baseHash\": \"base-1\"" : "")}} + }, + "configRevisionHash": "revision-new", + "appliedConfigHash": "{{appliedRevision}}"{{(includeBaseHash ? ",\n \"baseHash\": \"base-1\"" : "")}} } """); return document.RootElement.Clone(); @@ -620,7 +727,9 @@ private static JsonElement ConfigWithGatewayPort(string gatewayPort) "port": {{gatewayPort}}, "auth": { "allowTailscale": true } } - } + }, + "configRevisionHash": "revision-new", + "appliedConfigHash": "revision-new" } """); return document.RootElement.Clone(); @@ -636,7 +745,9 @@ private static JsonElement ImplicitServeConfig() "tailscale": { "mode": "serve" } } }, - "baseHash": "base-1" + "baseHash": "base-1", + "configRevisionHash": "revision-new", + "appliedConfigHash": "revision-new" } """); return document.RootElement.Clone(); @@ -644,6 +755,7 @@ private static JsonElement ImplicitServeConfig() private sealed class FakeConfigClient(JsonElement config) : IGatewayTailscaleAuthConfigClient { + public JsonElement ConfigResponse { get; set; } = config; public IReadOnlyList Scopes { get; set; } = ["operator.admin"]; public IReadOnlyList GrantedOperatorScopes => Scopes; public bool IsConnectedToGateway { get; set; } = true; @@ -667,7 +779,7 @@ public Task RequestConfigDetailedAsync(int timeoutMs = 15000) return Task.FromException(ConfigError); var result = EmitConfig - ? Task.FromResult(config.Clone()) + ? Task.FromResult(ConfigResponse.Clone()) : new TaskCompletionSource().Task; AfterConfig?.Invoke(); return result; From cd2e9239358eeb9f46634090a17583f7c07fce1f Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Mon, 12 Oct 2026 18:03:33 +0100 Subject: [PATCH 17/38] fix: require applied Core revision before Tailscale trust --- .../GatewayTailscaleAuthUpgrade.cs | 28 +++++++++++++++++-- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs index cc104d0fbc..976ff5426f 100644 --- a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs +++ b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs @@ -394,7 +394,7 @@ public async Task EnableAsync( cancellationToken.ThrowIfCancellationRequested(); - if (record!.TrustTailscaleAuth && AllowsTailscaleAuth(snapshot.Root)) + if (record!.TrustTailscaleAuth && snapshot.IsApplied && AllowsTailscaleAuth(snapshot.Root)) return new(GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled); if (string.IsNullOrWhiteSpace(snapshot.BaseHash)) @@ -529,6 +529,9 @@ public async Task RevalidateAsync( return false; } + if (!snapshot.IsApplied) + return false; + if (AllowsTailscaleAuth(snapshot.Root)) { if (_liveVerifier is null || !TryGetGatewayPort(snapshot.Root, out var gatewayPort)) @@ -594,7 +597,16 @@ private static ConfigSnapshot CaptureSnapshot(JsonElement response) baseHash = Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(raw))); } - return new(root.Clone(), baseHash); + var configRevisionHash = response.TryGetProperty("configRevisionHash", out var revisionElement) && + revisionElement.ValueKind == JsonValueKind.String + ? revisionElement.GetString() + : null; + var appliedConfigHash = response.TryGetProperty("appliedConfigHash", out var appliedElement) && + appliedElement.ValueKind == JsonValueKind.String + ? appliedElement.GetString() + : null; + + return new(root.Clone(), baseHash, configRevisionHash, appliedConfigHash); } private static JsonElement CreateAllowTailscalePatch() @@ -662,5 +674,15 @@ private static bool TryGetGatewayPort(JsonElement config, out int port) port is > 0 and <= 65535; } - private sealed record ConfigSnapshot(JsonElement Root, string? BaseHash); + private sealed record ConfigSnapshot( + JsonElement Root, + string? BaseHash, + string? ConfigRevisionHash, + string? AppliedConfigHash) + { + public bool IsApplied => + !string.IsNullOrWhiteSpace(ConfigRevisionHash) && + !string.IsNullOrWhiteSpace(AppliedConfigHash) && + string.Equals(ConfigRevisionHash, AppliedConfigHash, StringComparison.Ordinal); + } } From 41c800e53c2133756dcc69b6a03415809b01b84e Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Sun, 11 Oct 2026 22:01:44 +0100 Subject: [PATCH 18/38] fix: retain Tailscale auth outcome in sanitized diagnostics --- .../GatewayConnectionManager.cs | 34 ++++++---- .../GatewayConnectionManagerTests.cs | 66 +++++++++++++++++++ 2 files changed, 89 insertions(+), 11 deletions(-) diff --git a/src/OpenClaw.Connection/GatewayConnectionManager.cs b/src/OpenClaw.Connection/GatewayConnectionManager.cs index d0a58e864d..cb6ee47ea3 100644 --- a/src/OpenClaw.Connection/GatewayConnectionManager.cs +++ b/src/OpenClaw.Connection/GatewayConnectionManager.cs @@ -227,19 +227,31 @@ public async Task EnableTailscaleDashboardAut await _transitionSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false); try { - if (!string.Equals(_activeGatewayRecordId, gatewayId, StringComparison.Ordinal)) - return new(GatewayTailscaleAuthUpgradeOutcome.NotActive); - + GatewayTailscaleAuthUpgradeResult result; var client = OperatorClient; - if (client is null) - return new(GatewayTailscaleAuthUpgradeOutcome.NotConnected); + if (!string.Equals(_activeGatewayRecordId, gatewayId, StringComparison.Ordinal)) + { + result = new(GatewayTailscaleAuthUpgradeOutcome.NotActive); + } + else if (client is null) + { + result = new(GatewayTailscaleAuthUpgradeOutcome.NotConnected); + } + else + { + var service = new GatewayTailscaleAuthUpgradeService(_registry); + result = await service.EnableAsync( + gatewayId, + new GatewayTailscaleAuthConfigClientAdapter(client), + cancellationToken) + .ConfigureAwait(false); + } - var service = new GatewayTailscaleAuthUpgradeService(_registry); - return await service.EnableAsync( - gatewayId, - new GatewayTailscaleAuthConfigClientAdapter(client), - cancellationToken) - .ConfigureAwait(false); + _diagnostics.Record( + "tailscale-auth", + $"Dashboard auth upgrade: {result.Outcome}", + result.Error); + return result; } finally { diff --git a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs index 99803f3f33..b97f1e32a5 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; @@ -3343,6 +3344,54 @@ public async Task DiagnosticEvent_Fires_OnCredentialResolution() Assert.Contains(events, e => e.Category == "credential"); } + [Fact] + public async Task TailscaleDashboardAuthFailure_RecordsOutcomeAndError() + { + const string fixtureToken = "fixture-operator-token"; + const string gatewayId = "tailscale-gateway"; + using var data = new TempDirectory("openclaw-tailscale-auth-test-"); + await using var fixture = await FixtureGatewayServer.StartAsync( + GatewayScenario.CreateNativeSetup((_, _) => new { ok = true }), + fixtureToken); + + var registry = new GatewayRegistry(data.Path); + registry.AddOrUpdate(new GatewayRecord + { + Id = gatewayId, + Url = "wss://openclaw.tailnet.ts.net", + IsLocal = true, + SetupManagedDistroName = "OpenClawGateway", + }); + registry.SetActive(gatewayId); + var resolver = new MockCredentialResolver + { + OperatorCredential = new GatewayCredential(fixtureToken, false, "fixture"), + }; + var factory = new FixtureGatewayClientFactory(fixture.Endpoint.ToString()); + await using var manager = new GatewayConnectionManager( + resolver, factory, registry, NullLogger.Instance); + + await manager.ConnectAsync(gatewayId); + await fixture.HandshakeCompleted.WaitAsync(TimeSpan.FromSeconds(5)); + await WaitUntilAsync(() => manager.OperatorClient is + { IsConnectedToGateway: true, HasHandshakeSnapshot: true }); + + Assert.Equal("wss://openclaw.tailnet.ts.net", factory.RequestedGatewayUrl); + Assert.Contains("operator.admin", manager.OperatorClient!.GrantedOperatorScopes); + + var result = await manager.EnableTailscaleDashboardAuthAsync(gatewayId); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, result.Outcome); + Assert.Contains("Fixture Gateway is read-only", result.Error ?? string.Empty); + Assert.Contains(fixture.Requests, request => request.Method == "config.get" && request.Outcome == "ok"); + Assert.Contains(fixture.Requests, request => + request.Method == "config.patch" && request.Outcome == "error:FIXTURE_READ_ONLY"); + var diagnostic = Assert.Single(manager.Diagnostics.GetAll(), + entry => entry.Category == "tailscale-auth"); + Assert.Equal("Dashboard auth upgrade: PatchRejected", diagnostic.Message); + Assert.Contains("Fixture Gateway is read-only", diagnostic.Detail ?? string.Empty); + } + [Fact] public async Task Dispose_CleansUp() { @@ -5742,6 +5791,23 @@ public IGatewayClientLifecycle Create(string gatewayUrl, GatewayCredential crede } } + private sealed class FixtureGatewayClientFactory(string fixtureEndpoint) : IGatewayClientFactory + { + private readonly GatewayClientFactory _inner = new(); + + public string? RequestedGatewayUrl { get; private set; } + + public IGatewayClientLifecycle Create( + string gatewayUrl, + GatewayCredential credential, + string identityPath, + IOpenClawLogger logger) + { + RequestedGatewayUrl = gatewayUrl; + return _inner.Create(fixtureEndpoint, credential, identityPath, logger); + } + } + private sealed class ThrowingWriteFileSystem : IFileSystem { public bool FileExists(string path) => File.Exists(path); From 7dc15646c6b1b895924224be6f635d3df0686fc8 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Mon, 12 Oct 2026 19:43:23 +0100 Subject: [PATCH 19/38] test: qualify missing diagnostic and expose handshake failures --- .../GatewayConnectionManagerTests.cs | 23 ++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs index b97f1e32a5..feecbe2cff 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs @@ -3372,7 +3372,22 @@ public async Task TailscaleDashboardAuthFailure_RecordsOutcomeAndError() resolver, factory, registry, NullLogger.Instance); await manager.ConnectAsync(gatewayId); - await fixture.HandshakeCompleted.WaitAsync(TimeSpan.FromSeconds(5)); + try + { + await fixture.HandshakeCompleted.WaitAsync(TimeSpan.FromSeconds(5)); + } + catch (TimeoutException ex) + { + var snapshot = manager.CurrentSnapshot; + var requests = string.Join(", ", fixture.Requests.Select(request => $"{request.Method}={request.Outcome}")); + var diagnostics = string.Join(" | ", manager.Diagnostics.GetAll().Select(entry => $"{entry.Category}: {entry.Message}; {entry.Detail}")); + throw new TimeoutException( + $"Fixture handshake failed. Operator={snapshot.OperatorState}; error={snapshot.OperatorError}; " + + $"errorKind={snapshot.OperatorErrorKind}; protocol={snapshot.OperatorProtocolCompatibility}; " + + $"clientCreated={factory.RequestedGatewayUrl is not null}; gatewayReady={manager.OperatorClient?.IsConnectedToGateway}; " + + $"connections={fixture.ConnectionCount}; sharedConnects={fixture.SharedCredentialConnects}; " + + $"deviceRejections={fixture.DeviceTokenRejections}; requests={requests}; diagnostics={diagnostics}", ex); + } await WaitUntilAsync(() => manager.OperatorClient is { IsConnectedToGateway: true, HasHandshakeSnapshot: true }); @@ -3386,8 +3401,10 @@ await WaitUntilAsync(() => manager.OperatorClient is Assert.Contains(fixture.Requests, request => request.Method == "config.get" && request.Outcome == "ok"); Assert.Contains(fixture.Requests, request => request.Method == "config.patch" && request.Outcome == "error:FIXTURE_READ_ONLY"); - var diagnostic = Assert.Single(manager.Diagnostics.GetAll(), - entry => entry.Category == "tailscale-auth"); + var upgradeEvents = manager.Diagnostics.GetAll() + .Where(entry => entry.Category == "tailscale-auth") + .ToArray(); + var diagnostic = Assert.Single(upgradeEvents); Assert.Equal("Dashboard auth upgrade: PatchRejected", diagnostic.Message); Assert.Contains("Fixture Gateway is read-only", diagnostic.Detail ?? string.Empty); } From d98a0e12db9bf56ae2fa7d4137b8ea3c60041d1a Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Tue, 13 Oct 2026 01:52:35 +0100 Subject: [PATCH 20/38] fix: retain Tailscale Dashboard trust with inherited Node options --- .../GatewayTailscaleAuthUpgrade.cs | 9 +- .../GatewayTailscaleAuthLiveVerifierTests.cs | 122 ++++++++++++++++++ 2 files changed, 127 insertions(+), 4 deletions(-) diff --git a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs index 976ff5426f..8d4164b9e7 100644 --- a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs +++ b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs @@ -301,12 +301,13 @@ unset sudo_argv unset worker_argv declare -a worker_argv=() while IFS= read -r -d '' arg; do worker_argv+=("$arg"); done < "/proc/$route_owner/cmdline" 2>/dev/null - test "${#worker_argv[@]}" -eq 4 || continue - case "${worker_argv[1]}" in */dist/infra/tailscale-route-owner.worker.js) ;; *) continue;; esac - test "${worker_argv[2]}" = --openclaw-tailscale-route-owner || continue + test "${#worker_argv[@]}" -ge 4 || continue + worker_script_index=$((${#worker_argv[@]} - 3)) + case "${worker_argv[$worker_script_index]}" in */dist/infra/tailscale-route-owner.worker.js) ;; *) continue;; esac + test "${worker_argv[$((worker_script_index + 1))]}" = --openclaw-tailscale-route-owner || continue expected_direct='{"argv":["/usr/bin/tailscale","serve","--yes","--bg=false","{{managedIngressPort}}"]}' expected_sudo='{"argv":["sudo","-n","/usr/bin/tailscale","serve","--yes","--bg=false","{{managedIngressPort}}"]}' - test "${worker_argv[3]}" = "$expected_direct" || test "${worker_argv[3]}" = "$expected_sudo" || continue + test "${worker_argv[$((worker_script_index + 2))]}" = "$expected_direct" || test "${worker_argv[$((worker_script_index + 2))]}" = "$expected_sudo" || continue candidate_count=$((candidate_count + 1)) matched_pid=$candidate_pid matched_start=$candidate_start diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs index 813a29a4e8..497c981786 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -1,3 +1,5 @@ +using System.Diagnostics; +using System.Text; using System.Text.Json; namespace OpenClaw.Connection.Tests; @@ -209,6 +211,34 @@ public async Task VerifyAsync_RejectsForegroundIngressNotOwnedByGatewayService() Assert.Equal(GatewayTailscaleAuthLiveState.NotReady, result); } + [Theory] + [InlineData("plain", "Ready")] + [InlineData("node-options", "Ready")] + [InlineData("trailing-argument", "NotReady")] + [InlineData("wrong-worker", "NotReady")] + [InlineData("wrong-marker", "NotReady")] + [InlineData("wrong-payload", "NotReady")] + [InlineData("wrong-parent", "NotReady")] + [InlineData("wrong-executable", "NotReady")] + [InlineData("wrong-cgroup", "NotReady")] + [InlineData("duplicate-owner", "NotReady")] + public async Task VerifyAsync_ExecutesForegroundOwnershipProbe(string scenario, string expected) + { + using var fixture = new ManagedIngressProcessFixture(scenario); + FakeWslCommandRunner? runner = null; + runner = new FakeWslCommandRunner((_, command, cancellationToken) => + command.Contains("serve", StringComparer.Ordinal) + ? Task.FromResult(ForegroundServeStatus(proxyPort: 35225)) + : command.FirstOrDefault() == "/bin/bash" + ? fixture.RunAsync(runner!.StandardInputs.Single(), cancellationToken) + : Task.FromResult(RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(expected, result.ToString()); + } + [Theory] [InlineData(0, "unavailable")] [InlineData(0, "unexpected")] @@ -657,6 +687,98 @@ private static WslCommandResult Status(string backendState, string dnsName) => TrustTailscaleAuth = true, }; + private sealed class ManagedIngressProcessFixture : IDisposable + { + private readonly string _root = Path.Combine(Path.GetTempPath(), "openclaw-ingress-" + Guid.NewGuid().ToString("N")); + + public ManagedIngressProcessFixture(string scenario) + { + Directory.CreateDirectory(_root); + const string node = "/usr/bin/node"; + const string cgroup = "/user.slice/openclaw-gateway.service"; + WriteProcess(101, 1, node, cgroup, scenario == "node-options" + ? [node, "--max-old-space-size=12043", "--stack-size=984", "/gateway/dist/index.js", "gateway"] + : [node, "/gateway/dist/index.js", "gateway"]); + string[] workerArguments = scenario == "node-options" + ? [node, "--max-old-space-size=12043", "--stack-size=984"] + : [node]; + workerArguments = [.. workerArguments, + scenario == "wrong-worker" ? "/other/worker.js" : "/gateway/dist/infra/tailscale-route-owner.worker.js", + scenario == "wrong-marker" ? "--other-owner" : "--openclaw-tailscale-route-owner", + scenario == "wrong-payload" ? "{\"argv\":[\"/usr/bin/tailscale\",\"serve\",\"--yes\",\"--bg=false\",\"19999\"]}" + : "{\"argv\":[\"/usr/bin/tailscale\",\"serve\",\"--yes\",\"--bg=false\",\"35225\"]}"]; + if (scenario == "trailing-argument") + workerArguments = [.. workerArguments, "extra"]; + WriteProcess(102, scenario == "wrong-parent" ? 999 : 101, + scenario == "wrong-executable" ? "/other/node" : node, + scenario == "wrong-cgroup" ? "/other.service" : cgroup, workerArguments); + string[] routeArguments = ["/usr/bin/tailscale", "serve", "--yes", "--bg=false", "35225"]; + WriteProcess(103, 102, "/usr/bin/tailscale", cgroup, routeArguments); + if (scenario == "duplicate-owner") + WriteProcess(104, 102, "/usr/bin/tailscale", cgroup, routeArguments); + File.WriteAllText(Path.Combine(_root, "listeners"), + "LISTEN 0 128 127.0.0.1:18789 0.0.0.0:* users:((\"node\",pid=101,fd=1))\n" + + "LISTEN 0 128 127.0.0.1:35225 0.0.0.0:* users:((\"node\",pid=101,fd=2))\n"); + } + + private void WriteProcess(int pid, int parent, string executable, string cgroup, string[] arguments) + { + var directory = Path.Combine(_root, pid.ToString()); + Directory.CreateDirectory(directory); + File.WriteAllText(Path.Combine(directory, "cmdline"), string.Join('\0', arguments) + '\0', new UTF8Encoding(false)); + File.WriteAllText(Path.Combine(directory, "exe"), executable); + File.WriteAllText(Path.Combine(directory, "cgroup"), "0::" + cgroup + "\n"); + File.WriteAllText(Path.Combine(directory, "status"), $"PPid:\t{parent}\n"); + File.WriteAllText(Path.Combine(directory, "stat"), string.Join(' ', Enumerable.Repeat("1", 21).Append(pid.ToString()))); + } + + public async Task RunAsync(string script, CancellationToken cancellationToken) + { + var bash = OperatingSystem.IsWindows() + ? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Git", "bin", "bash.exe") + : "/bin/bash"; + Assert.True(File.Exists(bash), $"Ownership probe regression requires Bash at {bash}."); + var start = new ProcessStartInfo(bash) + { + UseShellExecute = false, + CreateNoWindow = true, + RedirectStandardInput = true, + RedirectStandardOutput = true, + RedirectStandardError = true, + }; + start.ArgumentList.Add("-s"); + var root = _root.Replace('\\', '/'); + if (OperatingSystem.IsWindows()) + root = "/" + char.ToLowerInvariant(root[0]) + root[2..]; + var fixtureScript = "fixture_proc='" + root.Replace("'", "'\\''") + "'\n" + + "fixture_systemctl() { printf 101; }\n" + + "fixture_ss() { /usr/bin/cat \"$fixture_proc/listeners\"; }\n" + + "fixture_readlink() { /usr/bin/cat \"$1\"; }\n" + + script.Replace("for proc in /proc/[0-9]*; do", "for proc in \"$fixture_proc\"/[0-9]*; do", StringComparison.Ordinal) + .Replace("/proc/", "$fixture_proc/", StringComparison.Ordinal) + .Replace("/usr/bin/systemctl", "fixture_systemctl", StringComparison.Ordinal) + .Replace("/usr/bin/ss", "fixture_ss", StringComparison.Ordinal) + .Replace("/usr/bin/readlink -f", "fixture_readlink", StringComparison.Ordinal); + using var process = Process.Start(start)!; + var output = process.StandardOutput.ReadToEndAsync(cancellationToken); + var error = process.StandardError.ReadToEndAsync(cancellationToken); + try + { + await process.StandardInput.WriteAsync(fixtureScript.AsMemory(), cancellationToken); + process.StandardInput.Close(); + await process.WaitForExitAsync(cancellationToken); + return new WslCommandResult(process.ExitCode, await output, await error); + } + finally + { + if (!process.HasExited) + process.Kill(entireProcessTree: true); + } + } + + public void Dispose() => Directory.Delete(_root, recursive: true); + } + private sealed class FakeWslCommandRunner( Func, CancellationToken, Task> runInDistro) : IWslCommandRunner From 82258a449124bdd02c04f8b18a053000188bfe54 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Tue, 13 Oct 2026 06:06:26 +0100 Subject: [PATCH 21/38] fix(connection): inspect privileged Serve ownership under root --- .../GatewayTailscaleAuthUpgrade.cs | 50 +++++--- src/OpenClaw.Connection/WslCommandRunner.cs | 19 +++ .../GatewayTailscaleAuthLiveVerifierTests.cs | 116 ++++++++++++++++-- 3 files changed, 159 insertions(+), 26 deletions(-) diff --git a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs index 8d4164b9e7..a116af180d 100644 --- a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs +++ b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs @@ -1,3 +1,4 @@ +using System.Globalization; using System.Security.Cryptography; using System.Text; using System.Text.Json; @@ -95,6 +96,8 @@ internal sealed class GatewayTailscaleAuthLiveVerifier : IGatewayTailscaleAuthLi ["/usr/bin/tailscale", "status", "--json"]; private static readonly IReadOnlyList ServeStatusCommand = ["/usr/bin/tailscale", "serve", "status", "--json"]; + private static readonly IReadOnlyList GatewayProcessCommand = + ["/usr/bin/systemctl", "--user", "show", "openclaw-gateway", "-p", "MainPID", "--value"]; private readonly IWslCommandRunner _commandRunner; private readonly TimeSpan _timeout; @@ -212,16 +215,35 @@ public async Task VerifyAsync( WslCommandResult ownershipResult; try { + var serviceBefore = await _commandRunner.RunInDistroAsync( + distroName, GatewayProcessCommand, timeout.Token) + .ConfigureAwait(false); + if (!serviceBefore.Success || + !int.TryParse(serviceBefore.StandardOutput.Trim(), NumberStyles.None, + CultureInfo.InvariantCulture, out var gatewayProcessId) || gatewayProcessId <= 0) + { + return GatewayTailscaleAuthLiveState.Unavailable; + } var ownershipScript = BuildManagedIngressOwnershipScript( gatewayPort, - managedIngressPort) + managedIngressPort, + gatewayProcessId) .Replace("\r", string.Empty, StringComparison.Ordinal); - ownershipResult = await _commandRunner.RunInDistroWithStandardInputAsync( - distroName, - ["/bin/bash", "-s"], + ownershipResult = await _commandRunner.RunWithStandardInputAsync( + BuildRootProbeArguments(distroName, ["/bin/bash", "-s"]), ownershipScript, timeout.Token) .ConfigureAwait(false); + var serviceAfter = await _commandRunner.RunInDistroAsync( + distroName, GatewayProcessCommand, timeout.Token) + .ConfigureAwait(false); + if (!serviceAfter.Success || + !int.TryParse(serviceAfter.StandardOutput.Trim(), NumberStyles.None, + CultureInfo.InvariantCulture, out var gatewayProcessIdAfter) || + gatewayProcessIdAfter != gatewayProcessId) + { + return GatewayTailscaleAuthLiveState.Unavailable; + } } catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { @@ -250,12 +272,11 @@ private static IReadOnlyList BuildRootProbeArguments( private static string BuildManagedIngressOwnershipScript( int gatewayPort, - int managedIngressPort) + int managedIngressPort, + int gatewayProcessId) { var script = $$""" - pid_before=$(/usr/bin/systemctl --user show openclaw-gateway -p MainPID --value 2>/dev/null) - case "$pid_before" in ''|*[!0-9]*) /usr/bin/printf unavailable; exit 0;; esac - test "$pid_before" -gt 0 || { /usr/bin/printf unavailable; exit 0; } + pid_before={{gatewayProcessId.ToString(CultureInfo.InvariantCulture)}} main_cgroup=$(/usr/bin/awk -F: '$1 == "0" { print $3 }' "/proc/$pid_before/cgroup" 2>/dev/null) main_start_before=$(/usr/bin/awk '{ print $22 }' "/proc/$pid_before/stat" 2>/dev/null) main_exe=$(/usr/bin/readlink -f "/proc/$pid_before/exe" 2>/dev/null) @@ -271,17 +292,17 @@ private static string BuildManagedIngressOwnershipScript( matched_worker='' matched_worker_start='' for proc in /proc/[0-9]*; do - unset argv - declare -a argv=() - while IFS= read -r -d '' arg; do argv+=("$arg"); done < "$proc/cmdline" 2>/dev/null - test "${#argv[@]}" -eq 5 || continue - test "${argv[0]}" = /usr/bin/tailscale && test "${argv[1]}" = serve && test "${argv[2]}" = --yes && test "${argv[3]}" = --bg=false && test "${argv[4]}" = {{managedIngressPort}} || continue candidate_pid=${proc##*/} candidate_exe=$(/usr/bin/readlink -f "$proc/exe" 2>/dev/null) candidate_cgroup=$(/usr/bin/awk -F: '$1 == "0" { print $3 }' "$proc/cgroup" 2>/dev/null) candidate_start=$(/usr/bin/awk '{ print $22 }' "$proc/stat" 2>/dev/null) candidate_parent=$(/usr/bin/awk '/^PPid:/ { print $2 }' "$proc/status" 2>/dev/null) test "$candidate_exe" = /usr/bin/tailscale && test "$candidate_cgroup" = "$main_cgroup" && test -n "$candidate_start" || continue + unset argv + declare -a argv=() + while IFS= read -r -d '' arg; do argv+=("$arg"); done < "$proc/cmdline" 2>/dev/null + test "${#argv[@]}" -eq 5 || continue + test "${argv[0]}" = /usr/bin/tailscale && test "${argv[1]}" = serve && test "${argv[2]}" = --yes && test "${argv[3]}" = --bg=false && test "${argv[4]}" = {{managedIngressPort}} || continue route_owner=$candidate_parent parent_exe=$(/usr/bin/readlink -f "/proc/$candidate_parent/exe" 2>/dev/null) if test "$parent_exe" = /usr/bin/sudo; then @@ -316,12 +337,11 @@ unset worker_argv matched_worker=$route_owner matched_worker_start=$worker_start done - pid_after=$(/usr/bin/systemctl --user show openclaw-gateway -p MainPID --value 2>/dev/null) main_start_after=$(/usr/bin/awk '{ print $22 }' "/proc/$pid_before/stat" 2>/dev/null) main_exe_after=$(/usr/bin/readlink -f "/proc/$pid_before/exe" 2>/dev/null) listeners_raw_after=$(/usr/bin/ss -H -ltnp 2>/dev/null) || { /usr/bin/printf unavailable; exit 0; } listeners_after=$(/usr/bin/printf '%s\n' "$listeners_raw_after" | /usr/bin/grep -E "$listener_pattern" || true) - test "$pid_before" = "$pid_after" && test "$main_start_before" = "$main_start_after" && test "$main_exe" = "$main_exe_after" && test "$listeners_before" = "$listeners_after" || { /usr/bin/printf unavailable; exit 0; } + test "$main_start_before" = "$main_start_after" && test "$main_exe" = "$main_exe_after" && test "$listeners_before" = "$listeners_after" || { /usr/bin/printf unavailable; exit 0; } gateway_owner=$(/usr/bin/printf '%s\n' "$listeners_after" | /usr/bin/grep -E '(^|[[:space:]])127\.0\.0\.1:{{gatewayPort}}([[:space:]]|$)' | /usr/bin/grep -F "pid=$pid_before,") ingress_owner=$(/usr/bin/printf '%s\n' "$listeners_after" | /usr/bin/grep -E '(^|[[:space:]])127\.0\.0\.1:{{managedIngressPort}}([[:space:]]|$)' | /usr/bin/grep -F "pid=$pid_before,") candidate_start_after=$(/usr/bin/awk '{ print $22 }' "/proc/$matched_pid/stat" 2>/dev/null) diff --git a/src/OpenClaw.Connection/WslCommandRunner.cs b/src/OpenClaw.Connection/WslCommandRunner.cs index df22851bca..5e443194ed 100644 --- a/src/OpenClaw.Connection/WslCommandRunner.cs +++ b/src/OpenClaw.Connection/WslCommandRunner.cs @@ -25,6 +25,18 @@ Task RunAsync( CancellationToken cancellationToken = default, IReadOnlyDictionary? environment = null); + Task RunWithStandardInputAsync( + IReadOnlyList arguments, + string standardInput, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) => + cancellationToken.IsCancellationRequested + ? Task.FromCanceled(cancellationToken) + : Task.FromResult(new WslCommandResult( + -1, + string.Empty, + "This WSL command runner does not support standard input.")); + Task> ListDistrosAsync(CancellationToken cancellationToken = default); Task TerminateDistroAsync(string name, CancellationToken cancellationToken = default); @@ -101,6 +113,13 @@ public Task RunInDistroAsync( standardInput); } + public Task RunWithStandardInputAsync( + IReadOnlyList arguments, + string standardInput, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) => + RunProcessAsync("wsl.exe", arguments, cancellationToken, environment, standardInput); + public Task RunInDistroWithStandardInputAsync( string name, IReadOnlyList command, diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs index 497c981786..e3abc96543 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -110,6 +110,21 @@ await Assert.ThrowsAnyAsync(() => cancellation.Token)); } + [Fact] + public async Task ExplicitArgumentStandardInputCompatibilityDefault_FailsClosed() + { + IWslCommandRunner runner = new LegacyWslCommandRunner(); + + var result = await runner.RunWithStandardInputAsync( + ["-d", "OpenClawGateway", "--user", "root", "--", "/bin/bash", "-s"], "exit 0"); + + Assert.False(result.Success); + using var cancellation = new CancellationTokenSource(); + cancellation.Cancel(); + await Assert.ThrowsAnyAsync(() => runner.RunWithStandardInputAsync( + ["-d", "OpenClawGateway", "--user", "root", "--", "/bin/bash", "-s"], "exit 0", cancellation.Token)); + } + [Theory] [InlineData("other.tail.example.", 18789, false, "NotReady")] [InlineData("host.tail.example.", 19999, false, "NotReady")] @@ -159,7 +174,7 @@ public async Task VerifyAsync_AcceptsCurrentForegroundServeStatusShape() var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); Assert.Equal(GatewayTailscaleAuthLiveState.Ready, result); - Assert.Equal(3, runner.ProbeCalls); + Assert.Equal(5, runner.ProbeCalls); } [Fact] @@ -177,14 +192,17 @@ public async Task VerifyAsync_AcceptsManagedForegroundIngressOwnedByGatewayServi var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); Assert.Equal(GatewayTailscaleAuthLiveState.Ready, result); - Assert.Equal(3, runner.ProbeCalls); - Assert.Equal("/bin/bash", runner.Commands[2][0]); - Assert.Equal("-s", runner.Commands[2][1]); + Assert.Equal(5, runner.ProbeCalls); + Assert.Equal("/bin/bash", runner.Commands[3][0]); + Assert.Equal("-s", runner.Commands[3][1]); + Assert.Equal( + ["-d", "OpenClawGateway", "--", "/usr/bin/systemctl", "--user", "show", "openclaw-gateway", "-p", "MainPID", "--value"], + runner.HostArguments[2]); + Assert.Equal(["-d", "OpenClawGateway", "--user", "root", "--", "/bin/bash", "-s"], runner.HostArguments[3]); + Assert.Equal(runner.HostArguments[2], runner.HostArguments[4]); Assert.Single(runner.StandardInputs); var script = runner.StandardInputs[0]; Assert.DoesNotContain('\r', script); - Assert.Contains("systemctl --user show openclaw-gateway", script, StringComparison.Ordinal); - Assert.Equal(2, script.Split("systemctl", StringSplitOptions.None).Length - 1); Assert.Contains(":18789", script, StringComparison.Ordinal); Assert.Contains(":35225", script, StringComparison.Ordinal); Assert.Contains("/proc/$pid_before/cgroup", script, StringComparison.Ordinal); @@ -222,6 +240,9 @@ public async Task VerifyAsync_RejectsForegroundIngressNotOwnedByGatewayService() [InlineData("wrong-executable", "NotReady")] [InlineData("wrong-cgroup", "NotReady")] [InlineData("duplicate-owner", "NotReady")] + [InlineData("sudo-route", "Ready")] + [InlineData("sudo-trailing-argument", "NotReady")] + [InlineData("sudo-wrong-parent", "NotReady")] public async Task VerifyAsync_ExecutesForegroundOwnershipProbe(string scenario, string expected) { using var fixture = new ManagedIngressProcessFixture(scenario); @@ -230,7 +251,7 @@ public async Task VerifyAsync_ExecutesForegroundOwnershipProbe(string scenario, command.Contains("serve", StringComparer.Ordinal) ? Task.FromResult(ForegroundServeStatus(proxyPort: 35225)) : command.FirstOrDefault() == "/bin/bash" - ? fixture.RunAsync(runner!.StandardInputs.Single(), cancellationToken) + ? fixture.RunAsync(runner!.StandardInputs.Single(), cancellationToken, runner.PrivilegedStandardInput) : Task.FromResult(RunningStatus())); var verifier = new GatewayTailscaleAuthLiveVerifier(runner); @@ -239,6 +260,48 @@ public async Task VerifyAsync_ExecutesForegroundOwnershipProbe(string scenario, Assert.Equal(expected, result.ToString()); } + [Fact] + public async Task VerifyAsync_ServiceRestartDuringPrivilegedInspectionIsUnavailable() + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ForegroundServeStatus(proxyPort: 35225) + : command.FirstOrDefault() == "/bin/bash" + ? new WslCommandResult(0, "owned", "") + : RunningStatus())); + runner.ServiceResults.Enqueue(new WslCommandResult(0, "101\n", "")); + runner.ServiceResults.Enqueue(new WslCommandResult(0, "202\n", "")); + + var result = await new GatewayTailscaleAuthLiveVerifier(runner).VerifyAsync( + ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.Unavailable, result); + Assert.Equal(runner.HostArguments[2], runner.HostArguments[4]); + Assert.DoesNotContain("root", runner.HostArguments[4]); + } + + [Theory] + [InlineData("0")] + [InlineData("-1")] + [InlineData("2147483648")] + [InlineData("101\n202")] + [InlineData("101; exit 0")] + public async Task VerifyAsync_InvalidServiceProcessDoesNotDispatchPrivilegedInspection(string processId) + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ForegroundServeStatus(proxyPort: 35225) + : RunningStatus())); + runner.ServiceResults.Enqueue(new WslCommandResult(0, processId, "")); + + var result = await new GatewayTailscaleAuthLiveVerifier(runner).VerifyAsync( + ManagedRecord(), 18789, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthLiveState.Unavailable, result); + Assert.False(runner.PrivilegedStandardInput); + Assert.Empty(runner.StandardInputs); + } + [Theory] [InlineData(0, "unavailable")] [InlineData(0, "unexpected")] @@ -702,18 +765,31 @@ public ManagedIngressProcessFixture(string scenario) string[] workerArguments = scenario == "node-options" ? [node, "--max-old-space-size=12043", "--stack-size=984"] : [node]; + var sudoRoute = scenario.StartsWith("sudo-", StringComparison.Ordinal); workerArguments = [.. workerArguments, scenario == "wrong-worker" ? "/other/worker.js" : "/gateway/dist/infra/tailscale-route-owner.worker.js", scenario == "wrong-marker" ? "--other-owner" : "--openclaw-tailscale-route-owner", scenario == "wrong-payload" ? "{\"argv\":[\"/usr/bin/tailscale\",\"serve\",\"--yes\",\"--bg=false\",\"19999\"]}" - : "{\"argv\":[\"/usr/bin/tailscale\",\"serve\",\"--yes\",\"--bg=false\",\"35225\"]}"]; + : sudoRoute + ? "{\"argv\":[\"sudo\",\"-n\",\"/usr/bin/tailscale\",\"serve\",\"--yes\",\"--bg=false\",\"35225\"]}" + : "{\"argv\":[\"/usr/bin/tailscale\",\"serve\",\"--yes\",\"--bg=false\",\"35225\"]}"]; if (scenario == "trailing-argument") workerArguments = [.. workerArguments, "extra"]; WriteProcess(102, scenario == "wrong-parent" ? 999 : 101, scenario == "wrong-executable" ? "/other/node" : node, scenario == "wrong-cgroup" ? "/other.service" : cgroup, workerArguments); string[] routeArguments = ["/usr/bin/tailscale", "serve", "--yes", "--bg=false", "35225"]; - WriteProcess(103, 102, "/usr/bin/tailscale", cgroup, routeArguments); + if (sudoRoute) + { + string[] sudoArguments = ["sudo", "-n", .. routeArguments]; + if (scenario == "sudo-trailing-argument") + sudoArguments = [.. sudoArguments, "extra"]; + WriteProcess(103, scenario == "sudo-wrong-parent" ? 999 : 102, "/usr/bin/sudo", cgroup, sudoArguments); + WriteProcess(104, 103, "/usr/bin/tailscale", cgroup, routeArguments); + File.WriteAllText(Path.Combine(_root, "privileged"), "yes"); + } + else + WriteProcess(103, 102, "/usr/bin/tailscale", cgroup, routeArguments); if (scenario == "duplicate-owner") WriteProcess(104, 102, "/usr/bin/tailscale", cgroup, routeArguments); File.WriteAllText(Path.Combine(_root, "listeners"), @@ -732,7 +808,8 @@ private void WriteProcess(int pid, int parent, string executable, string cgroup, File.WriteAllText(Path.Combine(directory, "stat"), string.Join(' ', Enumerable.Repeat("1", 21).Append(pid.ToString()))); } - public async Task RunAsync(string script, CancellationToken cancellationToken) + public async Task RunAsync( + string script, CancellationToken cancellationToken, bool privilegedInspection = false) { var bash = OperatingSystem.IsWindows() ? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Git", "bin", "bash.exe") @@ -753,7 +830,8 @@ public async Task RunAsync(string script, CancellationToken ca var fixtureScript = "fixture_proc='" + root.Replace("'", "'\\''") + "'\n" + "fixture_systemctl() { printf 101; }\n" + "fixture_ss() { /usr/bin/cat \"$fixture_proc/listeners\"; }\n" + - "fixture_readlink() { /usr/bin/cat \"$1\"; }\n" + + "fixture_privileged=" + (privilegedInspection ? "yes" : "no") + "\n" + + "fixture_readlink() { if test -f \"$fixture_proc/privileged\" && test \"$fixture_privileged\" != yes; then case \"$1\" in */103/exe|*/104/exe) return 1;; esac; fi; /usr/bin/cat \"$1\"; }\n" + script.Replace("for proc in /proc/[0-9]*; do", "for proc in \"$fixture_proc\"/[0-9]*; do", StringComparison.Ordinal) .Replace("/proc/", "$fixture_proc/", StringComparison.Ordinal) .Replace("/usr/bin/systemctl", "fixture_systemctl", StringComparison.Ordinal) @@ -788,6 +866,8 @@ private sealed class FakeWslCommandRunner( public List> Commands { get; } = []; public List> HostArguments { get; } = []; public List StandardInputs { get; } = []; + public bool PrivilegedStandardInput { get; private set; } + public Queue ServiceResults { get; } = []; public Task RunInDistroAsync( string name, @@ -801,6 +881,9 @@ public Task RunInDistroAsync( ProbeCalls++; DistroName = name; Commands.Add(command); + HostArguments.Add(["-d", name, "--", .. command]); + if (command.FirstOrDefault() == "/usr/bin/systemctl") + return Task.FromResult(ServiceResults.Count > 0 ? ServiceResults.Dequeue() : new WslCommandResult(0, "101\n", "")); return runInDistro(name, command, cancellationToken); } @@ -832,6 +915,17 @@ public Task RunAsync( return runInDistro(DistroName, command, cancellationToken); } + public Task RunWithStandardInputAsync( + IReadOnlyList arguments, + string standardInput, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) + { + StandardInputs.Add(standardInput); + PrivilegedStandardInput = arguments.Count >= 6 && arguments[2] == "--user" && arguments[3] == "root"; + return RunAsync(arguments, cancellationToken, environment); + } + public Task> ListDistrosAsync( CancellationToken cancellationToken = default) => throw new NotSupportedException(); From 63adc635dd835b6fd5d66ca94cd005d5419847cd Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Wed, 14 Oct 2026 12:43:52 +0100 Subject: [PATCH 22/38] fix: show dashboard retry guidance after link preparation failure --- .../Services/GatewayDashboardLauncher.cs | 1 + .../SetupDashboardHandoffTests.cs | 41 +++++++++++++++++++ 2 files changed, 42 insertions(+) diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs index 765aa7c9cf..6b1ef83a7e 100644 --- a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs @@ -65,6 +65,7 @@ private async Task PrepareAndLaunchAsync( if (!result.Success) { reportLinkFailure(result); + reportFailure(); return false; } diff --git a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs index d5c52ff2b1..ce61f283ca 100644 --- a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs +++ b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs @@ -275,6 +275,47 @@ await Assert.ThrowsAnyAsync(() => launcher.OpenSaved Assert.Equal(0, launches); } + [Theory] + [InlineData(false)] + [InlineData(true)] + public async Task DashboardLinkFailure_RequestsVisibleRecoveryWithoutLaunchingOrRetrying(bool saved) + { + var revalidations = 0; + var launches = 0; + var validations = 0; + var failures = 0; + var opened = 0; + var linkFailures = new List(); + var request = new GatewayDashboardLinkRequest(Gateway.Url, "channels", null, false, "gateway-a"); + var service = new GatewayDashboardLinkService((_, _) => + { + revalidations++; + return Task.FromResult(false); + }, key => "localized:" + key); + var launcher = new GatewayDashboardLauncher( + () => true, + _ => request, + service, + _ => { launches++; return Task.FromResult(true); }, + result => linkFailures.Add(result), + () => failures++, + () => opened++); + + var success = saved + ? await launcher.OpenSavedAsync(request, _ => { validations++; return Task.FromResult(true); }) + : await launcher.OpenAsync("channels"); + + Assert.False(success); + Assert.Equal(1, revalidations); + var failure = Assert.Single(linkFailures); + Assert.Equal("localized:DashboardLink_NoBrowserCompatibleCredential", failure.Error); + Assert.Null(failure.Url); + Assert.Equal(1, failures); + Assert.Equal(0, launches); + Assert.Equal(0, validations); + Assert.Equal(0, opened); + } + [Theory] [InlineData("tunnel")] [InlineData("credential")] From 881c208c585d8aa2899ea66128aebb5ed07f0f78 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Thu, 15 Oct 2026 09:10:49 +0100 Subject: [PATCH 23/38] test: assert typed Gateway rejection in cron fixture --- tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs index efe891364d..21f8bcfb91 100644 --- a/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs +++ b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs @@ -56,12 +56,12 @@ public async Task CronEditing_StoresExactSchedulesAndKeepsOtherMutationsDisabled Assert.False(toggled.GetProperty("enabled").GetBoolean()); Assert.Equal("America/Chicago", toggled.GetProperty("schedule").GetProperty("tz").GetString()); var beforeInvalid = JsonSerializer.Serialize(scenario.GetCronJobs()); - await Assert.ThrowsAsync(() => client.SendWizardRequestAsync("cron.update", + await Assert.ThrowsAsync(() => client.SendWizardRequestAsync("cron.update", new { id = "listed", patch = new { schedule = new { kind = "every", everyMs = "invalid" } } })); Assert.Equal(beforeInvalid, JsonSerializer.Serialize(scenario.GetCronJobs())); - await Assert.ThrowsAsync(() => client.SendWizardRequestAsync("cron.update", + await Assert.ThrowsAsync(() => client.SendWizardRequestAsync("cron.update", new { id = "unknown", patch = new { name = "Unknown" } })); - await Assert.ThrowsAsync(() => client.SendWizardRequestAsync("cron.run", new { id = "listed" })); + await Assert.ThrowsAsync(() => client.SendWizardRequestAsync("cron.run", new { id = "listed" })); Assert.Empty(server.UnexpectedRequests); } From 89c020894f9893bf8beef5bc40572cf53e246c84 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Thu, 15 Oct 2026 15:20:51 +0100 Subject: [PATCH 24/38] fix(tray): preserve localized dashboard launch failure --- src/OpenClaw.Tray.WinUI/App.xaml.cs | 4 +-- .../Services/GatewayDashboardLauncher.cs | 10 +++--- .../Services/IWindowManager.cs | 2 +- .../Services/WindowManager.cs | 7 ++-- .../SetupDashboardHandoffTests.cs | 34 +++++++++---------- 5 files changed, 30 insertions(+), 27 deletions(-) diff --git a/src/OpenClaw.Tray.WinUI/App.xaml.cs b/src/OpenClaw.Tray.WinUI/App.xaml.cs index 4d43abb847..a8f04dc1f2 100644 --- a/src/OpenClaw.Tray.WinUI/App.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/App.xaml.cs @@ -4101,8 +4101,8 @@ private GatewayDashboardLauncher CreateGatewayDashboardLauncher( result => ShowConnectionSettingsForPairingIssue( "Dashboard", result.Error ?? "Dashboard URL is unavailable"), - () => AsyncEventHandlerGuard.Run( - () => _windowManager?.ShowDashboardLaunchFailureAsync(retry) ?? Task.CompletedTask, + reason => AsyncEventHandlerGuard.Run( + () => _windowManager?.ShowDashboardLaunchFailureAsync(retry, reason) ?? Task.CompletedTask, new AppLogger(), "Dashboard launch error"), () => _appNotificationService?.Dismiss(GatewayDashboardLauncher.FailureNotificationId), diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs index 6b1ef83a7e..6562acc63a 100644 --- a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs @@ -10,7 +10,7 @@ internal sealed class GatewayDashboardLauncher( GatewayDashboardLinkService linkService, Func> launchBrowser, Action reportLinkFailure, - Action reportFailure, + Action reportFailure, Action? reportOpened = null, Action? reportRevalidationWarning = null) { @@ -28,13 +28,13 @@ public async Task OpenAsync(string? path = null, CancellationToken cancell } catch (Exception ex) when (IsExpectedLaunchFailure(ex)) { - reportFailure(); + reportFailure(null); return false; } if (request is null) { - reportFailure(); + reportFailure(null); return false; } @@ -65,7 +65,7 @@ private async Task PrepareAndLaunchAsync( if (!result.Success) { reportLinkFailure(result); - reportFailure(); + reportFailure(result.Error); return false; } @@ -83,7 +83,7 @@ private async Task PrepareAndLaunchAsync( catch (Exception ex) when (IsExpectedLaunchFailure(ex)) { // Browser failures can include a credential-bearing URL. Do not log them. - reportFailure(); + reportFailure(null); return false; } diff --git a/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs b/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs index ee7e30d870..e0703fcd38 100644 --- a/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs +++ b/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs @@ -29,7 +29,7 @@ internal interface IWindowManager Task ShowLocalAiSetupAsync(); Task ShowLocalAiModelSetupAsync() => ShowOnboardingAsync(); Task ShowGatewayWizardAsync(); - Task ShowDashboardLaunchFailureAsync(Action? retry); + Task ShowDashboardLaunchFailureAsync(Action? retry, string? localizedReason = null); Task ShowNativeSetupAsync(OpenClaw.SetupEngine.SetupNativeCompletion completion, CancellationToken ct); Task ShowNativeSetupFailureAsync(SetupNativeLaunchFailure failure, Action? retry); void CloseSetup(); diff --git a/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs b/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs index 53ee417479..b799c77e1d 100644 --- a/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs +++ b/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs @@ -136,11 +136,14 @@ public void InitializeRuntimeAnchor() private bool _dashboardFailureVisible; - public async Task ShowDashboardLaunchFailureAsync(Action? retry) + public async Task ShowDashboardLaunchFailureAsync(Action? retry, string? localizedReason = null) { if (_isShuttingDown || _dashboardFailureVisible) return; - var message = LocalizationHelper.GetString("Onboarding_DashboardLaunchFailed"); + var guidance = LocalizationHelper.GetString("Onboarding_DashboardLaunchFailed"); + var message = string.IsNullOrWhiteSpace(localizedReason) + ? guidance + : $"{localizedReason}{Environment.NewLine}{guidance}"; _callbacks.GetAppNotificationService()?.Show(new AppNotification { Id = GatewayDashboardLauncher.FailureNotificationId, diff --git a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs index ce61f283ca..e60c0b2537 100644 --- a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs +++ b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs @@ -154,7 +154,7 @@ public async Task SavedDashboard_WithoutBrowserCredential_BypassesCredentialFall service, url => { launched = url; return Task.FromResult(true); }, _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), - () => throw new InvalidOperationException("Unexpected launch failure")); + _ => throw new InvalidOperationException("Unexpected launch failure")); var opened = await launcher.OpenSavedAsync( new GatewayDashboardLinkRequest(Gateway.Url, null, null, AppendBrowserCredential: false), @@ -177,7 +177,7 @@ public async Task SavedDashboard_SharedCredentialStillRequiresEndpointAuthorizat service, _ => { launches++; return Task.FromResult(true); }, _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), - () => throw new InvalidOperationException("Unexpected launch failure")); + _ => throw new InvalidOperationException("Unexpected launch failure")); var opened = await launcher.OpenSavedAsync( new GatewayDashboardLinkRequest(Gateway.Url, null, "shared-token", AppendBrowserCredential: true), @@ -205,7 +205,7 @@ public async Task SavedDashboard_EmbeddedTokenStillRequiresEndpointAuthorization service, _ => { launches++; return Task.FromResult(true); }, _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), - () => throw new InvalidOperationException("Unexpected launch failure")); + _ => throw new InvalidOperationException("Unexpected launch failure")); var opened = await launcher.OpenSavedAsync( new GatewayDashboardLinkRequest( @@ -242,7 +242,7 @@ public async Task SavedDashboard_CancellationAfterLinkPreparationSkipsAuthorizat service, _ => { launches++; return Task.FromResult(true); }, _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), - () => throw new InvalidOperationException("Unexpected launch failure")); + _ => throw new InvalidOperationException("Unexpected launch failure")); await Assert.ThrowsAnyAsync(() => launcher.OpenSavedAsync( new GatewayDashboardLinkRequest(Gateway.Url, null, "shared-token", true, "gateway-a"), @@ -265,7 +265,7 @@ public async Task SavedDashboard_CancellationAfterAuthorizationSkipsBrowserDispa service, _ => { launches++; return Task.FromResult(true); }, _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), - () => throw new InvalidOperationException("Unexpected launch failure")); + _ => throw new InvalidOperationException("Unexpected launch failure")); await Assert.ThrowsAnyAsync(() => launcher.OpenSavedAsync( new GatewayDashboardLinkRequest(Gateway.Url, null, "shared-token", true), @@ -278,12 +278,12 @@ await Assert.ThrowsAnyAsync(() => launcher.OpenSaved [Theory] [InlineData(false)] [InlineData(true)] - public async Task DashboardLinkFailure_RequestsVisibleRecoveryWithoutLaunchingOrRetrying(bool saved) + public async Task DashboardLinkFailure_PassesLocalizedReasonToRecoveryWithoutLaunchingOrRetrying(bool saved) { var revalidations = 0; var launches = 0; var validations = 0; - var failures = 0; + var failureMessages = new List(); var opened = 0; var linkFailures = new List(); var request = new GatewayDashboardLinkRequest(Gateway.Url, "channels", null, false, "gateway-a"); @@ -298,7 +298,7 @@ public async Task DashboardLinkFailure_RequestsVisibleRecoveryWithoutLaunchingOr service, _ => { launches++; return Task.FromResult(true); }, result => linkFailures.Add(result), - () => failures++, + reason => failureMessages.Add(reason), () => opened++); var success = saved @@ -310,7 +310,7 @@ public async Task DashboardLinkFailure_RequestsVisibleRecoveryWithoutLaunchingOr var failure = Assert.Single(linkFailures); Assert.Equal("localized:DashboardLink_NoBrowserCompatibleCredential", failure.Error); Assert.Null(failure.Url); - Assert.Equal(1, failures); + Assert.Equal("localized:DashboardLink_NoBrowserCompatibleCredential", Assert.Single(failureMessages)); Assert.Equal(0, launches); Assert.Equal(0, validations); Assert.Equal(0, opened); @@ -324,7 +324,7 @@ public async Task DashboardLinkFailure_RequestsVisibleRecoveryWithoutLaunchingOr public async Task Failure_IsReportedOnceWithoutAutomaticRetry(string failure) { var launches = 0; - var failures = 0; + var failureMessages = new List(); var launcher = CreateDashboardLauncher( _ => failure == "credential" ? null : new(Gateway.Url, null, "shared", true), _ => @@ -334,10 +334,10 @@ public async Task Failure_IsReportedOnceWithoutAutomaticRetry(string failure) return Task.FromResult(false); }, ensureTunnel: () => failure != "tunnel", - reportFailure: () => failures++); + reportFailure: reason => failureMessages.Add(reason)); Assert.False(await launcher.OpenAsync()); Assert.Equal(failure is "browser" or "exception" ? 1 : 0, launches); - Assert.Equal(1, failures); + Assert.Null(Assert.Single(failureMessages)); } [Fact] @@ -354,18 +354,18 @@ public void EndpointBinding_ExcludesRotatingTokensButIncludesSshRealm() public async Task ExplicitDashboardRetry_KeepsRequestedPathAndClearsFailureOnlyAfterOpen() { var urls = new List(); - var failures = 0; + var failureMessages = new List(); var opened = 0; var launcher = CreateDashboardLauncher( path => new(Gateway.Url, path, "synthetic", true), url => { urls.Add(url); return Task.FromResult(urls.Count == 2); }, - reportFailure: () => failures++, reportOpened: () => opened++); + reportFailure: reason => failureMessages.Add(reason), reportOpened: () => opened++); Assert.False(await launcher.OpenAsync("channels")); Assert.Equal(0, opened); Assert.Single(urls); Assert.True(await launcher.OpenAsync("channels")); Assert.Equal(urls[0], urls[1]); - Assert.Equal(1, failures); + Assert.Null(Assert.Single(failureMessages)); Assert.Equal(1, opened); } @@ -373,7 +373,7 @@ private static GatewayDashboardLauncher CreateDashboardLauncher( Func resolveRequest, Func> launchBrowser, Func? ensureTunnel = null, - Action? reportFailure = null, + Action? reportFailure = null, Action? reportOpened = null) => new( ensureTunnel ?? (() => true), @@ -381,7 +381,7 @@ private static GatewayDashboardLauncher CreateDashboardLauncher( new GatewayDashboardLinkService((_, _) => Task.FromResult(true), key => key), launchBrowser, _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), - reportFailure ?? (() => throw new InvalidOperationException("Unexpected launch failure")), + reportFailure ?? (_ => throw new InvalidOperationException("Unexpected launch failure")), reportOpened); private sealed class StartupClock : TimeProvider From 54242049dd9a792bcdd7b308cb89563efd7cbc6d Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Thu, 15 Oct 2026 19:35:10 +0100 Subject: [PATCH 25/38] fix(windows): address PR 1128 review findings --- .../GatewayTailscaleAuthUpgrade.cs | 16 ++- src/OpenClaw.Shared/OpenClawGatewayClient.cs | 31 ++++-- .../Strings/en-us/Resources.resw | 6 +- .../Strings/fr-fr/Resources.resw | 6 +- .../Strings/nl-nl/Resources.resw | 6 +- .../Strings/pt-br/Resources.resw | 6 +- .../Strings/zh-cn/Resources.resw | 6 +- .../Strings/zh-tw/Resources.resw | 6 +- .../GatewayTailscaleAuthUpgradeTests.cs | 97 +++++++++++++++++++ .../OpenClawGatewayClientTests.cs | 48 +++++++++ .../LocalizationValidationTests.cs | 25 +++++ 11 files changed, 220 insertions(+), 33 deletions(-) diff --git a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs index a116af180d..c10f2513cb 100644 --- a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs +++ b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs @@ -598,11 +598,17 @@ private static async Task ReadConfigAsync( private static ConfigSnapshot CaptureSnapshot(JsonElement response) { - var root = response.TryGetProperty("parsed", out var parsed) - ? parsed - : response.TryGetProperty("config", out var config) - ? config - : response; + var hasRoot = response.TryGetProperty("sourceConfig", out var root) && + root.ValueKind == JsonValueKind.Object; + if (!hasRoot && response.TryGetProperty("resolved", out var resolved) && + resolved.ValueKind == JsonValueKind.Object) + { + root = resolved; + hasRoot = true; + } + + if (!hasRoot) + throw new InvalidOperationException("Resolved source config is unavailable."); var baseHash = response.TryGetProperty("baseHash", out var baseHashElement) && baseHashElement.ValueKind == JsonValueKind.String ? baseHashElement.GetString() diff --git a/src/OpenClaw.Shared/OpenClawGatewayClient.cs b/src/OpenClaw.Shared/OpenClawGatewayClient.cs index 8cd0cb1e95..ecbb62f6fd 100644 --- a/src/OpenClaw.Shared/OpenClawGatewayClient.cs +++ b/src/OpenClaw.Shared/OpenClawGatewayClient.cs @@ -1333,18 +1333,29 @@ private async Task SendResponseRequestAsync( try { - var sent = await SendRawAsync( - SerializeRequest(requestId, method, parameters), - connectionGeneration, - CancellationToken) - .ConfigureAwait(false); + bool sent; + using (var dispatchTimeout = new CancellationTokenSource(timeoutMs)) + { + sent = await SendRawAsync( + SerializeRequest(requestId, method, parameters), + connectionGeneration, + dispatchTimeout.Token) + .ConfigureAwait(false); + if (!sent && dispatchTimeout.IsCancellationRequested) + throw new TimeoutException($"Timed out sending {method} request"); + } + if (!sent) throw new InvalidOperationException($"Gateway connection changed before {method} could be sent."); - return await pending.Task.WaitAsync(TimeSpan.FromMilliseconds(timeoutMs), CancellationToken); - } - catch (TimeoutException ex) - { - throw new TimeoutException($"Timed out waiting for {method} response", ex); + + try + { + return await pending.Task.WaitAsync(TimeSpan.FromMilliseconds(timeoutMs), CancellationToken); + } + catch (TimeoutException ex) + { + throw new TimeoutException($"Timed out waiting for {method} response", ex); + } } finally { diff --git a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw index 7752f1e5b1..5804458641 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw @@ -6425,7 +6425,7 @@ Make sure the gateway is running. Connect to a gateway before saving config. - This operator token does not have operator.write permission, so config changes cannot be saved. + This operator token does not have operator.admin permission, so config changes cannot be saved. Config not loaded @@ -6506,7 +6506,7 @@ Make sure the gateway is running. This operator token lacks operator.read permission, so the gateway config cannot be loaded here. - This operator token can read config but lacks operator.write permission. You can inspect and validate drafts, but Save is disabled. + This operator token can read config but lacks operator.admin permission. You can inspect and validate drafts, but Save is disabled. No unsaved changes. @@ -6533,7 +6533,7 @@ Make sure the gateway is running. Config unavailable: missing operator.read - Read-only: missing operator.write + Read-only: missing operator.admin Fix validation errors before saving diff --git a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw index 785627d30b..b86015b867 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw @@ -6421,7 +6421,7 @@ Assurez-vous que la passerelle est en cours d'exécution. Connectez-vous à une passerelle avant d'enregistrer la configuration. - Ce jeton opérateur ne dispose pas de l'autorisation operator.write ; les modifications de configuration ne peuvent donc pas être enregistrées. + Ce jeton opérateur ne dispose pas de l'autorisation operator.admin ; les modifications de configuration ne peuvent donc pas être enregistrées. Configuration non chargée @@ -6502,7 +6502,7 @@ Assurez-vous que la passerelle est en cours d'exécution. Ce jeton opérateur ne dispose pas de l'autorisation operator.read ; la configuration de la passerelle ne peut donc pas être chargée ici. - Ce jeton opérateur peut lire la configuration, mais ne dispose pas de l'autorisation operator.write. Vous pouvez inspecter et valider les brouillons, mais Enregistrer est désactivé. + Ce jeton opérateur peut lire la configuration, mais ne dispose pas de l'autorisation operator.admin. Vous pouvez inspecter et valider les brouillons, mais Enregistrer est désactivé. Aucune modification non enregistrée. @@ -6529,7 +6529,7 @@ Assurez-vous que la passerelle est en cours d'exécution. Configuration indisponible : operator.read manquant - Lecture seule : operator.write manquant + Lecture seule : operator.admin manquant Corrigez les erreurs de validation avant d'enregistrer diff --git a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw index b9e0881c4c..17b2ec4961 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw @@ -6422,7 +6422,7 @@ Controleer of de gateway actief is. Maak verbinding met een gateway voordat u de configuratie opslaat. - Dit operatortoken heeft geen operator.write-machtiging, dus configuratiewijzigingen kunnen niet worden opgeslagen. + Dit operatortoken heeft geen operator.admin-machtiging, dus configuratiewijzigingen kunnen niet worden opgeslagen. Configuratie niet geladen @@ -6503,7 +6503,7 @@ Controleer of de gateway actief is. Dit operatortoken mist de operator.read-machtiging, dus de gatewayconfiguratie kan hier niet worden geladen. - Dit operatortoken kan de configuratie lezen, maar mist de operator.write-machtiging. U kunt concepten bekijken en valideren, maar Opslaan is uitgeschakeld. + Dit operatortoken kan de configuratie lezen, maar mist de operator.admin-machtiging. U kunt concepten bekijken en valideren, maar Opslaan is uitgeschakeld. Geen niet-opgeslagen wijzigingen. @@ -6530,7 +6530,7 @@ Controleer of de gateway actief is. Configuratie niet beschikbaar: operator.read ontbreekt - Alleen-lezen: operator.write ontbreekt + Alleen-lezen: operator.admin ontbreekt Los validatiefouten op voordat u opslaat diff --git a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw index 3dd78d5bda..d3512f83ff 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw @@ -6399,7 +6399,7 @@ Certifique-se de que o Gateway está em execução. Conecte-se a um Gateway antes de salvar a configuração. - Este token de operador não tem permissão operator.write, então as alterações de configuração não podem ser salvas. + Este token de operador não tem permissão operator.admin, então as alterações de configuração não podem ser salvas. Configuração não carregada @@ -6480,7 +6480,7 @@ Certifique-se de que o Gateway está em execução. Este token de operador não tem permissão operator.read, então a configuração do Gateway não pode ser carregada aqui. - Este token de operador pode ler a configuração, mas não tem permissão operator.write. Você pode inspecionar e validar rascunhos, mas Salvar está desativado. + Este token de operador pode ler a configuração, mas não tem permissão operator.admin. Você pode inspecionar e validar rascunhos, mas Salvar está desativado. Nenhuma alteração não salva. @@ -6507,7 +6507,7 @@ Certifique-se de que o Gateway está em execução. Configuração indisponível: operator.read ausente - Somente leitura: operator.write ausente + Somente leitura: operator.admin ausente Corrija os erros de validação antes de salvar diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw index 01da7008b6..da331e8d3c 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw @@ -6421,7 +6421,7 @@ 保存配置前请先连接到网关。 - 此操作员令牌没有 operator.write 权限,因此无法保存配置更改。 + 此操作员令牌没有 operator.admin 权限,因此无法保存配置更改。 配置未加载 @@ -6502,7 +6502,7 @@ 此操作员令牌缺少 operator.read 权限,因此无法在此处加载网关配置。 - 此操作员令牌可以读取配置,但缺少 operator.write 权限。你可以检查并验证草稿,但“保存”已禁用。 + 此操作员令牌可以读取配置,但缺少 operator.admin 权限。你可以检查并验证草稿,但“保存”已禁用。 没有未保存的更改。 @@ -6529,7 +6529,7 @@ 配置不可用:缺少 operator.read - 只读:缺少 operator.write + 只读:缺少 operator.admin 保存前请修复验证错误 diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw index f21e4eacba..22774a9c7d 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw @@ -6421,7 +6421,7 @@ 儲存設定前請先連線到閘道。 - 此操作員權杖沒有 operator.write 權限,因此無法儲存設定變更。 + 此操作員權杖沒有 operator.admin 權限,因此無法儲存設定變更。 設定未載入 @@ -6502,7 +6502,7 @@ 此操作員權杖缺少 operator.read 權限,因此無法在此載入閘道設定。 - 此操作員權杖可以讀取設定,但缺少 operator.write 權限。您可以檢查並驗證草稿,但「儲存」已停用。 + 此操作員權杖可以讀取設定,但缺少 operator.admin 權限。您可以檢查並驗證草稿,但「儲存」已停用。 沒有未儲存的變更。 @@ -6529,7 +6529,7 @@ 設定無法使用:缺少 operator.read - 唯讀:缺少 operator.write + 唯讀:缺少 operator.admin 儲存前請修正驗證錯誤 diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs index 817cc8a63c..d05c060ade 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs @@ -231,6 +231,83 @@ public async Task RevalidateAsync_CoreStillAllowsTailscale_KeepsMarkerAndReturns Assert.Equal(18789, liveVerifier.LastGatewayPort); } + [Theory] + [InlineData("sourceConfig")] + [InlineData("resolved")] + public async Task RevalidateAsync_UsesResolvedSourceForGrantAndProbePort(string sourceProperty) + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + using var response = JsonDocument.Parse($$""" + { + "parsed": { "gateway": { "port": 18789, "auth": { "allowTailscale": false } } }, + "{{sourceProperty}}": { "gateway": { "port": 19876, "auth": { "allowTailscale": true } } }, + "hash": "root-and-includes-cas", + "configRevisionHash": "revision-new", + "appliedConfigHash": "revision-new" + } + """); + var client = new FakeConfigClient(response.RootElement.Clone()); + var liveVerifier = new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready); + var service = new GatewayTailscaleAuthUpgradeService(registry, liveVerifier); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.True(trusted); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(19876, liveVerifier.LastGatewayPort); + Assert.Equal(1, liveVerifier.Calls); + } + + [Fact] + public async Task RevalidateAsync_MissingResolvedSourcePreservesMarkerAndSkipsProbe() + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); + registry.Save(); + using var response = JsonDocument.Parse(""" + { + "parsed": { "gateway": { "port": 19876, "auth": { "allowTailscale": true } } }, + "configRevisionHash": "revision-new", + "appliedConfigHash": "revision-new" + } + """); + var client = new FakeConfigClient(response.RootElement.Clone()); + var liveVerifier = new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready); + var service = new GatewayTailscaleAuthUpgradeService(registry, liveVerifier); + + var trusted = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); + + Assert.False(trusted); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(0, liveVerifier.Calls); + } + + [Fact] + public async Task EnableAsync_UsesResolvedSourceAndPreservesCoreCasHash() + { + var registry = CreateRegistry(); + using var response = JsonDocument.Parse(""" + { + "parsed": { "gateway": { "auth": { "allowTailscale": true } } }, + "sourceConfig": { "gateway": { "auth": { "allowTailscale": false } } }, + "hash": "root-and-includes-cas", + "configRevisionHash": "revision-new", + "appliedConfigHash": "revision-new" + } + """); + var client = new FakeConfigClient(response.RootElement.Clone()); + var service = new GatewayTailscaleAuthUpgradeService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.Succeeded, result.Outcome); + Assert.Equal(1, client.PatchCalls); + Assert.Equal("root-and-includes-cas", client.PatchBaseHash); + Assert.True(registry.GetActive()!.TrustTailscaleAuth); + } + [Fact] public async Task RevalidateAsync_OmittedGatewayPort_UsesCoreDefault() { @@ -268,6 +345,7 @@ public async Task RevalidateAsync_UnprovenAppliedRevision_PreservesMarkerAndCred using var response = JsonDocument.Parse($$""" { "{{documentProperty}}": { "gateway": { "auth": { "allowTailscale": true } } }, + "sourceConfig": { "gateway": { "auth": { "allowTailscale": true } } }, {{revisionProperties}} } """); @@ -711,6 +789,13 @@ private static JsonElement Config( }, "unrelated": "keep" }, + "sourceConfig": { + "gateway": { + {{(includeGatewayPort ? "\"port\": 18789," : "")}} + "auth": { "allowTailscale": {{allowTailscale.ToString().ToLowerInvariant()}} } + }, + "unrelated": "keep" + }, "configRevisionHash": "revision-new", "appliedConfigHash": "{{appliedRevision}}"{{(includeBaseHash ? ",\n \"baseHash\": \"base-1\"" : "")}} } @@ -728,6 +813,12 @@ private static JsonElement ConfigWithGatewayPort(string gatewayPort) "auth": { "allowTailscale": true } } }, + "sourceConfig": { + "gateway": { + "port": {{gatewayPort}}, + "auth": { "allowTailscale": true } + } + }, "configRevisionHash": "revision-new", "appliedConfigHash": "revision-new" } @@ -745,6 +836,12 @@ private static JsonElement ImplicitServeConfig() "tailscale": { "mode": "serve" } } }, + "sourceConfig": { + "gateway": { + "auth": { "mode": "token" }, + "tailscale": { "mode": "serve" } + } + }, "baseHash": "base-1", "configRevisionHash": "revision-new", "appliedConfigHash": "revision-new" diff --git a/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs b/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs index d1d6f42617..fcfea0500b 100644 --- a/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs +++ b/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs @@ -569,6 +569,14 @@ public int GetPendingRequestCount() return GetPendingRegistry().Count; } + public SemaphoreSlim GetSendLockForTest() + { + var field = typeof(WebSocketClientBase).GetField( + "_sendLock", + System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); + return (SemaphoreSlim)field!.GetValue(_client)!; + } + private PendingRequestRegistry GetPendingRegistry() { var field = typeof(OpenClawGatewayClient).GetField( @@ -876,6 +884,46 @@ public async Task SendWizardRequestAsync_DeadlineExpires_ThrowsTimeoutAndCleansT Assert.Equal(0, helper.GetPendingRequestCount()); } + [Fact] + public async Task SendWizardRequestAsync_DeadlineExpiresWhileQueuedForSend_DoesNotWriteAfterUnlock() + { + using var server = new LoopbackWebSocketServer(); + using var identity = new TempDirectory("wizard-request-send-timeout-"); + await server.StartAsync(); + var helper = new GatewayClientTestHelper( + gatewayUrl: server.WebSocketUrl, + identityPath: identity.Path); + using var client = helper.Client; + await client.ConnectAsync(); + helper.MarkHandshakeReady(); + + var sendLock = helper.GetSendLockForTest(); + await sendLock.WaitAsync(); + var lockHeld = true; + try + { + var request = client.SendWizardRequestAsync("wizard.status", timeoutMs: 150); + Assert.Equal(1, helper.GetPendingRequestCount()); + + var exception = await Assert.ThrowsAsync(async () => + await request.WaitAsync(TimeSpan.FromSeconds(2))); + + Assert.Equal("Timed out sending wizard.status request", exception.Message); + Assert.Equal(0, helper.GetPendingRequestCount()); + sendLock.Release(); + lockHeld = false; + + using var noFrameTimeout = new CancellationTokenSource(TimeSpan.FromMilliseconds(250)); + await Assert.ThrowsAnyAsync(async () => + await server.ReceiveTextAsync(noFrameTimeout.Token).WaitAsync(TimeSpan.FromSeconds(2))); + } + finally + { + if (lockHeld) + sendLock.Release(); + } + } + [Fact] public async Task SendWizardRequestAsync_LateResponseAfterTimeout_DoesNotChangeOutcomeOrTracking() { diff --git a/tests/OpenClaw.Tray.Tests/LocalizationValidationTests.cs b/tests/OpenClaw.Tray.Tests/LocalizationValidationTests.cs index 4c7e948d85..34e600e858 100644 --- a/tests/OpenClaw.Tray.Tests/LocalizationValidationTests.cs +++ b/tests/OpenClaw.Tray.Tests/LocalizationValidationTests.cs @@ -686,6 +686,31 @@ public void AllLocales_HaveExactlySameKeysAsEnUs() } } + [Fact] + public void ConfigReadOnlyGuidance_UsesTheRequiredAdminScopeInEveryLocale() + { + string[] keys = + [ + "ConfigPage_StatusReadOnlyMessage", + "ConfigPage_ConfigIsReadOnlyMessage", + "ConfigPage_SaveStatusReadOnlyMissingWrite", + ]; + + foreach (var localeDir in Directory.GetDirectories(GetStringsDirectory())) + { + var locale = Path.GetFileName(localeDir); + var resources = LoadResw(Path.Combine(localeDir, "Resources.resw")); + + foreach (var key in keys) + { + Assert.True(resources.TryGetValue(key, out var value), $"Locale '{locale}' is missing '{key}'."); + Assert.NotNull(value); + Assert.Contains("operator.admin", value, StringComparison.OrdinalIgnoreCase); + Assert.DoesNotContain("operator.write", value, StringComparison.OrdinalIgnoreCase); + } + } + } + [Fact] public void AccessibilityNames_ExistInEveryLocale() { From 095f43974d68afebf6d188d3b93b5cf0356a32c1 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Thu, 15 Oct 2026 20:23:38 +0100 Subject: [PATCH 26/38] fix(windows): update shared config fixture contract --- tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs b/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs index 540dfe3d74..4bfd6d5c4f 100644 --- a/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs +++ b/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs @@ -223,7 +223,7 @@ public static GatewayScenario CreateBrowse(bool allowAgentCreation = false, bool ["config.get"] = JsonSerializer.SerializeToElement(new { path = "/fixture/openclaw.json", exists = true, raw = config.GetRawText(), - parsed = config, config, valid = true, hash = configHash, + parsed = config, sourceConfig = config, config, valid = true, hash = configHash, issues = Array.Empty(), warnings = Array.Empty(), legacyIssues = Array.Empty() }), ["config.schema"] = JsonSerializer.SerializeToElement(new From 44094c51eab3e9baebd2742ccbda8e1d1b6b37c2 Mon Sep 17 00:00:00 2001 From: "bakudies@microsoft.com" Date: Tue, 20 Oct 2026 00:04:34 -0700 Subject: [PATCH 27/38] fix(connection): gate Tailscale auth and preserve upgrade retry Require verified Core-managed ingress before auth changes, persist new trust only after confirmed acceptance, and report emitted Dashboard credentials accurately. Restore bootstrap provenance coverage and document supported topology and retry behavior. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .agents/skills/winnode/SKILL.md | 5 + docs/CONNECTION_ARCHITECTURE.md | 18 + docs/WSL_GATEWAY_ADMIN.md | 35 +- .../GatewayConnectionManager.cs | 4 +- src/OpenClaw.Connection/GatewayRecord.cs | 4 +- .../GatewayTailscaleAuthUpgrade.cs | 149 +++---- src/OpenClaw.Shared/Mcp/McpToolBridge.cs | 2 +- .../App.CapabilityHandlers.cs | 2 +- .../Pages/ConnectionPage.xaml.cs | 5 +- .../Pages/ConnectionPagePlan.cs | 2 + .../Strings/en-us/Resources.resw | 13 +- .../Strings/fr-fr/Resources.resw | 13 +- .../Strings/nl-nl/Resources.resw | 13 +- .../Strings/pt-br/Resources.resw | 13 +- .../Strings/zh-cn/Resources.resw | 13 +- .../Strings/zh-tw/Resources.resw | 13 +- .../GatewayConnectionManagerTests.cs | 13 +- .../GatewayTailscaleAuthUpgradeTests.cs | 408 +++++++++++------- .../Setup/SetupAndConnectTests.cs | 1 + .../AppRefactorContractTests.cs | 19 + .../ConnectionPageTailscaleRecoveryTests.cs | 25 ++ .../GatewayDashboardLinkServiceTests.cs | 40 ++ 22 files changed, 543 insertions(+), 267 deletions(-) diff --git a/.agents/skills/winnode/SKILL.md b/.agents/skills/winnode/SKILL.md index 04455501a6..a3d76ea623 100644 --- a/.agents/skills/winnode/SKILL.md +++ b/.agents/skills/winnode/SKILL.md @@ -468,6 +468,11 @@ Build the same gateway dashboard URL the tray opens. {"path": "string"} // optional ``` Returns `{ url, credentialSource, usesSharedGatewayToken, hasTokenQuery }`. +`credentialSource` is the selected credential's provenance, not proof it was +included in the URL. `usesSharedGatewayToken` reports actual browser credential +inclusion: false for verified Tailscale identity and bootstrap-only links, true +for shared-token fallback. Device/bootstrap credentials are not exported. +`hasTokenQuery` checks the query only; it does not describe a token fragment. ## App connection diagnostics and setup (app.connection.*) diff --git a/docs/CONNECTION_ARCHITECTURE.md b/docs/CONNECTION_ARCHITECTURE.md index b1da5f3b9f..600270a726 100644 --- a/docs/CONNECTION_ARCHITECTURE.md +++ b/docs/CONNECTION_ARCHITECTURE.md @@ -665,6 +665,24 @@ Many gateway records may be saved, but only `ActiveId` in `gateways.json` is the ## Credential precedence +### Tailscale dashboard auth upgrade + +`GatewayConnectionManager` serializes enablement and dashboard revalidation with +gateway transitions. Both use `GatewayTailscaleAuthUpgradeService` and the same +live ingress verifier. Enablement requires Core-managed foreground Serve before +dispatching the hash-conditional auth-only patch. It records new trust only after +confirmed patch acceptance, not before dispatch or after an unknown outcome. +The marker is not a readiness claim. `GatewayDashboardLinkService` still verifies +applied config and live ingress before omitting a browser credential. See the +[supported topology and retry contract](WSL_GATEWAY_ADMIN.md#upgrade-dashboard-authentication-on-an-existing-gateway). + +`app.dashboard.url` retains the selected credential's `credentialSource` as +provenance, while `usesSharedGatewayToken` reports the emitted link's +`BrowserCredentialIncluded`. Verified Tailscale identity can therefore report a +shared-token source with `usesSharedGatewayToken=false`. Shared fallback reports +true; bootstrap-only links retain bootstrap provenance without exporting that +credential. `hasTokenQuery` describes the query only, not a token in the fragment. + ### Native onboarding connection boundary `SetupNativeConnectionPage` retains an immutable `SetupNativeConnectionRequest`. diff --git a/docs/WSL_GATEWAY_ADMIN.md b/docs/WSL_GATEWAY_ADMIN.md index 36eefaa93d..390b264710 100644 --- a/docs/WSL_GATEWAY_ADMIN.md +++ b/docs/WSL_GATEWAY_ADMIN.md @@ -120,7 +120,40 @@ wsl.exe -d OpenClawGateway --user openclaw -- bash -lc "systemctl --user status The generated WSL distro is Ubuntu 24.04 (noble). Tailscale Serve setup requires that exact generated distro and rejects another `BaseDistro` before replacing an existing gateway. Setup installs Tailscale from its signed stable APT repository rather than executing the mutable `install.sh` bootstrap script as root. -Tailscale Serve preserves Companion token and device authentication by default (`gateway.auth.allowTailscale=false`). Setup runs `tailscale up`, Serve, reset, logout, and daemon management as root; the `openclaw` account is never made a Tailscale operator. Tailscale's LocalAPI permits read-only operations, such as identity lookup, to local unprivileged clients while reserving mutation for root or an explicitly configured operator. In the setup review, **Trust Tailscale identities for gateway authentication** is an explicit opt-in; when enabled, verified Tailscale identity headers and tailnet ACLs become part of the gateway access-control boundary. Token and device credentials remain available for Companion pairing and compatibility. Do not enable Funnel for this generated gateway: this workflow supports private tailnet Serve only. +Tailscale Serve preserves Companion token and device authentication by default (`gateway.auth.allowTailscale=false`). Setup runs `tailscale up`, Serve, reset, logout, and daemon management as root; the `openclaw` account is never made a Tailscale operator. Tailscale's LocalAPI permits read-only operations, such as identity lookup, to local unprivileged clients while reserving mutation for root or an explicitly configured operator. In the setup review, **Trust Tailscale identities for gateway authentication** is an explicit opt-in that writes the auth setting and records consent. Consent alone does not establish working identity authentication: the setup-generated background Serve route is not Core-managed identity ingress. Token and device credentials remain available for Companion pairing and compatibility. Do not enable Funnel for this generated gateway: this workflow supports private tailnet Serve only. + +### Upgrade dashboard authentication on an existing gateway + +In Connection, select the managed Tailscale gateway, connect with +`operator.admin`, then choose **Use Tailscale identity for dashboard** from its +saved-row menu and confirm. This auth-only action requires +`gateway.tailscale.mode="serve"` and verified Core-owned foreground Serve ingress. +It reads configuration and checks ingress before changing either Core or local +trust. Missing or unavailable ingress returns a not-ready message. + +The default setup topology has `gateway.tailscale.mode="off"` and root-owned +`tailscale serve --bg`. It is unsupported by this action, even if Serve forwards +HTTPS successfully. Ask the gateway administrator to review the installed Core +version and deployment. The action does not migrate the distro, switch Serve +ownership, restart services, or change token/device credentials. Do not toggle +the mode alone and assume that proves compatible ingress. + +On supported ingress, the action sends only +`{"gateway":{"auth":{"allowTailscale":true}}}` with the fresh Core config hash. +A new local `TrustTailscaleAuth` marker is saved only after Core confirms patch +acceptance. The success message reports acceptance, not completed asynchronous +application. Dashboard links separately verify matching applied configuration +and live ingress before omitting the browser token. + +A rejected, timed-out, lost, or canceled response does not create new trust. +Reconnect and repeat the same action; it remains available after registry reload, +and its minimal patch is idempotent even if Core accepted the earlier request. +Cancellation during dispatch waits for the bounded request to finish before +returning, without saving new trust. A local save failure restores the in-memory +marker and leaves the same retry available. Existing true consent is preserved +on ambiguous failures; only authoritative applied config revocation clears it. +When live identity cannot be verified, links use an independently approved shared +browser credential or fail closed if none is available. ## Use root instead of sudo diff --git a/src/OpenClaw.Connection/GatewayConnectionManager.cs b/src/OpenClaw.Connection/GatewayConnectionManager.cs index cb6ee47ea3..29b414e60c 100644 --- a/src/OpenClaw.Connection/GatewayConnectionManager.cs +++ b/src/OpenClaw.Connection/GatewayConnectionManager.cs @@ -239,7 +239,9 @@ public async Task EnableTailscaleDashboardAut } else { - var service = new GatewayTailscaleAuthUpgradeService(_registry); + var service = new GatewayTailscaleAuthUpgradeService( + _registry, + _tailscaleAuthLiveVerifier); result = await service.EnableAsync( gatewayId, new GatewayTailscaleAuthConfigClientAdapter(client), diff --git a/src/OpenClaw.Connection/GatewayRecord.cs b/src/OpenClaw.Connection/GatewayRecord.cs index b981a43ff4..6fb9a7a7a5 100644 --- a/src/OpenClaw.Connection/GatewayRecord.cs +++ b/src/OpenClaw.Connection/GatewayRecord.cs @@ -34,8 +34,8 @@ public sealed record GatewayRecord public string? SetupManagedDistroName { get; init; } /// - /// True when setup or an explicit upgrade granted this managed gateway's - /// Dashboard access to verified Tailscale identity authentication. + /// Explicit setup consent or a confirmed, accepted auth upgrade for this managed + /// gateway. Dashboard access still requires applied config and live ingress verification. /// public bool TrustTailscaleAuth { get; init; } diff --git a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs index b4dd1daab8..50df5b95b7 100644 --- a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs +++ b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs @@ -17,6 +17,8 @@ public enum GatewayTailscaleAuthUpgradeOutcome ConfigUnavailable, PatchRejected, PersistenceFailed, + UnsupportedTopology, + IngressNotReady, } public sealed record GatewayTailscaleAuthUpgradeResult( @@ -411,52 +413,37 @@ public async Task EnableAsync( cancellationToken.ThrowIfCancellationRequested(); - if (record!.TrustTailscaleAuth && snapshot.IsApplied && AllowsTailscaleAuth(snapshot.Root)) - return new(GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled); + if (!UsesManagedTailscaleServe(snapshot.Root)) + return new(GatewayTailscaleAuthUpgradeOutcome.UnsupportedTopology); - if (string.IsNullOrWhiteSpace(snapshot.BaseHash)) - { - return new(GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable, "Config base hash is unavailable."); - } + if (_liveVerifier is null || !TryGetGatewayPort(snapshot.Root, out var gatewayPort)) + return new(GatewayTailscaleAuthUpgradeOutcome.IngressNotReady); - var previousValue = false; - var changed = false; - if (!record.TrustTailscaleAuth) + try { - _registry.Update(gatewayId, current => - { - if (!GatewayTailscaleAuthUpgradePolicy.CanOffer(current)) - return current; - - previousValue = current.TrustTailscaleAuth; - changed = true; - return current with { TrustTailscaleAuth = true }; - }); - - if (!changed) - return new(GatewayTailscaleAuthUpgradeOutcome.NotActive); - - try - { - _registry.Save(); - } - catch (Exception ex) + if (await _liveVerifier.VerifyAsync(record!, gatewayPort, cancellationToken).ConfigureAwait(false) != + GatewayTailscaleAuthLiveState.Ready) { - _registry.Update(gatewayId, current => current with { TrustTailscaleAuth = previousValue }); - return new(GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, ex.Message); + return new(GatewayTailscaleAuthUpgradeOutcome.IngressNotReady); } } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + throw; + } + catch (Exception ex) + { + return new(GatewayTailscaleAuthUpgradeOutcome.IngressNotReady, ex.Message); + } + + cancellationToken.ThrowIfCancellationRequested(); - if (cancellationToken.IsCancellationRequested) + if (record!.TrustTailscaleAuth && snapshot.IsApplied && AllowsTailscaleAuth(snapshot.Root)) + return new(GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled); + + if (string.IsNullOrWhiteSpace(snapshot.BaseHash)) { - var rollback = RollBackMarkerAfterRejectedPatch( - gatewayId, - changed, - previousValue, - patchError: null); - if (rollback.Outcome == GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed) - return rollback; - cancellationToken.ThrowIfCancellationRequested(); + return new(GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable, "Config base hash is unavailable."); } // Core beta.7 and current main define config.patch as JSON Merge Patch. @@ -475,21 +462,12 @@ public async Task EnableAsync( { // Dispatch cannot be canceled at the client boundary. Observe its bounded // result before returning so callers never proceed beside an in-flight - // mutation. Roll back only a definitive gateway rejection; otherwise the - // marker remains for the next trust-aware live revalidation. + // mutation. Cancellation does not issue new trust, even if Core accepted + // the patch. A later explicit retry safely repeats the idempotent leaf. try { - var completedPatch = await patchTask!.ConfigureAwait(false); - if (!completedPatch.Ok && completedPatch.IsGatewayRejection) - { - var rollback = RollBackMarkerAfterRejectedPatch( - gatewayId, - changed, - previousValue, - completedPatch.Error); - if (rollback.Outcome == GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed) - return rollback; - } + if (patchTask is not null) + await patchTask.ConfigureAwait(false); } catch { @@ -499,21 +477,43 @@ public async Task EnableAsync( } catch (Exception ex) { - // The response can be lost after Core commits the patch. Keep the marker so - // the next trust-aware launch revalidates the authoritative Core state. + // An unknown result must not hide a new opt-in's retry. Existing trust + // remains intact; only authoritative applied config can revoke it. return new(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, ex.Message); } - if (!patch.Ok && patch.IsGatewayRejection) - return RollBackMarkerAfterRejectedPatch(gatewayId, changed, previousValue, patch.Error); - + cancellationToken.ThrowIfCancellationRequested(); if (!patch.Ok) - { - // The request may have committed before its response was lost. Preserve - // the marker so the next trust-aware launch revalidates Core state. return new(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, patch.Error); + + if (!record.TrustTailscaleAuth) + { + var changed = false; + _registry.Update(gatewayId, current => + { + if (!GatewayTailscaleAuthUpgradePolicy.CanOffer(current)) + return current; + + changed = true; + return current with { TrustTailscaleAuth = true }; + }); + + if (!changed) + return new(GatewayTailscaleAuthUpgradeOutcome.NotActive); + + try + { + _registry.Save(); + } + catch (Exception ex) + { + _registry.Update(gatewayId, current => current with { TrustTailscaleAuth = false }); + return new(GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, ex.Message); + } } + // Acceptance is not evidence of asynchronous Core apply or continued ingress + // readiness. Dashboard-link creation still performs its live revalidation. return new(GatewayTailscaleAuthUpgradeOutcome.Succeeded); } @@ -640,28 +640,15 @@ private static JsonElement CreateAllowTailscalePatch() return document.RootElement.Clone(); } - private GatewayTailscaleAuthUpgradeResult RollBackMarkerAfterRejectedPatch( - string gatewayId, - bool changed, - bool previousValue, - string? patchError) - { - if (!changed) - return new(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, patchError); - - _registry.Update(gatewayId, current => current with { TrustTailscaleAuth = previousValue }); - try - { - _registry.Save(); - return new(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, patchError); - } - catch (Exception ex) - { - return new( - GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, - $"Local Tailscale trust-marker rollback failed: {ex.Message}"); - } - } + private static bool UsesManagedTailscaleServe(JsonElement config) => + config.ValueKind == JsonValueKind.Object && + config.TryGetProperty("gateway", out var gateway) && + gateway.ValueKind == JsonValueKind.Object && + gateway.TryGetProperty("tailscale", out var tailscale) && + tailscale.ValueKind == JsonValueKind.Object && + tailscale.TryGetProperty("mode", out var mode) && + mode.ValueKind == JsonValueKind.String && + string.Equals(mode.GetString(), "serve", StringComparison.Ordinal); // A true marker is issued only after this service or setup explicitly writes // allowTailscale=true. Omission therefore means that grant drifted or was revoked; diff --git a/src/OpenClaw.Shared/Mcp/McpToolBridge.cs b/src/OpenClaw.Shared/Mcp/McpToolBridge.cs index b05808c303..d06b0a23fd 100644 --- a/src/OpenClaw.Shared/Mcp/McpToolBridge.cs +++ b/src/OpenClaw.Shared/Mcp/McpToolBridge.cs @@ -380,7 +380,7 @@ private object HandleToolsList() ["app.search"] = "Search the command palette and return matching commands. Args: query (string, required). Returns array of { Title, Subtitle, Icon }.", ["app.dashboard.url"] = - "Build the same gateway dashboard URL the tray opens. Args: path (string, optional). Returns { url, credentialSource, usesSharedGatewayToken, hasTokenQuery }.", + "Build the same gateway dashboard URL the tray opens. Args: path (string, optional). Returns { url, credentialSource, usesSharedGatewayToken, hasTokenQuery }. credentialSource is selected credential provenance; usesSharedGatewayToken reports actual browser credential inclusion (false for verified Tailscale identity or bootstrap-only links, true for shared-token fallback). Device/bootstrap credentials are not exported. hasTokenQuery checks only the query, not a token fragment.", ["app.chat.snapshot"] = "READ-ALL: Return the current native chat snapshot for local automation. Args: threadId/sessionKey (string, optional). Returns connection state, compose target, thread summaries, queued outgoing messages, and recent timeline entries including chat text.", ["app.chat.send"] = diff --git a/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs b/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs index cf44efed81..a1739b7d38 100644 --- a/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs +++ b/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs @@ -268,7 +268,7 @@ private void WireAppCapabilityHandlers() { url, credentialSource, - usesSharedGatewayToken = !isBootstrapToken && credentialSource == CredentialResolver.SourceSharedGatewayToken, + usesSharedGatewayToken = result.BrowserCredentialIncluded, hasTokenQuery = url.Contains("?token=", StringComparison.Ordinal) || url.Contains("&token=", StringComparison.Ordinal) }; }; diff --git a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs index 0b2b55bafe..53e5ed9c7a 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs @@ -2660,7 +2660,10 @@ item.Tag is not string gatewayId || var result = await _connectionManager.EnableTailscaleDashboardAuthAsync(gatewayId); if (result.IsSuccess) { - SetGatewayHostActionStatus(LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthEnabled")); + var successKey = result.Outcome == GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled + ? "ConnectionPage_TailscaleDashboardAuthEnabled" + : "ConnectionPage_TailscaleDashboardAuthAccepted"; + SetGatewayHostActionStatus(LocalizationHelper.GetString(successKey)); LoadSavedGateways(); return; } diff --git a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs index b80684d097..eccd376a09 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs @@ -141,6 +141,8 @@ public static string TailscaleAuthFailureMessageResourceKey( GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable => "ConnectionPage_TailscaleDashboardAuthFailureConfigUnavailable", GatewayTailscaleAuthUpgradeOutcome.PatchRejected => "ConnectionPage_TailscaleDashboardAuthFailurePatchRejected", GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed => "ConnectionPage_TailscaleDashboardAuthFailurePersistenceFailed", + GatewayTailscaleAuthUpgradeOutcome.UnsupportedTopology => "ConnectionPage_TailscaleDashboardAuthFailureUnsupportedTopology", + GatewayTailscaleAuthUpgradeOutcome.IngressNotReady => "ConnectionPage_TailscaleDashboardAuthFailureIngressNotReady", _ => "ConnectionPage_TailscaleDashboardAuthFailureGeneric", }; diff --git a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw index 4e07cee36e..0012880cf7 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw @@ -5706,7 +5706,7 @@ Make sure the gateway is running. Use Tailscale identity for dashboard? - This enables verified Tailscale identity authentication on this managed gateway. Your saved token, device identity, WSL distro, and pairing remain unchanged. + This requests Tailscale identity authentication on a gateway with gateway-managed foreground Tailscale Serve. Your saved token, device identity, WSL distro, and pairing remain unchanged. This action does not change Serve. Enable @@ -5714,6 +5714,15 @@ Make sure the gateway is running. Tailscale dashboard identity enabled. + + The gateway accepted the Tailscale identity setting. Dashboard links will verify that it is applied and ready before omitting the token. + + + This action requires gateway-managed foreground Tailscale Serve. Setup's background Serve is not supported. Ask the gateway administrator to review the deployment. No setting was changed. + + + Gateway-managed Tailscale ingress is not ready or could not be verified. Check the gateway and Tailscale connection, then retry. No setting was changed. + This gateway is no longer a managed Tailscale gateway. Refresh the gateway list and try again. @@ -5730,7 +5739,7 @@ Make sure the gateway is running. The gateway configuration could not be read. Reconnect to the gateway and try again. - The gateway did not confirm the change. Reconnect and check whether Tailscale identity is enabled before retrying. + The gateway did not confirm the change. Reconnect and retry. Retrying safely reapplies only the same Tailscale setting. The local Tailscale trust setting could not be saved. Check access to the OpenClaw Tray data folder, then retry. diff --git a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw index 964d2719af..2b1ed436de 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw @@ -5702,7 +5702,7 @@ Assurez-vous que la passerelle est en cours d'exécution. Utiliser l’identité Tailscale pour le tableau de bord ? - Cela active l’authentification vérifiée par identité Tailscale sur cette passerelle gérée. Votre jeton enregistré, l’identité de l’appareil, la distribution WSL et l’association restent inchangés. + Cela demande l’authentification par identité Tailscale sur une passerelle qui gère Tailscale Serve au premier plan. Votre jeton enregistré, l’identité de l’appareil, la distribution WSL et l’association restent inchangés. Cette action ne modifie pas Serve. Activer @@ -5710,6 +5710,15 @@ Assurez-vous que la passerelle est en cours d'exécution. L’identité Tailscale est activée pour le tableau de bord. + + La passerelle a accepté le paramètre d’identité Tailscale. Les liens du tableau de bord vérifieront qu’il est appliqué et opérationnel avant d’omettre le jeton. + + + Cette action nécessite Tailscale Serve au premier plan, géré par la passerelle. Le mode Serve en arrière-plan créé par l’installation n’est pas pris en charge. Demandez à l’administrateur de la passerelle de vérifier le déploiement. Aucun paramètre n’a été modifié. + + + Le point d’entrée Tailscale géré par la passerelle n’est pas prêt ou n’a pas pu être vérifié. Vérifiez la passerelle et la connexion Tailscale, puis réessayez. Aucun paramètre n’a été modifié. + Cette passerelle n’est plus une passerelle Tailscale gérée. Actualisez la liste des passerelles et réessayez. @@ -5726,7 +5735,7 @@ Assurez-vous que la passerelle est en cours d'exécution. Impossible de lire la configuration de la passerelle. Reconnectez-vous à la passerelle et réessayez. - La passerelle n’a pas confirmé la modification. Reconnectez-vous et vérifiez si l’identité Tailscale est activée avant de réessayer. + La passerelle n’a pas confirmé la modification. Reconnectez-vous et réessayez. Une nouvelle tentative réapplique uniquement le même paramètre Tailscale en toute sécurité. Impossible d’enregistrer localement le paramètre de confiance Tailscale. Vérifiez l’accès au dossier de données OpenClaw Tray, puis réessayez. diff --git a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw index 3c57a79a5c..add4b99e65 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw @@ -5703,7 +5703,7 @@ Controleer of de gateway actief is. Tailscale-identiteit gebruiken voor het dashboard? - Hiermee wordt verificatie via Tailscale-identiteit ingeschakeld op deze beheerde gateway. Uw opgeslagen token, apparaatidentiteit, WSL-distributie en koppeling blijven ongewijzigd. + Hiermee vraagt u verificatie via Tailscale-identiteit aan op een gateway die Tailscale Serve op de voorgrond beheert. Uw opgeslagen token, apparaatidentiteit, WSL-distributie en koppeling blijven ongewijzigd. Deze actie wijzigt Serve niet. Inschakelen @@ -5711,6 +5711,15 @@ Controleer of de gateway actief is. Tailscale-identiteit voor het dashboard is ingeschakeld. + + De gateway heeft de instelling voor Tailscale-identiteit geaccepteerd. Dashboardlinks controleren of deze is toegepast en gereed is voordat het token wordt weggelaten. + + + Deze actie vereist Tailscale Serve op de voorgrond, beheerd door de gateway. Serve op de achtergrond uit de installatie wordt niet ondersteund. Vraag de gatewaybeheerder om de implementatie te controleren. Er is geen instelling gewijzigd. + + + De door de gateway beheerde Tailscale-toegang is niet gereed of kon niet worden geverifieerd. Controleer de gateway en de Tailscale-verbinding en probeer het opnieuw. Er is geen instelling gewijzigd. + Deze gateway is niet langer een beheerde Tailscale-gateway. Vernieuw de gatewaylijst en probeer het opnieuw. @@ -5727,7 +5736,7 @@ Controleer of de gateway actief is. De gatewayconfiguratie kon niet worden gelezen. Maak opnieuw verbinding met de gateway en probeer het opnieuw. - De gateway heeft de wijziging niet bevestigd. Maak opnieuw verbinding en controleer of Tailscale-identiteit is ingeschakeld voordat u het opnieuw probeert. + De gateway heeft de wijziging niet bevestigd. Maak opnieuw verbinding en probeer het opnieuw. Een nieuwe poging past veilig alleen dezelfde Tailscale-instelling opnieuw toe. De lokale instelling voor Tailscale-vertrouwen kon niet worden opgeslagen. Controleer de toegang tot de gegevensmap van OpenClaw Tray en probeer het opnieuw. diff --git a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw index 64ec285fcb..675fe20f79 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw @@ -5680,7 +5680,7 @@ Certifique-se de que o Gateway está em execução. Usar a identidade do Tailscale no painel? - Isso habilita a autenticação verificada pela identidade do Tailscale neste gateway gerenciado. O token salvo, a identidade do dispositivo, a distribuição WSL e o pareamento permanecem inalterados. + Isso solicita autenticação pela identidade do Tailscale em um gateway que gerencia o Tailscale Serve em primeiro plano. O token salvo, a identidade do dispositivo, a distribuição WSL e o pareamento permanecem inalterados. Esta ação não altera o Serve. Ativar @@ -5688,6 +5688,15 @@ Certifique-se de que o Gateway está em execução. Identidade do Tailscale para o painel ativada. + + O gateway aceitou a configuração de identidade do Tailscale. Os links do painel verificarão se ela foi aplicada e está pronta antes de omitir o token. + + + Esta ação requer o Tailscale Serve em primeiro plano, gerenciado pelo gateway. O Serve em segundo plano criado pela instalação não é compatível. Peça ao administrador do gateway para revisar a implantação. Nenhuma configuração foi alterada. + + + A entrada Tailscale gerenciada pelo gateway não está pronta ou não pôde ser verificada. Verifique o gateway e a conexão Tailscale e tente novamente. Nenhuma configuração foi alterada. + Este gateway não é mais um gateway Tailscale gerenciado. Atualize a lista de gateways e tente novamente. @@ -5704,7 +5713,7 @@ Certifique-se de que o Gateway está em execução. Não foi possível ler a configuração do gateway. Reconecte-se ao gateway e tente novamente. - O gateway não confirmou a alteração. Reconecte-se e verifique se a identidade Tailscale está habilitada antes de tentar novamente. + O gateway não confirmou a alteração. Reconecte-se e tente novamente. Uma nova tentativa reaplica com segurança apenas a mesma configuração do Tailscale. Não foi possível salvar localmente a configuração de confiança do Tailscale. Verifique o acesso à pasta de dados do OpenClaw Tray e tente novamente. diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw index cd417284b5..ac9e283393 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw @@ -5702,7 +5702,7 @@ 使用 Tailscale 身份访问仪表板? - 这将在此托管网关上启用经过验证的 Tailscale 身份认证。已保存的令牌、设备身份、WSL 发行版和配对信息均保持不变。 + 这将向自行管理前台 Tailscale Serve 的网关请求 Tailscale 身份认证。已保存的令牌、设备身份、WSL 发行版和配对信息均保持不变。此操作不会更改 Serve。 启用 @@ -5710,6 +5710,15 @@ 已启用仪表板的 Tailscale 身份认证。 + + 网关已接受 Tailscale 身份设置。仪表板链接将在确认设置已应用且就绪后才省略令牌。 + + + 此操作需要由网关管理的前台 Tailscale Serve。不支持安装程序创建的后台 Serve。请让网关管理员检查部署。未更改任何设置。 + + + 由网关管理的 Tailscale 入口尚未就绪或无法验证。请检查网关和 Tailscale 连接后重试。未更改任何设置。 + 此网关已不再是受管理的 Tailscale 网关。请刷新网关列表后重试。 @@ -5726,7 +5735,7 @@ 无法读取网关配置。请重新连接网关后重试。 - 网关未确认此更改。请重新连接,并在重试前检查是否已启用 Tailscale 身份认证。 + 网关未确认此更改。请重新连接后重试。重试只会安全地重新应用同一项 Tailscale 设置。 无法在本地保存 Tailscale 信任设置。请检查 OpenClaw Tray 数据文件夹的访问权限后重试。 diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw index df6b0f02ed..92db54c279 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw @@ -5702,7 +5702,7 @@ 使用 Tailscale 身分存取儀表板? - 這會在此受管理的閘道上啟用經過驗證的 Tailscale 身分驗證。已儲存的權杖、裝置身分、WSL 發行版本和配對資訊均維持不變。 + 這會向自行管理前景 Tailscale Serve 的閘道要求 Tailscale 身分驗證。已儲存的權杖、裝置身分、WSL 發行版本和配對資訊均維持不變。此操作不會變更 Serve。 啟用 @@ -5710,6 +5710,15 @@ 已啟用儀表板的 Tailscale 身分驗證。 + + 閘道已接受 Tailscale 身分設定。儀表板連結會在確認設定已套用且就緒後才省略權杖。 + + + 此操作需要由閘道管理的前景 Tailscale Serve。不支援安裝程式建立的背景 Serve。請讓閘道管理員檢查部署。未變更任何設定。 + + + 由閘道管理的 Tailscale 入口尚未就緒或無法驗證。請檢查閘道和 Tailscale 連線後重試。未變更任何設定。 + 此閘道已不再是受管理的 Tailscale 閘道。請重新整理閘道清單後再試一次。 @@ -5726,7 +5735,7 @@ 無法讀取閘道設定。請重新連線至閘道後再試一次。 - 閘道未確認這項變更。請重新連線,並在重試前確認是否已啟用 Tailscale 身分驗證。 + 閘道未確認這項變更。請重新連線後重試。重試只會安全地重新套用同一項 Tailscale 設定。 無法在本機儲存 Tailscale 信任設定。請檢查 OpenClaw Tray 資料資料夾的存取權限後再試一次。 diff --git a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs index feecbe2cff..3c352424a4 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs @@ -3345,7 +3345,7 @@ public async Task DiagnosticEvent_Fires_OnCredentialResolution() } [Fact] - public async Task TailscaleDashboardAuthFailure_RecordsOutcomeAndError() + public async Task TailscaleDashboardAuthUnsupportedTopology_RecordsOutcomeWithoutPatch() { const string fixtureToken = "fixture-operator-token"; const string gatewayId = "tailscale-gateway"; @@ -3396,17 +3396,16 @@ await WaitUntilAsync(() => manager.OperatorClient is var result = await manager.EnableTailscaleDashboardAuthAsync(gatewayId); - Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, result.Outcome); - Assert.Contains("Fixture Gateway is read-only", result.Error ?? string.Empty); + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.UnsupportedTopology, result.Outcome); + Assert.Null(result.Error); Assert.Contains(fixture.Requests, request => request.Method == "config.get" && request.Outcome == "ok"); - Assert.Contains(fixture.Requests, request => - request.Method == "config.patch" && request.Outcome == "error:FIXTURE_READ_ONLY"); + Assert.DoesNotContain(fixture.Requests, request => request.Method == "config.patch"); var upgradeEvents = manager.Diagnostics.GetAll() .Where(entry => entry.Category == "tailscale-auth") .ToArray(); var diagnostic = Assert.Single(upgradeEvents); - Assert.Equal("Dashboard auth upgrade: PatchRejected", diagnostic.Message); - Assert.Contains("Fixture Gateway is read-only", diagnostic.Detail ?? string.Empty); + Assert.Equal("Dashboard auth upgrade: UnsupportedTopology", diagnostic.Message); + Assert.Null(diagnostic.Detail); } [Fact] diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs index d05c060ade..65924bd348 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs @@ -9,16 +9,28 @@ public sealed class GatewayTailscaleAuthUpgradeTests : IDisposable private readonly TempDirectory _temp = new(); [Fact] - public async Task EnableAsync_PersistsRecordBeforePatchingCore() + public async Task EnableAsync_PersistsRecordOnlyAfterCoreAcceptance() { var registry = CreateRegistry(); var client = new FakeConfigClient(Config(allowTailscale: false)); - client.BeforePatch = () => Assert.True(registry.GetActive()!.TrustTailscaleAuth); - var service = new GatewayTailscaleAuthUpgradeService(registry); + registry.Save(); + bool? trustedBeforeAcceptance = null; + bool? couldRetryBeforeAcceptance = null; + client.BeforePatch = () => + { + trustedBeforeAcceptance = registry.GetActive()!.TrustTailscaleAuth; + var beforeAcceptance = new GatewayRegistry(_temp.Path); + beforeAcceptance.Load(); + couldRetryBeforeAcceptance = GatewayTailscaleAuthUpgradePolicy.CanOffer(beforeAcceptance.GetActive()); + }; + var service = new GatewayTailscaleAuthUpgradeService( + registry, new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready)); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.Succeeded, result.Outcome); + Assert.False(trustedBeforeAcceptance); + Assert.True(couldRetryBeforeAcceptance); Assert.True(registry.GetActive()!.TrustTailscaleAuth); Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); Assert.Equal(1, client.PatchCalls); @@ -36,18 +48,96 @@ public async Task EnableAsync_PersistsRecordBeforePatchingCore() Assert.Equal("test-token-placeholder", reloaded.GetActive()!.SharedGatewayToken); } + [Theory] + [InlineData("off", "UnsupportedTopology")] + [InlineData("serve", "IngressNotReady")] + public async Task EnableAsync_SetupBackgroundServe_DoesNotPatchOrPersistTrust( + string mode, string expectedOutcome) + { + var registry = CreateRegistry(); + registry.Save(); + var originalRegistry = File.ReadAllText(_temp.Combine("gateways.json")); + using var config = JsonDocument.Parse($$""" + { + "sourceConfig": { + "gateway": { + "port": 18789, + "bind": "loopback", + "auth": { "mode": "token", "token": "test-token-placeholder", "allowTailscale": false }, + "tailscale": { "mode": "{{mode}}" }, + "trustedProxies": ["127.0.0.1"] + } + }, + "baseHash": "setup-config", + "configRevisionHash": "setup-config", + "appliedConfigHash": "setup-config" + } + """); + var client = new FakeConfigClient(config.RootElement.Clone()); + var verifier = new GatewayTailscaleAuthLiveVerifier(new BackgroundServeCommandRunner()); + var service = new GatewayTailscaleAuthUpgradeService(registry, verifier); + + Assert.Equal(GatewayTailscaleAuthLiveState.NotReady, + await verifier.VerifyAsync(registry.GetActive()!, 18789, CancellationToken.None)); + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(expectedOutcome, result.Outcome.ToString()); + Assert.Equal(0, client.PatchCalls); + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(originalRegistry, File.ReadAllText(_temp.Combine("gateways.json"))); + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.True(GatewayTailscaleAuthUpgradePolicy.CanOffer(reloaded.GetActive())); + } + + [Theory] + [InlineData(false, "not-ready")] + [InlineData(true, "not-ready")] + [InlineData(false, "unavailable")] + [InlineData(true, "unavailable")] + [InlineData(false, "exception")] + [InlineData(true, "exception")] + [InlineData(false, "missing-verifier")] + [InlineData(true, "missing-verifier")] + public async Task EnableAsync_UnverifiedIngress_DoesNotPatchOrChangeTrust( + bool previouslyTrusted, string probeResult) + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = previouslyTrusted }); + registry.Save(); + var originalRegistry = File.ReadAllText(_temp.Combine("gateways.json")); + var client = new FakeConfigClient(Config(allowTailscale: previouslyTrusted)); + var verifier = probeResult == "missing-verifier" ? null : new FakeLiveVerifier(probeResult switch + { + "not-ready" => GatewayTailscaleAuthLiveState.NotReady, + "unavailable" => GatewayTailscaleAuthLiveState.Unavailable, + _ => (object)new IOException("probe failed"), + }); + var service = new GatewayTailscaleAuthUpgradeService(registry, verifier); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.IngressNotReady, result.Outcome); + Assert.Equal(0, client.PatchCalls); + Assert.Equal(previouslyTrusted, registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(originalRegistry, File.ReadAllText(_temp.Combine("gateways.json"))); + } + [Fact] public async Task EnableAsync_CoreAlreadyEnabled_RequiresAcceptedIdempotentPatch() { var registry = CreateRegistry(); var client = new FakeConfigClient(Config(allowTailscale: true)); - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.Succeeded, result.Outcome); Assert.True(registry.GetActive()!.TrustTailscaleAuth); Assert.Equal(1, client.PatchCalls); + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled, + (await service.EnableAsync("gateway-1", client, CancellationToken.None)).Outcome); + Assert.Equal(1, client.PatchCalls); } [Fact] @@ -57,7 +147,7 @@ public async Task EnableAsync_PersistedMarkerRevalidatesLiveCoreState() registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); registry.Save(); var client = new FakeConfigClient(Config(allowTailscale: false)); - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); @@ -74,7 +164,7 @@ public async Task EnableAsync_PersistedMarkerAndLiveCoreStateReturnAlreadyEnable registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); registry.Save(); var client = new FakeConfigClient(Config(allowTailscale: true)); - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); @@ -91,7 +181,7 @@ public async Task EnableAsync_PersistedMarkerDoesNotRequirePatchHashWhenCoreAllo registry.Update("gateway-1", current => current with { TrustTailscaleAuth = true }); registry.Save(); var client = new FakeConfigClient(Config(allowTailscale: true, includeBaseHash: false)); - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); @@ -109,7 +199,7 @@ public async Task EnableAsync_PersistedButUnappliedGrant_DoesNotReportAlreadyEna { PatchResult = new ConfigPatchResult { Ok = false, Error = "application pending" }, }; - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); @@ -123,7 +213,7 @@ public async Task EnableAsync_MissingBaseHash_FailsClosedBeforePatch() { var registry = CreateRegistry(); var client = new FakeConfigClient(Config(allowTailscale: false, includeBaseHash: false)); - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); @@ -145,7 +235,7 @@ public async Task EnableAsync_PatchRejected_LeavesRecordAndCredentialsUntouched( IsGatewayRejection = true, }, }; - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); @@ -154,21 +244,64 @@ public async Task EnableAsync_PatchRejected_LeavesRecordAndCredentialsUntouched( Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); } - [Fact] - public async Task EnableAsync_AmbiguousPatchFailure_PreservesMarkerForRevalidation() + [Theory] + [InlineData(false, "timeout")] + [InlineData(false, "exception")] + [InlineData(false, "rejection")] + [InlineData(true, "timeout")] + [InlineData(true, "exception")] + [InlineData(true, "rejection")] + public async Task EnableAsync_UnconfirmedPatch_PreservesExistingTrustAndNewOptInRetry( + bool previouslyTrusted, string failure) { var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = previouslyTrusted }); + registry.Save(); + var originalRegistry = File.ReadAllText(_temp.Combine("gateways.json")); var client = new FakeConfigClient(Config(allowTailscale: false)) { - PatchResult = new ConfigPatchResult { Ok = false, Error = "request timed out" }, + PatchResult = new ConfigPatchResult + { + Ok = false, + Error = "unconfirmed patch", + IsGatewayRejection = failure == "rejection", + }, + PatchError = failure == "exception" ? new IOException("response lost") : null, }; - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, result.Outcome); - Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(previouslyTrusted, registry.GetActive()!.TrustTailscaleAuth); Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); + Assert.Equal(originalRegistry, File.ReadAllText(_temp.Combine("gateways.json"))); + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.Equal(!previouslyTrusted, GatewayTailscaleAuthUpgradePolicy.CanOffer(reloaded.GetActive())); + Assert.Equal(previouslyTrusted, reloaded.GetActive()!.TrustTailscaleAuth); + } + + [Theory] + [InlineData(false)] + [InlineData(true)] + public async Task EnableAsync_ConfigTimeoutBeforeDispatchPreservesRetryAndTrust(bool previouslyTrusted) + { + var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = previouslyTrusted }); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: false)) + { + ConfigError = new TimeoutException("config read timed out"), + }; + var result = await CreateReadyService(registry).EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable, result.Outcome); + Assert.Equal(0, client.PatchCalls); + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.Equal(previouslyTrusted, reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal(!previouslyTrusted, GatewayTailscaleAuthUpgradePolicy.CanOffer(reloaded.GetActive())); } [Theory] @@ -199,16 +332,25 @@ public async Task EnableAsync_WithoutAdminScope_DoesNotRequestPatchOrPersistMark [Fact] public async Task EnableAsync_SaveFailure_RestoresInMemoryMarker() { - var registry = CreateRegistry(new FailingWriteFileSystem()); + var registry = CreateRegistry(new FailOnSecondWriteFileSystem()); + registry.Save(); var client = new FakeConfigClient(Config(allowTailscale: true)); - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, result.Outcome); Assert.False(registry.GetActive()!.TrustTailscaleAuth); Assert.Equal("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); - Assert.Equal(0, client.PatchCalls); + Assert.Equal(1, client.PatchCalls); + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.True(GatewayTailscaleAuthUpgradePolicy.CanOffer(reloaded.GetActive())); + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.Succeeded, + (await service.EnableAsync("gateway-1", client, CancellationToken.None)).Outcome); + reloaded.Load(); + Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal(2, client.PatchCalls); } [Fact] @@ -291,14 +433,14 @@ public async Task EnableAsync_UsesResolvedSourceAndPreservesCoreCasHash() using var response = JsonDocument.Parse(""" { "parsed": { "gateway": { "auth": { "allowTailscale": true } } }, - "sourceConfig": { "gateway": { "auth": { "allowTailscale": false } } }, + "sourceConfig": { "gateway": { "auth": { "allowTailscale": false }, "tailscale": { "mode": "serve" } } }, "hash": "root-and-includes-cas", "configRevisionHash": "revision-new", "appliedConfigHash": "revision-new" } """); var client = new FakeConfigClient(response.RootElement.Clone()); - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); @@ -363,22 +505,26 @@ public async Task RevalidateAsync_UnprovenAppliedRevision_PreservesMarkerAndCred } [Fact] - public async Task RevalidateAsync_AmbiguousAdoptionTrustsOnlyAfterAppliedRevisionConverges() + public async Task EnableAsync_AmbiguousAdoptionCanRetryAfterReloadBeforeAppliedRevisionConverges() { var registry = CreateRegistry(); + registry.Save(); var client = new FakeConfigClient(Config(allowTailscale: false)) { PatchResult = new ConfigPatchResult { Ok = false, Error = "response lost" }, }; - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, result.Outcome); var reloaded = new GatewayRegistry(_temp.Path); reloaded.Load(); - service = new GatewayTailscaleAuthUpgradeService( - reloaded, new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready)); + Assert.True(GatewayTailscaleAuthUpgradePolicy.CanOffer(reloaded.GetActive())); + service = CreateReadyService(reloaded); client.ConfigResponse = Config(allowTailscale: true, appliedRevision: "revision-old"); + client.PatchResult = new ConfigPatchResult { Ok = true }; + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.Succeeded, + (await service.EnableAsync("gateway-1", client, CancellationToken.None)).Outcome); var pending = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); client.ConfigResponse = Config(allowTailscale: true); var applied = await service.RevalidateAsync("gateway-1", client, CancellationToken.None); @@ -387,7 +533,7 @@ public async Task RevalidateAsync_AmbiguousAdoptionTrustsOnlyAfterAppliedRevisio Assert.True(applied); Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); Assert.Equal("test-token-placeholder", reloaded.GetActive()!.SharedGatewayToken); - Assert.Equal(1, client.PatchCalls); + Assert.Equal(2, client.PatchCalls); } [Fact] @@ -606,12 +752,17 @@ await Assert.ThrowsAnyAsync(() => } [Fact] - public async Task EnableAsync_CancellationAfterMarkerPersistenceRollsBackBeforeDispatch() + public async Task EnableAsync_CancellationAfterIngressProbeDoesNotPersistOrDispatch() { using var cancellation = new CancellationTokenSource(); - var registry = CreateRegistry(new CancelOnFirstWriteFileSystem(cancellation)); + var registry = CreateRegistry(); + registry.Save(); var client = new FakeConfigClient(Config(allowTailscale: false)); - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = new GatewayTailscaleAuthUpgradeService( + registry, new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready) + { + AfterVerify = cancellation.Cancel, + }); await Assert.ThrowsAnyAsync(() => service.EnableAsync("gateway-1", client, cancellation.Token)); @@ -621,106 +772,57 @@ await Assert.ThrowsAnyAsync(() => var reloaded = new GatewayRegistry(_temp.Path); reloaded.Load(); Assert.False(reloaded.GetActive()!.TrustTailscaleAuth); + Assert.True(GatewayTailscaleAuthUpgradePolicy.CanOffer(reloaded.GetActive())); } - [Fact] - public async Task EnableAsync_CancellationBeforeDispatchSurfacesRollbackPersistenceFailure() - { - using var cancellation = new CancellationTokenSource(); - var registry = CreateRegistry(new CancelThenFailRollbackFileSystem(cancellation)); - var client = new FakeConfigClient(Config(allowTailscale: false)); - var service = new GatewayTailscaleAuthUpgradeService(registry); - - var result = await service.EnableAsync("gateway-1", client, cancellation.Token); - - Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, result.Outcome); - Assert.Contains("trust-marker rollback failed", result.Error); - Assert.DoesNotContain("Core rejected", result.Error); - Assert.Equal(0, client.PatchCalls); - var reloaded = new GatewayRegistry(_temp.Path); - reloaded.Load(); - Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); - } - - [Fact] - public async Task EnableAsync_CancellationDuringPatchPreservesMarkerForRevalidation() + [Theory] + [InlineData(false, "accepted")] + [InlineData(false, "rejected")] + [InlineData(false, "unknown")] + [InlineData(false, "exception")] + [InlineData(true, "accepted")] + [InlineData(true, "rejected")] + [InlineData(true, "unknown")] + [InlineData(true, "exception")] + public async Task EnableAsync_CancellationDuringPatchDrainsWithoutChangingTrust( + bool previouslyTrusted, string completion) { using var cancellation = new CancellationTokenSource(); var registry = CreateRegistry(); + registry.Update("gateway-1", current => current with { TrustTailscaleAuth = previouslyTrusted }); + registry.Save(); + var originalRegistry = File.ReadAllText(_temp.Combine("gateways.json")); var patchCompletion = new TaskCompletionSource( TaskCreationOptions.RunContinuationsAsynchronously); var client = new FakeConfigClient(Config(allowTailscale: false)) { PatchCompletion = patchCompletion, }; - var service = new GatewayTailscaleAuthUpgradeService(registry); + var service = CreateReadyService(registry); var enableTask = service.EnableAsync("gateway-1", client, cancellation.Token); await client.PatchStarted.Task.WaitAsync(TimeSpan.FromSeconds(1)); cancellation.Cancel(); Assert.False(enableTask.IsCompleted); - patchCompletion.SetResult(new ConfigPatchResult { Ok = true }); + Assert.Equal(originalRegistry, File.ReadAllText(_temp.Combine("gateways.json"))); + if (completion == "exception") + patchCompletion.SetException(new IOException("response lost")); + else + patchCompletion.SetResult(new ConfigPatchResult + { + Ok = completion == "accepted", + IsGatewayRejection = completion == "rejected", + }); await Assert.ThrowsAnyAsync(() => enableTask); - Assert.True(registry.GetActive()!.TrustTailscaleAuth); + Assert.True(patchCompletion.Task.IsCompleted); + Assert.Equal(previouslyTrusted, registry.GetActive()!.TrustTailscaleAuth); Assert.Equal(1, client.PatchCalls); - } - - [Fact] - public async Task EnableAsync_CancellationDuringPatchRollsBackDefinitiveGatewayRejection() - { - using var cancellation = new CancellationTokenSource(); - var registry = CreateRegistry(); - var patchCompletion = new TaskCompletionSource( - TaskCreationOptions.RunContinuationsAsynchronously); - var client = new FakeConfigClient(Config(allowTailscale: false)) - { - PatchCompletion = patchCompletion, - }; - var service = new GatewayTailscaleAuthUpgradeService(registry); - - var enableTask = service.EnableAsync("gateway-1", client, cancellation.Token); - await client.PatchStarted.Task.WaitAsync(TimeSpan.FromSeconds(1)); - cancellation.Cancel(); - patchCompletion.SetResult(new ConfigPatchResult - { - Ok = false, - Error = "base hash mismatch", - IsGatewayRejection = true, - }); - - await Assert.ThrowsAnyAsync(() => enableTask); - Assert.False(registry.GetActive()!.TrustTailscaleAuth); - } - - [Fact] - public async Task EnableAsync_CancellationDuringPatchSurfacesRollbackPersistenceFailure() - { - using var cancellation = new CancellationTokenSource(); - var registry = CreateRegistry(new FailOnSecondWriteFileSystem()); - var patchCompletion = new TaskCompletionSource( - TaskCreationOptions.RunContinuationsAsynchronously); - var client = new FakeConfigClient(Config(allowTailscale: false)) - { - PatchCompletion = patchCompletion, - }; - var service = new GatewayTailscaleAuthUpgradeService(registry); - - var enableTask = service.EnableAsync("gateway-1", client, cancellation.Token); - await client.PatchStarted.Task.WaitAsync(TimeSpan.FromSeconds(1)); - cancellation.Cancel(); - patchCompletion.SetResult(new ConfigPatchResult - { - Ok = false, - Error = "base hash mismatch", - IsGatewayRejection = true, - }); - - var result = await enableTask; - Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, result.Outcome); + Assert.Equal(originalRegistry, File.ReadAllText(_temp.Combine("gateways.json"))); var reloaded = new GatewayRegistry(_temp.Path); reloaded.Load(); - Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal(previouslyTrusted, reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal(!previouslyTrusted, GatewayTailscaleAuthUpgradePolicy.CanOffer(reloaded.GetActive())); } [Fact] @@ -774,6 +876,9 @@ private GatewayRegistry CreateRegistry(IFileSystem? fileSystem = null) SharedGatewayToken = "test-token-placeholder", }; + private static GatewayTailscaleAuthUpgradeService CreateReadyService(GatewayRegistry registry) => + new(registry, new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready)); + private static JsonElement Config( bool allowTailscale, bool includeBaseHash = true, @@ -785,6 +890,7 @@ private static JsonElement Config( "parsed": { "gateway": { {{(includeGatewayPort ? "\"port\": 18789," : "")}} + "tailscale": { "mode": "serve" }, "auth": { "allowTailscale": {{allowTailscale.ToString().ToLowerInvariant()}} } }, "unrelated": "keep" @@ -792,6 +898,7 @@ private static JsonElement Config( "sourceConfig": { "gateway": { {{(includeGatewayPort ? "\"port\": 18789," : "")}} + "tailscale": { "mode": "serve" }, "auth": { "allowTailscale": {{allowTailscale.ToString().ToLowerInvariant()}} } }, "unrelated": "keep" @@ -862,6 +969,7 @@ private sealed class FakeConfigClient(JsonElement config) : IGatewayTailscaleAut public JsonElement? PatchedConfig { get; private set; } public ConfigPatchResult PatchResult { get; set; } = new() { Ok = true }; public Exception? ConfigError { get; set; } + public Exception? PatchError { get; set; } public bool EmitConfig { get; set; } = true; public Action? AfterConfig { get; set; } public Action? BeforePatch { get; set; } @@ -892,51 +1000,12 @@ public Task PatchConfigDetailedAsync( PatchBaseHash = baseHash; PatchedConfig = fullConfig.Clone(); PatchStarted.TrySetResult(); + if (PatchError is not null) + return Task.FromException(PatchError); return PatchCompletion?.Task ?? Task.FromResult(PatchResult); } } - private sealed class CancelOnFirstWriteFileSystem(CancellationTokenSource cancellation) : IFileSystem - { - private readonly RealFileSystem _inner = new(); - private int _writes; - - public bool FileExists(string path) => _inner.FileExists(path); - public string ReadAllText(string path) => _inner.ReadAllText(path); - public void WriteAllText(string path, string content) - { - _inner.WriteAllText(path, content); - if (Interlocked.Increment(ref _writes) == 1) - cancellation.Cancel(); - } - public void CreateDirectory(string path) => _inner.CreateDirectory(path); - public bool DirectoryExists(string path) => _inner.DirectoryExists(path); - public void CopyFile(string source, string destination, bool overwrite) => - _inner.CopyFile(source, destination, overwrite); - public void DeleteFile(string path) => _inner.DeleteFile(path); - } - - private sealed class CancelThenFailRollbackFileSystem(CancellationTokenSource cancellation) : IFileSystem - { - private readonly RealFileSystem _inner = new(); - private int _writes; - - public bool FileExists(string path) => _inner.FileExists(path); - public string ReadAllText(string path) => _inner.ReadAllText(path); - public void WriteAllText(string path, string content) - { - if (Interlocked.Increment(ref _writes) == 2) - throw new IOException("rollback write failed"); - _inner.WriteAllText(path, content); - cancellation.Cancel(); - } - public void CreateDirectory(string path) => _inner.CreateDirectory(path); - public bool DirectoryExists(string path) => _inner.DirectoryExists(path); - public void CopyFile(string source, string destination, bool overwrite) => - _inner.CopyFile(source, destination, overwrite); - public void DeleteFile(string path) => _inner.DeleteFile(path); - } - private sealed class FailOnSecondWriteFileSystem : IFileSystem { private readonly RealFileSystem _inner = new(); @@ -947,7 +1016,7 @@ private sealed class FailOnSecondWriteFileSystem : IFileSystem public void WriteAllText(string path, string content) { if (Interlocked.Increment(ref _writes) == 2) - throw new IOException("rollback write failed"); + throw new IOException("trust-marker write failed"); _inner.WriteAllText(path, content); } public void CreateDirectory(string path) => _inner.CreateDirectory(path); @@ -957,17 +1026,6 @@ public void CopyFile(string source, string destination, bool overwrite) => public void DeleteFile(string path) => _inner.DeleteFile(path); } - private sealed class FailingWriteFileSystem : IFileSystem - { - public bool FileExists(string path) => false; - public string ReadAllText(string path) => throw new NotSupportedException(); - public void WriteAllText(string path, string content) => throw new IOException("write failed"); - public void CreateDirectory(string path) { } - public bool DirectoryExists(string path) => true; - public void CopyFile(string source, string destination, bool overwrite) => throw new NotSupportedException(); - public void DeleteFile(string path) { } - } - private sealed class FakeLiveVerifier : IGatewayTailscaleAuthLiveVerifier { private readonly Queue _results; @@ -976,6 +1034,7 @@ private sealed class FakeLiveVerifier : IGatewayTailscaleAuthLiveVerifier public int Calls { get; private set; } public int? LastGatewayPort { get; private set; } + public Action? AfterVerify { get; init; } public Task VerifyAsync( GatewayRecord record, @@ -986,6 +1045,7 @@ public Task VerifyAsync( LastGatewayPort = gatewayPort; cancellationToken.ThrowIfCancellationRequested(); var result = _results.Count > 1 ? _results.Dequeue() : _results.Peek(); + AfterVerify?.Invoke(); return result switch { GatewayTailscaleAuthLiveState state => Task.FromResult(state), @@ -994,4 +1054,32 @@ public Task VerifyAsync( }; } } + + private sealed class BackgroundServeCommandRunner : IWslCommandRunner + { + public Task RunAsync( + IReadOnlyList arguments, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) + { + Assert.Equal(["-d", "OpenClawGateway", "--user", "root", "--"], arguments.Take(5)); + return Task.FromResult(new WslCommandResult(0, arguments.Contains("serve") + ? """{"Web":{"openclaw-host.tail1234.ts.net:443":{"Handlers":{"/":{"Proxy":"http://127.0.0.1:18789"}}}}}""" + : """{"BackendState":"Running","Self":{"DNSName":"openclaw-host.tail1234.ts.net."}}""", "")); + } + + public Task RunInDistroAsync( + string name, IReadOnlyList command, CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null, string? standardInput = null) => + throw new NotSupportedException(); + + public Task> ListDistrosAsync( + CancellationToken cancellationToken = default) => throw new NotSupportedException(); + + public Task TerminateDistroAsync( + string name, CancellationToken cancellationToken = default) => throw new NotSupportedException(); + + public Task UnregisterDistroAsync( + string name, CancellationToken cancellationToken = default) => throw new NotSupportedException(); + } } diff --git a/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs b/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs index adffa6b95a..f81ad57454 100644 --- a/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs +++ b/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs @@ -765,6 +765,7 @@ public async Task ExternalLike_QrOnlyFreshTray_RequiresExplicitDeviceApproval() var dashboard = dashboardDoc.RootElement; var dashboardUrl = dashboard.GetProperty("url").GetString(); Assert.NotNull(dashboardUrl); + Assert.Equal("record.BootstrapToken", dashboard.GetProperty("credentialSource").GetString()); Assert.False(dashboard.GetProperty("usesSharedGatewayToken").GetBoolean()); Assert.False(dashboard.GetProperty("hasTokenQuery").GetBoolean()); Assert.DoesNotContain("token=", dashboardUrl, StringComparison.OrdinalIgnoreCase); diff --git a/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs b/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs index c1e2612837..39d84212a0 100644 --- a/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs +++ b/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs @@ -520,6 +520,25 @@ public void DashboardLinkPolicy_StaysDelegatedToFocusedService() Assert.DoesNotContain("GatewayDashboardUrlBuilder.Build(", source); } + [Fact] + public void DashboardUrlResponse_ReportsEmittedCredentialWithoutChangingProvenance() + { + var source = ReadAppSources(); + var start = source.IndexOf("app.DashboardUrlHandler = async (path) =>", StringComparison.Ordinal); + Assert.True(start >= 0); + var end = source.IndexOf("app.ChatSnapshotHandler", start, StringComparison.Ordinal); + Assert.True(end > start); + var handler = source[start..end]; + + // Retire with mounted handler coverage that does not start real app services. + Assert.Contains("TryResolveChatCredentials(out var gatewayUrl, out var dashboardCredential, out var credentialSource, out var isBootstrapToken)", handler); + Assert.Contains("!isBootstrapToken && credentialSource == CredentialResolver.SourceSharedGatewayToken", handler); + AssertInOrder(handler, "new GatewayDashboardLinkRequest(", "dashboardCredential,", "usesSharedCredential,", "tailscaleGatewayId)"); + Assert.Contains("usesSharedGatewayToken = result.BrowserCredentialIncluded", handler); + AssertInOrder(handler, "var url = result.Url!;", "url,", "credentialSource,", "usesSharedGatewayToken = result.BrowserCredentialIncluded"); + Assert.DoesNotContain("usesSharedGatewayToken = !isBootstrapToken", handler); + } + [Fact] public void SshTunnelExit_RecoversActiveRegistryGatewayThroughConnectionManager() { diff --git a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs index 071a673f09..eece340610 100644 --- a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs +++ b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs @@ -27,6 +27,9 @@ public void FailedDashboardAuth_UsesLocalizedRecoveryOutcomeInsteadOfRawDetails( Assert.Contains("ConnectionPagePlan.TailscaleAuthFailureMessageResourceKey(result.Outcome)", method); Assert.DoesNotContain("result.Error", method); Assert.DoesNotContain("result.Outcome.ToString()", method); + Assert.Contains("result.Outcome == GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled", method); + Assert.Contains("? \"ConnectionPage_TailscaleDashboardAuthEnabled\"", method); + Assert.Contains(": \"ConnectionPage_TailscaleDashboardAuthAccepted\"", method); } [Theory] @@ -37,12 +40,34 @@ public void FailedDashboardAuth_UsesLocalizedRecoveryOutcomeInsteadOfRawDetails( [InlineData(GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable, "ConnectionPage_TailscaleDashboardAuthFailureConfigUnavailable")] [InlineData(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, "ConnectionPage_TailscaleDashboardAuthFailurePatchRejected")] [InlineData(GatewayTailscaleAuthUpgradeOutcome.PersistenceFailed, "ConnectionPage_TailscaleDashboardAuthFailurePersistenceFailed")] + [InlineData(GatewayTailscaleAuthUpgradeOutcome.UnsupportedTopology, "ConnectionPage_TailscaleDashboardAuthFailureUnsupportedTopology")] + [InlineData(GatewayTailscaleAuthUpgradeOutcome.IngressNotReady, "ConnectionPage_TailscaleDashboardAuthFailureIngressNotReady")] [InlineData(GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled, "ConnectionPage_TailscaleDashboardAuthFailureGeneric")] public void TailscaleDashboardAuthFailure_MapsOutcomeToLocalizedRecoveryMessage( GatewayTailscaleAuthUpgradeOutcome outcome, string expectedResourceKey) => Assert.Equal(expectedResourceKey, ConnectionPagePlan.TailscaleAuthFailureMessageResourceKey(outcome)); + [Fact] + public void EnableDashboardAuth_UsesLiveVerifierAndOfferPolicyWithoutPageOwnedMutation() + { + var root = TestRepositoryPaths.GetRepositoryRoot(); + var manager = File.ReadAllText(Path.Combine(root, "src", "OpenClaw.Connection", "GatewayConnectionManager.cs")); + var start = manager.IndexOf("public async Task EnableTailscaleDashboardAuthAsync(", StringComparison.Ordinal); + var end = manager.IndexOf("public async Task RevalidateTailscaleDashboardAuthAsync(", start, StringComparison.Ordinal); + Assert.True(start >= 0 && end > start); + var enable = manager[start..end]; + Assert.Contains("new GatewayTailscaleAuthUpgradeService(\n", enable.Replace("\r", "")); + Assert.Contains("_tailscaleAuthLiveVerifier);", enable); + Assert.Contains("_transitionSemaphore.WaitAsync(cancellationToken)", enable); + Assert.Contains("_transitionSemaphore.Release();", enable); + + var page = File.ReadAllText(Path.Combine(root, "src", "OpenClaw.Tray.WinUI", "Pages", "ConnectionPage.xaml.cs")); + Assert.Contains("row.IsActive && GatewayTailscaleAuthUpgradePolicy.CanOffer(gatewayRecord)", page); + Assert.Contains("enableTailscaleAuth.Click += OnEnableTailscaleDashboardAuth;", page); + Assert.DoesNotContain("TrustTailscaleAuth = true", page); + } + [Fact] public void SavedDashboardLaunch_DelegatesToSharedDashboardLinkService() { diff --git a/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs index 1368b31442..6012ebb5ef 100644 --- a/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs +++ b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs @@ -107,6 +107,7 @@ public async Task BuildAsync_TokenFreeBootstrapRequest_PreservesDashboardUrl() var service = CreateService((_, _) => Task.FromResult(false)); var result = await service.BuildAsync(Request( + browserCredential: "bootstrap-do-not-export", appendBrowserCredential: false, tailscaleGatewayId: null)); @@ -116,6 +117,45 @@ public async Task BuildAsync_TokenFreeBootstrapRequest_PreservesDashboardUrl() Assert.DoesNotContain("token=", result.Url); } + [Theory] + [InlineData("shared", true, "record.SharedGatewayToken", false)] + [InlineData("shared", false, "record.SharedGatewayToken", true)] + [InlineData("bootstrap", false, "record.BootstrapToken", false)] + public async Task BuildAsync_ResolvedCredentialProvenanceDoesNotImplyBrowserInclusion( + string credentialKind, bool identityReady, string expectedSource, bool expectedInclusion) + { + using var data = new TempDirectory(); + var registry = new GatewayRegistry(data.Path); + var record = new GatewayRecord + { + Id = "gateway-1", + Url = "wss://host.tail1234.ts.net", + SharedGatewayToken = credentialKind == "shared" ? "shared-token" : null, + BootstrapToken = credentialKind == "bootstrap" ? "bootstrap-do-not-export" : null, + TrustTailscaleAuth = credentialKind == "shared", + }; + registry.AddOrUpdate(record); + registry.SetActive(record.Id); + Assert.True(InteractiveGatewayCredentialResolver.TryResolve( + registry, data.Path, DeviceIdentityFileReader.Instance, record.Url, null, null, out var credential)); + Assert.NotNull(credential); + Assert.Equal(expectedSource, credential.Source); + var service = CreateService((_, _) => Task.FromResult(identityReady)); + + var result = await service.BuildAsync(new GatewayDashboardLinkRequest( + credential.GatewayUrl, null, credential.Token, + !credential.IsBootstrapToken && credential.Source == CredentialResolver.SourceSharedGatewayToken, + record.TrustTailscaleAuth ? record.Id : null)); + + Assert.True(result.Success); + Assert.Equal(identityReady, result.TrustTailscaleAuth); + Assert.Equal(expectedInclusion, result.BrowserCredentialIncluded); + Assert.Equal(expectedInclusion + ? "https://host.tail1234.ts.net#token=shared-token" + : "https://host.tail1234.ts.net", result.Url); + Assert.DoesNotContain("bootstrap-do-not-export", result.Url); + } + [Fact] public async Task BuildAsync_TrustedTailscaleAuthStripsEmbeddedTokenFragment() { From 454bb5d82923f862151c4210bc31213fa7f7446b Mon Sep 17 00:00:00 2001 From: "bakudies@microsoft.com" Date: Tue, 20 Oct 2026 09:11:54 -0700 Subject: [PATCH 28/38] test(shared): preserve typed rejection after main integration Keep chat acknowledgement rejection coverage unchanged and require the typed Gateway rejection for the newly merged context-usage fixture's response-aware sessions.reset call. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs index b4f58c9866..d20c47195e 100644 --- a/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs +++ b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs @@ -173,7 +173,7 @@ public async Task ContextUsageScenario_RealClientReceivesStrictPromptsReplayHist await server.NotifySessionsChangedAsync(deadline.Token); await refreshed.Task.WaitAsync(deadline.Token); await Assert.ThrowsAsync(() => client.SendChatMessageForRunAsync(ContextUsageFixture.SecondPrompt, ContextUsageFixture.SessionKey)); - await Assert.ThrowsAsync(() => client.SendWizardRequestAsync("sessions.reset", new { key = ContextUsageFixture.SessionKey })); + await Assert.ThrowsAsync(() => client.SendWizardRequestAsync("sessions.reset", new { key = ContextUsageFixture.SessionKey })); Assert.Empty(server.UnexpectedRequests); static JsonElement UsageRow(JsonElement listing) => listing.GetProperty("sessions").EnumerateArray() From 368584f4d22ffd3c851cc7b3eb33a6c8118ff4a8 Mon Sep 17 00:00:00 2001 From: "bakudies@microsoft.com" Date: Tue, 20 Oct 2026 09:40:58 -0700 Subject: [PATCH 29/38] test(connection): avoid MSYS overhead in ownership fixtures Use Bash built-in reads for synthetic listener and executable files instead of repeatedly launching cat. Preserve unreadable-file failure, privileged-access checks, every ownership assertion and the unchanged five-second verifier deadline. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../GatewayTailscaleAuthLiveVerifierTests.cs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs index 94e32b3196..d02bb097d1 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -828,11 +828,13 @@ public async Task RunAsync( var root = _root.Replace('\\', '/'); if (OperatingSystem.IsWindows()) root = "/" + char.ToLowerInvariant(root[0]) + root[2..]; + // Synthetic file reads do not need repeated MSYS process launches. + // Keep the real verifier deadline and ownership assertions unchanged. var fixtureScript = "fixture_proc='" + root.Replace("'", "'\\''") + "'\n" + "fixture_systemctl() { printf 101; }\n" + - "fixture_ss() { /usr/bin/cat \"$fixture_proc/listeners\"; }\n" + + "fixture_ss() { test -r \"$fixture_proc/listeners\" || return 1; printf '%s\\n' \"$(< \"$fixture_proc/listeners\")\"; }\n" + "fixture_privileged=" + (privilegedInspection ? "yes" : "no") + "\n" + - "fixture_readlink() { if test -f \"$fixture_proc/privileged\" && test \"$fixture_privileged\" != yes; then case \"$1\" in */103/exe|*/104/exe) return 1;; esac; fi; /usr/bin/cat \"$1\"; }\n" + + "fixture_readlink() { if test -f \"$fixture_proc/privileged\" && test \"$fixture_privileged\" != yes; then case \"$1\" in */103/exe|*/104/exe) return 1;; esac; fi; test -r \"$1\" || return 1; printf '%s' \"$(< \"$1\")\"; }\n" + script.Replace("for proc in /proc/[0-9]*; do", "for proc in \"$fixture_proc\"/[0-9]*; do", StringComparison.Ordinal) .Replace("/proc/", "$fixture_proc/", StringComparison.Ordinal) .Replace("/usr/bin/systemctl", "fixture_systemctl", StringComparison.Ordinal) From 857f74b5f0c8ffa4585a2c1dbdd7f452d0661820 Mon Sep 17 00:00:00 2001 From: TheAngryPit <16145902+TheAngryPit@users.noreply.github.com> Date: Tue, 20 Oct 2026 17:42:12 +0100 Subject: [PATCH 30/38] test: diagnose approval watcher and UI bootstrap failures Capture synthetic event details only on the existing failed predicate and split the existing WinRT/bootstrap phase. Preserve assertions, wait budgets, authority and product behavior. Validation: DevBuild; Shared 4486 passed, 36 skipped; Tray 4318 passed; affected native UI 20 passed. Whole-file whitespace verification reports eight unchanged baseline lines. Hosted failure causes remain unestablished. --- .../ExecApprovalsStoreTests.cs | 20 ++++++++++++++++--- .../OpenClaw.Tray.UITests/UIThreadFixture.cs | 7 +++++-- 2 files changed, 22 insertions(+), 5 deletions(-) diff --git a/tests/OpenClaw.Shared.Tests/ExecApprovalsStoreTests.cs b/tests/OpenClaw.Shared.Tests/ExecApprovalsStoreTests.cs index 4a068f602a..765c3c91bf 100644 --- a/tests/OpenClaw.Shared.Tests/ExecApprovalsStoreTests.cs +++ b/tests/OpenClaw.Shared.Tests/ExecApprovalsStoreTests.cs @@ -1617,7 +1617,16 @@ public async Task Changed_ReactivateAfterUnobservedEdit_DoesNotSuppressRevertToP WriteAtomically(FilePath, originalJson); - await WaitForConditionAsync(() => changes.Count == 1, "Expected the reverted external update event."); + await WaitForConditionAsync( + () => changes.Count == 1, + "Expected the reverted external update event.", + failureDetails: () => + { + var observed = changes.ToArray(); + return $"originalHash={Hash(originalJson)}; reactivatedHash={reactivated.Snapshot?.Hash}; " + + $"eventCount={observed.Length}; " + + $"events={JsonSerializer.Serialize(observed.Select(change => new { change.Sequence, change.Kind, change.Hash }))}"; + }); await Task.Delay(250); var change = Assert.Single(changes); @@ -1823,7 +1832,11 @@ private static void WriteAtomically(string filePath, string json) File.Move(tempPath, filePath, overwrite: true); } - private static async Task WaitForConditionAsync(Func condition, string message, int timeoutMs = 5000) + private static async Task WaitForConditionAsync( + Func condition, + string message, + int timeoutMs = 5000, + Func? failureDetails = null) { var deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs); while (DateTime.UtcNow < deadline) @@ -1836,7 +1849,8 @@ private static async Task WaitForConditionAsync(Func condition, string mes await Task.Delay(50); } - Assert.True(condition(), message); + var satisfied = condition(); + Assert.True(satisfied, satisfied || failureDetails is null ? message : $"{message} {failureDetails()}"); } } diff --git a/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs b/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs index d60a264d76..d6f75c449e 100644 --- a/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs +++ b/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs @@ -99,7 +99,9 @@ public UIThreadFixture() { var threadState = _uiThread.IsAlive ? _uiThread.ThreadState.ToString() : "stopped"; throw new InvalidOperationException( - $"UIThreadFixture failed to initialize within {timeoutSeconds}s; phase='{_startupPhase}', threadState='{threadState}'"); + $"UIThreadFixture failed to initialize within {timeoutSeconds}s; phase='{_startupPhase}', " + + $"threadState='{threadState}', callerManagedThreadId={Environment.CurrentManagedThreadId}, " + + $"uiManagedThreadId={_uiThread.ManagedThreadId}"); } if (_startupError != null) @@ -204,10 +206,11 @@ private void UIThreadProc() { OnboardingNativeProof.InitializeProductProcessDpi(); OnboardingNativeProof.TraceDpiContext("UIThreadProc: before bootstrap"); - _startupPhase = "initializing Windows App SDK bootstrap"; + _startupPhase = "initializing WinRT COM wrappers"; WinRT.ComWrappersSupport.InitializeComWrappers(); // Initialize WinAppSDK runtime (unpackaged process). + _startupPhase = "initializing Windows App SDK bootstrap"; if (Interlocked.Exchange(ref s_bootstrapInitialized, 1) == 0) { Bootstrap.Initialize(WinAppSdkMajorMinor, WinAppSdkVersionTag); From 50ce3d649269d520a84ea55f7b290fdef9b1aa96 Mon Sep 17 00:00:00 2001 From: Vitor Cepeda Lopes <7040636+TheAngryPit@users.noreply.github.com> Date: Wed, 21 Oct 2026 01:21:20 +0100 Subject: [PATCH 31/38] test(ui): record OCR failure phase diagnostics Record credential-free failure phase, timing and runtime metadata without changing OCR deadlines, label checks or fallback behavior. Preserve the original exception if diagnostics fail. The independent P0-P3 review and UI-test project build passed. Full product build and all 4486 Tray tests passed. Shared retained one symlink-privilege setup failure before assertions and 26 explicit skips. The historical OCR cancellation cause and native authorization and upgrade proof remain open. --- .../OnboardingNativeProof.cs | 201 ++++++++++++++---- 1 file changed, 159 insertions(+), 42 deletions(-) diff --git a/tests/OpenClaw.Tray.UITests/OnboardingNativeProof.cs b/tests/OpenClaw.Tray.UITests/OnboardingNativeProof.cs index 2ab970a791..92f227176e 100644 --- a/tests/OpenClaw.Tray.UITests/OnboardingNativeProof.cs +++ b/tests/OpenClaw.Tray.UITests/OnboardingNativeProof.cs @@ -472,7 +472,7 @@ internal static async Task CaptureAsync(Window window, string name, ITest var path = Path.Combine(directory, $"{name}.png"); bitmap.Save(path, System.Drawing.Imaging.ImageFormat.Png); var sha = Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(path))); - var ocr = await AssertLabelsAsync(path, requiredLabels); + var ocr = await CaptureLabelEvidenceAsync(path, requiredLabels); var manualLabelEvidence = ocr.MissingLabels.Length == 0 ? [] : await ReadExactVisibleLabelEvidenceAsync(handle, bounds, ocr.MissingLabels); var metadata = new @@ -710,49 +710,166 @@ private static Task ReadExactVisibleLabelEvidenceAsync( }).ToArray(); }); - private static async Task AssertLabelsAsync(string path, string[] labels) + private static async Task CaptureLabelEvidenceAsync(string path, string[] labels) { - var engine = Windows.Media.Ocr.OcrEngine.TryCreateFromLanguage(new Windows.Globalization.Language("en-US")) - ?? throw new InvalidOperationException("English Windows OCR is required for native-window proof."); - var file = await Windows.Storage.StorageFile.GetFileFromPathAsync(path); - using var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); - var decoder = await BitmapDecoder.CreateAsync(stream); static string Normalize(string text) => string.Concat(text.Where(char.IsLetterOrDigit)).ToLowerInvariant(); - using var originalBitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore); - using var originalTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(3)); - var original = await engine.RecognizeAsync(originalBitmap).AsTask(originalTimeout.Token); - if (labels.All(label => Normalize(original.Text).Contains(Normalize(label), StringComparison.Ordinal))) - return new(original.Text, original.Text, 1, decoder.PixelWidth, decoder.PixelHeight, - decoder.PixelWidth, decoder.PixelHeight, []); - // OCR operates on the entire immutable capture at a bounded analysis resolution. - // One higher-resolution analysis pass, never iterative label/geometry polling. - // Retain the original PNG; do not recolor, crop or relax expected labels. - var max = Windows.Media.Ocr.OcrEngine.MaxImageDimension; - var factor = Math.Min(2d, (double)max / Math.Max(decoder.PixelWidth, decoder.PixelHeight)); - var transform = new BitmapTransform - { - ScaledWidth = (uint)Math.Max(1, Math.Round(decoder.PixelWidth * factor)), - ScaledHeight = (uint)Math.Max(1, Math.Round(decoder.PixelHeight * factor)), - InterpolationMode = BitmapInterpolationMode.Cubic, - }; - using var bitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, - transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); - using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(3)); - var result = await engine.RecognizeAsync(bitmap).AsTask(timeout.Token); - var missing = labels.Where(label => !Normalize(result.Text).Contains(Normalize(label), StringComparison.Ordinal)).ToArray(); - File.WriteAllText(Path.ChangeExtension(path, ".ocr.json"), JsonSerializer.Serialize(new - { - image = path, sha256 = Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(path))), - requiredLabels = labels, originalText = original.Text, scaledText = result.Text, - missingLabels = missing, factor, - }, new JsonSerializerOptions { WriteIndented = true })); - // Coordinator-approved evidence split only for the two documented capital-I/l - // ambiguities. Never substitute text or call OCR successful; human pixel review - // and exact visible HWND-scoped native labels are both still required. - foreach (var label in missing) - Assert.Contains(label, new[] { "Connect your AI", "Local AI on this PC" }); - return new(original.Text, result.Text, factor, decoder.PixelWidth, decoder.PixelHeight, - transform.ScaledWidth, transform.ScaledHeight, missing); + static object? Optional(Func read) + { + try { return read(); } + catch { return null; } + } + object? ReadRecognitionAdmissionContext() + { + try + { + return new + { + managedThreadId = Optional(() => Environment.CurrentManagedThreadId), + apartment = Optional(() => System.Threading.Thread.CurrentThread.GetApartmentState().ToString()), + synchronizationContext = Optional(() => System.Threading.SynchronizationContext.Current?.GetType().FullName), + }; + } + catch { return null; } + } + + var started = Stopwatch.GetTimestamp(); + var phase = "create-engine"; + var pass = 0; + uint? imageWidth = null; + uint? imageHeight = null; + uint? recognitionWidth = null; + uint? recognitionHeight = null; + int? timeoutRequestedMilliseconds = null; + CancellationToken? activeToken = null; + Task? recognitionTask = null; + long? recognitionStartedTicks = null; + object? recognitionAdmissionContext = null; + try + { + var engine = Windows.Media.Ocr.OcrEngine.TryCreateFromLanguage(new Windows.Globalization.Language("en-US")) + ?? throw new InvalidOperationException("English Windows OCR is required for native-window proof."); + phase = "open-image"; + var file = await Windows.Storage.StorageFile.GetFileFromPathAsync(path); + phase = "decode-image"; + using var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); + var decoder = await BitmapDecoder.CreateAsync(stream); + try { imageWidth = decoder.PixelWidth; } + catch { } + try { imageHeight = decoder.PixelHeight; } + catch { } + phase = "prepare-original-bitmap"; + using var originalBitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore); + recognitionWidth = imageWidth; + recognitionHeight = imageHeight; + var originalAdmissionContext = ReadRecognitionAdmissionContext(); + using var originalTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(3)); + activeToken = originalTimeout.Token; + timeoutRequestedMilliseconds = 3000; + phase = "recognize-original"; + pass = 1; + recognitionAdmissionContext = originalAdmissionContext; + try { recognitionStartedTicks = Stopwatch.GetTimestamp(); } + catch { recognitionStartedTicks = null; } + var originalTask = engine.RecognizeAsync(originalBitmap).AsTask(originalTimeout.Token); + recognitionTask = originalTask; + var original = await originalTask; + recognitionStartedTicks = null; + recognitionAdmissionContext = null; + recognitionTask = null; + activeToken = null; + timeoutRequestedMilliseconds = null; + phase = "inspect-original-result"; + if (labels.All(label => Normalize(original.Text).Contains(Normalize(label), StringComparison.Ordinal))) + return new(original.Text, original.Text, 1, decoder.PixelWidth, decoder.PixelHeight, + decoder.PixelWidth, decoder.PixelHeight, []); + phase = "prepare-scaled-bitmap"; + var max = Windows.Media.Ocr.OcrEngine.MaxImageDimension; + var factor = Math.Min(2d, (double)max / Math.Max(decoder.PixelWidth, decoder.PixelHeight)); + var transform = new BitmapTransform + { + ScaledWidth = (uint)Math.Max(1, Math.Round(decoder.PixelWidth * factor)), + ScaledHeight = (uint)Math.Max(1, Math.Round(decoder.PixelHeight * factor)), + InterpolationMode = BitmapInterpolationMode.Cubic, + }; + using var bitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, + transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); + recognitionWidth = transform.ScaledWidth; + recognitionHeight = transform.ScaledHeight; + var scaledAdmissionContext = ReadRecognitionAdmissionContext(); + using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(3)); + activeToken = timeout.Token; + timeoutRequestedMilliseconds = 3000; + phase = "recognize-scaled"; + pass = 2; + recognitionAdmissionContext = scaledAdmissionContext; + try { recognitionStartedTicks = Stopwatch.GetTimestamp(); } + catch { recognitionStartedTicks = null; } + var resultTask = engine.RecognizeAsync(bitmap).AsTask(timeout.Token); + recognitionTask = resultTask; + var result = await resultTask; + recognitionStartedTicks = null; + recognitionAdmissionContext = null; + recognitionTask = null; + activeToken = null; + timeoutRequestedMilliseconds = null; + phase = "inspect-scaled-result"; + var missing = labels.Where(label => !Normalize(result.Text).Contains(Normalize(label), StringComparison.Ordinal)).ToArray(); + phase = "write-success-evidence"; + File.WriteAllText(Path.ChangeExtension(path, ".ocr.json"), JsonSerializer.Serialize(new + { + image = path, sha256 = Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(path))), + requiredLabels = labels, originalText = original.Text, scaledText = result.Text, + missingLabels = missing, factor, + }, new JsonSerializerOptions { WriteIndented = true })); + phase = "validate-missing-labels"; + foreach (var label in missing) + Assert.Contains(label, new[] { "Connect your AI", "Local AI on this PC" }); + return new(original.Text, result.Text, factor, decoder.PixelWidth, decoder.PixelHeight, + transform.ScaledWidth, transform.ScaledHeight, missing); + } + catch (Exception exception) + { + try + { + var diagnostic = new + { + schemaVersion = 1, + image = Optional(() => Path.GetFileName(path)), + sha256 = Optional(() => Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(path)))), + phase, + elapsedMilliseconds = Optional(() => Stopwatch.GetElapsedTime(started).TotalMilliseconds), + pass, + dimensions = new + { + imageWidth, imageHeight, + recognitionWidth, recognitionHeight, + }, + timeoutRequestedMilliseconds, + cancellationTokenSourceCreated = timeoutRequestedMilliseconds.HasValue, + recognitionElapsedMilliseconds = Optional(() => recognitionStartedTicks.HasValue + ? Stopwatch.GetElapsedTime(recognitionStartedTicks.Value).TotalMilliseconds + : (double?)null), + recognitionAdmissionContext, + cancellationRequested = Optional(() => activeToken?.IsCancellationRequested), + taskStatus = Optional(() => recognitionTask?.Status.ToString()), + exceptionType = Optional(() => exception.GetType().FullName), + exceptionHResult = Optional(() => exception.HResult), + runtime = new + { + dotnet = Optional(() => Environment.Version.ToString()), + ocrAssembly = Optional(() => typeof(Windows.Media.Ocr.OcrEngine).Assembly.GetName().FullName), + bitmapAssembly = Optional(() => typeof(BitmapDecoder).Assembly.GetName().FullName), + managedThreadId = Optional(() => Environment.CurrentManagedThreadId), + apartment = Optional(() => System.Threading.Thread.CurrentThread.GetApartmentState().ToString()), + synchronizationContext = Optional(() => System.Threading.SynchronizationContext.Current?.GetType().FullName), + }, + }; + File.WriteAllText(Path.ChangeExtension(path, ".ocr-failure.json"), JsonSerializer.Serialize(diagnostic, + new JsonSerializerOptions { WriteIndented = true })); + } + catch { } + throw; + } } private static SourceIdentity ReadSourceIdentity() From 3e68ea958a100c8641e27ebb4d56f55dd29d5fec Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Fri, 30 Oct 2026 23:07:35 +0000 Subject: [PATCH 32/38] test: expect typed gateway rejections in fixtures --- tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs index 82779350f0..50917d9b2b 100644 --- a/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs +++ b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs @@ -26,7 +26,7 @@ public async Task BrowseQuestionDiscovery_ReturnsNoQuestionsWithoutEnablingInter Assert.True(result.IsSupported); Assert.Empty(result.Questions); Assert.Contains(server.Requests, request => request.Method == "question.list" && request.Outcome == "ok"); - var error = await Assert.ThrowsAsync(() => + var error = await Assert.ThrowsAsync(() => connected.Client.SendWizardRequestAsync("question.request", new { title = "Not an interactive fixture" })); Assert.Contains("Unknown fixture Gateway method", error.Message); Assert.Equal("question.request", Assert.Single(server.UnexpectedRequests).Method); @@ -54,7 +54,7 @@ public async Task PlacementCatalog_RealClientLoadsSyntheticLocalEnvironmentWitho Assert.Empty(catalog.Workspaces); foreach (var method in new[] { "projects.list", "agents.list", "environments.list" }) Assert.Contains(server.Requests, request => request.Method == method && request.Outcome == "ok"); - var error = await Assert.ThrowsAsync(() => + var error = await Assert.ThrowsAsync(() => connected.Client.SendWizardRequestAsync("projects.add", new { gitUrl = "https://example.test/fixture.git" })); Assert.Contains("read-only", error.Message); Assert.Contains(server.Requests, request => request.Method == "projects.add" && request.Outcome == "error:FIXTURE_READ_ONLY"); @@ -101,7 +101,7 @@ public async Task ReadOnlyScenarios_ListEmptyQuestionsThroughRealClient(bool nat Assert.True(result.IsSupported); Assert.Empty(result.Questions); Assert.DoesNotContain("question.resolve", scenario.ReadMethods); - var error = await Assert.ThrowsAsync(() => + var error = await Assert.ThrowsAsync(() => connected.Client.SendWizardRequestAsync("question.list", new { unexpected = true })); Assert.Contains("Unsupported fixture request parameter", error.Message); Assert.Empty(server.UnexpectedRequests); From a60d8036ae05dc80b9ce2198e31d669ea062bb31 Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Thu, 12 Nov 2026 11:53:02 +0000 Subject: [PATCH 33/38] test: reveal paginated Usage rows and diagnose Systems bounds --- .../GatewayFixtureUiTests.UsageResponsive.cs | 7 +++ .../SystemsPageProofTests.cs | 51 ++++++++++++++++++- 2 files changed, 56 insertions(+), 2 deletions(-) diff --git a/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs b/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs index 1b57275397..1bb5c82eb7 100644 --- a/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs +++ b/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs @@ -626,6 +626,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. diff --git a/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs b/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs index 7af08f3091..3bb3861054 100644 --- a/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs +++ b/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs @@ -352,8 +352,55 @@ await TestSupport.WaitForRenderedConditionAsync(() => { var details = Find(cards[0], "SystemsDetails"); var bounds = Bounds(details, cards[0]); - Assert.True(bounds.Top >= 0 && bounds.Bottom <= cards[0].ActualHeight + .5, - "Expanded contents stay inside their own bordered row."); + var detailsStayInsideRow = bounds.Top >= 0 && bounds.Bottom <= cards[0].ActualHeight + .5; + var geometryMessage = "Expanded contents stay inside their own bordered row."; + if (!detailsStayInsideRow) + { + try + { + geometryMessage += " " + + $"selectedId='{controller.State.SelectedId}', rowCount={cards.Length}, " + + $"rowId='{AutomationProperties.GetAutomationId(cards[0])}', expanded={cards[0].IsExpanded}, " + + $"detailsInRow={bounds}, rowSize={cards[0].ActualWidth:R}x{cards[0].ActualHeight:R}, " + + $"detailsSize={details.ActualWidth:R}x{details.ActualHeight:R}, " + + $"rootSize={surface.XamlRoot?.Size}, scale={surface.XamlRoot?.RasterizationScale:R}, " + + $"windowSize={ui.TestWindow.AppWindow.Size}"; + var chrome = VisualTreeHelper.GetChild(cards[0], 0) as Grid; + var clip = chrome?.Children.OfType().FirstOrDefault(element => element.Name == "ExpanderContentClip"); + var content = clip?.Child as Border; + string Describe(FrameworkElement? element) + { + if (element is null) return ""; + var automationId = AutomationProperties.GetAutomationId(element); + var transform = element.RenderTransform is CompositeTransform composite + ? $"Composite(translate={composite.TranslateX:R},{composite.TranslateY:R}, " + + $"scale={composite.ScaleX:R},{composite.ScaleY:R})" + : element.RenderTransform?.GetType().Name ?? "none"; + return $"{element.GetType().Name}(name='{element.Name}', id='{automationId}', " + + $"loaded={element.IsLoaded}, visibility={element.Visibility}, " + + $"actual={element.ActualWidth:R}x{element.ActualHeight:R}, desired={element.DesiredSize}, " + + $"opacity={element.Opacity:R}, renderTransform={transform}, " + + $"surfaceBounds={Bounds(element, surface)})"; + } + var owners = new List(); + for (DependencyObject? current = details; current is not null; current = VisualTreeHelper.GetParent(current)) + { + if (current is FrameworkElement owner) + owners.Add(Describe(owner)); + if (ReferenceEquals(current, cards[0])) + break; + } + geometryMessage += $", surface={Describe(surface)}, row={Describe(cards[0])}, " + + $"details={Describe(details)}, clip={Describe(clip)}, clipContent={Describe(content)}, " + + $"templateContentVisibility={clip?.Visibility}, " + + $"ownersFromDetailsToRow=[{string.Join(" <- ", owners)}]"; + } + catch (Exception diagnosticFailure) + { + geometryMessage += $", diagnosticError={diagnosticFailure.GetType().Name}"; + } + } + Assert.True(detailsStayInsideRow, geometryMessage); } Find(surface, "SystemsRow_node:gap-2").IsExpanded = true; await TestSupport.WaitForRenderedConditionAsync(() => controller.State.SelectedId == "node:gap-2", From efe81dd5d43b1e1941ac44d869063c4e7c3427bd Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Thu, 12 Nov 2026 15:48:54 +0000 Subject: [PATCH 34/38] fix(connection): preserve managed gateway for equivalent root URLs --- src/OpenClaw.Connection/GatewayRegistry.cs | 36 ++++++++++++ .../GatewayRegistryTests.cs | 28 ++++++++++ .../SetupCodeFlowTests.cs | 56 +++++++++++++++++++ 3 files changed, 120 insertions(+) diff --git a/src/OpenClaw.Connection/GatewayRegistry.cs b/src/OpenClaw.Connection/GatewayRegistry.cs index 77cc95d789..1e73e072ea 100644 --- a/src/OpenClaw.Connection/GatewayRegistry.cs +++ b/src/OpenClaw.Connection/GatewayRegistry.cs @@ -528,6 +528,9 @@ private static bool GatewayUrlsEquivalent(string? left, string? right) return false; } + if (AreEquivalentRootUrls(normalizedLeft, leftUri, normalizedRight, rightUri)) + return true; + return string.Equals(leftUri.Scheme, rightUri.Scheme, StringComparison.OrdinalIgnoreCase) && leftUri.Port == rightUri.Port && IsLoopbackHost(leftUri.Host) && @@ -535,6 +538,39 @@ private static bool GatewayUrlsEquivalent(string? left, string? right) string.Equals(leftUri.PathAndQuery, rightUri.PathAndQuery, StringComparison.Ordinal); } + private static bool AreEquivalentRootUrls(string leftUrl, Uri leftUri, string rightUrl, Uri rightUri) => + string.Equals(leftUri.Scheme, rightUri.Scheme, StringComparison.OrdinalIgnoreCase) && + string.Equals(leftUri.Host, rightUri.Host, StringComparison.OrdinalIgnoreCase) && + leftUri.Port == rightUri.Port && + string.Equals(leftUri.AbsolutePath, "/", StringComparison.Ordinal) && + string.Equals(rightUri.AbsolutePath, "/", StringComparison.Ordinal) && + HasRootPathSpelling(leftUrl) && + HasRootPathSpelling(rightUrl) && + string.Equals(GetQueryAndFragment(leftUrl), GetQueryAndFragment(rightUrl), StringComparison.Ordinal); + + private static bool HasRootPathSpelling(string url) + { + var schemeSeparator = url.IndexOf("://", StringComparison.Ordinal); + if (schemeSeparator < 0) + return false; + + var authorityStart = schemeSeparator + 3; + var pathOrSuffixStart = url.IndexOfAny(['/', '?', '#'], authorityStart); + if (pathOrSuffixStart < 0 || url[pathOrSuffixStart] != '/') + return true; + + var suffixStart = url.IndexOfAny(['?', '#'], pathOrSuffixStart); + var pathEnd = suffixStart < 0 ? url.Length : suffixStart; + return pathEnd == pathOrSuffixStart + 1; + } + + private static string GetQueryAndFragment(string url) + { + var authorityStart = url.IndexOf("://", StringComparison.Ordinal) + 3; + var suffixStart = url.IndexOfAny(['?', '#'], authorityStart); + return suffixStart < 0 ? string.Empty : url[suffixStart..]; + } + private static bool IsLoopbackHost(string host) => host.Equals("localhost", StringComparison.OrdinalIgnoreCase) || host.Equals("127.0.0.1", StringComparison.OrdinalIgnoreCase) || diff --git a/tests/OpenClaw.Connection.Tests/GatewayRegistryTests.cs b/tests/OpenClaw.Connection.Tests/GatewayRegistryTests.cs index b4e36292ef..6890c12e09 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayRegistryTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayRegistryTests.cs @@ -360,6 +360,34 @@ public void FindByUrl_IsCaseInsensitive() Assert.NotNull(found); } + [Theory] + [InlineData("wss://Gateway.Example.com/", "wss://gateway.example.com")] + [InlineData("wss://gateway.example.com:443/?token=a#device", "wss://gateway.example.com?token=a#device")] + public void FindByUrl_TreatsEquivalentRemoteRootPathSpellingsAsSameEndpoint(string storedUrl, string lookupUrl) + { + _registry.AddOrUpdate(MakeRecord("gw-remote", storedUrl)); + + Assert.Equal("gw-remote", _registry.FindByUrl(lookupUrl)?.Id); + Assert.Equal("gw-remote", Assert.Single(_registry.FindAllByUrl(lookupUrl)).Id); + } + + [Theory] + [InlineData("wss://gateway.example.com/?token=old", "wss://gateway.example.com?token=new")] + [InlineData("wss://gateway.example.com/?token=a", "wss://gateway.example.com?token=A")] + [InlineData("wss://gateway.example.com/#old", "wss://gateway.example.com#new")] + [InlineData("wss://gateway.example.com/#Device", "wss://gateway.example.com#device")] + [InlineData("wss://gateway.example.com:8443/", "wss://gateway.example.com")] + [InlineData("wss://gateway.example.com:8443/", "ws://gateway.example.com:8443")] + [InlineData("wss://gateway-one.example.com/", "wss://gateway-two.example.com")] + [InlineData("wss://gateway.example.com/workspace/", "wss://gateway.example.com/workspace")] + [InlineData("wss://gateway.example.com/nested/..", "wss://gateway.example.com/")] + public void FindByUrl_DoesNotMergeRootSlashUrlsAcrossEndpointBoundaries(string storedUrl, string lookupUrl) + { + _registry.AddOrUpdate(MakeRecord("gw-remote", storedUrl)); + + Assert.Null(_registry.FindByUrl(lookupUrl)); + } + [Fact] public void FindByUrl_TreatsLoopbackLocalhostAnd127AsSameGateway() { diff --git a/tests/OpenClaw.Connection.Tests/SetupCodeFlowTests.cs b/tests/OpenClaw.Connection.Tests/SetupCodeFlowTests.cs index 0a590a278d..82be952d1f 100644 --- a/tests/OpenClaw.Connection.Tests/SetupCodeFlowTests.cs +++ b/tests/OpenClaw.Connection.Tests/SetupCodeFlowTests.cs @@ -227,6 +227,62 @@ public async Task ApplySetupCode_LoopbackEquivalentUrl_PreservesExistingSharedTo manager.Dispose(); } + [Fact] + public async Task ApplySetupCode_RemoteRootSlashUrl_PreservesManagedRecordIdentityAndCredentials() + { + _registry.AddOrUpdate(new GatewayRecord + { + Id = "managed-gw", + Url = "wss://gateway.example.com/", + SharedGatewayToken = "original-shared-token", + IsLocal = true, + RequiresV2Signature = true, + SetupManagedDistroName = "Ubuntu-24.04", + TrustTailscaleAuth = true + }); + _registry.SetActive(null); + _registry.Save(); + Assert.Null(_registry.GetActive()); + + var json = """{"url":"wss://gateway.example.com","bootstrapToken":"new-boot-tok"}"""; + var code = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(json)); + var resolver = new CredentialResolver(new FakeIdentityReader()); + var factory = new RecordingClientFactory(); + var manager = new GatewayConnectionManager( + resolver, factory, _registry, NullLogger.Instance); + + var result = await manager.ApplySetupCodeAsync(code); + + Assert.Equal(SetupCodeOutcome.Success, result.Outcome); + Assert.Single(_registry.GetAll()); + var active = _registry.GetActive(); + Assert.Equal("managed-gw", active!.Id); + Assert.Equal("wss://gateway.example.com", active.Url); + Assert.Equal("original-shared-token", active.SharedGatewayToken); + Assert.Equal("new-boot-tok", active.BootstrapToken); + Assert.True(active.IsLocal); + Assert.True(active.RequiresV2Signature); + Assert.Equal("Ubuntu-24.04", active.SetupManagedDistroName); + Assert.True(active.TrustTailscaleAuth); + Assert.Single(factory.Calls); + Assert.Equal(_registry.GetIdentityDirectory("managed-gw"), factory.Calls[0].IdentityPath); + + var reloadedRegistry = new GatewayRegistry(_tempDir); + reloadedRegistry.Load(); + Assert.Single(reloadedRegistry.GetAll()); + Assert.Equal("managed-gw", reloadedRegistry.ActiveGatewayId); + var reloadedActive = reloadedRegistry.GetActive()!; + Assert.Equal("managed-gw", reloadedActive.Id); + Assert.Equal("original-shared-token", reloadedActive.SharedGatewayToken); + Assert.Equal("new-boot-tok", reloadedActive.BootstrapToken); + Assert.True(reloadedActive.IsLocal); + Assert.True(reloadedActive.RequiresV2Signature); + Assert.Equal("Ubuntu-24.04", reloadedActive.SetupManagedDistroName); + Assert.True(reloadedActive.TrustTailscaleAuth); + + manager.Dispose(); + } + [Fact] public async Task ApplySetupCode_InvalidCode_ReturnsError() { From 19f586b9cf91f2cc23926bdcbebe70caf96d79dd Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Fri, 13 Nov 2026 21:48:40 +0000 Subject: [PATCH 35/38] test: reconcile dashboard caller and timing guards with main --- .../GatewayConnectionManagerTests.cs | 2 +- .../GatewayTailscaleAuthUpgradeTests.cs | 6 +++++- tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs | 6 +++++- .../OpenClawGatewayClientTests.cs | 14 +++++++------- .../Presentation/HubSearchCatalogTests.cs | 9 ++++++--- 5 files changed, 24 insertions(+), 13 deletions(-) diff --git a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs index 44311deceb..06564e572f 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs @@ -3675,7 +3675,7 @@ public async Task TailscaleDashboardAuthUnsupportedTopology_RecordsOutcomeWithou await manager.ConnectAsync(gatewayId); try { - await fixture.HandshakeCompleted.WaitAsync(TimeSpan.FromSeconds(5)); + await fixture.HandshakeCompleted.WaitAsync(StepTimeout); } catch (TimeoutException ex) { diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs index 3625407bb5..53bcf975be 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs @@ -6,6 +6,10 @@ namespace OpenClaw.Connection.Tests; public sealed class GatewayTailscaleAuthUpgradeTests : IDisposable { + private static readonly TimeSpan StepTimeout = + int.TryParse(Environment.GetEnvironmentVariable("OPENCLAW_TEST_GATEWAY_STEP_TIMEOUT_SECONDS"), out var seconds) && seconds > 0 + ? TimeSpan.FromSeconds(seconds) : TimeSpan.FromSeconds(15); + private readonly TempDirectory _temp = new(); [Fact] @@ -819,7 +823,7 @@ public async Task EnableAsync_CancellationDuringPatchDrainsWithoutChangingTrust( var service = CreateReadyService(registry); var enableTask = service.EnableAsync("gateway-1", client, cancellation.Token); - await client.PatchStarted.Task.WaitAsync(TimeSpan.FromSeconds(1)); + await client.PatchStarted.Task.WaitAsync(StepTimeout); cancellation.Cancel(); Assert.False(enableTask.IsCompleted); diff --git a/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs b/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs index 980e5d93bd..d0544ab993 100644 --- a/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs +++ b/tests/OpenClaw.Shared.Tests/AppCapabilityTests.cs @@ -5,6 +5,10 @@ namespace OpenClaw.Shared.Tests; public class AppCapabilityTests { + private static readonly TimeSpan StepTimeout = + int.TryParse(Environment.GetEnvironmentVariable("OPENCLAW_TEST_GATEWAY_STEP_TIMEOUT_SECONDS"), out var seconds) && seconds > 0 + ? TimeSpan.FromSeconds(seconds) : TimeSpan.FromSeconds(15); + private static JsonElement ParseArgs(string json) { using var doc = JsonDocument.Parse(json); @@ -178,7 +182,7 @@ public async Task DashboardUrl_AwaitsAsyncHandler() }; var responseTask = cap.ExecuteAsync(req); - Assert.Equal("settings", await handlerStarted.Task.WaitAsync(TimeSpan.FromSeconds(5))); + Assert.Equal("settings", await handlerStarted.Task.WaitAsync(StepTimeout)); Assert.False(responseTask.IsCompleted); handlerResult.SetResult(new { url = expectedUrl }); diff --git a/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs b/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs index 8ae195eef2..5ebeeca903 100644 --- a/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs +++ b/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs @@ -1783,7 +1783,7 @@ public async Task PatchConfigDetailedAsync_ClassifiesGatewayRejectionAsAuthorita using var config = JsonDocument.Parse("{}"); var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 10_000); - var request = await server.ReceiveTextAsync().WaitAsync(TimeSpan.FromSeconds(2)); + var request = await server.ReceiveTextAsync().WaitAsync(StepTimeout); var requestId = ReadRequestId(request); await server.SendTextAsync(JsonSerializer.Serialize(new { @@ -1793,7 +1793,7 @@ await server.SendTextAsync(JsonSerializer.Serialize(new error = new { code = "INVALID_REQUEST", message = "patch rejected" }, })); - var result = await responseTask.WaitAsync(TimeSpan.FromSeconds(2)); + var result = await responseTask.WaitAsync(StepTimeout); Assert.False(result.Ok); Assert.True(result.IsGatewayRejection); @@ -1815,7 +1815,7 @@ public async Task PatchConfigDetailedAsync_DoesNotClassifyUnavailableAsAuthorita using var config = JsonDocument.Parse("{}"); var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 10_000); - var request = await server.ReceiveTextAsync().WaitAsync(TimeSpan.FromSeconds(2)); + var request = await server.ReceiveTextAsync().WaitAsync(StepTimeout); var requestId = ReadRequestId(request); await server.SendTextAsync(JsonSerializer.Serialize(new { @@ -1825,7 +1825,7 @@ await server.SendTextAsync(JsonSerializer.Serialize(new error = new { code = "UNAVAILABLE", message = "runtime activation failed" }, })); - var result = await responseTask.WaitAsync(TimeSpan.FromSeconds(2)); + var result = await responseTask.WaitAsync(StepTimeout); Assert.False(result.Ok); Assert.False(result.IsGatewayRejection); @@ -1847,8 +1847,8 @@ public async Task PatchConfigDetailedAsync_DoesNotClassifyTimeoutAsGatewayReject using var config = JsonDocument.Parse("{}"); var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 250); - await server.ReceiveTextAsync().WaitAsync(TimeSpan.FromSeconds(2)); - var result = await responseTask.WaitAsync(TimeSpan.FromSeconds(2)); + await server.ReceiveTextAsync().WaitAsync(StepTimeout); + var result = await responseTask.WaitAsync(StepTimeout); Assert.False(result.Ok); Assert.False(result.IsGatewayRejection); @@ -2102,7 +2102,7 @@ public async Task SendWizardRequestAsync_DeadlineExpiresWhileQueuedForSend_DoesN Assert.Equal(1, helper.GetPendingRequestCount()); var exception = await Assert.ThrowsAsync(async () => - await request.WaitAsync(TimeSpan.FromSeconds(2))); + await request.WaitAsync(StepTimeout)); Assert.Equal("Timed out sending wizard.status request", exception.Message); Assert.Equal(0, helper.GetPendingRequestCount()); diff --git a/tests/OpenClaw.Tray.Tests/Presentation/HubSearchCatalogTests.cs b/tests/OpenClaw.Tray.Tests/Presentation/HubSearchCatalogTests.cs index c7c3cdb0ec..65062988af 100644 --- a/tests/OpenClaw.Tray.Tests/Presentation/HubSearchCatalogTests.cs +++ b/tests/OpenClaw.Tray.Tests/Presentation/HubSearchCatalogTests.cs @@ -173,10 +173,13 @@ public async Task ContextualDashboardPath_ReleasedChatReachesBrowserWithExactSes { string? launched = null; var launcher = new GatewayDashboardLauncher(() => true, - () => new("wss://gateway.example/control/", "shared secret", false, - CredentialResolver.SourceSharedGatewayToken), + path => new("wss://gateway.example/control/", path, "shared secret", true), + new GatewayDashboardLinkService( + (_, _) => throw new InvalidOperationException("Unexpected Tailscale revalidation"), + key => key), url => { launched = url; return Task.FromResult(true); }, - () => throw new InvalidOperationException("Unexpected failure")); + _ => throw new InvalidOperationException("Unexpected link failure"), + _ => throw new InvalidOperationException("Unexpected launch failure")); var path = HubSearchCatalog.ContextualDashboardPath( new(WorkspacePageId.Home, sessionKey), "agent:main:main"); From 1e8d771b438dd7b0a11d5855d79f181e19e403af Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Sat, 14 Nov 2026 00:02:34 +0000 Subject: [PATCH 36/38] test: wait for native attachment and isolate ownership probe deadline --- .../GatewayTailscaleAuthLiveVerifierTests.cs | 6 +++++- tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs | 5 ++++- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs index 8f9dbcafad..ae5951ff9e 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -6,6 +6,10 @@ namespace OpenClaw.Connection.Tests; public sealed class GatewayTailscaleAuthLiveVerifierTests { + private static readonly TimeSpan StepTimeout = + int.TryParse(Environment.GetEnvironmentVariable("OPENCLAW_TEST_GATEWAY_STEP_TIMEOUT_SECONDS"), out var seconds) && seconds > 0 + ? TimeSpan.FromSeconds(seconds) : TimeSpan.FromSeconds(15); + [Theory] [MemberData(nameof(StatusResults))] public async Task VerifyAsync_ClassifiesStatusResult( @@ -254,7 +258,7 @@ public async Task VerifyAsync_ExecutesForegroundOwnershipProbe(string scenario, : command.FirstOrDefault() == "/bin/bash" ? fixture.RunAsync(runner!.StandardInputs.Single(), cancellationToken, runner.PrivilegedStandardInput) : Task.FromResult(RunningStatus())); - var verifier = new GatewayTailscaleAuthLiveVerifier(runner); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, StepTimeout); var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); diff --git a/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs b/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs index 7ab667e5e3..9b7aee18cf 100644 --- a/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs +++ b/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs @@ -2333,10 +2333,13 @@ private async Task WithPageAsync(double height, Action config var navigated = new List(); try { - await ui.RunOnUIAsync(() => + await ui.RunOnUIAsync(async () => { if (fitNativeViewport) { + await TestSupport.WaitForRenderedConditionAsync( + () => ui.Container.IsLoaded && ui.Container.XamlRoot is not null, + "Systems native viewport is attached before reading its scale"); // The suite's default 1x1 off-screen window can clip a dialog's // Cancel button out of the native focus viewport. previousWindowSize = ui.TestWindow.AppWindow.Size; From 7676549cad2f9696a3855e4654bf0f4f30b850c4 Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Sat, 14 Nov 2026 01:26:41 +0000 Subject: [PATCH 37/38] fix(connection): preserve native WSL probe time budgets --- .../GatewayTailscaleAuthUpgrade.cs | 8 +++---- .../GatewayTailscaleAuthLiveVerifierTests.cs | 21 +++++++++++++++++++ 2 files changed, 25 insertions(+), 4 deletions(-) diff --git a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs index 32147b24a8..728f85bde3 100644 --- a/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs +++ b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs @@ -106,7 +106,6 @@ Task VerifyAsync( internal sealed class GatewayTailscaleAuthLiveVerifier : IGatewayTailscaleAuthLiveVerifier { - private static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(5); private static readonly IReadOnlyList StatusCommand = ["/usr/bin/tailscale", "status", "--json"]; private static readonly IReadOnlyList ServeStatusCommand = @@ -115,14 +114,14 @@ internal sealed class GatewayTailscaleAuthLiveVerifier : IGatewayTailscaleAuthLi ["/usr/bin/systemctl", "--user", "show", "openclaw-gateway", "-p", "MainPID", "--value"]; private readonly IWslCommandRunner _commandRunner; - private readonly TimeSpan _timeout; + private readonly TimeSpan? _timeout; public GatewayTailscaleAuthLiveVerifier( IWslCommandRunner commandRunner, TimeSpan? timeout = null) { _commandRunner = commandRunner ?? throw new ArgumentNullException(nameof(commandRunner)); - _timeout = timeout ?? DefaultTimeout; + _timeout = timeout; } public async Task VerifyAsync( @@ -138,7 +137,8 @@ public async Task VerifyAsync( } using var timeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); - timeout.CancelAfter(_timeout); + if (_timeout is { } probeTimeout) + timeout.CancelAfter(probeTimeout); WslCommandResult statusResult; try diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs index ae5951ff9e..bd68e87c75 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -69,6 +69,27 @@ public async Task VerifyAsync_RunnerFailureIsUnavailable() Assert.Equal(GatewayTailscaleAuthLiveState.Unavailable, result); } + [Fact] + public async Task VerifyAsync_DefaultPreservesRunnerBudgetForHealthySlowProbes() + { + var runner = new FakeWslCommandRunner(async (_, command, cancellationToken) => + { + if (command.SequenceEqual(["/usr/bin/tailscale", "status", "--json"])) + await Task.Delay(TimeSpan.FromSeconds(5.1), cancellationToken); + return command.Contains("serve", StringComparer.Ordinal) + ? ForegroundServeStatus(proxyPort: 35225) + : command.FirstOrDefault() == "/bin/bash" + ? new WslCommandResult(0, "owned", "") + : RunningStatus(); + }); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None) + .WaitAsync(StepTimeout); + + Assert.Equal(GatewayTailscaleAuthLiveState.Ready, result); + } + [Fact] public async Task VerifyAsync_TimeoutIsUnavailable() { From 2eb343965d3606992f5da8206e4bbb065a376ba7 Mon Sep 17 00:00:00 2001 From: TheAngryPit <7040636+TheAngryPit@users.noreply.github.com> Date: Sat, 14 Nov 2026 01:57:15 +0000 Subject: [PATCH 38/38] test(connection): identify intentional probe latency --- .../GatewayTailscaleAuthLiveVerifierTests.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs index bd68e87c75..6774df551b 100644 --- a/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -75,6 +75,7 @@ public async Task VerifyAsync_DefaultPreservesRunnerBudgetForHealthySlowProbes() var runner = new FakeWslCommandRunner(async (_, command, cancellationToken) => { if (command.SequenceEqual(["/usr/bin/tailscale", "status", "--json"])) + // test-timing-exception: Deliberate probe latency crosses the former deadline; this is not a readiness wait. await Task.Delay(TimeSpan.FromSeconds(5.1), cancellationToken); return command.Contains("serve", StringComparer.Ordinal) ? ForegroundServeStatus(proxyPort: 35225)