diff --git a/.agents/skills/winnode/SKILL.md b/.agents/skills/winnode/SKILL.md index bb13dddf08..34060e892d 100644 --- a/.agents/skills/winnode/SKILL.md +++ b/.agents/skills/winnode/SKILL.md @@ -617,6 +617,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/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 53645034c1..13e2450592 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -334,6 +334,7 @@ new attempt. This boundary does not change release signing or Windows policy. | Desktop lobster quick-chat mounts and dedicated session identity | `DesktopCompanionChatHost` borrows the current app provider and owns separate retained dedicated/reply Reactor mounts, window-owned attachment picking and invocation-scoped voice-service callbacks. Notification replacement hides the mount and cancels capture without discarding its draft; late picker/capture results cannot cross hide or Gateway changes. `DesktopCompanionChatSessions` retains one confirmed or in-flight dedicated session per Gateway; closing a bubble does not repeat `sessions.create`. `ReactorChatHostExtensions` remains the shared mount owner and `OpenClawReactorChatRoot` supplies the compact layout. Chat notifications select their existing action-route session, never the main conversation as a fallback | authoritative | | Gateway/operator/node status flyout controls | `GatewayStatusContent` | 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` (Tailscale revalidation and fallback decisions) + `GatewayDashboardUrlBuilder` (URL scheme and token-fragment policy) | authoritative | | App-owned non-tray window creation, reuse, focus, theme, and lifetime | `IWindowManager` + `WindowManager`; Workspace is the only application chat host, and the never-activated runtime anchor stays hidden without shell switcher registration | authoritative | | Standalone compact chat hosting and prewarming | Removed; chat entry points use Workspace, with no hidden replacement window during background startup | closed | | Composer session picker and compact-host layout mode | Removed, including the picker-only `IsVisibleInChatPicker` helper; non-picker session filters remain. Workspace owns session selection, while actual-width observation retains responsive model/reasoning controls and transcript geometry | closed | @@ -1041,6 +1042,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 Settings, Workspace, status, setup, canvas-request, or runtime-anchor owner, nor revive the retired chat popup | 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 and browser-credential fallback decisions, plus dashboard URL scheme and token-fragment policy | GatewayDashboardLinkService (Tailscale revalidation and fallback decisions) + GatewayDashboardUrlBuilder (URL scheme validation and token-fragment construction) | 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 summaries, bounded redacted structured details, 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; preview limits do not truncate the separately bounded full-detail projection; yield continuation input stays suppressed; 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/docs/CONNECTION_ARCHITECTURE.md b/docs/CONNECTION_ARCHITECTURE.md index fb8e883f06..8a7cf90bae 100644 --- a/docs/CONNECTION_ARCHITECTURE.md +++ b/docs/CONNECTION_ARCHITECTURE.md @@ -824,6 +824,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 22768dc7a4..a5708c1cca 100644 --- a/src/OpenClaw.Connection/GatewayConnectionManager.cs +++ b/src/OpenClaw.Connection/GatewayConnectionManager.cs @@ -57,6 +57,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 INativeGatewayRuntime? _nativeGatewayRuntime; private GatewayRecord? _nativeGatewayRecord; @@ -142,6 +143,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)); _nativeGatewayRuntime = nativeGatewayRuntime; _identityStore = identityStore; _nodeConnector = nodeConnector; @@ -216,6 +219,76 @@ 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 + { + GatewayTailscaleAuthUpgradeResult result; + var client = OperatorClient; + 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, + _tailscaleAuthLiveVerifier); + result = await service.EnableAsync( + gatewayId, + new GatewayTailscaleAuthConfigClientAdapter(client), + cancellationToken) + .ConfigureAwait(false); + } + + _diagnostics.Record( + "tailscale-auth", + $"Dashboard auth upgrade: {result.Outcome}", + result.Error); + return result; + } + 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; internal async Task RequireNativeSetupClientAsync( diff --git a/src/OpenClaw.Connection/GatewayRecord.cs b/src/OpenClaw.Connection/GatewayRecord.cs index de142fc582..6fb9a7a7a5 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; } + /// + /// 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; } + /// /// Installed MSIX package family owned by the native gateway runtime. Native gateways /// are non-isolated and must never also carry a setup-managed WSL distro marker. @@ -121,6 +127,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) @@ -130,6 +137,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/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/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs new file mode 100644 index 0000000000..728f85bde3 --- /dev/null +++ b/src/OpenClaw.Connection/GatewayTailscaleAuthUpgrade.cs @@ -0,0 +1,720 @@ +using System.Globalization; +using System.Security.Cryptography; +using System.Text; +using System.Text.Json; +using OpenClaw.Shared; + +namespace OpenClaw.Connection; + +// Coordinates explicit Tailscale-auth upgrades for eligible managed Gateways. +// Usage: +// var result = await upgrade.EnableAsync(gatewayId, client, cancellationToken); +// var trusted = await upgrade.RevalidateAsync(gatewayId, client, cancellationToken); +/// Outcomes from a managed Gateway Tailscale-auth upgrade. +public enum GatewayTailscaleAuthUpgradeOutcome +{ + Succeeded, + AlreadyEnabled, + Ineligible, + NotActive, + NotConnected, + MissingConfigScope, + ConfigUnavailable, + PatchRejected, + PersistenceFailed, + UnsupportedTopology, + IngressNotReady, +} + +/// The outcome and optional diagnostic from a Tailscale-auth upgrade attempt. +public sealed record GatewayTailscaleAuthUpgradeResult( + GatewayTailscaleAuthUpgradeOutcome Outcome, + string? Error = null) +{ + /// Whether the upgrade succeeded or the requested trust was already enabled. + public bool IsSuccess => Outcome is + GatewayTailscaleAuthUpgradeOutcome.Succeeded or + GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled; +} + +/// Eligibility rules for offering a managed Gateway Tailscale-auth upgrade. +public static class GatewayTailscaleAuthUpgradePolicy +{ + /// Whether the record identifies a locally managed Tailscale Gateway. + public static bool IsEligible(GatewayRecord? record) + { + if (record is null || + !record.IsLocal || + record.SshTunnel is not null || + GatewayRecordEditing.ResolveManagedDistroName(record) is null) + { + return false; + } + + return GatewayTopologyClassifier.Classify(record.Url, useSshTunnel: false).DetectedKind == + GatewayKind.Tailscale; + } + + /// Whether the upgrade can be offered without replacing existing trust. + public static bool CanOffer(GatewayRecord? record) => + record?.TrustTailscaleAuth != true && IsEligible(record); +} + +internal interface IGatewayTailscaleAuthConfigClient +{ + IReadOnlyList GrantedOperatorScopes { get; } + bool IsConnectedToGateway { get; } + long? SessionMutationConnectionEpoch { get; } + Task RequestConfigDetailedAsync(int timeoutMs = 15000); + Task PatchConfigOnConnectionAsync( + JsonElement fullConfig, + string? baseHash, + long connectionEpoch, + int timeoutMs = 15000); +} + +internal sealed class GatewayTailscaleAuthConfigClientAdapter(IOperatorGatewayClient client) + : IGatewayTailscaleAuthConfigClient +{ + public IReadOnlyList GrantedOperatorScopes => client.GrantedOperatorScopes; + public bool IsConnectedToGateway => client.IsConnectedToGateway; + public long? SessionMutationConnectionEpoch => client.SessionMutationConnectionEpoch; + public Task RequestConfigDetailedAsync(int timeoutMs = 15000) => + client.RequestConfigDetailedAsync(timeoutMs); + public Task PatchConfigOnConnectionAsync( + JsonElement fullConfig, + string? baseHash, + long connectionEpoch, + int timeoutMs = 15000) => + client.PatchConfigOnConnectionAsync(fullConfig, baseHash, connectionEpoch, 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 IReadOnlyList StatusCommand = + ["/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; + + public GatewayTailscaleAuthLiveVerifier( + IWslCommandRunner commandRunner, + TimeSpan? timeout = null) + { + _commandRunner = commandRunner ?? throw new ArgumentNullException(nameof(commandRunner)); + _timeout = timeout; + } + + 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); + if (_timeout is { } probeTimeout) + timeout.CancelAfter(probeTimeout); + + 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; + } + + if (serveStatus.FunnelEnabled) + return GatewayTailscaleAuthLiveState.NotReady; + if (serveStatus.ForegroundProxyPort is not { } managedIngressPort) + return GatewayTailscaleAuthLiveState.NotReady; + + 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, + gatewayProcessId) + .Replace("\r", string.Empty, StringComparison.Ordinal); + 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) + { + 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 string BuildManagedIngressOwnershipScript( + int gatewayPort, + int managedIngressPort, + int gatewayProcessId) + { + var script = $$""" + 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) + 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 + 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 + 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[@]}" -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[$((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 + 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 + 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 "$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 script; + } +} + +/// Applies and revalidates Tailscale-auth trust for the active managed Gateway. +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; + } + + /// Verifies managed ingress, requests Tailscale auth, and persists accepted trust. + /// The active Gateway to upgrade. + /// The connection-bound Gateway config client. + /// Requests cancellation of the upgrade flow. + /// The upgrade outcome. + 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 (client.SessionMutationConnectionEpoch is not { } connectionEpoch) + return new(GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable, "Gateway connection epoch is unavailable."); + + 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 (!UsesManagedTailscaleServe(snapshot.Root)) + return new(GatewayTailscaleAuthUpgradeOutcome.UnsupportedTopology); + + if (_liveVerifier is null || !TryGetGatewayPort(snapshot.Root, out var gatewayPort)) + return new(GatewayTailscaleAuthUpgradeOutcome.IngressNotReady); + + try + { + if (await _liveVerifier.VerifyAsync(record!, gatewayPort, cancellationToken).ConfigureAwait(false) != + GatewayTailscaleAuthLiveState.Ready) + { + return new(GatewayTailscaleAuthUpgradeOutcome.IngressNotReady); + } + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + throw; + } + catch (Exception ex) + { + return new(GatewayTailscaleAuthUpgradeOutcome.IngressNotReady, ex.Message); + } + + cancellationToken.ThrowIfCancellationRequested(); + + if (record!.TrustTailscaleAuth && snapshot.IsApplied && AllowsTailscaleAuth(snapshot.Root)) + return new(GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled); + + if (string.IsNullOrWhiteSpace(snapshot.BaseHash)) + { + return new(GatewayTailscaleAuthUpgradeOutcome.ConfigUnavailable, "Config base hash is unavailable."); + } + + // 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.PatchConfigOnConnectionAsync(configPatch, snapshot.BaseHash, connectionEpoch); + 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. Cancellation does not issue new trust, even if Core accepted + // the patch. A later explicit retry safely repeats the idempotent leaf. + try + { + if (patchTask is not null) + await patchTask.ConfigureAwait(false); + } + catch + { + // A transport failure is ambiguous: Core may have committed. + } + throw; + } + catch (Exception ex) + { + return new(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, ex.Message); + } + + cancellationToken.ThrowIfCancellationRequested(); + if (!patch.Ok) + 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); + } + + /// Checks whether persisted Tailscale-auth trust still matches Gateway config and ingress. + /// The Gateway whose trust is checked. + /// The current Gateway config client. + /// Cancels config and ingress checks. + /// when current config and ingress satisfy the trust policy. + 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 (!snapshot.IsApplied) + 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 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() + : 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))); + } + + 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() + { + using var document = JsonDocument.Parse(""" + { "gateway": { "auth": { "allowTailscale": true } } } + """); + return document.RootElement.Clone(); + } + + 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); + + 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, + string? ConfigRevisionHash, + string? AppliedConfigHash) + { + public bool IsApplied => + !string.IsNullOrWhiteSpace(ConfigRevisionHash) && + !string.IsNullOrWhiteSpace(AppliedConfigHash) && + string.Equals(ConfigRevisionHash, AppliedConfigHash, StringComparison.Ordinal); + } +} diff --git a/src/OpenClaw.Connection/IGatewayConnectionManager.cs b/src/OpenClaw.Connection/IGatewayConnectionManager.cs index c27a662b50..b1ec966d5c 100644 --- a/src/OpenClaw.Connection/IGatewayConnectionManager.cs +++ b/src/OpenClaw.Connection/IGatewayConnectionManager.cs @@ -39,6 +39,15 @@ Task ConnectAsync(string? gatewayId, CancellationToken cancellationToken) 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.Connection/OperatorScopeHelper.cs b/src/OpenClaw.Connection/OperatorScopeHelper.cs index 6520fcb74b..80c7f42e48 100644 --- a/src/OpenClaw.Connection/OperatorScopeHelper.cs +++ b/src/OpenClaw.Connection/OperatorScopeHelper.cs @@ -16,8 +16,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.Connection/WslCommandRunner.cs b/src/OpenClaw.Connection/WslCommandRunner.cs index 5bdcdef51e..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); @@ -36,6 +48,19 @@ Task RunInDistroAsync( CancellationToken cancellationToken = default, IReadOnlyDictionary? environment = null, string? standardInput = 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.")); } /// @@ -88,6 +113,21 @@ 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, + string standardInput, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) + => RunInDistroAsync(name, command, cancellationToken, environment, standardInput); + public Task TerminateDistroAsync(string name, CancellationToken cancellationToken = default) => RunAsync(["--terminate", name], cancellationToken); @@ -173,6 +213,7 @@ private async Task RunProcessAsync( var stderrTask = process.StandardError.ReadToEndAsync(timeoutCts.Token); bool timedOut = false; + OperationCanceledException? cancellationException = null; try { if (standardInput is not null) @@ -208,17 +249,27 @@ await process.StandardInput.WriteAsync( // 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 { } } string stdout, stderr; 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; + return timedOut ? new WslCommandResult(-1, stdout, "wsl.exe timed out", TimedOut: true) : new WslCommandResult(process.ExitCode, stdout, stderr); diff --git a/src/OpenClaw.SetupEngine/PairOperatorStep.cs b/src/OpenClaw.SetupEngine/PairOperatorStep.cs index 2f2a51abfc..b0ab067764 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)); @@ -49,6 +51,7 @@ public override async Task ExecuteAsync(SetupContext ctx, Cancellati BootstrapToken = ctx.BootstrapToken, IsLocal = true, SetupManagedDistroName = ctx.DistroName, + TrustTailscaleAuth = ResolveEffectiveTailscaleAuthTrust(ctx.Config), LastConnected = DateTime.UtcNow }; @@ -170,6 +173,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 67044d1ef6..314a6e7699 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 51020e9315..78c67c6008 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), @@ -199,11 +199,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/ConfigPatchResult.cs b/src/OpenClaw.Shared/ConfigPatchResult.cs index a40b8c5e91..23d59d5094 100644 --- a/src/OpenClaw.Shared/ConfigPatchResult.cs +++ b/src/OpenClaw.Shared/ConfigPatchResult.cs @@ -17,6 +17,9 @@ public sealed class ConfigPatchResult /// True when the request deadline elapsed without a response. public bool TimedOut { get; init; } + /// True when the Gateway explicitly denied the patch before accepting it. + public bool IsGatewayRejection { get; init; } + /// Optional safe error detail. Remote rejection text is withheld; pages use localized fallback guidance. public string? Error { get; init; } diff --git a/src/OpenClaw.Shared/IOperatorGatewayClient.cs b/src/OpenClaw.Shared/IOperatorGatewayClient.cs index cabf8f1c25..ea5a7d59ad 100644 --- a/src/OpenClaw.Shared/IOperatorGatewayClient.cs +++ b/src/OpenClaw.Shared/IOperatorGatewayClient.cs @@ -158,6 +158,8 @@ async Task RunCronJobDetailedAsync(string jobId, bool forc Task RequestCronRunsAsync(string? id = null, int limit = 20, int offset = 0); /// Requests the effective Gateway configuration and raises . 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); /// Applies a full configuration document against an optional Gateway base hash. diff --git a/src/OpenClaw.Shared/Mcp/McpToolBridge.cs b/src/OpenClaw.Shared/Mcp/McpToolBridge.cs index 0a5aac8113..82b9c34853 100644 --- a/src/OpenClaw.Shared/Mcp/McpToolBridge.cs +++ b/src/OpenClaw.Shared/Mcp/McpToolBridge.cs @@ -416,7 +416,7 @@ private object HandleToolsList() ["app.search"] = "Search locally available navigation destinations without opening them or making Gateway requests. Args: query (string, required). Returns up to 10 { Title, Subtitle, Icon, Group, OpensDashboard, HasDashboardCounterpart }. Message snippets are excluded; settings results navigate rather than toggle.", ["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.Shared/OpenClawGatewayClient.cs b/src/OpenClaw.Shared/OpenClawGatewayClient.cs index 0ecb638950..47f18ea4f8 100644 --- a/src/OpenClaw.Shared/OpenClawGatewayClient.cs +++ b/src/OpenClaw.Shared/OpenClawGatewayClient.cs @@ -1820,19 +1820,33 @@ private async Task SendResponseRequestAsync( try { - var sent = await SendRawAsync( - SerializeRequest(requestId, method, parameters), - connectionGeneration, - requestToken) - .WaitAsync(requestToken) - .ConfigureAwait(false); + bool sent; + using (var dispatchTimeout = CancellationTokenSource.CreateLinkedTokenSource(requestToken)) + { + dispatchTimeout.CancelAfter(timeoutMs); + sent = await SendRawAsync( + SerializeRequest(requestId, method, parameters), + connectionGeneration, + dispatchTimeout.Token) + .ConfigureAwait(false); + if (!sent && dispatchTimeout.IsCancellationRequested) + { + requestToken.ThrowIfCancellationRequested(); + 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), requestToken); - } - catch (TimeoutException ex) - { - throw new TimeoutException($"Timed out waiting for {method} response", ex); + + try + { + return await pending.Task.WaitAsync(TimeSpan.FromMilliseconds(timeoutMs), requestToken); + } + catch (TimeoutException ex) + { + throw new TimeoutException($"Timed out waiting for {method} response", ex); + } } finally { @@ -2084,6 +2098,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"); @@ -2149,6 +2166,7 @@ private async Task PatchConfigCoreAsync( return new ConfigPatchResult { Ok = false, + IsGatewayRejection = GatewayRequestErrors.Code(ex) == "INVALID_REQUEST", TimedOut = ex is TimeoutException, HasStaleBaseHashSignal = staleBaseHash, }; diff --git a/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs b/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs new file mode 100644 index 0000000000..a02271c40a --- /dev/null +++ b/src/OpenClaw.Shared/TailscaleServeStatusPolicy.cs @@ -0,0 +1,353 @@ +using System.Text.Json; + +namespace OpenClaw.Shared; + +// Parses Tailscale Serve status and reports Gateway routing, Funnel state, and +// the foreground proxy port. +// Usage: +// if (TailscaleServeStatusPolicy.TryParse(status, port, endpoint, out var result) && result.RoutesToGateway) ... +/// Parsed Gateway routing, Funnel state, and foreground proxy port. +public sealed record TailscaleServeStatusResult( + bool RoutesToGateway, + bool FunnelEnabled, + int? ForegroundProxyPort = null); + +/// Validates and interprets the JSON returned by Tailscale Serve status. +public static class TailscaleServeStatusPolicy +{ + /// Parses Serve status and reports whether a parsed Serve route targets the Gateway port. + /// The Serve status JSON. + /// The expected local Gateway port. + /// The expected tailnet endpoint, when known. + /// The parsed route and Funnel state on success. + /// when the status has a valid shape. + 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 || + !TryCollectServeConfigs(root, out var configs)) + { + return false; + } + + 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.Value) || + !TryReadFunnelState(config.Value, out var configFunnelEnabled)) + { + return false; + } + 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, + ForegroundProxyPort: foregroundProxyPort); + return true; + } + catch (JsonException) + { + return false; + } + } + + private static bool TryCollectServeConfigs( + JsonElement root, + out IReadOnlyList configs) + { + var collected = new List { new(root, IsForeground: false) }; + 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(new ServeConfig(entry.Value, IsForeground: true)); + } + + configs = collected; + return true; + } + + 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 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 GatewayWebProxyMatch.None; + + var found = false; + foreach (var webEndpoint in web.EnumerateObject()) + { + if (!EndpointMatches(webEndpoint.Name, expectedEndpoint)) + continue; + + if (found || + 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) + { + return GatewayWebProxyMatch.Invalid; + } + + if (!TryReadLoopbackGatewayProxyPort( + proxy.GetString(), + out proxyPort, + out isLiteralIpv4Loopback)) + { + return GatewayWebProxyMatch.Invalid; + } + + found = true; + } + + return found ? GatewayWebProxyMatch.Valid : GatewayWebProxyMatch.None; + } + + 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 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) + { + 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.AppShutdownCoordinator.cs b/src/OpenClaw.Tray.WinUI/App.AppShutdownCoordinator.cs index 0d2a815d40..895c63ccbb 100644 --- a/src/OpenClaw.Tray.WinUI/App.AppShutdownCoordinator.cs +++ b/src/OpenClaw.Tray.WinUI/App.AppShutdownCoordinator.cs @@ -84,6 +84,7 @@ private AppShutdownPlan BuildShutdownPlan() })); } + _gatewayDashboardLinkService = null; // Native withdrawal borrows the authorized manager connection. Drain recovery // and withdraw before that owner is disconnected, even when the Gateway stays running. var localAiLifecycle = _localAiGatewayLifecycle; diff --git a/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs b/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs index 8bda77cf06..e9d7f416ba 100644 --- a/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs +++ b/src/OpenClaw.Tray.WinUI/App.CapabilityHandlers.cs @@ -235,25 +235,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" }; - if (!GatewayDashboardUrlBuilder.TryBuild( - gatewayUrl, - path, - token, - !isBootstrapToken && credentialSource == CredentialResolver.SourceSharedGatewayToken, - out var url, - out var urlError)) - return new { error = urlError }; + var active = _gatewayRegistry?.GetActive(); + var activeMatches = active is not null && + string.Equals(active.Url, gatewayUrl, StringComparison.OrdinalIgnoreCase); + 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" }; + + var result = await service.BuildAsync(new GatewayDashboardLinkRequest( + gatewayUrl, + path, + dashboardCredential, + usesSharedCredential, + tailscaleGatewayId)); + if (!result.Success) + return new { error = result.Error }; + + var url = result.Url!; return new { 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/App.xaml.cs b/src/OpenClaw.Tray.WinUI/App.xaml.cs index 2b37d77d04..ab9044f4e5 100644 --- a/src/OpenClaw.Tray.WinUI/App.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/App.xaml.cs @@ -61,6 +61,7 @@ public partial class App : Application, OpenClawTray.Services.IAppCommands, IPer private GatewayConnectionManager? _connectionManager; internal InteractiveGatewayEndpointAuthorizer? InteractiveEndpointAuthorizer { get; private set; } private GatewayDirectConnectService? _gatewayDirectConnectService; + private GatewayDashboardLinkService? _gatewayDashboardLinkService; private GatewayRegistry? _gatewayRegistry; private OpenClawTray.Services.ManagedLocalGatewayAutoRepairMonitor? _managedLocalAutoRepairMonitor; private ManagedLocalGatewayPortProvenanceService? _managedLocalPortProvenance; @@ -806,14 +807,20 @@ _dispatcherQueue is null GetSettingsStore: () => SettingsStore, OpenSetupDashboard: async (completion, path, ct) => { - var launcher = CreateDashboardLauncher(() => - throw new InvalidOperationException("Windows did not open the Gateway dashboard."), - completion); - return await launcher.OpenAsync(path, () => + var service = _gatewayDashboardLinkService + ?? throw new InvalidOperationException("The Gateway dashboard launcher is unavailable."); + var launcher = CreateGatewayDashboardLauncher( + service, + requestPath => ResolveActiveDashboardLinkRequest(requestPath, completion), + static () => { }, + reportLinkFailure: _ => { }, + reportFailure: reason => throw new InvalidOperationException( + reason ?? "The Gateway dashboard could not be opened.")); + return await launcher.OpenAsync(path, authorizeDispatch: () => { ct.ThrowIfCancellationRequested(); RequireSetupDashboardAuthority(completion); - }); + }, cancellationToken: ct); })); _updateCoordinator = new UpdateCoordinator( _appState, @@ -1035,6 +1042,11 @@ _dispatcherQueue is null endpointProvenanceProbe: managedLocalPortProvenance.InspectAsync, validationTunnelFactory: () => new SshTunnelService(appLogger), nativeGatewayRuntime: nativeGatewayRuntime); + _gatewayDashboardLinkService = new GatewayDashboardLinkService( + (gatewayId, cancellationToken) => _connectionManager.RevalidateTailscaleDashboardAuthAsync( + gatewayId, + cancellationToken), + LocalizationHelper.GetString); _connectionManager.OperatorClientChanged += OnOperatorClientChanged; _connectionManager.StateChanged += OnManagerStateChanged; _localAiGatewayLifecycle.Attach(_connectionManager, _localAiRuntime); @@ -4155,14 +4167,87 @@ private void OpenDashboard(string? path = null) private Task TryOpenDashboardAsync(string? path) { - var launcher = CreateDashboardLauncher( - () => AsyncEventHandlerGuard.Run( - () => _windowManager?.ShowDashboardLaunchFailureAsync( - () => OpenDashboard(path)) - ?? Task.CompletedTask, new AppLogger(), "Dashboard launch error")); + var service = _gatewayDashboardLinkService; + if (service is null) + { + ShowConnectionSettingsForPairingIssue("Dashboard", "Connection manager is not initialized"); + return Task.FromResult(false); + } + + var launcher = CreateGatewayDashboardLauncher( + service, + path => ResolveActiveDashboardLinkRequest(path), + () => OpenDashboard(path)); return launcher.OpenAsync(path); } + private GatewayDashboardLinkRequest? ResolveActiveDashboardLinkRequest( + string? path, + SetupNativeCompletion? setupCompletion = null) + { + if (!TryResolveChatCredentials( + out var gatewayUrl, + out var token, + out var credentialSource, + out var isBootstrapToken, + setupCompletion)) + return null; + + var appendBrowserCredential = + !isBootstrapToken && credentialSource == CredentialResolver.SourceSharedGatewayToken; + var active = _gatewayRegistry?.GetActive(); + var tailscaleGatewayId = active?.TrustTailscaleAuth == true && + string.Equals(active.Url, gatewayUrl, StringComparison.OrdinalIgnoreCase) + ? active.Id + : null; + + return new GatewayDashboardLinkRequest( + gatewayUrl, + path, + token, + appendBrowserCredential, + tailscaleGatewayId); + } + + internal async Task OpenDashboardFromLinkServiceAsync( + GatewayDashboardLinkRequest request, + Func> validateBeforeLaunch, + Action retry) + { + var service = _gatewayDashboardLinkService; + if (service is null) + { + ShowConnectionSettingsForPairingIssue("Dashboard", "Connection manager is not initialized"); + return; + } + + var launcher = CreateGatewayDashboardLauncher(service, _ => request, retry); + await launcher.OpenSavedAsync(request, validateBeforeLaunch); + } + + private GatewayDashboardLauncher CreateGatewayDashboardLauncher( + GatewayDashboardLinkService service, + Func resolveRequest, + Action retry, + Action? reportLinkFailure = null, + Action? reportFailure = null) => + new( + EnsureSshTunnelConfigured, + resolveRequest, + service, + new DashboardBrowser( + async url => await global::Windows.System.Launcher.LaunchUriAsync(new Uri(url)), + Logger.Info).OpenAsync, + reportLinkFailure ?? (result => ShowConnectionSettingsForPairingIssue( + "Dashboard", + result.Error ?? "Dashboard URL is unavailable")), + reportFailure ?? (reason => AsyncEventHandlerGuard.Run( + () => _windowManager?.ShowDashboardLaunchFailureAsync(retry, reason) ?? Task.CompletedTask, + new AppLogger(), + "Dashboard launch error")), + () => _appNotificationService?.Dismiss(GatewayDashboardLauncher.FailureNotificationId), + warning => Logger.Warn(warning)); + private bool IsSetupDashboardCredentialAllowed(SetupNativeCompletion completion, GatewayRecord record) { if (record.Id != completion.Verification.GatewayId || @@ -4180,16 +4265,6 @@ private void RequireSetupDashboardAuthority(SetupNativeCompletion completion) throw new SetupNativeOwnershipException(); } - private GatewayDashboardLauncher CreateDashboardLauncher( - Action reportFailure, SetupNativeCompletion? setupCompletion = null) => new( - EnsureSshTunnelConfigured, - () => TryResolveChatCredentials(out var url, out var token, out var source, out var bootstrap, setupCompletion) - ? new InteractiveGatewayCredential(url, token, bootstrap, source) : null, - new DashboardBrowser( - async url => await global::Windows.System.Launcher.LaunchUriAsync(new Uri(url)), Logger.Info).OpenAsync, - reportFailure, - () => _appNotificationService?.Dismiss(GatewayDashboardLauncher.FailureNotificationId)); - // ── IAppCommands implementation ───────────────────────────────────── void IAppCommands.OpenDashboard(string? path) => OpenDashboard(path); diff --git a/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs b/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs index 7fe8be91f8..0c6dc7aaf9 100644 --- a/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs +++ b/src/OpenClaw.Tray.WinUI/Helpers/GatewayDashboardUrlBuilder.cs @@ -6,7 +6,8 @@ public static string Build( string gatewayUrl, string? path, string? sharedGatewayToken, - bool appendSharedGatewayToken) + bool appendSharedGatewayToken, + bool trustTailscaleAuth = false) { ArgumentException.ThrowIfNullOrWhiteSpace(gatewayUrl); @@ -42,9 +43,9 @@ public static string Build( fragment.Add(session); AppendPreservedFragmentFields(fragment, routeFragment); AppendPreservedFragmentFields(fragment, uri.Fragment); - if (appendSharedGatewayToken && !string.IsNullOrEmpty(sharedGatewayToken)) + if (!trustTailscaleAuth && appendSharedGatewayToken && !string.IsNullOrEmpty(sharedGatewayToken)) fragment.Add($"token={Uri.EscapeDataString(sharedGatewayToken)}"); - else if (appendSharedGatewayToken) + else if (!trustTailscaleAuth && appendSharedGatewayToken) { var existingToken = FindNamedParameter(routeFragment, "token") ?? FindNamedParameter(uri.Fragment, "token"); @@ -61,11 +62,12 @@ public static bool TryBuild( string? sharedGatewayToken, bool appendSharedGatewayToken, out string url, - out string error) + out string error, + bool trustTailscaleAuth = false) { try { - url = Build(gatewayUrl, path, sharedGatewayToken, appendSharedGatewayToken); + url = Build(gatewayUrl, path, sharedGatewayToken, appendSharedGatewayToken, trustTailscaleAuth); error = string.Empty; return true; } @@ -198,4 +200,23 @@ private static string WithoutTokenQuery(string query) return kept.Count == 0 ? string.Empty : "?" + string.Join('&', kept); } + + 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 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/Pages/ConnectionPage.xaml.cs b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs index 43eb968c85..5530ffb35c 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPage.xaml.cs @@ -1920,6 +1920,17 @@ private SettingsExpander 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 = LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthMenu"), + Tag = row.Id, + }; + enableTailscaleAuth.Click += OnEnableTailscaleDashboardAuth; + flyout.Items.Add(enableTailscaleAuth); + } if (row.HasHostTerminal) { var openTerminal = new MenuFlyoutItem { Text = row.HostTerminalLabel, Tag = row.Id }; @@ -2652,32 +2663,15 @@ private async Task OnSavedRowOpenDashboardAsync(object sender) if (sender is not MenuFlyoutItem item || item.Tag is not string gwId) return; var rec = _gatewayRegistry?.GetById(gwId); if (rec == null) return; + var recordSnapshot = rec with { }; try { - if (!string.IsNullOrWhiteSpace(rec.SharedGatewayToken)) - { - var provenanceService = CurrentApp.ManagedLocalPortProvenance; - if (provenanceService is null) - return; - _ = await provenanceService.InspectAsync(rec); - var candidate = new GatewayCredential( - rec.SharedGatewayToken!, - IsBootstrapToken: false, - CredentialResolver.SourceSharedGatewayToken); - if (CurrentApp.InteractiveEndpointAuthorizer?.IsCredentialAllowed(rec, candidate) != true) - { - CurrentApp.ShowTransientConnectionError( - "Dashboard blocked because the saved gateway address is not owned by the verified managed gateway."); - return; - } - } - if (!GatewayDashboardUrlBuilder.TryBuild( - rec.Url, + recordSnapshot.Url, path: null, - rec.SharedGatewayToken, - appendSharedGatewayToken: !string.IsNullOrWhiteSpace(rec.SharedGatewayToken), - out var url, + sharedGatewayToken: null, + appendSharedGatewayToken: false, + out _, out _)) { CurrentApp.ShowTransientConnectionError( @@ -2685,7 +2679,17 @@ private async Task OnSavedRowOpenDashboardAsync(object sender) return; } - await global::Windows.System.Launcher.LaunchUriAsync(new Uri(url)); + await CurrentApp.OpenDashboardFromLinkServiceAsync(new GatewayDashboardLinkRequest( + recordSnapshot.Url, + null, + recordSnapshot.SharedGatewayToken, + !string.IsNullOrWhiteSpace(recordSnapshot.SharedGatewayToken), + recordSnapshot.TrustTailscaleAuth ? recordSnapshot.Id : null), + result => ValidateSavedDashboardFallbackAsync(recordSnapshot, result), + () => AsyncEventHandlerGuard.Run( + () => OnSavedRowOpenDashboardAsync(sender), + new AppLogger(), + nameof(OnSavedRowOpenDashboard))); } catch (Exception ex) { @@ -2693,6 +2697,78 @@ private async Task OnSavedRowOpenDashboardAsync(object sender) } } + private async Task ValidateSavedDashboardFallbackAsync( + GatewayRecord record, + GatewayDashboardLinkResult result) + { + if (!result.BrowserCredentialIncluded) + { + 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 (CurrentApp.InteractiveEndpointAuthorizer?.IsCredentialAllowed(record, candidate) == true) + { + 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), + 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 = LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthTitle"), + Content = LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthBody"), + PrimaryButtonText = LocalizationHelper.GetString("ConnectionPage_TailscaleDashboardAuthEnable"), + 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) + { + var successKey = result.Outcome == GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled + ? "ConnectionPage_TailscaleDashboardAuthEnabled" + : "ConnectionPage_TailscaleDashboardAuthAccepted"; + SetGatewayHostActionStatus(LocalizationHelper.GetString(successKey)); + LoadSavedGateways(); + return; + } + + var messageKey = ConnectionPagePlan.TailscaleAuthFailureMessageResourceKey(result.Outcome); + SetGatewayHostActionStatus(LocalizationHelper.GetString(messageKey), 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/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs index c7ffa2c67d..eccd376a09 100644 --- a/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs +++ b/src/OpenClaw.Tray.WinUI/Pages/ConnectionPagePlan.cs @@ -131,6 +131,21 @@ 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", + GatewayTailscaleAuthUpgradeOutcome.UnsupportedTopology => "ConnectionPage_TailscaleDashboardAuthFailureUnsupportedTopology", + GatewayTailscaleAuthUpgradeOutcome.IngressNotReady => "ConnectionPage_TailscaleDashboardAuthFailureIngressNotReady", + _ => "ConnectionPage_TailscaleDashboardAuthFailureGeneric", + }; + public ConnectionPageMode Mode { get; init; } = ConnectionPageMode.Welcome; // ─── Status strip ─── diff --git a/src/OpenClaw.Tray.WinUI/Services/DashboardBrowser.cs b/src/OpenClaw.Tray.WinUI/Services/DashboardBrowser.cs index 6498bf565b..030bb11da9 100644 --- a/src/OpenClaw.Tray.WinUI/Services/DashboardBrowser.cs +++ b/src/OpenClaw.Tray.WinUI/Services/DashboardBrowser.cs @@ -1,10 +1,5 @@ // Final hand-off of a credential-bearing Gateway Dashboard URL to Windows. // -// Usage (App.CreateDashboardLauncher): -// var browser = new DashboardBrowser( -// async url => await Launcher.LaunchUriAsync(new Uri(url)), Logger.Info); -// new GatewayDashboardLauncher(..., browser.OpenAsync, ...); -// // Ordinary runs pass the URL straight to Windows. Gateway fixture runs never reach a real // browser: the launch is logged with a redacted URL and reported as opened, so full-app // tests can observe that dispatch happened (or did not) without leaking the fixture token. diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs index 83171b7945..a377cceb5a 100644 --- a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLauncher.cs @@ -1,32 +1,93 @@ -using OpenClaw.Connection; using OpenClaw.SetupEngine; -using OpenClawTray.Helpers; using System.ComponentModel; using System.Runtime.InteropServices; namespace OpenClawTray.Services; -/// Uses the normal Dashboard credential path without setup completion authority. internal sealed class GatewayDashboardLauncher( Func ensureTunnel, - Func resolveCredential, + Func resolveRequest, + GatewayDashboardLinkService linkService, Func> launchBrowser, - Action reportFailure, - Action? reportOpened = null) + Action reportLinkFailure, + Action reportFailure, + Action? reportOpened = null, + Action? reportRevalidationWarning = null) { internal const string FailureNotificationId = "setup-dashboard-launch"; - public async Task OpenAsync(string? path = null, Action? authorizeDispatch = null) + + public async Task OpenAsync( + string? path = null, + Action? authorizeDispatch = null, + CancellationToken cancellationToken = default) { + cancellationToken.ThrowIfCancellationRequested(); + GatewayDashboardLinkRequest? request; try { if (!ensureTunnel()) throw new InvalidOperationException("The Gateway tunnel is unavailable."); - var credential = resolveCredential() - ?? throw new InvalidOperationException("The Gateway credential is unavailable."); - var url = GatewayDashboardUrlBuilder.Build(credential.GatewayUrl, path, credential.Token, - !credential.IsBootstrapToken && credential.Source == CredentialResolver.SourceSharedGatewayToken); + request = resolveRequest(path); + } + catch (Exception ex) when (IsExpectedLaunchFailure(ex)) + { + reportFailure(null); + return false; + } + + if (request is null) + { + reportFailure(null); + return false; + } + + return await PrepareAndLaunchAsync( + request, + validateBeforeLaunch: null, + authorizeDispatch, + cancellationToken); + } + + internal Task OpenSavedAsync( + GatewayDashboardLinkRequest request, + Func> validateBeforeLaunch, + CancellationToken cancellationToken = default, + Action? authorizeDispatch = null) + { + ArgumentNullException.ThrowIfNull(request); + ArgumentNullException.ThrowIfNull(validateBeforeLaunch); + return PrepareAndLaunchAsync(request, validateBeforeLaunch, authorizeDispatch, cancellationToken); + } + + private async Task PrepareAndLaunchAsync( + GatewayDashboardLinkRequest request, + Func>? validateBeforeLaunch, + Action? authorizeDispatch, + CancellationToken cancellationToken) + { + cancellationToken.ThrowIfCancellationRequested(); + var result = await linkService.BuildAsync(request, cancellationToken); + cancellationToken.ThrowIfCancellationRequested(); + if (result.RevalidationError is not null) + reportRevalidationWarning?.Invoke(result.RevalidationError); + + if (!result.Success) + { + reportLinkFailure(result); + reportFailure(result.Error); + return false; + } + + cancellationToken.ThrowIfCancellationRequested(); + if (result.BrowserCredentialIncluded && validateBeforeLaunch is not null && + !await validateBeforeLaunch(result)) + return false; + cancellationToken.ThrowIfCancellationRequested(); + + try + { authorizeDispatch?.Invoke(); - if (!await launchBrowser(url)) + if (!await launchBrowser(result.Url!)) throw new InvalidOperationException("Windows did not open the Dashboard."); } catch (SetupNativeOwnershipException) @@ -35,15 +96,16 @@ public async Task OpenAsync(string? path = null, Action? authorizeDispatch } catch (Exception ex) when (IsExpectedLaunchFailure(ex)) { - // Browser failures can include the full credential-bearing URL. Do not log them. - reportFailure(); + // Browser failures can include a credential-bearing URL. Do not log them. + reportFailure(null); return false; } + reportOpened?.Invoke(); return true; } private static bool IsExpectedLaunchFailure(Exception error) => error is InvalidOperationException or IOException or UnauthorizedAccessException or - ArgumentException or Win32Exception or COMException; + ArgumentException or FormatException or Win32Exception or COMException; } diff --git a/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs new file mode 100644 index 0000000000..3f5e3bb375 --- /dev/null +++ b/src/OpenClaw.Tray.WinUI/Services/GatewayDashboardLinkService.cs @@ -0,0 +1,112 @@ +using OpenClawTray.Helpers; + +namespace OpenClawTray.Services; + +// Builds Dashboard links with current Tailscale trust and credential requirements. +// Usage: +// var result = await links.BuildAsync(request, cancellationToken); +/// Inputs used to build a Gateway Dashboard link. +public sealed record GatewayDashboardLinkRequest( + string GatewayUrl, + string? Path, + string? BrowserCredential, + bool AppendBrowserCredential, + string? TailscaleGatewayId = null); + +/// The Dashboard link and credential or revalidation result. +public sealed record GatewayDashboardLinkResult( + string? Url, + bool TrustTailscaleAuth, + string? Error = null, + string? RevalidationError = null, + bool BrowserCredentialIncluded = false) +{ + public bool Success => Url is not null && Error is null; +} + +/// Builds Dashboard URLs, revalidating trust when a Tailscale Gateway ID is supplied. +public sealed class GatewayDashboardLinkService +{ + 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 localize) + { + _revalidateTailscaleAuth = revalidateTailscaleAuth + ?? throw new ArgumentNullException(nameof(revalidateTailscaleAuth)); + _localize = localize ?? throw new ArgumentNullException(nameof(localize)); + } + + /// Revalidates Tailscale trust when applicable and builds a browser-compatible URL. + /// The Gateway URL, path, and available browser credential. + /// Cancels trust revalidation. + /// The built link or the reason a compatible link could not be created. + 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 = _localize(RevalidationFailedKey); + } + } + + if (!string.IsNullOrWhiteSpace(request.TailscaleGatewayId) && + !trustTailscaleAuth && + (!request.AppendBrowserCredential || string.IsNullOrWhiteSpace(request.BrowserCredential))) + { + return new GatewayDashboardLinkResult( + Url: null, + TrustTailscaleAuth: false, + Error: _localize(NoBrowserCompatibleCredentialKey), + RevalidationError: revalidationError); + } + + if (!GatewayDashboardUrlBuilder.TryBuild( + request.GatewayUrl, + request.Path, + request.BrowserCredential, + request.AppendBrowserCredential && !trustTailscaleAuth, + out var url, + out var urlError, + trustTailscaleAuth)) + { + return new GatewayDashboardLinkResult( + Url: null, + TrustTailscaleAuth: trustTailscaleAuth, + Error: urlError, + RevalidationError: revalidationError); + } + + var browserCredentialIncluded = GatewayDashboardUrlBuilder.HasSharedTokenFragment(url); + + return new GatewayDashboardLinkResult( + url, + trustTailscaleAuth, + RevalidationError: revalidationError, + BrowserCredentialIncluded: browserCredentialIncluded); + } +} diff --git a/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs b/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs index 942a7dd022..9e5409f5ab 100644 --- a/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs +++ b/src/OpenClaw.Tray.WinUI/Services/IWindowManager.cs @@ -42,7 +42,7 @@ internal interface IWindowManager /// Shows the Local AI setup flow. Task ShowLocalAiSetupAsync(); Task ShowGatewayWizardAsync(); - Task ShowDashboardLaunchFailureAsync(Action? retry); + Task ShowDashboardLaunchFailureAsync(Action? retry, string? localizedReason = null); Task ShowNativeSetupAsync(OpenClaw.SetupEngine.SetupNativeCompletion completion, CancellationToken ct); Task ShowNativeSetupPreparingAsync(OpenClaw.SetupEngine.GatewayAiSetupCompletion proof, Func> verify, CancellationToken ct); diff --git a/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs b/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs index 64f01148f6..dcaf59b174 100644 --- a/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs +++ b/src/OpenClaw.Tray.WinUI/Services/WindowManager.cs @@ -143,11 +143,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/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw index 3147581ee4..2c0aee7cce 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw @@ -5003,6 +5003,60 @@ Open Channels in the web dashboard. Open dashboard + + Use Tailscale identity for dashboard + + + Use Tailscale identity for dashboard? + + + 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 + + + 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. + + + Select this gateway as active, then try again. + + + Connect to this gateway, then try again. + + + 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. + + + 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. + + + Tailscale dashboard identity could not be enabled. Reconnect to the gateway and try again. + + + No browser-compatible gateway credential is available + + + Tailscale dashboard authentication revalidation failed + Options for {0} @@ -5526,7 +5580,7 @@ Open Channels in the web dashboard. 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 @@ -5607,7 +5661,7 @@ Open Channels in the web dashboard. 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. @@ -5634,7 +5688,7 @@ Open Channels in the web dashboard. 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 42129c9a42..f8b934eab4 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw @@ -4995,6 +4995,60 @@ Ouvrir Canaux dans le tableau de bord web. Ouvrir le tableau de bord + + Utiliser l’identité Tailscale pour le tableau de bord + + + Utiliser l’identité Tailscale pour le tableau de bord ? + + + 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 + + + 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. + + + Sélectionnez cette passerelle comme passerelle active, puis réessayez. + + + Connectez-vous à cette passerelle, puis réessayez. + + + 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. + + + 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. + + + 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 + + + La revalidation de l’authentification Tailscale du tableau de bord a échoué + Options pour {0} @@ -5518,7 +5572,7 @@ Ouvrir Canaux dans le tableau de bord web. 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 @@ -5599,7 +5653,7 @@ Ouvrir Canaux dans le tableau de bord web. 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. @@ -5626,7 +5680,7 @@ Ouvrir Canaux dans le tableau de bord web. 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 d7f061b2bb..e9d7bff3e2 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw @@ -4996,6 +4996,60 @@ Open Kanalen in het webdashboard. Dashboard openen + + Tailscale-identiteit gebruiken voor het dashboard + + + Tailscale-identiteit gebruiken voor het dashboard? + + + 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 + + + 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. + + + Stel deze gateway in als actief en probeer het opnieuw. + + + Maak verbinding met deze gateway en probeer het opnieuw. + + + 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. + + + 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. + + + 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 + + + Herverificatie van Tailscale-authenticatie voor het dashboard is mislukt + Opties voor {0} @@ -5519,7 +5573,7 @@ Open Kanalen in het webdashboard. 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 @@ -5600,7 +5654,7 @@ Open Kanalen in het webdashboard. 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. @@ -5627,7 +5681,7 @@ Open Kanalen in het webdashboard. 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 27aafb20d6..1c469aa99e 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw @@ -4972,6 +4972,60 @@ Abrir Canais no painel web. Abrir painel + + Usar identidade Tailscale para o painel + + + Usar a identidade do Tailscale no painel? + + + 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 + + + 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. + + + Defina este gateway como ativo e tente novamente. + + + Conecte-se a este gateway e tente novamente. + + + 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. + + + 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. + + + 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 + + + Falha na revalidação da autenticação do painel pelo Tailscale + Opções de {0} @@ -5495,7 +5549,7 @@ Abrir Canais no painel web. 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 @@ -5576,7 +5630,7 @@ Abrir Canais no painel web. 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. @@ -5603,7 +5657,7 @@ Abrir Canais no painel web. 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 8ba82d96da..af67f9a080 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw @@ -4995,6 +4995,60 @@ 打开仪表板 + + 使用 Tailscale 身份访问仪表板 + + + 使用 Tailscale 身份访问仪表板? + + + 这将向自行管理前台 Tailscale Serve 的网关请求 Tailscale 身份认证。已保存的令牌、设备身份、WSL 发行版和配对信息均保持不变。此操作不会更改 Serve。 + + + 启用 + + + 已启用仪表板的 Tailscale 身份认证。 + + + 网关已接受 Tailscale 身份设置。仪表板链接将在确认设置已应用且就绪后才省略令牌。 + + + 此操作需要由网关管理的前台 Tailscale Serve。不支持安装程序创建的后台 Serve。请让网关管理员检查部署。未更改任何设置。 + + + 由网关管理的 Tailscale 入口尚未就绪或无法验证。请检查网关和 Tailscale 连接后重试。未更改任何设置。 + + + 此网关已不再是受管理的 Tailscale 网关。请刷新网关列表后重试。 + + + 请将此网关设为当前活动网关后重试。 + + + 请先连接到此网关,然后重试。 + + + 请使用具有 operator.admin 权限的连接重新连接。若无法获得此权限,请联系网关管理员。 + + + 无法读取网关配置。请重新连接网关后重试。 + + + 网关未确认此更改。请重新连接后重试。重试只会安全地重新应用同一项 Tailscale 设置。 + + + 无法在本地保存 Tailscale 信任设置。请检查 OpenClaw Tray 数据文件夹的访问权限后重试。 + + + 无法启用 Tailscale 仪表板身份认证。请重新连接网关后重试。 + + + 没有可供浏览器使用的网关凭据 + + + 重新验证仪表板的 Tailscale 身份认证失败 + {0} 的选项 @@ -5518,7 +5572,7 @@ 保存配置前请先连接到网关。 - 此操作员令牌没有 operator.write 权限,因此无法保存配置更改。 + 此操作员令牌没有 operator.admin 权限,因此无法保存配置更改。 配置未加载 @@ -5599,7 +5653,7 @@ 此操作员令牌缺少 operator.read 权限,因此无法在此处加载网关配置。 - 此操作员令牌可以读取配置,但缺少 operator.write 权限。你可以检查并验证草稿,但“保存”已禁用。 + 此操作员令牌可以读取配置,但缺少 operator.admin 权限。你可以检查并验证草稿,但“保存”已禁用。 没有未保存的更改。 @@ -5626,7 +5680,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 89b3a4f6f2..8914b1bfb5 100644 --- a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw +++ b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw @@ -4995,6 +4995,60 @@ 開啟儀表板 + + 使用 Tailscale 身分存取儀表板 + + + 使用 Tailscale 身分存取儀表板? + + + 這會向自行管理前景 Tailscale Serve 的閘道要求 Tailscale 身分驗證。已儲存的權杖、裝置身分、WSL 發行版本和配對資訊均維持不變。此操作不會變更 Serve。 + + + 啟用 + + + 已啟用儀表板的 Tailscale 身分驗證。 + + + 閘道已接受 Tailscale 身分設定。儀表板連結會在確認設定已套用且就緒後才省略權杖。 + + + 此操作需要由閘道管理的前景 Tailscale Serve。不支援安裝程式建立的背景 Serve。請讓閘道管理員檢查部署。未變更任何設定。 + + + 由閘道管理的 Tailscale 入口尚未就緒或無法驗證。請檢查閘道和 Tailscale 連線後重試。未變更任何設定。 + + + 此閘道已不再是受管理的 Tailscale 閘道。請重新整理閘道清單後再試一次。 + + + 請將此閘道設為目前作用中的閘道,然後再試一次。 + + + 請先連線到此閘道,然後再試一次。 + + + 請使用具備 operator.admin 權限的連線重新連線。若無法取得此權限,請聯絡閘道管理員。 + + + 無法讀取閘道設定。請重新連線至閘道後再試一次。 + + + 閘道未確認這項變更。請重新連線後重試。重試只會安全地重新套用同一項 Tailscale 設定。 + + + 無法在本機儲存 Tailscale 信任設定。請檢查 OpenClaw Tray 資料資料夾的存取權限後再試一次。 + + + 無法啟用 Tailscale 儀表板身分驗證。請重新連線至閘道後再試一次。 + + + 沒有可供瀏覽器使用的閘道認證 + + + 重新驗證儀表板的 Tailscale 身分驗證失敗 + {0} 的選項 @@ -5518,7 +5572,7 @@ 儲存設定前請先連線到閘道。 - 此操作員權杖沒有 operator.write 權限,因此無法儲存設定變更。 + 此操作員權杖沒有 operator.admin 權限,因此無法儲存設定變更。 設定未載入 @@ -5599,7 +5653,7 @@ 此操作員權杖缺少 operator.read 權限,因此無法在此載入閘道設定。 - 此操作員權杖可以讀取設定,但缺少 operator.write 權限。您可以檢查並驗證草稿,但「儲存」已停用。 + 此操作員權杖可以讀取設定,但缺少 operator.admin 權限。您可以檢查並驗證草稿,但「儲存」已停用。 沒有未儲存的變更。 @@ -5626,7 +5680,7 @@ 設定無法使用:缺少 operator.read - 唯讀:缺少 operator.write + 唯讀:缺少 operator.admin 儲存前請修正驗證錯誤 diff --git a/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs b/tests/OpenClaw.Connection.Tests/GatewayConnectionManagerTests.cs index c7df832d40..06564e572f 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; @@ -2907,7 +2908,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); @@ -3644,6 +3645,70 @@ public async Task DiagnosticEvent_Fires_OnCredentialResolution() Assert.Contains(events, e => e.Category == "credential"); } + [Fact] + public async Task TailscaleDashboardAuthUnsupportedTopology_RecordsOutcomeWithoutPatch() + { + 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); + try + { + await fixture.HandshakeCompleted.WaitAsync(StepTimeout); + } + 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 }); + + 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.UnsupportedTopology, result.Outcome); + Assert.Null(result.Error); + Assert.Contains(fixture.Requests, request => request.Method == "config.get" && request.Outcome == "ok"); + 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: UnsupportedTopology", diagnostic.Message); + Assert.Null(diagnostic.Detail); + } + [Fact] public async Task Dispose_CleansUp() { @@ -6117,6 +6182,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); 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/GatewayTailscaleAuthLiveVerifierTests.cs b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs new file mode 100644 index 0000000000..6774df551b --- /dev/null +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthLiveVerifierTests.cs @@ -0,0 +1,1001 @@ +using System.Diagnostics; +using System.Text; +using System.Text.Json; + +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( + WslCommandResult commandResult, + string expected, + int expectedProbeCalls) + { + 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(expectedProbeCalls, runner.ProbeCalls); + if (expectedProbeCalls == 2) + { + 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_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) + : 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() + { + 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)); + } + + [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)); + } + + [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")] + [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); + } + + [Fact] + public async Task VerifyAsync_AcceptsCurrentForegroundServeStatusShape() + { + var runner = new FakeWslCommandRunner((_, command, _) => Task.FromResult( + command.Contains("serve", StringComparer.Ordinal) + ? ForegroundServeStatus() + : 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(5, 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(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(":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] + 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("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")] + [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); + 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, runner.PrivilegedStandardInput) + : Task.FromResult(RunningStatus())); + var verifier = new GatewayTailscaleAuthLiveVerifier(runner, StepTimeout); + + var result = await verifier.VerifyAsync(ManagedRecord(), 18789, CancellationToken.None); + + 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")] + [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] + [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()); + Assert.Equal(2, runner.ProbeCalls); + } + + [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(), "NotReady", 2 }, + { Status("NeedsLogin", "host.tail.example."), "NotReady", 1 }, + { Status("Stopped", "host.tail.example."), "NotReady", 1 }, + { Status("Running", ""), "NotReady", 1 }, + { new WslCommandResult(0, "{}", ""), "NotReady", 1 }, + { new WslCommandResult(0, "not-json", ""), "Unavailable", 1 }, + { new WslCommandResult(1, "", "tailscaled unavailable"), "Unavailable", 1 }, + }; + + 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" + }, + { + """ + { + "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."); + + 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 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://{{proxyHost}}:{{proxyPort}}" } } + } + }, + "AllowFunnel": {{funnelEnabled.ToString().ToLowerInvariant()}} + } + } + } + """, + ""); + + 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 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]; + 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\"]}" + : 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"]; + 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"), + "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, bool privilegedInspection = false) + { + 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() { 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; 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) + .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 + { + public int ProbeCalls { get; private set; } + public string? DistroName { get; private set; } + 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, + IReadOnlyList command, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null, + string? standardInput = null) + { + if (standardInput is not null) + StandardInputs.Add(standardInput); + 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); + } + + public Task RunInDistroWithStandardInputAsync( + string name, + IReadOnlyList command, + string standardInput, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) + { + return RunInDistroAsync(name, command, cancellationToken, environment, standardInput); + } + + 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 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(); + + public Task TerminateDistroAsync( + string name, + CancellationToken cancellationToken = default) => + throw new NotSupportedException(); + + public Task UnregisterDistroAsync( + string name, + 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, + string? standardInput = null) => + 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..53bcf975be --- /dev/null +++ b/tests/OpenClaw.Connection.Tests/GatewayTailscaleAuthUpgradeTests.cs @@ -0,0 +1,1124 @@ +using System.Text.Json; +using OpenClaw.Shared; +using OpenClaw.TestSupport; + +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] + public async Task EnableAsync_PersistsRecordOnlyAfterCoreAcceptance() + { + var registry = CreateRegistry(); + var client = new FakeConfigClient(Config(allowTailscale: false)); + 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); + 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); + } + + [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 = 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] + 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 = 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.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 = CreateReadyService(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 = CreateReadyService(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_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 = 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("test-token-placeholder", registry.GetActive()!.SharedGatewayToken); + } + + [Fact] + public async Task EnableAsync_MissingBaseHash_FailsClosedBeforePatch() + { + var registry = CreateRegistry(); + var client = new FakeConfigClient(Config(allowTailscale: false, includeBaseHash: false)); + var service = CreateReadyService(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 = CreateReadyService(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); + } + + [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 = "unconfirmed patch", + IsGatewayRejection = failure == "rejection", + }, + PatchError = failure == "exception" ? new IOException("response lost") : null, + }; + var service = CreateReadyService(registry); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, result.Outcome); + 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] + [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 = hasWriteScope ? ["operator.read", "operator.write"] : ["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.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] + public async Task EnableAsync_SaveFailure_RestoresInMemoryMarker() + { + var registry = CreateRegistry(new FailOnSecondWriteFileSystem()); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: true)); + 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(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] + 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); + } + + [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 }, "tailscale": { "mode": "serve" } } }, + "hash": "root-and-includes-cas", + "configRevisionHash": "revision-new", + "appliedConfigHash": "revision-new" + } + """); + var client = new FakeConfigClient(response.RootElement.Clone()); + var service = CreateReadyService(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() + { + 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("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 } } }, + "sourceConfig": { "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 EnableAsync_AmbiguousAdoptionCanRetryAfterReloadBeforeAppliedRevisionConverges() + { + var registry = CreateRegistry(); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: false)) + { + PatchResult = new ConfigPatchResult { Ok = false, Error = "response lost" }, + }; + 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(); + 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); + + Assert.False(pending); + Assert.True(applied); + Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal("test-token-placeholder", reloaded.GetActive()!.SharedGatewayToken); + Assert.Equal(2, 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")] + [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_ConnectionChangeAfterConfigReadDoesNotDispatchPatch() + { + var registry = CreateRegistry(); + var client = new FakeConfigClient(Config(allowTailscale: false)); + client.AfterConfig = () => client.SessionMutationConnectionEpoch = 2; + var service = new GatewayTailscaleAuthUpgradeService( + registry, new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready)); + + var result = await service.EnableAsync("gateway-1", client, CancellationToken.None); + + Assert.Equal(GatewayTailscaleAuthUpgradeOutcome.PatchRejected, result.Outcome); + Assert.Equal(1, client.PatchOnConnectionCalls); + Assert.Equal(1, client.RequestedPatchConnectionEpoch); + Assert.Equal(0, client.PatchCalls); + Assert.False(registry.GetActive()!.TrustTailscaleAuth); + } + + [Fact] + public async Task EnableAsync_CancellationAfterIngressProbeDoesNotPersistOrDispatch() + { + using var cancellation = new CancellationTokenSource(); + var registry = CreateRegistry(); + registry.Save(); + var client = new FakeConfigClient(Config(allowTailscale: false)); + var service = new GatewayTailscaleAuthUpgradeService( + registry, new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready) + { + AfterVerify = cancellation.Cancel, + }); + + 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); + Assert.True(GatewayTailscaleAuthUpgradePolicy.CanOffer(reloaded.GetActive())); + } + + [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 = CreateReadyService(registry); + + var enableTask = service.EnableAsync("gateway-1", client, cancellation.Token); + await client.PatchStarted.Task.WaitAsync(StepTimeout); + cancellation.Cancel(); + + Assert.False(enableTask.IsCompleted); + 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(patchCompletion.Task.IsCompleted); + Assert.Equal(previouslyTrusted, registry.GetActive()!.TrustTailscaleAuth); + Assert.Equal(1, client.PatchCalls); + Assert.Equal(originalRegistry, File.ReadAllText(_temp.Combine("gateways.json"))); + var reloaded = new GatewayRegistry(_temp.Path); + reloaded.Load(); + Assert.Equal(previouslyTrusted, reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal(!previouslyTrusted, GatewayTailscaleAuthUpgradePolicy.CanOffer(reloaded.GetActive())); + } + + [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 GatewayTailscaleAuthUpgradeService CreateReadyService(GatewayRegistry registry) => + new(registry, new FakeLiveVerifier(GatewayTailscaleAuthLiveState.Ready)); + + private static JsonElement Config( + bool allowTailscale, + bool includeBaseHash = true, + bool includeGatewayPort = true, + string appliedRevision = "revision-new") + { + using var document = JsonDocument.Parse($$""" + { + "parsed": { + "gateway": { + {{(includeGatewayPort ? "\"port\": 18789," : "")}} + "tailscale": { "mode": "serve" }, + "auth": { "allowTailscale": {{allowTailscale.ToString().ToLowerInvariant()}} } + }, + "unrelated": "keep" + }, + "sourceConfig": { + "gateway": { + {{(includeGatewayPort ? "\"port\": 18789," : "")}} + "tailscale": { "mode": "serve" }, + "auth": { "allowTailscale": {{allowTailscale.ToString().ToLowerInvariant()}} } + }, + "unrelated": "keep" + }, + "configRevisionHash": "revision-new", + "appliedConfigHash": "{{appliedRevision}}"{{(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 } + } + }, + "sourceConfig": { + "gateway": { + "port": {{gatewayPort}}, + "auth": { "allowTailscale": true } + } + }, + "configRevisionHash": "revision-new", + "appliedConfigHash": "revision-new" + } + """); + return document.RootElement.Clone(); + } + + private static JsonElement ImplicitServeConfig() + { + using var document = JsonDocument.Parse(""" + { + "parsed": { + "gateway": { + "auth": { "mode": "token" }, + "tailscale": { "mode": "serve" } + } + }, + "sourceConfig": { + "gateway": { + "auth": { "mode": "token" }, + "tailscale": { "mode": "serve" } + } + }, + "baseHash": "base-1", + "configRevisionHash": "revision-new", + "appliedConfigHash": "revision-new" + } + """); + return document.RootElement.Clone(); + } + + 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; + public long? SessionMutationConnectionEpoch { get; set; } = 1; + public int ConfigRequests { get; private set; } + public int PatchCalls { get; private set; } + public int PatchOnConnectionCalls { get; private set; } + public string? PatchBaseHash { get; private set; } + public long? RequestedPatchConnectionEpoch { get; private set; } + 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; } + 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(ConfigResponse.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(); + if (PatchError is not null) + return Task.FromException(PatchError); + return PatchCompletion?.Task ?? Task.FromResult(PatchResult); + } + + public Task PatchConfigOnConnectionAsync( + JsonElement fullConfig, + string? baseHash, + long connectionEpoch, + int timeoutMs = 15000) + { + PatchOnConnectionCalls++; + RequestedPatchConnectionEpoch = connectionEpoch; + return SessionMutationConnectionEpoch == connectionEpoch + ? PatchConfigDetailedAsync(fullConfig, baseHash, timeoutMs) + : Task.FromException( + new InvalidOperationException("The Gateway connection changed before the request could be sent.")); + } + } + + 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("trust-marker 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 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 Action? AfterVerify { get; init; } + + public Task VerifyAsync( + GatewayRecord record, + int gatewayPort, + CancellationToken cancellationToken) + { + Calls++; + LastGatewayPort = gatewayPort; + cancellationToken.ThrowIfCancellationRequested(); + var result = _results.Count > 1 ? _results.Dequeue() : _results.Peek(); + AfterVerify?.Invoke(); + return result switch + { + GatewayTailscaleAuthLiveState state => Task.FromResult(state), + Exception error => Task.FromException(error), + _ => throw new InvalidOperationException("Unsupported fake live-verifier result."), + }; + } + } + + 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.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() { diff --git a/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs b/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs index b94dd45d6d..f81ad57454 100644 --- a/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs +++ b/tests/OpenClaw.E2ETests/Setup/SetupAndConnectTests.cs @@ -763,9 +763,12 @@ public async Task ExternalLike_QrOnlyFreshTray_RequiresExplicitDeviceApproval() using var dashboardDoc = await externalTray.Client.CallToolExpectSuccessAsync("app.dashboard.url"); 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); 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 ce6f0a2d3d..5d6db7d1cb 100644 --- a/tests/OpenClaw.SetupEngine.Tests/SetupStepsTests.cs +++ b/tests/OpenClaw.SetupEngine.Tests/SetupStepsTests.cs @@ -5882,11 +5882,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)); } @@ -7462,6 +7474,63 @@ private async Task AcceptLoopAsync() public void Dispose() => _listener.Stop(); } + [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 5b006ffa7b..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); @@ -156,6 +160,60 @@ public async Task SettingsSet_WithHandlerSuccessPayload_ReturnsData() Assert.True(res.Ok); } + [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 => + { + handlerStarted.TrySetResult(path); + return handlerResult.Task; + } + }; + var req = new NodeInvokeRequest + { + Id = "1", + Command = "app.dashboard.url", + Args = ParseArgs("{\"path\":\"settings\"}") + }; + + var responseTask = cap.ExecuteAsync(req); + Assert.Equal("settings", await handlerStarted.Task.WaitAsync(StepTimeout)); + 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] + 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/ExecApprovalsStoreTests.cs b/tests/OpenClaw.Shared.Tests/ExecApprovalsStoreTests.cs index 32553c7cde..fe8e3cdd8b 100644 --- a/tests/OpenClaw.Shared.Tests/ExecApprovalsStoreTests.cs +++ b/tests/OpenClaw.Shared.Tests/ExecApprovalsStoreTests.cs @@ -1624,7 +1624,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); @@ -1830,7 +1839,10 @@ private static void WriteAtomically(string filePath, string json) File.Move(tempPath, filePath, overwrite: true); } - private static async Task WaitForConditionAsync(Func condition, string message) + private static async Task WaitForConditionAsync( + Func condition, + string message, + Func? failureDetails = null) { var started = Stopwatch.GetTimestamp(); while (Stopwatch.GetElapsedTime(started) < ObservationTimeout) @@ -1843,7 +1855,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.Shared.Tests/GatewayFixtureInteractiveTests.cs b/tests/OpenClaw.Shared.Tests/GatewayFixtureInteractiveTests.cs index cade201551..bdd11f0641 100644 --- a/tests/OpenClaw.Shared.Tests/GatewayFixtureInteractiveTests.cs +++ b/tests/OpenClaw.Shared.Tests/GatewayFixtureInteractiveTests.cs @@ -662,6 +662,7 @@ private async Task ReadAsync() } } catch (OperationCanceledException) when (_lifetime.IsCancellationRequested) { } + catch (ObjectDisposedException) when (_lifetime.IsCancellationRequested || _expectServerShutdown) { } catch (WebSocketException) when (_lifetime.IsCancellationRequested || _expectServerShutdown) { } catch (ObjectDisposedException) when (_lifetime.IsCancellationRequested) { } finally diff --git a/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs index 6c2668e3ec..a13ff936c1 100644 --- a/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs +++ b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.cs @@ -50,6 +50,7 @@ public async Task BrowseQuestionDiscovery_ReturnsNoQuestionsWithoutEnablingInter Assert.Contains(server.Requests, request => request.Method == "question.list" && request.Outcome == "ok"); var error = await Assert.ThrowsAsync(() => connected.Client.SendWizardRequestAsync("question.request", new { title = "Not an interactive fixture" })); + Assert.True(GatewayRequestErrors.TryGetCodes(error, out _, out _)); Assert.Contains("Unknown fixture Gateway method", error.Message); Assert.Equal("question.request", Assert.Single(server.UnexpectedRequests).Method); } @@ -78,6 +79,7 @@ public async Task PlacementCatalog_RealClientLoadsSyntheticLocalEnvironmentWitho Assert.Contains(server.Requests, request => request.Method == method && request.Outcome == "ok"); var error = await Assert.ThrowsAsync(() => connected.Client.SendWizardRequestAsync("projects.add", new { gitUrl = "https://example.test/fixture.git" })); + Assert.True(GatewayRequestErrors.TryGetCodes(error, out _, out _)); Assert.Contains("read-only", error.Message); Assert.Contains(server.Requests, request => request.Method == "projects.add" && request.Outcome == "error:FIXTURE_READ_ONLY"); Assert.Empty(server.UnexpectedRequests); @@ -101,6 +103,7 @@ public async Task ReadOnlyScenarios_ListEmptyQuestionsThroughRealClient(bool nat Assert.DoesNotContain("question.resolve", scenario.ReadMethods); var error = await Assert.ThrowsAsync(() => connected.Client.SendWizardRequestAsync("question.list", new { unexpected = true })); + Assert.True(GatewayRequestErrors.TryGetCodes(error, out _, out _)); Assert.Contains("Unsupported fixture request parameter", error.Message); Assert.Empty(server.UnexpectedRequests); } @@ -164,10 +167,16 @@ public async Task SessionCreation_IsOptInResponseBoundAndPreservesParent(bool al var history = await client.SendWizardRequestAsync("chat.history", new { sessionKey = result.Key }); Assert.Empty(history.GetProperty("messages").EnumerateArray()); Assert.Equal(result.SessionId, history.GetProperty("sessionId").GetString()); - await Assert.ThrowsAsync(() => client.SendWizardRequestAsync( - "sessions.create", new { parentSessionKey = GatewayScenario.OtherSessionKey, fork = true })); - await Assert.ThrowsAsync(() => client.SendWizardRequestAsync( - "sessions.create", new { parentSessionKey = "unknown" })); + var unsupportedParameter = await Assert.ThrowsAsync(() => + client.SendWizardRequestAsync( + "sessions.create", new { parentSessionKey = GatewayScenario.OtherSessionKey, fork = true })); + Assert.Equal("UNKNOWN", GatewayRequestErrors.Code(unsupportedParameter)); + Assert.Equal("Unsupported fixture request parameter.", unsupportedParameter.Message); + var unknownParent = await Assert.ThrowsAsync(() => + client.SendWizardRequestAsync( + "sessions.create", new { parentSessionKey = "unknown" })); + Assert.Equal("UNKNOWN", GatewayRequestErrors.Code(unknownParent)); + Assert.Equal("Unknown fixture session key.", unknownParent.Message); Assert.Equal(6, (await client.SendWizardRequestAsync("sessions.list")).GetProperty("count").GetInt32()); Assert.Empty(server.UnexpectedRequests); } @@ -229,6 +238,62 @@ public async Task NativeSetup_ResponderGuardStillFaultsServerDisposal(bool cance } } + [Fact] + public async Task CronEditing_StoresExactSchedulesOnTheCurrentFixture() + { + var token = CreateToken(); + var scenario = GatewayScenario.CreateAutomations(); + await using var server = await FixtureGatewayServer.StartAsync(scenario, token); + await using var connected = await ConnectedClient.OpenAsync(server, token); + var client = connected.Client; + var listed = await client.SendWizardRequestAsync("cron.list", new { includeDisabled = true }); + Assert.Contains(listed.GetProperty("jobs").EnumerateArray(), job => + job.GetProperty("id").GetString() == "morning-brief"); + + foreach (var schedule in new object[] + { + new { kind = "cron", expr = "0 4 * * *", tz = "Pacific/Auckland" }, + new { kind = "cron", expr = "0 4 * * *", tz = "UTC" }, + new { kind = "cron", expr = "0 4 * * *" }, + new { kind = "every", everyMs = 60_000 } + }) + { + var response = await client.SendWizardRequestAsync("cron.update", new + { + id = "morning-brief", patch = new { schedule } + }); + var refreshed = await client.SendWizardRequestAsync("cron.list", new { includeDisabled = true }); + var stored = refreshed.GetProperty("jobs").EnumerateArray().Single(job => job.GetProperty("id").GetString() == "morning-brief"); + Assert.Equal(JsonSerializer.Serialize(schedule), response.GetProperty("schedule").GetRawText()); + Assert.Equal(response.GetProperty("schedule").GetRawText(), stored.GetProperty("schedule").GetRawText()); + } + var added = await client.SendWizardRequestAsync("cron.add", new + { + name = "New fixture job", + schedule = new { kind = "cron", expr = "0 5 * * *" }, + sessionTarget = "isolated", + payload = new { kind = "agentTurn", message = "Synthetic fixture task." } + }); + Assert.Equal("created-1", added.GetProperty("id").GetString()); + Assert.False(added.GetProperty("schedule").TryGetProperty("tz", out _)); + Assert.Equal(1, server.Requests.Count(request => request.Method == "cron.add")); + var toggled = await client.SendWizardRequestAsync("cron.update", new + { + id = "morning-brief", patch = new { enabled = false } + }); + Assert.False(toggled.GetProperty("enabled").GetBoolean()); + Assert.Equal("every", toggled.GetProperty("schedule").GetProperty("kind").GetString()); + var beforeInvalid = JsonSerializer.Serialize(scenario.GetCronJobs()); + var invalidSchedule = await Assert.ThrowsAsync(() => client.SendWizardRequestAsync("cron.update", + new { id = "morning-brief", patch = new { schedule = new { kind = "every", everyMs = "invalid" } } })); + Assert.Equal("INVALID_REQUEST", GatewayRequestErrors.Code(invalidSchedule)); + Assert.Equal(beforeInvalid, JsonSerializer.Serialize(scenario.GetCronJobs())); + var unknownJob = await Assert.ThrowsAsync(() => client.SendWizardRequestAsync("cron.update", + new { id = "unknown", patch = new { name = "Unknown" } })); + Assert.Equal("CRON_JOB_NOT_FOUND", GatewayRequestErrors.DetailCode(unknownJob)); + Assert.Empty(server.UnexpectedRequests); + } + [Fact] public async Task RestartClose_DrainsConcurrentClosesBeforeConnectionResourcesAreDisposed() { @@ -368,7 +433,8 @@ 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 })); + var resetDenied = await Assert.ThrowsAsync(() => client.SendWizardRequestAsync("sessions.reset", new { key = ContextUsageFixture.SessionKey })); + Assert.True(GatewayRequestErrors.TryGetCodes(resetDenied, out _, out _)); Assert.Empty(server.UnexpectedRequests); static JsonElement UsageRow(JsonElement listing) => listing.GetProperty("sessions").EnumerateArray() @@ -412,7 +478,7 @@ public async Task SessionMutations_AuthenticatedAcceptanceIsOptInAndResponseBoun server.ReleaseSessionMutations(); if (!allow) { - await Assert.ThrowsAsync(() => patch); + await Assert.ThrowsAnyAsync(() => patch); return; } await patch.WaitAsync(Deadline); @@ -764,7 +830,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"); @@ -787,7 +853,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." })); @@ -831,8 +897,10 @@ await Assert.ThrowsAsync(() => server.PublishChatFinalAsync( GatewayScenario.OtherSessionKey, sent.RunId!, "Wrong session.")); await Assert.ThrowsAsync(() => server.PublishChatFinalAsync( GatewayScenario.MainSessionKey, "unissued-run", "Unknown run.")); - await Assert.ThrowsAsync(() => + var wrongSessionAbort = await Assert.ThrowsAsync(() => client.SendChatAbortAsync(sent.RunId!, GatewayScenario.OtherSessionKey)); + Assert.Equal("UNKNOWN", GatewayRequestErrors.Code(wrongSessionAbort)); + Assert.Equal("Chat run was not issued for this fixture session.", wrongSessionAbort.Message); server.HoldChatAborts(); var abort = client.SendChatAbortAsync(sent.RunId!, GatewayScenario.MainSessionKey); @@ -844,7 +912,8 @@ await Assert.ThrowsAsync(() => if (fail) { var error = await Assert.ThrowsAsync(() => abort.WaitAsync(Deadline)); - Assert.Contains("Fixture abort rejected.", error.Message); + Assert.Equal("UNKNOWN", GatewayRequestErrors.Code(error)); + Assert.Equal("Fixture abort rejected.", error.Message); } else await abort.WaitAsync(Deadline); @@ -958,7 +1027,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" })); @@ -1071,7 +1140,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 6ae17ff352..77acbe470b 100644 --- a/tests/OpenClaw.Shared.Tests/GatewayProtocolLiveRoundTripTests.cs +++ b/tests/OpenClaw.Shared.Tests/GatewayProtocolLiveRoundTripTests.cs @@ -346,7 +346,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 572582a89d..36152c657d 100644 --- a/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs +++ b/tests/OpenClaw.Shared.Tests/OpenClawGatewayClientTests.cs @@ -684,7 +684,11 @@ await server.SendTextAsync(JsonSerializer.Serialize(new if (unavailable) await Assert.ThrowsAsync(() => getting.WaitAsync(StepTimeout)); else - await Assert.ThrowsAsync(() => getting.WaitAsync(StepTimeout)); + { + var error = await Assert.ThrowsAsync(() => getting.WaitAsync(StepTimeout)); + Assert.Equal("QUESTION_NOT_FOUND", error.Message); + Assert.Equal("UNKNOWN", GatewayRequestErrors.Code(error)); + } } [Theory] @@ -717,8 +721,14 @@ await server.SendTextAsync(JsonSerializer.Serialize(new })); var error = await Record.ExceptionAsync(() => sending.WaitAsync(StepTimeout)); Assert.IsType(expectedType, error); - if (expectedType != typeof(InvalidOperationException)) - Assert.DoesNotContain("private answer", error.Message); + if (GatewayRequestErrors.TryGetCodes(error!, out var code, out var detailCode)) + { + Assert.Equal("INVALID_REQUEST", code); + Assert.Null(detailCode); + Assert.Equal("private answer: QUESTION_ALREADY_TERMINAL QUESTION_INVALID_ANSWER", error!.Message); + } + else + Assert.DoesNotContain("private answer", error!.Message); Assert.Equal(0, helper.GetPendingRequestCount()); } @@ -1407,6 +1417,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( @@ -1615,7 +1633,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()); } @@ -1663,6 +1681,15 @@ public async Task ConfirmedMutation_RefusesCapturedEpochAfterConnectionChanged(s }; await Assert.ThrowsAsync(() => send); Assert.Equal(0, helper.GetPendingRequestCount()); + var probe = client.SendWizardRequestAsync("epoch.probe"); + var probeFrame = await server.ReceiveTextAsync().WaitAsync(StepTimeout); + using (var json = JsonDocument.Parse(probeFrame)) + Assert.Equal("epoch.probe", json.RootElement.GetProperty("method").GetString()); + await server.SendTextAsync(JsonSerializer.Serialize(new + { + type = "res", id = ReadRequestId(probeFrame), ok = true, payload = new { ok = true } + })); + Assert.True((await probe).GetProperty("ok").GetBoolean()); } [Fact] @@ -1749,6 +1776,51 @@ await server.SendTextAsync(JsonSerializer.Serialize(new Assert.Equal(0, helper.GetPendingRequestCount()); } + [Fact] + public async Task SearchSessions_CallerCancellationWhileQueuedDoesNotWriteAfterUnlock() + { + using var server = new LoopbackWebSocketServer(); + using var identity = new TempDirectory("search-request-cancel-send-"); + 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 + { + using var cancellation = new CancellationTokenSource(); + var search = client.SearchSessionsAsync("private-query", messages: true, cancellation.Token); + Assert.Equal(1, helper.GetPendingRequestCount()); + + cancellation.Cancel(); + await Assert.ThrowsAnyAsync(() => search.WaitAsync(StepTimeout)); + Assert.Equal(0, helper.GetPendingRequestCount()); + + sendLock.Release(); + lockHeld = false; + + var probe = client.SendWizardRequestAsync("health"); + var probeFrame = await server.ReceiveTextAsync().WaitAsync(StepTimeout); + using (var json = JsonDocument.Parse(probeFrame)) + Assert.Equal("health", json.RootElement.GetProperty("method").GetString()); + await server.SendTextAsync(JsonSerializer.Serialize(new + { + type = "res", id = ReadRequestId(probeFrame), ok = true, payload = new { ok = true } + })); + Assert.True((await probe).GetProperty("ok").GetBoolean()); + Assert.True(helper.IsTransportConnectedForTest()); + } + finally + { + if (lockHeld) + sendLock.Release(); + } + } + [Fact] public async Task SendWizardRequestAsync_GatewayError_PropagatesUnchangedAndCleansTracking() { @@ -1828,6 +1900,94 @@ await server.SendTextAsync( public void LocalRefusalCarriesNoGatewayCodes() => Assert.False(GatewayRequestErrors.TryGetCodes(new InvalidOperationException("hello-ok pending"), out _, out _)); + [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(); + helper.MarkHandshakeReady(); + using var config = JsonDocument.Parse("{}"); + + var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 10_000); + var request = await server.ReceiveTextAsync().WaitAsync(StepTimeout); + 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(StepTimeout); + + Assert.False(result.Ok); + Assert.True(result.IsGatewayRejection); + Assert.Null(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(); + helper.MarkHandshakeReady(); + using var config = JsonDocument.Parse("{}"); + + var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 10_000); + var request = await server.ReceiveTextAsync().WaitAsync(StepTimeout); + 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(StepTimeout); + + Assert.False(result.Ok); + Assert.False(result.IsGatewayRejection); + Assert.Null(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(); + helper.MarkHandshakeReady(); + using var config = JsonDocument.Parse("{}"); + + var responseTask = client.PatchConfigDetailedAsync(config.RootElement, "base-hash", 250); + await server.ReceiveTextAsync().WaitAsync(StepTimeout); + var result = await responseTask.WaitAsync(StepTimeout); + + Assert.False(result.Ok); + Assert.False(result.IsGatewayRejection); + Assert.True(result.TimedOut); + Assert.Null(result.Error); + } + [Fact] public async Task PatchConfigDetailedAsync_RejectedSave_DoesNotDiscloseTransformedOrPartialEchoes() { @@ -2052,6 +2212,52 @@ 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(StepTimeout)); + + Assert.Equal("Timed out sending wizard.status request", exception.Message); + Assert.Equal(0, helper.GetPendingRequestCount()); + sendLock.Release(); + lockHeld = false; + + var probe = client.SendWizardRequestAsync("wizard.after-timeout"); + var probeFrame = await server.ReceiveTextAsync().WaitAsync(StepTimeout); + using (var json = JsonDocument.Parse(probeFrame)) + Assert.Equal("wizard.after-timeout", json.RootElement.GetProperty("method").GetString()); + await server.SendTextAsync(JsonSerializer.Serialize(new + { + type = "res", id = ReadRequestId(probeFrame), ok = true, payload = new { ok = true } + })); + Assert.True((await probe).GetProperty("ok").GetBoolean()); + } + finally + { + if (lockHeld) + sendLock.Release(); + } + } + [Fact] public async Task SendWizardRequestAsync_LateResponseAfterTimeout_DoesNotChangeOutcomeOrTracking() { diff --git a/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs b/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs index 431cc4447a..b2a74ddffb 100644 --- a/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs +++ b/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs @@ -430,7 +430,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 diff --git a/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs b/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs index 19a9776df4..b896ad3668 100644 --- a/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs +++ b/tests/OpenClaw.Tray.Tests/AppRefactorContractTests.cs @@ -624,17 +624,56 @@ public void Dashboard_SurfacesSshTunnelConfigurationFailure() Assert.Contains("AsyncEventHandlerGuard.Run(", entry); var method = ExtractMethod(source, "TryOpenDashboardAsync"); - Assert.Contains("CreateDashboardLauncher(", method); - var launcher = source[source.IndexOf("private GatewayDashboardLauncher CreateDashboardLauncher", StringComparison.Ordinal)..]; + Assert.Contains("CreateGatewayDashboardLauncher(", method); + var launcher = source[source.IndexOf("private GatewayDashboardLauncher CreateGatewayDashboardLauncher", StringComparison.Ordinal)..]; launcher = launcher[..launcher.IndexOf("// ── IAppCommands", StringComparison.Ordinal)]; Assert.Contains("EnsureSshTunnelConfigured,", launcher); Assert.Contains("new DashboardBrowser(", launcher); Assert.DoesNotContain("Process.Start", launcher); - Assert.Contains("ShowDashboardLaunchFailureAsync", method); + Assert.Contains("ShowDashboardLaunchFailureAsync", launcher); Assert.DoesNotContain("GatewayDashboardUrlBuilder.Build", method); Assert.DoesNotContain("Process.Start", method); } + [Fact] + public void SetupDashboard_RechecksCurrentGatewayImmediatelyBeforeBrowserDispatch() + { + var source = ReadAppSources(); + + Assert.Contains("requestPath => ResolveActiveDashboardLinkRequest(requestPath, completion)", source); + Assert.Contains("authorizeDispatch: () =>", source); + Assert.Contains("RequireSetupDashboardAuthority(completion)", source); + } + + [Fact] + public void DashboardLinkPolicy_StaysDelegatedToFocusedService() + { + var source = ReadAppSources(); + + Assert.Contains("GatewayDashboardLinkService", source); + Assert.DoesNotContain("OpenDashboardAfterTailscaleAuthRevalidationAsync", source); + Assert.DoesNotContain(".RevalidateTailscaleDashboardAuthAsync(active.Id)", source); + 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]; + + 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 SavedDashboard_InvalidUrl_UsesLocalizedCopy() { @@ -649,7 +688,7 @@ public void SavedDashboard_InvalidUrl_UsesLocalizedCopy() "CurrentApp.ShowTransientConnectionError(", "LocalizationHelper.GetString(\"ConnectionPage_SavedDashboardInvalidAddress\")", "return;", - "Launcher.LaunchUriAsync("); + "OpenDashboardFromLinkServiceAsync("); Assert.DoesNotContain("urlError", method); var resources = File.ReadAllText(Path.Combine( diff --git a/tests/OpenClaw.Tray.Tests/AutomationsWebHandoffTests.cs b/tests/OpenClaw.Tray.Tests/AutomationsWebHandoffTests.cs index 224721b449..d4ad0b5206 100644 --- a/tests/OpenClaw.Tray.Tests/AutomationsWebHandoffTests.cs +++ b/tests/OpenClaw.Tray.Tests/AutomationsWebHandoffTests.cs @@ -21,8 +21,9 @@ public sealed class AutomationsWebHandoffTests public async Task OpenInWeb_LaunchesTheAutomationsRouteThroughTheDashboardLauncher(string gatewayUrl, string? jobId, string expected) { string? launched = null; - var launcher = new GatewayDashboardLauncher(() => true, - () => new(gatewayUrl, "shared secret", false, CredentialResolver.SourceSharedGatewayToken), + var launcher = CreateDashboardLauncher( + gatewayUrl, + appendBrowserCredential: true, url => { launched = url; return Task.FromResult(true); }, () => throw new InvalidOperationException("Unexpected failure")); @@ -38,10 +39,12 @@ public async Task OpenInWeb_LaunchesTheAutomationsRouteThroughTheDashboardLaunch public async Task OpenInWeb_NeverExportsDeviceOrBootstrapTokens(string source, bool bootstrap) { string? launched = null; - var launcher = new GatewayDashboardLauncher(() => true, - () => new("wss://gateway.example/control", "do-not-export", bootstrap, source), + var launcher = CreateDashboardLauncher( + "wss://gateway.example/control", + appendBrowserCredential: !bootstrap && source == CredentialResolver.SourceSharedGatewayToken, url => { launched = url; return Task.FromResult(true); }, - () => throw new InvalidOperationException("Unexpected failure")); + () => throw new InvalidOperationException("Unexpected failure"), + bootstrap ? null : "do-not-export"); Assert.True(await launcher.OpenAsync(CronProtocol.WebPath("job-1"))); Assert.Equal("https://gateway.example/control/cron?job=job-1", launched); @@ -52,8 +55,9 @@ public async Task OpenInWeb_FailureIsReportedWithoutRetrying() { var launches = 0; var failures = 0; - var launcher = new GatewayDashboardLauncher(() => true, - () => new("wss://gateway.example", "shared", false, CredentialResolver.SourceSharedGatewayToken), + var launcher = CreateDashboardLauncher( + "wss://gateway.example", + appendBrowserCredential: true, _ => { launches++; return Task.FromResult(false); }, () => failures++); @@ -61,6 +65,20 @@ public async Task OpenInWeb_FailureIsReportedWithoutRetrying() Assert.Equal((1, 1), (launches, failures)); } + private static GatewayDashboardLauncher CreateDashboardLauncher( + string gatewayUrl, + bool appendBrowserCredential, + Func> launchBrowser, + Action reportFailure, + string? token = "shared secret") => + new( + () => true, + path => new GatewayDashboardLinkRequest(gatewayUrl, path, token, appendBrowserCredential), + new GatewayDashboardLinkService((_, _) => Task.FromResult(false), key => key), + launchBrowser, + _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), + _ => reportFailure()); + private static string? ParseJob(string url) { var uri = new Uri(url); diff --git a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs index e791458de4..eece340610 100644 --- a/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs +++ b/tests/OpenClaw.Tray.Tests/ConnectionPageTailscaleRecoveryTests.cs @@ -5,6 +5,132 @@ 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); + Assert.Contains("result.Outcome == GatewayTailscaleAuthUpgradeOutcome.AlreadyEnabled", method); + Assert.Contains("? \"ConnectionPage_TailscaleDashboardAuthEnabled\"", method); + Assert.Contains(": \"ConnectionPage_TailscaleDashboardAuthAccepted\"", 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.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() + { + 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]; + + 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); + + 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 credentialExportGuard = validation.IndexOf( + "if (!result.BrowserCredentialIncluded)", + StringComparison.Ordinal); + var bypassReturn = validation.IndexOf( + "return true;", + credentialExportGuard, + StringComparison.Ordinal); + var provenanceLookup = validation.IndexOf( + "ManagedLocalPortProvenance", + bypassReturn, + StringComparison.Ordinal); + var credentialAuthorization = validation.IndexOf( + "InteractiveEndpointAuthorizer?.IsCredentialAllowed", + provenanceLookup, + StringComparison.Ordinal); + + 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] public void NetworkFailure_ForManagedTailscaleGateway_UsesDedicatedRecoveryPlan() { @@ -64,4 +190,5 @@ public void NetworkFailure_ForUnmanagedTailscaleGateway_UsesOrdinaryNetworkRecov Assert.Equal(RecoveryCategory.Network, plan.Recovery); Assert.NotEqual("Tailscale gateway unavailable", plan.StripHeadline); } + } 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/Dashboards/DashboardModelsTests.cs b/tests/OpenClaw.Tray.Tests/Dashboards/DashboardModelsTests.cs index 691df2cd10..29009eb079 100644 --- a/tests/OpenClaw.Tray.Tests/Dashboards/DashboardModelsTests.cs +++ b/tests/OpenClaw.Tray.Tests/Dashboards/DashboardModelsTests.cs @@ -83,11 +83,15 @@ public sealed class DashboardsWebHandoffTests public async Task Handoff_ThroughTheDashboardLauncher_OpensTheWebGalleryNotABoard(string gatewayUrl, string expected) { var launched = new List(); - var launcher = new OpenClawTray.Services.GatewayDashboardLauncher(() => true, - () => new OpenClaw.Connection.InteractiveGatewayCredential(gatewayUrl, "do-not-export", false, - OpenClaw.Connection.CredentialResolver.SourceDeviceToken), + var linkService = new OpenClawTray.Services.GatewayDashboardLinkService( + (_, _) => Task.FromResult(false), key => key); + var launcher = new OpenClawTray.Services.GatewayDashboardLauncher( + () => true, + path => new OpenClawTray.Services.GatewayDashboardLinkRequest(gatewayUrl, path, null, false), + linkService, url => { launched.Add(url); return Task.FromResult(true); }, - () => throw new InvalidOperationException("Unexpected launch failure")); + _ => throw new InvalidOperationException("Unexpected link failure"), + _ => throw new InvalidOperationException("Unexpected launch failure")); Assert.True(await launcher.OpenAsync(DashboardsRoute.WebGalleryPath)); var url = Assert.Single(launched); diff --git a/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs new file mode 100644 index 0000000000..dfc456d23d --- /dev/null +++ b/tests/OpenClaw.Tray.Tests/GatewayDashboardLinkServiceTests.cs @@ -0,0 +1,345 @@ +using System.Text.Json; +using OpenClaw.Connection; +using OpenClaw.Shared; +using OpenClaw.TestSupport; +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.True(result.BrowserCredentialIncluded); + 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.False(result.BrowserCredentialIncluded); + 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.True(result.BrowserCredentialIncluded); + Assert.Contains("token=shared-token", result.Url); + } + + [Theory] + [InlineData(false)] + [InlineData(true)] + public async Task BuildAsync_ExternalServe_PreservesConsentAndRequiresApprovedSharedFallback( + bool approveSharedFallback) + { + using var temp = new TempDirectory(); + var registry = new GatewayRegistry(temp.Path); + registry.AddOrUpdate(new GatewayRecord + { + Id = "gateway-1", + Url = "wss://host.tail1234.ts.net", + IsLocal = true, + SetupManagedDistroName = "OpenClawGateway", + TrustTailscaleAuth = true, + SharedGatewayToken = "shared-token", + }); + registry.SetActive("gateway-1"); + registry.Save(); + var commandRunner = new ExternalServeCommandRunner(); + var client = new AppliedTailscaleConfigClient(); + var upgrade = new GatewayTailscaleAuthUpgradeService( + registry, new GatewayTailscaleAuthLiveVerifier(commandRunner)); + var service = CreateService((id, cancellationToken) => + upgrade.RevalidateAsync(id, client, cancellationToken)); + + var result = await service.BuildAsync(Request( + appendBrowserCredential: approveSharedFallback, + tailscaleGatewayId: "gateway-1", + gatewayUrl: "wss://host.tail1234.ts.net")); + + Assert.Equal(1, client.ConfigRequests); + Assert.Equal(2, commandRunner.ProbeCalls); + Assert.False(result.TrustTailscaleAuth); + Assert.Equal(approveSharedFallback, result.Success); + Assert.Equal(approveSharedFallback, result.BrowserCredentialIncluded); + if (approveSharedFallback) + Assert.Equal("https://host.tail1234.ts.net/settings/profile#token=shared-token", result.Url); + else + { + Assert.Null(result.Url); + Assert.Equal("localized:DashboardLink_NoBrowserCompatibleCredential", result.Error); + } + var reloaded = new GatewayRegistry(temp.Path); + reloaded.Load(); + Assert.True(reloaded.GetActive()!.TrustTailscaleAuth); + Assert.Equal("shared-token", reloaded.GetActive()!.SharedGatewayToken); + } + + [Fact] + 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)); + + Assert.True(result.Success); + Assert.False(result.BrowserCredentialIncluded); + Assert.NotNull(result.Url); + 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() + { + 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_ExistingTokenFragmentIsOmittedWithoutBrowserCredentialApproval() + { + 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.False(result.BrowserCredentialIncluded); + Assert.Equal("https://gateway.example.test/mount/settings/profile#view=compact", 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("localized:DashboardLink_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("localized:DashboardLink_TailscaleRevalidationFailed", 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("localized:DashboardLink_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("localized:DashboardLink_TailscaleRevalidationFailed", result.RevalidationError); + Assert.DoesNotContain("sensitive", result.RevalidationError); + } + + private static GatewayDashboardLinkService CreateService( + Func> revalidate) => + new(revalidate, key => $"localized:{key}"); + + private sealed class AppliedTailscaleConfigClient : IGatewayTailscaleAuthConfigClient + { + public IReadOnlyList GrantedOperatorScopes => ["operator.admin"]; + public bool IsConnectedToGateway => true; + public long? SessionMutationConnectionEpoch => 1; + public int ConfigRequests { get; private set; } + + public Task RequestConfigDetailedAsync(int timeoutMs = 15000) + { + ConfigRequests++; + using var config = JsonDocument.Parse(""" + { + "sourceConfig": { + "gateway": { + "auth": { "allowTailscale": true }, + "tailscale": { "mode": "off" }, + "trustedProxies": ["127.0.0.1"] + } + }, + "configRevisionHash": "applied-config", + "appliedConfigHash": "applied-config" + } + """); + return Task.FromResult(config.RootElement.Clone()); + } + + public Task PatchConfigDetailedAsync( + JsonElement fullConfig, string? baseHash, int timeoutMs = 15000) => + throw new NotSupportedException(); + + public Task PatchConfigOnConnectionAsync( + JsonElement fullConfig, string? baseHash, long connectionEpoch, int timeoutMs = 15000) => + connectionEpoch == SessionMutationConnectionEpoch + ? PatchConfigDetailedAsync(fullConfig, baseHash, timeoutMs) + : Task.FromException(new InvalidOperationException( + "The Gateway connection changed before the request could be sent.")); + } + + private sealed class ExternalServeCommandRunner : IWslCommandRunner + { + public int ProbeCalls { get; private set; } + + public Task RunAsync( + IReadOnlyList arguments, + CancellationToken cancellationToken = default, + IReadOnlyDictionary? environment = null) + { + ProbeCalls++; + return Task.FromResult(new WslCommandResult(0, arguments.Contains("serve") + ? """{"Web":{"host.tail1234.ts.net:443":{"Handlers":{"/":{"Proxy":"http://127.0.0.1:18789"}}}}}""" + : """{"BackendState":"Running","Self":{"DNSName":"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(); + } + + private static GatewayDashboardLinkRequest Request( + bool appendBrowserCredential = true, + string? browserCredential = "shared-token", + string? tailscaleGatewayId = null, + string? gatewayUrl = null) => new( + gatewayUrl ?? "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 3a8bd127d4..14c6c3bf2d 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_TrustedTailscaleAuthRemovesTokenFragmentAndPreservesAllowedFields() + { + Assert.Equal("https://gateway.example/mount#view=compact", + 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/LocalizationValidationTests.cs b/tests/OpenClaw.Tray.Tests/LocalizationValidationTests.cs index 3c8cd09e1b..1148dbb99a 100644 --- a/tests/OpenClaw.Tray.Tests/LocalizationValidationTests.cs +++ b/tests/OpenClaw.Tray.Tests/LocalizationValidationTests.cs @@ -724,6 +724,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() { diff --git a/tests/OpenClaw.Tray.Tests/NativeCompletionPresentationTests.cs b/tests/OpenClaw.Tray.Tests/NativeCompletionPresentationTests.cs index db60e37003..1c2428caa9 100644 --- a/tests/OpenClaw.Tray.Tests/NativeCompletionPresentationTests.cs +++ b/tests/OpenClaw.Tray.Tests/NativeCompletionPresentationTests.cs @@ -338,9 +338,9 @@ public void NativeChannelDestinationsOpenGatewayDashboardAfterVerifiedConnection var app = Read(@"src\OpenClaw.Tray.WinUI\App.xaml.cs"); var callback = app[app.IndexOf("OpenSetupDashboard: async (completion, path, ct) =>", StringComparison.Ordinal)..]; callback = callback[..callback.IndexOf("}));", StringComparison.Ordinal)]; - Assert.Contains("CreateDashboardLauncher(", callback); + Assert.Contains("CreateGatewayDashboardLauncher(", callback); Assert.Contains("throw new InvalidOperationException(", callback); - var dispatchGate = callback[callback.IndexOf("launcher.OpenAsync(path, () =>", StringComparison.Ordinal)..]; + var dispatchGate = callback[callback.IndexOf("launcher.OpenAsync(path, authorizeDispatch: ()", StringComparison.Ordinal)..]; Assert.True(dispatchGate.IndexOf("ct.ThrowIfCancellationRequested();", StringComparison.Ordinal) < dispatchGate.IndexOf("RequireSetupDashboardAuthority(completion);", StringComparison.Ordinal)); Assert.Contains("IsSetupDashboardCredentialAllowed(setupCompletion, record)", app); diff --git a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj index 451b948fee..904461e9ce 100644 --- a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj +++ b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj @@ -198,6 +198,7 @@ + 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([])); } 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"); diff --git a/tests/OpenClaw.Tray.Tests/Services/AppNotificationServiceTests.cs b/tests/OpenClaw.Tray.Tests/Services/AppNotificationServiceTests.cs index 03a70bcf0e..26fe5efdf2 100644 --- a/tests/OpenClaw.Tray.Tests/Services/AppNotificationServiceTests.cs +++ b/tests/OpenClaw.Tray.Tests/Services/AppNotificationServiceTests.cs @@ -125,10 +125,14 @@ public async Task NavigateAction_DashboardWaitsForBrowserResultWithoutConsumingR var launch = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); string? launchedUrl = null; var failures = 0; - var launcher = new GatewayDashboardLauncher(() => true, - () => new InteractiveGatewayCredential("http://127.0.0.1:18789", "fixture-token", false, - CredentialResolver.SourceSharedGatewayToken), - url => { launchedUrl = url; return launch.Task; }, () => failures++); + var launcher = new GatewayDashboardLauncher( + () => true, + path => new GatewayDashboardLinkRequest( + "http://127.0.0.1:18789", path, "fixture-token", AppendBrowserCredential: true), + new GatewayDashboardLinkService((_, _) => Task.FromResult(false), key => key), + url => { launchedUrl = url; return launch.Task; }, + _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), + _ => failures++); var action = service.NavigateActionAsync("channel", (target, _) => WorkspaceNavigation.DispatchAsync(target, diff --git a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs index 0e365cff84..38911a2185 100644 --- a/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs +++ b/tests/OpenClaw.Tray.Tests/SetupDashboardHandoffTests.cs @@ -120,10 +120,9 @@ public void RetiredOrInvalidHandoff_IsVisibleFailureRoute_NotGlobalDashboardFall public async Task OrdinaryDashboard_UsesRequestedPathAndNormalCredentials(string? path, string suffix) { string? launched = null; - var launcher = new GatewayDashboardLauncher(() => true, - () => new(Gateway.Url, "synthetic shared", false, CredentialResolver.SourceSharedGatewayToken), - url => { launched = url; return Task.FromResult(true); }, - () => throw new InvalidOperationException("Unexpected failure")); + var launcher = CreateDashboardLauncher( + _ => new(Gateway.Url, path, "synthetic shared", true), + url => { launched = url; return Task.FromResult(true); }); Assert.True(await launcher.OpenAsync(path)); Assert.Equal("https://gateway.example/control" + suffix + "#token=synthetic%20shared", launched); Assert.DoesNotContain("custodian", launched); @@ -135,14 +134,211 @@ public async Task OrdinaryDashboard_UsesRequestedPathAndNormalCredentials(string public async Task DeviceAndBootstrapTokens_NeverEnterBrowserUrl(string source, bool bootstrap) { string? launched = null; - var launcher = new GatewayDashboardLauncher(() => true, - () => new(Gateway.Url, "do-not-export", bootstrap, source), - url => { launched = url; return Task.FromResult(true); }, - () => throw new InvalidOperationException("Unexpected failure")); + Assert.Equal(bootstrap ? CredentialResolver.SourceBootstrapToken : CredentialResolver.SourceDeviceToken, source); + var launcher = CreateDashboardLauncher( + _ => new(Gateway.Url, null, "do-not-export", false), + url => { launched = url; return Task.FromResult(true); }); Assert.True(await launcher.OpenAsync()); 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); + } + + [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_AuthorizesDispatchAfterCredentialValidation() + { + var calls = new List(); + 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, + _ => { calls.Add("launch"); 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, TailscaleGatewayId: "gateway-a"), + _ => { calls.Add("validate"); return Task.FromResult(true); }, + authorizeDispatch: () => calls.Add("authorize")); + + Assert.True(opened); + Assert.Equal(new[] { "validate", "authorize", "launch" }, calls); + } + + [Fact] + public async Task SavedDashboard_ApprovedEmbeddedTokenStillRequiresEndpointAuthorization() + { + 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: 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(false)] + [InlineData(true)] + public async Task DashboardLinkFailure_PassesLocalizedReasonToRecoveryWithoutLaunchingOrRetrying(bool saved) + { + var revalidations = 0; + var launches = 0; + var validations = 0; + var failureMessages = new List(); + 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), + reason => failureMessages.Add(reason), + () => 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("localized:DashboardLink_NoBrowserCompatibleCredential", Assert.Single(failureMessages)); + Assert.Equal(0, launches); + Assert.Equal(0, validations); + Assert.Equal(0, opened); + } + [Theory] [InlineData("tunnel")] [InlineData("credential")] @@ -151,18 +347,20 @@ public async Task DeviceAndBootstrapTokens_NeverEnterBrowserUrl(string source, b public async Task Failure_IsReportedOnceWithoutAutomaticRetry(string failure) { var launches = 0; - var failures = 0; - var launcher = new GatewayDashboardLauncher(() => failure != "tunnel", - () => failure == "credential" ? null : new(Gateway.Url, "shared", false, CredentialResolver.SourceSharedGatewayToken), + var failureMessages = new List(); + var launcher = CreateDashboardLauncher( + _ => failure == "credential" ? null : new(Gateway.Url, null, "shared", true), _ => { launches++; if (failure == "exception") throw new InvalidOperationException("synthetic-secret-url"); return Task.FromResult(false); - }, () => failures++); + }, + ensureTunnel: () => failure != "tunnel", + 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] @@ -182,9 +380,10 @@ public async Task CancelledDispatchGate_PropagatesWithoutLaunchingOrReportingFai var failures = 0; using var cts = new CancellationTokenSource(); cts.Cancel(); - var launcher = new GatewayDashboardLauncher(() => true, - () => new(Gateway.Url, "synthetic", false, CredentialResolver.SourceSharedGatewayToken), - _ => { launches++; return Task.FromResult(true); }, () => failures++); + var launcher = CreateDashboardLauncher( + _ => new(Gateway.Url, "channels", "synthetic", AppendBrowserCredential: true), + _ => { launches++; return Task.FromResult(true); }, + reportFailure: _ => failures++); await Assert.ThrowsAsync(() => launcher.OpenAsync("channels", () => cts.Token.ThrowIfCancellationRequested())); Assert.Equal(0, launches); @@ -195,21 +394,36 @@ await Assert.ThrowsAsync(() => public async Task ExplicitDashboardRetry_KeepsRequestedPathAndClearsFailureOnlyAfterOpen() { var urls = new List(); - var failures = 0; + var failureMessages = new List(); var opened = 0; - var launcher = new GatewayDashboardLauncher(() => true, - () => new(Gateway.Url, "synthetic", false, CredentialResolver.SourceSharedGatewayToken), + var launcher = CreateDashboardLauncher( + path => new(Gateway.Url, path, "synthetic", true), url => { urls.Add(url); return Task.FromResult(urls.Count == 2); }, - () => failures++, () => 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); } + private static GatewayDashboardLauncher CreateDashboardLauncher( + Func resolveRequest, + Func> launchBrowser, + Func? ensureTunnel = null, + Action? reportFailure = null, + Action? reportOpened = null) => + new( + ensureTunnel ?? (() => true), + resolveRequest, + new GatewayDashboardLinkService((_, _) => Task.FromResult(true), key => key), + launchBrowser, + _ => throw new InvalidOperationException("Unexpected Dashboard link failure"), + reportFailure ?? (_ => throw new InvalidOperationException("Unexpected launch failure")), + reportOpened); + [Fact] public async Task SetupChannelDashboardFailureRetainsReceiptForExplicitRetry() { @@ -223,10 +437,10 @@ public async Task SetupChannelDashboardFailureRetainsReceiptForExplicitRetry() (_, _) => Task.FromResult(new SetupVerifiedNativeRoute(Receipt(), completion.Target.SessionKey)), async (_, _) => { - var dashboard = new GatewayDashboardLauncher(() => true, - () => new(Gateway.Url, "synthetic", false, CredentialResolver.SourceSharedGatewayToken), - _ => Task.FromResult(++browserCalls > 1), () => { }); - if (!await dashboard.OpenAsync("channels", () => { })) + var dashboard = CreateDashboardLauncher( + _ => new GatewayDashboardLinkRequest(Gateway.Url, "channels", "synthetic", AppendBrowserCredential: true), + _ => Task.FromResult(++browserCalls > 1)); + if (!await dashboard.OpenAsync("channels")) throw new IOException("Synthetic browser dispatch failure"); }, _ => { }); diff --git a/tests/OpenClaw.Tray.Tests/SetupNativeChatPresentationTests.cs b/tests/OpenClaw.Tray.Tests/SetupNativeChatPresentationTests.cs index 2a458b3276..a64c5c3fca 100644 --- a/tests/OpenClaw.Tray.Tests/SetupNativeChatPresentationTests.cs +++ b/tests/OpenClaw.Tray.Tests/SetupNativeChatPresentationTests.cs @@ -503,8 +503,9 @@ public async Task SetupDashboardDispatchRequiresTheOriginalGatewayAndIdentity(st completion.Verification, completion.Target.SessionKey)), async (selected, _) => { - var dashboard = new GatewayDashboardLauncher(() => true, - () => + var dashboard = new GatewayDashboardLauncher( + () => true, + _ => { if (mutation == "gateway") identity.Registry.AddOrUpdate(Gateway with { Url = "wss://replaced.test/" }); @@ -513,16 +514,19 @@ public async Task SetupDashboardDispatchRequiresTheOriginalGatewayAndIdentity(st File.Delete(identity.IdentityFile); new DeviceIdentity(Path.GetDirectoryName(identity.IdentityFile)!).Initialize(); } - return new InteractiveGatewayCredential( - Gateway.Url, "synthetic shared", false, CredentialResolver.SourceSharedGatewayToken); + return new GatewayDashboardLinkRequest( + Gateway.Url, "channels", "synthetic shared", AppendBrowserCredential: true); }, + new GatewayDashboardLinkService((_, _) => Task.FromResult(false), key => key), _ => { browserLaunches++; return Task.FromResult(true); - }, () => { }); + }, + _ => { }, + _ => { }); var request = new SetupNativeNavigationRequest(selected); - if (!await dashboard.OpenAsync("channels", () => + if (!await dashboard.OpenAsync("channels", authorizeDispatch: () => request.GetConnectedClient(identity.Registry, h.Connection))) throw new InvalidOperationException("The bound dashboard was not dispatched."); }, value => failure = value); diff --git a/tests/OpenClaw.Tray.Tests/Usage/UsageHandoffTests.cs b/tests/OpenClaw.Tray.Tests/Usage/UsageHandoffTests.cs index f4fafcd416..b776359fc2 100644 --- a/tests/OpenClaw.Tray.Tests/Usage/UsageHandoffTests.cs +++ b/tests/OpenClaw.Tray.Tests/Usage/UsageHandoffTests.cs @@ -28,10 +28,14 @@ public async Task OpenInBrowser_OpensTheMountedUsageRouteWithoutRangeOrSessionCo Assert.Empty(commands.Navigations); string? launched = null; - var launcher = new GatewayDashboardLauncher(() => true, - () => new(gatewayUrl, "synthetic shared", false, CredentialResolver.SourceSharedGatewayToken), + var launcher = new GatewayDashboardLauncher( + () => true, + route => new GatewayDashboardLinkRequest( + gatewayUrl, route, "synthetic shared", AppendBrowserCredential: true), + new GatewayDashboardLinkService((_, _) => Task.FromResult(false), key => key), url => { launched = url; return Task.FromResult(true); }, - () => throw new InvalidOperationException("Unexpected launch failure.")); + _ => throw new InvalidOperationException("Unexpected Dashboard link failure."), + _ => throw new InvalidOperationException("Unexpected launch failure.")); Assert.True(await launcher.OpenAsync(path)); Assert.Equal(expected, launched); Assert.DoesNotContain("session", launched, StringComparison.OrdinalIgnoreCase); diff --git a/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs b/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs index a5809ef9af..71d6c3593e 100644 --- a/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs +++ b/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.UsageResponsive.cs @@ -711,6 +711,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/OnboardingNativeProof.cs b/tests/OpenClaw.Tray.UITests/OnboardingNativeProof.cs index 69a8274fc1..fed07c2e8b 100644 --- a/tests/OpenClaw.Tray.UITests/OnboardingNativeProof.cs +++ b/tests/OpenClaw.Tray.UITests/OnboardingNativeProof.cs @@ -558,7 +558,7 @@ await TestSupport.WaitForRenderedConditionAsync(() => 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 @@ -820,46 +820,169 @@ 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); - var original = await RunOcrPassAsync(ct => engine.RecognizeAsync(originalBitmap).AsTask(ct)); - 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 + static object? Optional(Func read) { - 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); - var result = await RunOcrPassAsync(ct => engine.RecognizeAsync(bitmap).AsTask(ct)); - var missing = labels.Where(label => !Normalize(result.Text).Contains(Normalize(label), StringComparison.Ordinal)).ToArray(); - File.WriteAllText(Path.ChangeExtension(path, ".ocr.json"), JsonSerializer.Serialize(new + 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 { - 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 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. - AssertManualLabelExceptions(missing, original.Text, result.Text); - return new(original.Text, result.Text, factor, decoder.PixelWidth, decoder.PixelHeight, - transform.ScaledWidth, transform.ScaledHeight, missing); + 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(); + timeoutRequestedMilliseconds = (int)OcrPassTimeout.TotalMilliseconds; + phase = "recognize-original"; + pass = 1; + recognitionAdmissionContext = originalAdmissionContext; + try { recognitionStartedTicks = Stopwatch.GetTimestamp(); } + catch { recognitionStartedTicks = null; } + var original = await RunOcrPassAsync(ct => + { + activeToken = ct; + var task = engine.RecognizeAsync(originalBitmap).AsTask(ct); + recognitionTask = task; + return task; + }); + 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(); + timeoutRequestedMilliseconds = (int)OcrPassTimeout.TotalMilliseconds; + phase = "recognize-scaled"; + pass = 2; + recognitionAdmissionContext = scaledAdmissionContext; + try { recognitionStartedTicks = Stopwatch.GetTimestamp(); } + catch { recognitionStartedTicks = null; } + var result = await RunOcrPassAsync(ct => + { + activeToken = ct; + var task = engine.RecognizeAsync(bitmap).AsTask(ct); + recognitionTask = task; + return task; + }); + 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"; + AssertManualLabelExceptions(missing, original.Text, result.Text); + 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; + } } internal static void AssertManualLabelExceptions(string[] missingLabels, string originalText, string scaledText) diff --git a/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs b/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs index 8d459567e8..60c6b2c7e7 100644 --- a/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs +++ b/tests/OpenClaw.Tray.UITests/SystemsPageProofTests.cs @@ -372,8 +372,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", diff --git a/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs b/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs index 0c37bf00d2..5519c44207 100644 --- a/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs +++ b/tests/OpenClaw.Tray.UITests/UIThreadFixture.cs @@ -132,7 +132,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)