The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers"; |
| 2 | import type { RelayManagedEndpointRuntimeConfig } from "@t3tools/contracts/relay"; |
| 3 | import * as Random from "effect/Random"; |
| 4 | import * as EnvironmentKeys from "./cloud/environmentKeys.ts"; |
| 5 | import * as AssetSigner from "./assets/AssetSigner.ts"; |
| 6 | import * as WorkspacePreviewRevisions from "./assets/WorkspacePreviewRevisions.ts"; |
| 7 | import * as DatabaseStorage from "./persistence/DatabaseStorage.ts"; |
| 8 | import * as StorageCleanup from "./storageCleanup.ts"; |
| 9 | import * as PullRequestSyncReactor from "./orchestration-v2/PullRequestSyncReactor.ts"; |
| 10 | import * as PullRequestWatchReactor from "./orchestration-v2/PullRequestWatchReactor.ts"; |
| 11 | import * as DelegatedTaskQuestionReactor from "./orchestration-v2/DelegatedTaskQuestionReactor.ts"; |
| 12 | // Effect wraps this raw Node HTTP server after its startup and write-error guards attach. |
| 13 | // @effect-diagnostics nodeBuiltinImport:off |
| 14 | import * as NodeHttp from "node:http"; |
| 15 | |
| 16 | import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer"; |
| 17 | import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; |
| 18 | import * as NodeServices from "@effect/platform-node/NodeServices"; |
| 19 | import { EnvironmentHttpApi, type RepositoryIdentity } from "@t3tools/contracts"; |
| 20 | import * as HostProcess from "@t3tools/shared/HostProcess"; |
| 21 | import * as Cause from "effect/Cause"; |
| 22 | import * as Duration from "effect/Duration"; |
| 23 | import * as Deferred from "effect/Deferred"; |
| 24 | import * as Effect from "effect/Effect"; |
| 25 | import * as Option from "effect/Option"; |
| 26 | import * as Layer from "effect/Layer"; |
| 27 | import * as Stream from "effect/Stream"; |
| 28 | import { FetchHttpClient, HttpRouter, HttpServer } from "effect/http"; |
| 29 | import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder"; |
| 30 | |
| 31 | import * as BackgroundPolicy from "./background/BackgroundPolicy.ts"; |
| 32 | import * as HostPowerMonitor from "./background/HostPowerMonitor.ts"; |
| 33 | import * as NonBlockingSpawner from "./process/NonBlockingSpawner.ts"; |
| 34 | import * as KeepAwake from "./background/KeepAwake.ts"; |
| 35 | import * as ServerConfig from "./config.ts"; |
| 36 | import { withRootRequestSpans, withUntracedRequests } from "./http.ts"; |
| 37 | import * as ServerHttp from "./http.ts"; |
| 38 | import { |
| 39 | guardHttpResponseWriteErrors, |
| 40 | keepIdleConnections, |
| 41 | rejectRequestsUntilServing, |
| 42 | } from "./httpResponseErrorGuard.ts"; |
| 43 | import { resolveLauncherPath } from "./cloud/pinnedRuntime.ts"; |
| 44 | import { fixPath } from "./os-jank.ts"; |
| 45 | import * as Ws from "./ws.ts"; |
| 46 | import * as AgentScopeLive from "./process/agentScope.ts"; |
| 47 | import * as ExternalLauncher from "./process/externalLauncher.ts"; |
| 48 | import * as SpawnWorker from "./process/SpawnWorker.ts"; |
| 49 | import * as NodePtyAdapter from "./terminal/NodePtyAdapter.ts"; |
| 50 | import * as PullRequestHttp from "./pullRequest/http.ts"; |
| 51 | import * as SpeechModelStore from "./speech/SpeechModelStore.ts"; |
| 52 | import * as SpeechService from "./speech/SpeechService.ts"; |
| 53 | import * as CloudSpeech from "./speech/CloudSpeech.ts"; |
| 54 | import { speechHttpApiLayer } from "./speech/http.ts"; |
| 55 | import { speechStreamRouteLayer } from "./speech/stream.ts"; |
| 56 | import * as PullRequestProviderRegistry from "./pullRequest/PullRequestProviderRegistry.ts"; |
| 57 | import * as PullRequestService from "./pullRequest/PullRequestService.ts"; |
| 58 | import * as IssueService from "./issue/IssueService.ts"; |
| 59 | import * as IssueTrackerConnections from "./issue/IssueTrackerConnections.ts"; |
| 60 | import * as IssueTrackerBindings from "./persistence/IssueTrackerBindings.ts"; |
| 61 | import * as IssueTrackerRegistry from "./issue/IssueTrackerRegistry.ts"; |
| 62 | import * as SqlitePersistence from "./persistence/Sqlite.ts"; |
| 63 | import * as PullRequestFilesViewed from "./persistence/PullRequestFilesViewed.ts"; |
| 64 | import * as PullRequestReviewGuides from "./persistence/PullRequestReviewGuides.ts"; |
| 65 | import * as PullRequestReviewGuideService from "./pullRequest/PullRequestReviewGuideService.ts"; |
| 66 | import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts"; |
| 67 | import * as AnalyticsService from "./telemetry/AnalyticsService.ts"; |
| 68 | import * as DelegatedTaskAnalytics from "./telemetry/DelegatedTaskAnalytics.ts"; |
| 69 | import * as ProviderUsageAnalytics from "./telemetry/ProviderUsageAnalytics.ts"; |
| 70 | import * as ModelManifest from "./provider/ModelManifest.ts"; |
| 71 | import * as ResetCreditCoordinator from "./provider/resetCreditCoordinator.ts"; |
| 72 | import * as EventNdjsonLogger from "./provider/EventNdjsonLogger.ts"; |
| 73 | import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions"; |
| 74 | import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions"; |
| 75 | import * as OpenCodeRuntime from "@t3tools/provider-opencode/server/OpenCodeRuntime"; |
| 76 | import * as OpenCodeServerLedger from "@t3tools/provider-opencode/server/OpenCodeServerLedger"; |
| 77 | import * as ProviderHostLive from "./provider/ProviderHostLive.ts"; |
| 78 | import * as DocumentText from "./provider/DocumentText.ts"; |
| 79 | import * as AcpRegistrySupport from "@t3tools/provider-acp-registry/server/AcpRegistrySupport"; |
| 80 | import * as CheckpointDiffQuery from "./checkpointing/CheckpointDiffQuery.ts"; |
| 81 | import * as NativeChildWorkQuery from "./orchestration-v2/NativeChildWorkQuery.ts"; |
| 82 | import * as CheckpointStore from "./checkpointing/CheckpointStore.ts"; |
| 83 | import * as SourceControlBuiltInDrivers from "./sourceControl/builtInDrivers.ts"; |
| 84 | import * as SourceControlSignIn from "./sourceControl/SourceControlSignIn.ts"; |
| 85 | import { BUILT_IN_SOURCE_CONTROL_DRIVER_LIST } from "./sourceControl/sourceControlDefinitions.ts"; |
| 86 | import * as TextGeneration from "./textGeneration/TextGeneration.ts"; |
| 87 | import * as SecretCheck from "./secrets/SecretCheck.ts"; |
| 88 | import * as SecretResolver from "./secrets/SecretResolver.ts"; |
| 89 | import * as ProviderInstanceRegistryHydration from "./provider/ProviderInstanceRegistryHydration.ts"; |
| 90 | import * as ProjectSettingsOverrideSweep from "./provider/ProjectSettingsOverrideSweep.ts"; |
| 91 | import * as TerminalManager from "./terminal/Manager.ts"; |
| 92 | import * as McpHttpServer from "./mcp/McpHttpServer.ts"; |
| 93 | import * as PeerForwarding from "./peer/PeerForwarding.ts"; |
| 94 | import * as RemoteDelegation from "./peer/RemoteDelegation.ts"; |
| 95 | import * as PeerClientPairing from "./peer/PeerClientPairing.ts"; |
| 96 | import * as PeerClientPairingHttp from "./peer/http.ts"; |
| 97 | import * as PeerLinkRequests from "./peer/PeerLinkRequests.ts"; |
| 98 | import * as PeerLinks from "./peer/PeerLinks.ts"; |
| 99 | import * as PeerMcpClient from "./peer/PeerMcpClient.ts"; |
| 100 | import * as PeerThreadRelay from "./peer/PeerThreadRelay.ts"; |
| 101 | import * as McpSessionRegistry from "./mcp/McpSessionRegistry.ts"; |
| 102 | import * as PreviewAutomationBroker from "./mcp/PreviewAutomationBroker.ts"; |
| 103 | import * as DeviceService from "./device/DeviceService.ts"; |
| 104 | import * as DeviceHubProxy from "./device/DeviceHubProxy.ts"; |
| 105 | import * as PreviewManager from "./preview/Manager.ts"; |
| 106 | import * as PortScanner from "./preview/PortScanner.ts"; |
| 107 | import * as PreviewTunnel from "./preview/PreviewTunnel.ts"; |
| 108 | import * as ServerBrowser from "./preview/ServerBrowser.ts"; |
| 109 | import * as PreviewAgentActivity from "./preview/PreviewAgentActivity.ts"; |
| 110 | import * as DesktopBrowserChannel from "./preview/DesktopBrowserChannel.ts"; |
| 111 | import * as ServerBrowserStream from "./preview/ServerBrowserStream.ts"; |
| 112 | import * as PreviewBrowser from "./preview/PreviewBrowser.ts"; |
| 113 | import * as ProcessRunner from "./processRunner.ts"; |
| 114 | import * as GitManager from "./git/GitManager.ts"; |
| 115 | import * as EnvironmentTheme from "./environmentTheme.ts"; |
| 116 | import * as Keybindings from "./keybindings.ts"; |
| 117 | import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts"; |
| 118 | import * as ServerOwnership from "./serverOwnership.ts"; |
| 119 | import * as AgentAwarenessRelay from "./relay/AgentAwarenessRelay.ts"; |
| 120 | import { hasCloudPublicConfig } from "./cloud/publicConfig.ts"; |
| 121 | import * as ServerSettings from "./serverSettings.ts"; |
| 122 | import * as ManagedLimits from "./policy/managedLimits.ts"; |
| 123 | import * as ManagedPolicy from "./policy/ManagedPolicy.ts"; |
| 124 | import * as ProjectEnrichmentService from "./project/ProjectEnrichmentService.ts"; |
| 125 | import * as NativeAppIconResolver from "./assets/NativeAppIconResolver.ts"; |
| 126 | import * as AntigravityInstallation from "./provider/AntigravityInstallation.ts"; |
| 127 | import * as ProviderInstallation from "./provider/providerInstallation.ts"; |
| 128 | import * as CodexInstallation from "./provider/CodexInstallation.ts"; |
| 129 | import * as ProviderInstallationGate from "./provider/ProviderInstallationGate.ts"; |
| 130 | import * as ProviderInstanceRegistry from "./provider/ProviderInstanceRegistry.ts"; |
| 131 | import * as ProviderAdapterRegistry from "./orchestration-v2/ProviderAdapterRegistry.ts"; |
| 132 | import * as ProviderRegistry from "./provider/ProviderRegistry.ts"; |
| 133 | import * as ProviderUsageLimitsIngestion from "./provider/ProviderUsageLimitsIngestion.ts"; |
| 134 | import * as UsageLimitSources from "./usage/UsageLimitSources.ts"; |
| 135 | import * as ProjectFaviconResolver from "./project/ProjectFaviconResolver.ts"; |
| 136 | import * as T3ProjectFileLoader from "./project/T3ProjectFileLoader.ts"; |
| 137 | import * as RepositoryIdentityResolver from "./project/RepositoryIdentityResolver.ts"; |
| 138 | import * as WorkspaceEntries from "./workspace/WorkspaceEntries.ts"; |
| 139 | import * as KnownWorkspaces from "./workspace/KnownWorkspaces.ts"; |
| 140 | import * as WorkspaceFileSystem from "./workspace/WorkspaceFileSystem.ts"; |
| 141 | import * as WorkspacePaths from "./workspace/WorkspacePaths.ts"; |
| 142 | import * as GitVcsDriver from "./vcs/GitVcsDriver.ts"; |
| 143 | import * as VcsAutomaticFetchInterval from "./vcs/VcsAutomaticFetchInterval.ts"; |
| 144 | import * as VcsDriverRegistry from "./vcs/VcsDriverRegistry.ts"; |
| 145 | import * as VcsProjectConfig from "./vcs/VcsProjectConfig.ts"; |
| 146 | import * as VcsProcess from "./vcs/VcsProcess.ts"; |
| 147 | import * as VcsProvisioningService from "./vcs/VcsProvisioningService.ts"; |
| 148 | import * as VcsStatusBroadcaster from "./vcs/VcsStatusBroadcaster.ts"; |
| 149 | import * as ProjectCloneTracker from "./project/ProjectCloneTracker.ts"; |
| 150 | import * as GitWorkflowService from "./git/GitWorkflowService.ts"; |
| 151 | import * as ReviewService from "./review/ReviewService.ts"; |
| 152 | import * as SourceControlProviderRegistry from "./sourceControl/SourceControlProviderRegistry.ts"; |
| 153 | import * as PullRequestReadCache from "./pullRequest/PullRequestReadCache.ts"; |
| 154 | import * as SourceControlRateLimit from "@t3tools/source-control-core/server/SourceControlRateLimit"; |
| 155 | import * as SourceControlRepositoryService from "./sourceControl/SourceControlRepositoryService.ts"; |
| 156 | import * as WorktreeSetupTracker from "./project/WorktreeSetupTracker.ts"; |
| 157 | import * as Observability from "./observability/Observability.ts"; |
| 158 | import * as HeapSnapshot from "./observability/HeapSnapshot.ts"; |
| 159 | import * as EventLoopMonitor from "./observability/EventLoopMonitor.ts"; |
| 160 | import * as ServerEnvironment from "./environment/ServerEnvironment.ts"; |
| 161 | import * as DirectEndpoints from "./environment/DirectEndpoints.ts"; |
| 162 | import * as RemoteOpenTargets from "./environment/RemoteOpenTargets.ts"; |
| 163 | import * as AuthHttp from "./auth/http.ts"; |
| 164 | import * as ReplayMarkers from "./auth/replayMarkers.ts"; |
| 165 | import * as ServerSecretStore from "./auth/ServerSecretStore.ts"; |
| 166 | import * as CodexManagedTokenBroker from "./provider/CodexManagedTokenBroker.ts"; |
| 167 | import * as WebhookRoute from "./scheduledTasks/webhookRoute.ts"; |
| 168 | import * as RelayDeliveryProof from "./scheduledTasks/RelayDeliveryProof.ts"; |
| 169 | import * as HeldHooksWaker from "./relay/HeldHooksWaker.ts"; |
| 170 | import * as McpOAuth from "./auth/McpOAuth.ts"; |
| 171 | import * as McpOAuthHttp from "./auth/mcpOAuthHttp.ts"; |
| 172 | import { |
| 173 | relayHookBaseUrl, |
| 174 | ScheduledTaskWebhookOrigin, |
| 175 | } from "./scheduledTasks/ScheduledTaskService.ts"; |
| 176 | import { |
| 177 | CLOUD_ENDPOINT_RUNTIME_CONFIG, |
| 178 | decodeRuntimeConfig, |
| 179 | RELAY_URL_SECRET, |
| 180 | } from "./cloud/config.ts"; |
| 181 | import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts"; |
| 182 | import * as EnvironmentAuthPolicy from "./auth/EnvironmentAuthPolicy.ts"; |
| 183 | import * as CloudHttp from "./cloud/http.ts"; |
| 184 | import * as GuestHttp from "./guest/http.ts"; |
| 185 | import * as LinkThreadHttp from "./peer/linkThreadHttp.ts"; |
| 186 | import * as CloudLink from "./cloud/CloudLink.ts"; |
| 187 | import * as ConnectReachability from "./cloud/ConnectReachability.ts"; |
| 188 | import { pendingServiceUpdateExists } from "./cloud/updateHandoff.ts"; |
| 189 | import * as RelayTracing from "./cloud/relayTracing.ts"; |
| 190 | import * as CloudManagedEndpointRuntime from "./cloud/ManagedEndpointRuntime.ts"; |
| 191 | import * as RelayClientLedger from "./cloud/RelayClientLedger.ts"; |
| 192 | import { |
| 193 | MANAGED_TUNNEL_FIRST_REGISTRATION_JITTER, |
| 194 | makeManagedTunnelRecovery, |
| 195 | managedTunnelStartupAction, |
| 196 | retryDesiredLinkReconcile, |
| 197 | retryManagedTunnelRegistration, |
| 198 | watchManagedTunnelOrigin, |
| 199 | } from "./cloud/managedTunnelStartup.ts"; |
| 200 | import * as CloudCliTokenManager from "./cloud/CliTokenManager.ts"; |
| 201 | import * as CloudCliState from "./cloud/CliState.ts"; |
| 202 | import * as ServerSelfUpdate from "./cloud/selfUpdate.ts"; |
| 203 | import * as DesktopAppUpdate from "./desktopUpdate/DesktopAppUpdate.ts"; |
| 204 | import * as ServiceLauncherClient from "./cloud/serviceLauncherClient.ts"; |
| 205 | import * as ProcessDiagnostics from "./diagnostics/ProcessDiagnostics.ts"; |
| 206 | import * as HostResources from "./resourceTelemetry/HostResources.ts"; |
| 207 | import * as ProcessResourceMonitor from "./diagnostics/ProcessResourceMonitor.ts"; |
| 208 | import * as TraceDiagnostics from "./diagnostics/TraceDiagnostics.ts"; |
| 209 | import * as TriageService from "./triage/TriageService.ts"; |
| 210 | import * as DesktopTelemetryReceiver from "./resourceTelemetry/DesktopTelemetryReceiver.ts"; |
| 211 | import * as NativeTelemetryClient from "./resourceTelemetry/NativeTelemetryClient.ts"; |
| 212 | import * as ResourceAttribution from "./resourceTelemetry/ResourceAttribution.ts"; |
| 213 | import * as ResourceMonitorBinary from "./resourceTelemetry/ResourceMonitorBinary.ts"; |
| 214 | import * as ProcessGroupMetrics from "./resourceTelemetry/ProcessGroupMetrics.ts"; |
| 215 | import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts"; |
| 216 | import * as AntigravityUsage from "./provider/Drivers/AntigravityUsage.ts"; |
| 217 | import { MuseUsageHome } from "@t3tools/provider-muse/server"; |
| 218 | import * as CursorAccountReader from "@t3tools/provider-cursor/server/CursorAccountReader"; |
| 219 | import * as CursorUsageAccounts from "@t3tools/provider-cursor/server/CursorUsageAccounts"; |
| 220 | import * as UsageService from "./usage/UsageService.ts"; |
| 221 | import * as CodexUsageHistory from "./usage/CodexUsageHistory.ts"; |
| 222 | import * as RuntimeLayer from "./orchestration-v2/runtimeLayer.ts"; |
| 223 | import * as ThreadViewers from "./orchestration-v2/ThreadViewers.ts"; |
| 224 | import * as ProjectStore from "./orchestration-v2/ProjectStore.ts"; |
| 225 | import * as ThreadSearch from "./orchestration-v2/ThreadSearch.ts"; |
| 226 | import * as ThreadSettlementService from "./orchestration-v2/ThreadSettlementService.ts"; |
| 227 | import * as IdleCompactionService from "./orchestration-v2/IdleCompactionService.ts"; |
| 228 | import * as ThreadPullRequestService from "./orchestration-v2/ThreadPullRequestService.ts"; |
| 229 | import * as ThreadIssueService from "./orchestration-v2/ThreadIssueService.ts"; |
| 230 | import * as RunFinalizationService from "./orchestration-v2/RunFinalizationService.ts"; |
| 231 | import * as ProjectionMaintenance from "./orchestration-v2/ProjectionMaintenance.ts"; |
| 232 | import * as ProjectionStoreV2 from "./orchestration-v2/ProjectionStore.ts"; |
| 233 | import { makePersistedServerRuntimeState } from "./serverRuntimeState.ts"; |
| 234 | import { closeNonPrivateNetworkConnections, loopbackUrlHostForAddress } from "./startupAccess.ts"; |
| 235 | import * as OrchestrationHttp from "./orchestration-v2/http.ts"; |
| 236 | import * as ProjectHttp from "./project/http.ts"; |
| 237 | import * as NetService from "@t3tools/shared/Net"; |
| 238 | import * as RelayClient from "@t3tools/shared/relayClient"; |
| 239 | import { |
| 240 | disableTailscaleServe, |
| 241 | ensureTailscaleServe, |
| 242 | readTailscaleServeRootHolder, |
| 243 | readTailscaleServeRoutesTo, |
| 244 | readTailscaleStatus, |
| 245 | } from "@t3tools/tailscale"; |
| 246 | import * as ServerActivation from "./serverActivation.ts"; |
| 247 | |
| 248 | // Escaped MCP handoff provenance can exceed find-my-way's 100-character segment default. |
| 249 | const HTTP_ROUTER_CONFIG = { |
| 250 | maxParamLength: 512, |
| 251 | } as const; |
| 252 | |
| 253 | // Skip Effect's default 20 s grace; WebSocket scope finalizers already close connections gracefully. |
| 254 | const HTTP_PREEMPTIVE_SHUTDOWN_GRACE_MS = 0; |
| 255 | const layerResourceAttribution = ResourceAttribution.layer; |
| 256 | const layerApplicationObservability = EventLoopMonitor.layer.pipe( |
| 257 | Layer.provideMerge(Observability.layer), |
| 258 | Layer.provideMerge(layerResourceAttribution), |
| 259 | ); |
| 260 | |
| 261 | // Share rotation state so driver loggers cannot race. |
| 262 | const layerProviderEventLoggers = Layer.effect( |
| 263 | ProviderEventLoggers.ProviderEventLoggers, |
| 264 | Effect.gen(function* () { |
| 265 | const { providerEventLogPath } = yield* ServerConfig.ServerConfig; |
| 266 | const attribution = yield* ResourceAttribution.ResourceAttribution; |
| 267 | const store = yield* EventNdjsonLogger.makeEventNdjsonLogStore(providerEventLogPath, { |
| 268 | attribution, |
| 269 | }).pipe( |
| 270 | Effect.catch((error) => |
| 271 | Effect.logWarning(error.message, { error }).pipe( |
| 272 | Effect.annotateLogs({ scope: "provider-observability" }), |
| 273 | Effect.as(undefined), |
| 274 | ), |
| 275 | ), |
| 276 | ); |
| 277 | if (!store) return ProviderEventLoggers.NoOpProviderEventLoggers; |
| 278 | yield* Effect.addFinalizer(() => store.close()); |
| 279 | return { native: store.logger("native"), canonical: store.logger("canonical") }; |
| 280 | }), |
| 281 | ); |
| 282 | |
| 283 | const layerPtyAdapter = NodePtyAdapter.layer; |
| 284 | |
| 285 | const layerServerSettings = ServerSettings.layer.pipe( |
| 286 | Layer.provide(ServerSecretStore.layer), |
| 287 | Layer.provideMerge(ManagedPolicy.layer), |
| 288 | Layer.provideMerge(SqlitePersistence.layerConfig), |
| 289 | ); |
| 290 | |
| 291 | const layerNativeTelemetry = NativeTelemetryClient.layer.pipe( |
| 292 | Layer.provide(ResourceMonitorBinary.layer), |
| 293 | ); |
| 294 | const layerDesktopTelemetryReceiver = DesktopTelemetryReceiver.layer.pipe( |
| 295 | Layer.provideMerge(layerServerSettings), |
| 296 | ); |
| 297 | |
| 298 | const layerResourceTelemetry = ResourceTelemetry.layer.pipe( |
| 299 | Layer.provideMerge(layerNativeTelemetry), |
| 300 | Layer.provideMerge(layerDesktopTelemetryReceiver), |
| 301 | ); |
| 302 | |
| 303 | const layerHostPowerMonitor = HostPowerMonitor.layer.pipe( |
| 304 | Layer.provide(layerDesktopTelemetryReceiver), |
| 305 | ); |
| 306 | |
| 307 | // A fresh receiver layer would open a second reader on the desktop telemetry fd. |
| 308 | const layerDesktopAppUpdate = DesktopAppUpdate.layer.pipe( |
| 309 | Layer.provide(layerDesktopTelemetryReceiver), |
| 310 | ); |
| 311 | |
| 312 | const layerBackground = BackgroundPolicy.layer.pipe( |
| 313 | Layer.provide(layerHostPowerMonitor), |
| 314 | Layer.provideMerge(layerServerSettings), |
| 315 | ); |
| 316 | |
| 317 | const layerUsage = UsageService.layer.pipe( |
| 318 | Layer.provide( |
| 319 | Layer.mergeAll( |
| 320 | AntigravityUsage.layer, |
| 321 | MuseUsageHome.layer, |
| 322 | CodexUsageHistory.layer, |
| 323 | CursorUsageAccounts.layer.pipe(Layer.provide(CursorAccountReader.layer)), |
| 324 | ).pipe(Layer.provide(ProviderHostLive.layer.pipe(Layer.provide(ServerSecretStore.layer)))), |
| 325 | ), |
| 326 | Layer.provide(layerServerSettings), |
| 327 | ); |
| 328 | |
| 329 | const layerResourceDiagnostics = Layer.mergeAll( |
| 330 | HostResources.layer, |
| 331 | layerResourceTelemetry, |
| 332 | ProcessDiagnostics.layer.pipe(Layer.provide(layerResourceTelemetry)), |
| 333 | ProcessResourceMonitor.layer.pipe(Layer.provide(layerResourceTelemetry)), |
| 334 | ProcessGroupMetrics.layer.pipe(Layer.provide(layerResourceTelemetry)), |
| 335 | ); |
| 336 | |
| 337 | const layerRelayClient = Layer.unwrap( |
| 338 | Effect.gen(function* () { |
| 339 | const config = yield* ServerConfig.ServerConfig; |
| 340 | const policy = yield* ManagedPolicy.ManagedPolicy; |
| 341 | const layerCloudflared = RelayClient.layerCloudflared({ baseDir: config.baseDir }); |
| 342 | if (ManagedLimits.allowsConnect(policy)) return layerCloudflared; |
| 343 | // The connector only carries T3 Connect, so a policy without Connect never installs one. |
| 344 | const refused = Effect.fn("RelayClient.installRefusedByPolicy")(function* () { |
| 345 | return yield* new RelayClient.RelayClientInstallError({ |
| 346 | reason: "managed_by_policy", |
| 347 | message: ManagedLimits.refuseConnect(policy).message, |
| 348 | }); |
| 349 | }); |
| 350 | return Layer.effect( |
| 351 | RelayClient.RelayClient, |
| 352 | Effect.gen(function* () { |
| 353 | const relayClient = yield* RelayClient.RelayClient; |
| 354 | return RelayClient.RelayClient.of({ |
| 355 | ...relayClient, |
| 356 | install: refused(), |
| 357 | installWithProgress: refused, |
| 358 | }); |
| 359 | }), |
| 360 | ).pipe(Layer.provide(layerCloudflared)); |
| 361 | }), |
| 362 | ).pipe(Layer.provide(ManagedPolicy.layer)); |
| 363 | |
| 364 | // NodeServices and NodeHttpServer each output Node's own spawner, so each is followed by this one. |
| 365 | const layerSpawner = SpawnWorker.layerServer.pipe(Layer.provide(NodeServices.layer)); |
| 366 | |
| 367 | const layerHttpServer = Layer.unwrap( |
| 368 | Effect.gen(function* () { |
| 369 | const config = yield* ServerConfig.ServerConfig; |
| 370 | // Before binding: a host the policy does not allow must never listen, not even briefly. |
| 371 | const policy = yield* ManagedPolicy.ManagedPolicy; |
| 372 | const bindHost = yield* ManagedLimits.checkServerReachability(policy, { |
| 373 | authPolicy: EnvironmentAuthPolicy.resolveServerAuthPolicy(config), |
| 374 | host: config.host, |
| 375 | tailscaleServeEnabled: config.tailscaleServeEnabled, |
| 376 | privateNetworkOnly: config.privateNetworkOnly, |
| 377 | }); |
| 378 | yield* ManagedLimits.closeTailscaleServeTo(policy, { host: bindHost, port: config.port }); |
| 379 | const runSync = Effect.runSyncWith(yield* Effect.context<never>()); |
| 380 | return NodeHttpServer.layer( |
| 381 | () => { |
| 382 | const server = rejectRequestsUntilServing( |
| 383 | keepIdleConnections(guardHttpResponseWriteErrors(NodeHttp.createServer())), |
| 384 | ); |
| 385 | if (config.privateNetworkOnly) { |
| 386 | runSync(closeNonPrivateNetworkConnections(server)); |
| 387 | } |
| 388 | return server; |
| 389 | }, |
| 390 | { |
| 391 | host: bindHost, |
| 392 | port: config.port, |
| 393 | gracefulShutdownTimeout: HTTP_PREEMPTIVE_SHUTDOWN_GRACE_MS, |
| 394 | // Context takeover stays enabled (ws default) so the compression |
| 395 | // window is shared across frames — that also makes small frames cheap |
| 396 | // to compress, so no size threshold is set (ws only honors |
| 397 | // `threshold` when context takeover is disabled). |
| 398 | websocket: { perMessageDeflate: true }, |
| 399 | }, |
| 400 | ).pipe(Layer.merge(layerSpawner)); |
| 401 | }), |
| 402 | ).pipe( |
| 403 | Layer.provide(ManagedPolicy.layer), |
| 404 | // NodeHttpServer.layer also outputs NodeServices, whose spawner would shadow the wrapped one. |
| 405 | (layer) => NonBlockingSpawner.layer.pipe(Layer.provideMerge(layer)), |
| 406 | ); |
| 407 | |
| 408 | const layerPlatformServices = DocumentText.layer.pipe( |
| 409 | Layer.provideMerge(NonBlockingSpawner.layer), |
| 410 | Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer, layerSpawner)), |
| 411 | ); |
| 412 | |
| 413 | const layerPersistence = Layer.empty.pipe(Layer.provideMerge(SqlitePersistence.layerConfig)); |
| 414 | |
| 415 | const layerVcsDriverRegistry = VcsDriverRegistry.layer.pipe(Layer.provide(VcsProjectConfig.layer)); |
| 416 | |
| 417 | const layerSourceControlProviderRegistry = SourceControlProviderRegistry.layer.pipe( |
| 418 | Layer.provideMerge(SourceControlBuiltInDrivers.layer), |
| 419 | Layer.provideMerge(GitVcsDriver.layer), |
| 420 | Layer.provideMerge(layerVcsDriverRegistry), |
| 421 | ); |
| 422 | |
| 423 | const layerRepositoryIdentityResolver = Layer.effect( |
| 424 | RepositoryIdentityResolver.RepositoryIdentityResolver, |
| 425 | Effect.gen(function* () { |
| 426 | const registry = yield* SourceControlProviderRegistry.SourceControlProviderRegistry; |
| 427 | return yield* RepositoryIdentityResolver.make({ |
| 428 | refine: Effect.fn(function* (identity: RepositoryIdentity) { |
| 429 | for (const { kind } of BUILT_IN_SOURCE_CONTROL_DRIVER_LIST) { |
| 430 | const provider = yield* registry.get(kind); |
| 431 | if (provider.refineRepositoryIdentity === undefined) continue; |
| 432 | const refined = yield* provider.refineRepositoryIdentity({ |
| 433 | identity, |
| 434 | resolveContext: (input) => |
| 435 | registry.resolveHandle(input).pipe(Effect.map((handle) => handle.context)), |
| 436 | }); |
| 437 | if (refined !== identity) return refined; |
| 438 | } |
| 439 | return identity; |
| 440 | }), |
| 441 | }); |
| 442 | }), |
| 443 | ).pipe(Layer.provide(layerSourceControlProviderRegistry), Layer.provide(ProcessRunner.layer)); |
| 444 | |
| 445 | const layerPullRequestService = PullRequestService.layer.pipe( |
| 446 | Layer.provide(PullRequestProviderRegistry.layer), |
| 447 | Layer.provide(PullRequestFilesViewed.layer), |
| 448 | Layer.provide(PullRequestReadCache.layer), |
| 449 | Layer.provide(layerSourceControlProviderRegistry), |
| 450 | Layer.provide(SourceControlRateLimit.layer), |
| 451 | ); |
| 452 | |
| 453 | // Both read the one registry, so a standalone tracker connected in Settings is the same |
| 454 | // instance the listing reads through. |
| 455 | const layerIssueService = Layer.merge(IssueService.layer, IssueTrackerConnections.layer).pipe( |
| 456 | Layer.provide(Layer.merge(IssueTrackerRegistry.layer, IssueTrackerBindings.layer)), |
| 457 | ); |
| 458 | |
| 459 | // One instance serves MCP link calls and refreshes snapshots on thread events. |
| 460 | const layerThreadIssueService = ThreadIssueService.layer; |
| 461 | |
| 462 | const layerGitManager = GitManager.layer.pipe( |
| 463 | Layer.provide(Layer.merge(ProjectionStoreV2.layer, ProjectStore.layer)), |
| 464 | Layer.provide(layerPullRequestService.pipe(Layer.provide(RuntimeLayer.layerProjectService))), |
| 465 | Layer.provideMerge(RuntimeLayer.layerProjectSetupScriptRunner), |
| 466 | Layer.provideMerge(WorktreeSetupTracker.layer), |
| 467 | Layer.provideMerge(GitVcsDriver.layer), |
| 468 | Layer.provideMerge(layerSourceControlProviderRegistry), |
| 469 | Layer.provideMerge(TextGeneration.layer.pipe(Layer.provide(layerSourceControlProviderRegistry))), |
| 470 | ); |
| 471 | |
| 472 | const layerGit = Layer.empty.pipe( |
| 473 | Layer.provideMerge(layerGitManager), |
| 474 | Layer.provideMerge(GitVcsDriver.layer), |
| 475 | ); |
| 476 | |
| 477 | const layerGitWorkflow = GitWorkflowService.layer.pipe( |
| 478 | Layer.provideMerge(layerVcsDriverRegistry), |
| 479 | Layer.provideMerge(layerGit), |
| 480 | ); |
| 481 | |
| 482 | const layerSourceControlRepositoryService = SourceControlRepositoryService.layer.pipe( |
| 483 | Layer.provideMerge(GitVcsDriver.layer), |
| 484 | Layer.provideMerge(layerSourceControlProviderRegistry), |
| 485 | ); |
| 486 | |
| 487 | const layerProjectCloneTracker = ProjectCloneTracker.layer.pipe( |
| 488 | Layer.provide(layerSourceControlRepositoryService), |
| 489 | ); |
| 490 | |
| 491 | const layerKnownWorkspaces = KnownWorkspaces.layer.pipe( |
| 492 | Layer.provide(ProjectStore.layer), |
| 493 | Layer.provide(GitVcsDriver.layer), |
| 494 | ); |
| 495 | |
| 496 | const layerReview = ReviewService.layer.pipe( |
| 497 | Layer.provideMerge(layerKnownWorkspaces), |
| 498 | Layer.provideMerge(GitVcsDriver.layer), |
| 499 | Layer.provideMerge(layerVcsDriverRegistry), |
| 500 | ); |
| 501 | |
| 502 | const layerVcs = Layer.empty.pipe( |
| 503 | Layer.provideMerge(VcsProjectConfig.layer), |
| 504 | Layer.provideMerge(layerVcsDriverRegistry), |
| 505 | Layer.provideMerge(VcsProvisioningService.layer.pipe(Layer.provide(layerVcsDriverRegistry))), |
| 506 | Layer.provideMerge(layerGitWorkflow), |
| 507 | Layer.provideMerge(layerReview), |
| 508 | Layer.provideMerge(layerSourceControlRepositoryService), |
| 509 | Layer.provideMerge( |
| 510 | SourceControlSignIn.layer.pipe(Layer.provide(layerSourceControlProviderRegistry)), |
| 511 | ), |
| 512 | Layer.provideMerge(layerProjectCloneTracker), |
| 513 | Layer.provideMerge( |
| 514 | VcsStatusBroadcaster.layer.pipe( |
| 515 | Layer.provide(layerGitWorkflow), |
| 516 | // The orchestration runtime also consumes the broadcaster (run |
| 517 | // finalization), so the policy cannot read the store from the runtime's |
| 518 | // output. |
| 519 | Layer.provide( |
| 520 | VcsStatusBroadcaster.layerAutoPullPolicy.pipe(Layer.provide(ProjectStore.layer)), |
| 521 | ), |
| 522 | ), |
| 523 | ), |
| 524 | ); |
| 525 | |
| 526 | const layerCheckpointStore = CheckpointStore.layer.pipe(Layer.provide(layerVcsDriverRegistry)); |
| 527 | |
| 528 | const layerPortScanner = PortScanner.layer.pipe( |
| 529 | Layer.provide(ProcessRunner.layer), |
| 530 | Layer.provide(layerBackground), |
| 531 | ); |
| 532 | |
| 533 | const layerTerminal = TerminalManager.layer( |
| 534 | ProviderInstanceRegistryHydration.deriveProviderInstanceConfigMap, |
| 535 | ).pipe( |
| 536 | Layer.provide(layerPtyAdapter), |
| 537 | Layer.provide(layerPortScanner), |
| 538 | Layer.provide(layerNativeTelemetry), |
| 539 | ); |
| 540 | |
| 541 | const layerPreview = Layer.empty.pipe( |
| 542 | Layer.provideMerge(PreviewTunnel.layer), |
| 543 | Layer.provideMerge(PreviewManager.layer), |
| 544 | Layer.provideMerge(layerPortScanner), |
| 545 | ); |
| 546 | |
| 547 | const layerDevice = DeviceService.layer.pipe( |
| 548 | Layer.provide(layerServerSettings), |
| 549 | Layer.provide(ProcessRunner.layer), |
| 550 | Layer.provide(NetService.layer), |
| 551 | ); |
| 552 | |
| 553 | const layerWorkspaceEntries = WorkspaceEntries.layer.pipe(Layer.provide(WorkspacePaths.layer)); |
| 554 | |
| 555 | const layerWorkspaceFileSystem = WorkspaceFileSystem.layer.pipe( |
| 556 | Layer.provide(WorkspacePaths.layer), |
| 557 | Layer.provide(layerWorkspaceEntries), |
| 558 | Layer.provide(layerKnownWorkspaces), |
| 559 | ); |
| 560 | |
| 561 | const layerWorkspace = Layer.mergeAll( |
| 562 | WorkspacePaths.layer, |
| 563 | layerWorkspaceEntries, |
| 564 | layerWorkspaceFileSystem, |
| 565 | ); |
| 566 | |
| 567 | const layerProjectFaviconResolver = ProjectFaviconResolver.layer.pipe( |
| 568 | Layer.provide(WorkspacePaths.layer), |
| 569 | Layer.provide(T3ProjectFileLoader.layer), |
| 570 | ); |
| 571 | |
| 572 | const layerServerEnvironment = ServerEnvironment.layer.pipe(Layer.provide(ServerSecretStore.layer)); |
| 573 | |
| 574 | const layerAuth = EnvironmentAuth.layer.pipe( |
| 575 | Layer.provideMerge(layerPersistence), |
| 576 | Layer.provide(layerServerEnvironment), |
| 577 | Layer.provide(ServerSecretStore.layer), |
| 578 | ); |
| 579 | |
| 580 | const layerCloudManagedEndpointRuntime = Layer.mergeAll( |
| 581 | layerRelayClient, |
| 582 | CloudManagedEndpointRuntime.layer.pipe( |
| 583 | Layer.provide(ServerSecretStore.layer), |
| 584 | Layer.provide(layerRelayClient), |
| 585 | Layer.provide( |
| 586 | Layer.unwrap( |
| 587 | Effect.gen(function* () { |
| 588 | const config = yield* ServerConfig.ServerConfig; |
| 589 | return RelayClientLedger.layer({ stateDir: config.stateDir }); |
| 590 | }), |
| 591 | ), |
| 592 | ), |
| 593 | ), |
| 594 | ); |
| 595 | |
| 596 | const layerScheduledTaskWebhookOrigin = Layer.effect( |
| 597 | ScheduledTaskWebhookOrigin, |
| 598 | Effect.gen(function* () { |
| 599 | const secrets = yield* ServerSecretStore.ServerSecretStore; |
| 600 | return Effect.gen(function* () { |
| 601 | const [relayUrl, tunnelConfig] = yield* Effect.all([ |
| 602 | secrets.get(RELAY_URL_SECRET), |
| 603 | secrets.get(CLOUD_ENDPOINT_RUNTIME_CONFIG), |
| 604 | ]).pipe(Effect.orElseSucceed(() => [Option.none(), Option.none()] as const)); |
| 605 | if (Option.isNone(relayUrl) || Option.isNone(tunnelConfig)) { |
| 606 | return { relayHookBaseUrl: null }; |
| 607 | } |
| 608 | const config = decodeRuntimeConfig(new TextDecoder().decode(tunnelConfig.value)); |
| 609 | return { |
| 610 | relayHookBaseUrl: relayHookBaseUrl({ |
| 611 | relayUrl: new TextDecoder().decode(relayUrl.value), |
| 612 | tunnelName: Option.isSome(config) ? config.value.tunnelName : undefined, |
| 613 | }), |
| 614 | }; |
| 615 | }); |
| 616 | }), |
| 617 | ); |
| 618 | |
| 619 | const layerOrchestrationV2Runtime = RuntimeLayer.layerProduction.pipe( |
| 620 | Layer.provide(UsageLimitSources.layerResetFallback), |
| 621 | Layer.provide(layerScheduledTaskWebhookOrigin), |
| 622 | Layer.provide(ProviderUsageAnalytics.layer), |
| 623 | Layer.provide(layerCheckpointStore), |
| 624 | Layer.provide(layerGitWorkflow), |
| 625 | Layer.provide( |
| 626 | RunFinalizationService.layerObserver.pipe( |
| 627 | Layer.provide(ProjectionStoreV2.layer), |
| 628 | Layer.provide(layerPullRequestService), |
| 629 | Layer.provide(RuntimeLayer.layerProjectService), |
| 630 | ), |
| 631 | ), |
| 632 | ); |
| 633 | |
| 634 | const layerOrchestrationApplication = Layer.merge( |
| 635 | CheckpointDiffQuery.layer, |
| 636 | NativeChildWorkQuery.layer, |
| 637 | ).pipe(Layer.provideMerge(layerCheckpointStore), Layer.provideMerge(layerOrchestrationV2Runtime)); |
| 638 | |
| 639 | const layerThreadSettlementWorker = Layer.effectDiscard( |
| 640 | ThreadSettlementService.make.pipe(Effect.flatMap((service) => service.start())), |
| 641 | ).pipe(Layer.provide(layerPullRequestService), Layer.provide(ProjectionStoreV2.layer)); |
| 642 | |
| 643 | const layerIdleCompactionWorker = Layer.effectDiscard( |
| 644 | IdleCompactionService.make.pipe(Effect.flatMap((service) => service.start())), |
| 645 | ).pipe(Layer.provide(ProjectionStoreV2.layer)); |
| 646 | |
| 647 | const layerThreadPullRequestWorker = Layer.effectDiscard( |
| 648 | ThreadPullRequestService.make.pipe(Effect.flatMap((service) => service.start())), |
| 649 | ).pipe(Layer.provide(layerPullRequestService)); |
| 650 | |
| 651 | const layerProviderInstallationRefresh = Layer.effectDiscard( |
| 652 | Effect.gen(function* () { |
| 653 | const antigravity = yield* AntigravityInstallation.AntigravityInstallation; |
| 654 | const codex = yield* CodexInstallation.CodexInstallation; |
| 655 | const instances = yield* ProviderInstanceRegistry.ProviderInstanceRegistry; |
| 656 | const providers = yield* ProviderRegistry.ProviderRegistry; |
| 657 | yield* Stream.merge( |
| 658 | antigravity.changes.pipe( |
| 659 | Stream.changesWith((a, b) => a.installedVersion === b.installedVersion), |
| 660 | Stream.drop(1), |
| 661 | ), |
| 662 | codex.changes.pipe( |
| 663 | Stream.changesWith((a, b) => a.installedVersion === b.installedVersion), |
| 664 | Stream.drop(1), |
| 665 | ), |
| 666 | ).pipe( |
| 667 | Stream.runForEach((state) => |
| 668 | instances.listInstances.pipe( |
| 669 | Effect.flatMap((entries) => |
| 670 | Effect.forEach( |
| 671 | entries.filter((instance) => instance.driverKind === state.driver), |
| 672 | (instance) => providers.refreshInstance(instance.instanceId), |
| 673 | { discard: true }, |
| 674 | ), |
| 675 | ), |
| 676 | ), |
| 677 | ), |
| 678 | Effect.forkScoped, |
| 679 | ); |
| 680 | }), |
| 681 | ); |
| 682 | |
| 683 | // The desktop app and the background service start the server again after it exits. |
| 684 | const layerServerRestart = Layer.effect( |
| 685 | DatabaseStorage.ServerRestart, |
| 686 | Effect.gen(function* () { |
| 687 | const config = yield* ServerConfig.ServerConfig; |
| 688 | const launcher = yield* ServiceLauncherClient.ServiceLauncherClient; |
| 689 | // As in runServerCommand, only the desktop app passes a bootstrap token; `serve --mode desktop` by hand has no supervisor. |
| 690 | const desktopLaunched = config.mode === "desktop" && config.desktopBootstrapToken !== undefined; |
| 691 | if (!desktopLaunched && !launcher.managed) return null; |
| 692 | // Stop as a SIGTERM would: runMain's listener interrupts the server, so its shutdown path runs. |
| 693 | return Effect.sync(() => void process.emit("SIGTERM")); |
| 694 | }), |
| 695 | ); |
| 696 | |
| 697 | const layerRuntimeCoreDependenciesBase = Layer.mergeAll( |
| 698 | AgentAwarenessRelay.layer, |
| 699 | HeldHooksWaker.layer, |
| 700 | layerThreadSettlementWorker, |
| 701 | layerIdleCompactionWorker, |
| 702 | StorageCleanup.layer.pipe(Layer.provide(ProjectionStoreV2.layer)), |
| 703 | DatabaseStorage.layer.pipe( |
| 704 | Layer.provide(ProjectionMaintenance.layer), |
| 705 | Layer.provide(layerServerRestart), |
| 706 | ), |
| 707 | layerThreadPullRequestWorker, |
| 708 | KeepAwake.layer, |
| 709 | DelegatedTaskAnalytics.layer, |
| 710 | Layer.effectDiscard( |
| 711 | Effect.gen(function* () { |
| 712 | const service = yield* PullRequestSyncReactor.PullRequestSyncReactor; |
| 713 | yield* service.start(); |
| 714 | }), |
| 715 | ).pipe( |
| 716 | Layer.provideMerge(PullRequestSyncReactor.layer), |
| 717 | Layer.provide(layerPullRequestService), |
| 718 | Layer.provide(ProjectionStoreV2.layer), |
| 719 | ), |
| 720 | Layer.effectDiscard( |
| 721 | Effect.gen(function* () { |
| 722 | const service = yield* PullRequestWatchReactor.PullRequestWatchReactor; |
| 723 | yield* service.start(); |
| 724 | }), |
| 725 | ).pipe( |
| 726 | Layer.provide(PullRequestWatchReactor.layer), |
| 727 | Layer.provide(layerPullRequestService), |
| 728 | Layer.provide(ProjectionStoreV2.layer), |
| 729 | ), |
| 730 | Layer.effectDiscard( |
| 731 | Effect.gen(function* () { |
| 732 | const service = yield* DelegatedTaskQuestionReactor.DelegatedTaskQuestionReactor; |
| 733 | yield* service.start(); |
| 734 | }), |
| 735 | ).pipe(Layer.provide(DelegatedTaskQuestionReactor.layer), Layer.provide(ProjectionStoreV2.layer)), |
| 736 | ProviderUsageLimitsIngestion.layer, |
| 737 | layerProviderInstallationRefresh, |
| 738 | ProviderInstallation.layer, |
| 739 | ReplayMarkers.layer, |
| 740 | Layer.effectDiscard(ProjectSettingsOverrideSweep.sweep), |
| 741 | ).pipe( |
| 742 | Layer.provideMerge(layerOrchestrationApplication), |
| 743 | Layer.provideMerge(RuntimeLayer.layerEventInfrastructure), |
| 744 | Layer.provideMerge(Layer.merge(ProjectStore.layer, ThreadSearch.layer)), |
| 745 | Layer.provideMerge(SecretCheck.layer), |
| 746 | Layer.provideMerge(SecretResolver.layer), |
| 747 | // Above the settings it writes when a theme is applied. |
| 748 | Layer.provideMerge(EnvironmentTheme.layer), |
| 749 | Layer.provideMerge(layerServerSettings), |
| 750 | Layer.provideMerge(layerSourceControlProviderRegistry), |
| 751 | Layer.provideMerge(layerGit), |
| 752 | Layer.provideMerge(layerVcs), |
| 753 | Layer.provideMerge(Layer.mergeAll(layerTerminal, layerPreview, layerDevice)), |
| 754 | Layer.provideMerge(layerPersistence), |
| 755 | Layer.provideMerge(Layer.mergeAll(Keybindings.layer, UsageLimitSources.layer)), |
| 756 | Layer.provideMerge(ProviderRegistry.layer), |
| 757 | Layer.provideMerge( |
| 758 | ProviderInstanceRegistryHydration.layer.pipe(Layer.provide(SqlitePersistence.layerConfig)), |
| 759 | ), |
| 760 | // One gate for the server, below hydration so the Claude adapter sees it: layers memoize by |
| 761 | // reference, so the runtime layer shares it. |
| 762 | Layer.provideMerge(ProviderInstallationGate.layer), |
| 763 | // Provider hydration builds the Claude runner, which reports agents to the same scanner the |
| 764 | // terminal and preview layers share. |
| 765 | Layer.provideMerge(layerPortScanner), |
| 766 | Layer.provideMerge( |
| 767 | Layer.mergeAll( |
| 768 | AntigravityInstallation.AntigravityInstallation.layer.pipe( |
| 769 | Layer.provide(layerServerSettings), |
| 770 | ), |
| 771 | CodexInstallation.CodexInstallation.layer, |
| 772 | ), |
| 773 | ), |
| 774 | ); |
| 775 | |
| 776 | const layerRuntimeCoreDependencies = layerRuntimeCoreDependenciesBase.pipe( |
| 777 | Layer.provideMerge(layerPtyAdapter), |
| 778 | Layer.provideMerge(AcpRegistrySupport.layerFromHost.pipe(Layer.provide(ProviderHostLive.layer))), |
| 779 | Layer.provideMerge( |
| 780 | Layer.mergeAll( |
| 781 | layerProviderEventLoggers, |
| 782 | ModelManifest.layerModelCatalog.pipe(Layer.provideMerge(ModelManifest.layer)), |
| 783 | ResetCreditCoordinator.layer, |
| 784 | ProviderLatestVersions.layer, |
| 785 | McpProviderSessions.layer, |
| 786 | ), |
| 787 | ), |
| 788 | Layer.provideMerge( |
| 789 | OpenCodeRuntime.layer.pipe( |
| 790 | Layer.provide( |
| 791 | Layer.unwrap( |
| 792 | Effect.gen(function* () { |
| 793 | const config = yield* ServerConfig.ServerConfig; |
| 794 | return OpenCodeServerLedger.layer({ stateDir: config.stateDir }); |
| 795 | }), |
| 796 | ), |
| 797 | ), |
| 798 | ), |
| 799 | ), |
| 800 | Layer.provideMerge(layerWorkspace), |
| 801 | Layer.provideMerge(ProjectEnrichmentService.layer), |
| 802 | Layer.provideMerge(Layer.mergeAll(NativeAppIconResolver.layer, layerProjectFaviconResolver)), |
| 803 | Layer.provideMerge(layerRepositoryIdentityResolver), |
| 804 | Layer.provideMerge(CodexManagedTokenBroker.layer), |
| 805 | Layer.provideMerge(layerServerEnvironment), |
| 806 | Layer.provideMerge(layerAuth), |
| 807 | Layer.provideMerge( |
| 808 | Layer.mergeAll(AssetSigner.layer, EnvironmentKeys.layer, WorkspacePreviewRevisions.layer), |
| 809 | ), |
| 810 | Layer.provideMerge(ServerSecretStore.layer), |
| 811 | Layer.provideMerge( |
| 812 | Layer.mergeAll( |
| 813 | CloudCliTokenManager.layer.pipe( |
| 814 | Layer.provide(ServerSecretStore.layer), |
| 815 | Layer.provide(ExternalLauncher.layer), |
| 816 | ), |
| 817 | layerCloudManagedEndpointRuntime, |
| 818 | ), |
| 819 | ), |
| 820 | ); |
| 821 | |
| 822 | const layerRuntimeDependencies = layerRuntimeCoreDependencies.pipe( |
| 823 | Layer.provideMerge(layerUsage), |
| 824 | Layer.provideMerge(layerBackground), |
| 825 | // The same layer the event sink uses; memoized, subscriptions and batch ranking share it. |
| 826 | Layer.provideMerge(ThreadViewers.layer), |
| 827 | Layer.provideMerge(layerResourceDiagnostics), |
| 828 | Layer.provideMerge(TraceDiagnostics.layer), |
| 829 | Layer.provideMerge(TriageService.layer.pipe(Layer.provide(GitVcsDriver.layer))), |
| 830 | // Layers memoize by reference, so this is the same policy the settings layer reads. |
| 831 | Layer.provideMerge(AnalyticsService.layer.pipe(Layer.provide(ManagedPolicy.layer))), |
| 832 | Layer.provideMerge(ExternalLauncher.layer), |
| 833 | Layer.provideMerge(RemoteOpenTargets.layer), |
| 834 | Layer.provideMerge(DirectEndpoints.layer.pipe(Layer.provide(layerServerEnvironment))), |
| 835 | Layer.provideMerge(ServerLifecycleEvents.layer), |
| 836 | // GitVcsDriver.layer is memoized and some of its build sites live outside this file, so the |
| 837 | // fetch interval goes in context here, before the first build captures it. |
| 838 | Layer.provideMerge(VcsAutomaticFetchInterval.layer.pipe(Layer.provide(layerServerSettings))), |
| 839 | Layer.provide(NetService.layer), |
| 840 | ); |
| 841 | |
| 842 | const layerCommandReadiness = HttpRouter.middleware( |
| 843 | (httpEffect) => |
| 844 | Effect.flatMap(ServerRuntimeStartup.ServerRuntimeStartup, (startup) => |
| 845 | startup.awaitCommandReady.pipe(Effect.orDie, Effect.andThen(httpEffect)), |
| 846 | ), |
| 847 | { global: true }, |
| 848 | ); |
| 849 | |
| 850 | const layerMakeRoutes = Layer.mergeAll( |
| 851 | Layer.mergeAll( |
| 852 | HttpApiBuilder.layer(EnvironmentHttpApi).pipe( |
| 853 | Layer.provide(AuthHttp.layer), |
| 854 | Layer.provide(McpOAuthHttp.layer.pipe(Layer.provide(McpOAuth.layer))), |
| 855 | Layer.provide(PeerClientPairingHttp.layer.pipe(Layer.provide(PeerClientPairing.layerIssuer))), |
| 856 | Layer.provide(CloudHttp.layer), |
| 857 | Layer.provide(OrchestrationHttp.layer), |
| 858 | Layer.provide(PullRequestHttp.layer), |
| 859 | Layer.provide(ProjectHttp.layer), |
| 860 | Layer.provide(speechHttpApiLayer), |
| 861 | Layer.provide(ServerHttp.layerServerEnvironmentHttpApi), |
| 862 | Layer.provide(WebhookRoute.layer.pipe(Layer.provide(RelayDeliveryProof.layer))), |
| 863 | Layer.provide(AuthHttp.layerAuthenticatedAuth), |
| 864 | ), |
| 865 | ServerHttp.layerOtlpTracesProxyRoute, |
| 866 | ServerHttp.layerAssetRoute, |
| 867 | ServerHttp.layerAttachmentUploadRoute, |
| 868 | GuestHttp.layer, |
| 869 | LinkThreadHttp.layer, |
| 870 | DeviceHubProxy.layer, |
| 871 | ServerBrowserStream.routeLayer, |
| 872 | PreviewTunnel.routeLayer, |
| 873 | ServerHttp.layerStaticAndDevRoute, |
| 874 | Ws.layer, |
| 875 | speechStreamRouteLayer, |
| 876 | ), |
| 877 | McpHttpServer.layer.pipe( |
| 878 | Layer.provide(ProviderAdapterRegistry.layerFromProviderInstanceRegistry), |
| 879 | Layer.provide(McpOAuth.layerMcpClientAuthenticator), |
| 880 | Layer.provide(ProjectionStoreV2.layer), |
| 881 | ), |
| 882 | // Follows delegated tasks running in linked environments, including after a restart. |
| 883 | Layer.effectDiscard( |
| 884 | RemoteDelegation.RemoteDelegation.pipe(Effect.flatMap((remote) => remote.start())), |
| 885 | ), |
| 886 | ).pipe( |
| 887 | Layer.provide( |
| 888 | PullRequestReviewGuideService.layer.pipe(Layer.provide(PullRequestReviewGuides.layer)), |
| 889 | ), |
| 890 | // delegate_task to a linked environment, from /mcp and the follower above. |
| 891 | Layer.provide(RemoteDelegation.layer.pipe(Layer.provide(ProjectionStoreV2.layer))), |
| 892 | // Links agents ask for: shown in a thread from /mcp, answered over WebSocket. |
| 893 | Layer.provide(PeerLinkRequests.layer), |
| 894 | // Share the service so HTTP/WS clients single-flight reads and invalidate each other's cached patches. |
| 895 | Layer.provide(layerPullRequestService), |
| 896 | Layer.provide(layerThreadIssueService), |
| 897 | Layer.provide(layerIssueService), |
| 898 | // The same activity instance RunExecutionService reports to, by layer memoization. |
| 899 | Layer.provide( |
| 900 | ServerBrowser.layer.pipe( |
| 901 | Layer.provide(Layer.merge(DesktopBrowserChannel.layer, PreviewAgentActivity.layer)), |
| 902 | ), |
| 903 | ), |
| 904 | Layer.provide(PreviewBrowser.layer), |
| 905 | // Links to other environments, shared by clients (WebSocket) and agents (/mcp). |
| 906 | Layer.provide( |
| 907 | Layer.mergeAll(PeerForwarding.layer, PeerThreadRelay.layer, PeerClientPairing.layer).pipe( |
| 908 | Layer.provideMerge(PeerMcpClient.layer), |
| 909 | Layer.provideMerge(PeerLinks.layer), |
| 910 | ), |
| 911 | ), |
| 912 | Layer.provide( |
| 913 | SpeechService.layer.pipe( |
| 914 | Layer.provide(layerServerSettings), |
| 915 | Layer.provide(SpeechModelStore.layer), |
| 916 | ), |
| 917 | ), |
| 918 | Layer.provide(CloudSpeech.layer.pipe(Layer.provide(SecretResolver.layer))), |
| 919 | Layer.provide(layerServerSettings), |
| 920 | Layer.provide(PreviewAutomationBroker.layer), |
| 921 | Layer.provide(ServerSelfUpdate.layer.pipe(Layer.provide(layerDesktopAppUpdate))), |
| 922 | Layer.provide(layerCommandReadiness), |
| 923 | Layer.provide(ServerHttp.layerBrowserApiCors), |
| 924 | Layer.provide(ServerHttp.layerHttpCompression), |
| 925 | Layer.provide(ServerHttp.layerUnloggedSignedRequests), |
| 926 | ); |
| 927 | |
| 928 | const layerMakeServer = Layer.unwrap( |
| 929 | Effect.gen(function* () { |
| 930 | const config = yield* ServerConfig.ServerConfig; |
| 931 | // Before anything opens the database: one server per T3 home. |
| 932 | const ownership = yield* ServerOwnership.acquireServerOwnership(config.serverRuntimeStatePath); |
| 933 | const activation = yield* Deferred.make<void>(); |
| 934 | const awaitActivation = Deferred.await(activation); |
| 935 | const layerActivation = Layer.succeed(ServerActivation.ServerActivation, awaitActivation); |
| 936 | const runtimeStateParked = yield* Deferred.make<void>(); |
| 937 | const tailscaleParked = yield* Deferred.make<void>(); |
| 938 | const cloudLinkParked = yield* Deferred.make<void>(); |
| 939 | const routesReady = yield* Deferred.make<void>(); |
| 940 | const layerLauncher = ServiceLauncherClient.layer; |
| 941 | |
| 942 | // fixPath rewrites PATH, so pin the launcher the shell chose before it does. |
| 943 | const invokedAs = (yield* resolveLauncherPath) ?? (yield* HostProcess.InvokedAs); |
| 944 | yield* fixPath({ shellEnvironmentPrepared: config.shellEnvironmentPrepared }); |
| 945 | |
| 946 | const layerHttpListening = Layer.effectDiscard( |
| 947 | Effect.gen(function* () { |
| 948 | yield* HttpServer.HttpServer; |
| 949 | const startup = yield* ServerRuntimeStartup.ServerRuntimeStartup; |
| 950 | yield* startup.markHttpListening; |
| 951 | }), |
| 952 | ); |
| 953 | const layerDesktopReadySignal = Layer.effectDiscard( |
| 954 | Effect.gen(function* () { |
| 955 | const startup = yield* ServerRuntimeStartup.ServerRuntimeStartup; |
| 956 | const receiver = yield* DesktopTelemetryReceiver.DesktopTelemetryReceiver; |
| 957 | yield* startup.awaitCommandReady.pipe( |
| 958 | Effect.andThen(receiver.announceServerReady), |
| 959 | Effect.ignore, |
| 960 | Effect.forkScoped, |
| 961 | ); |
| 962 | }), |
| 963 | ); |
| 964 | const layerRuntimeState = Layer.effectDiscard( |
| 965 | Effect.gen(function* () { |
| 966 | yield* Deferred.succeed(runtimeStateParked, undefined).pipe(Effect.orDie); |
| 967 | yield* awaitActivation; |
| 968 | const server = yield* HttpServer.HttpServer; |
| 969 | const address = server.address; |
| 970 | if (typeof address === "string" || !("port" in address)) { |
| 971 | return; |
| 972 | } |
| 973 | |
| 974 | const launcher = yield* ServiceLauncherClient.ServiceLauncherClient; |
| 975 | const state = yield* makePersistedServerRuntimeState({ |
| 976 | config, |
| 977 | port: address.port, |
| 978 | serviceManaged: launcher.managed, |
| 979 | managedPolicy: yield* ManagedPolicy.loadedPolicy(yield* ManagedPolicy.ManagedPolicy), |
| 980 | }); |
| 981 | yield* ownership |
| 982 | .publish(state) |
| 983 | .pipe( |
| 984 | Effect.catchCause((cause) => |
| 985 | Effect.logWarning("Failed to persist server runtime state", { cause }), |
| 986 | ), |
| 987 | ); |
| 988 | }), |
| 989 | ); |
| 990 | const tailscaleServeRootHolder = (target: { readonly host: string; readonly port: number }) => |
| 991 | readTailscaleServeRootHolder(config.tailscaleServePort, target); |
| 992 | const layerTailscaleServe = config.tailscaleServeEnabled |
| 993 | ? Layer.effectDiscard( |
| 994 | Effect.acquireRelease( |
| 995 | Effect.gen(function* () { |
| 996 | yield* Deferred.succeed(tailscaleParked, undefined).pipe(Effect.orDie); |
| 997 | yield* awaitActivation; |
| 998 | const server = yield* HttpServer.HttpServer; |
| 999 | const address = server.address; |
| 1000 | if (typeof address === "string" || !("port" in address)) { |
| 1001 | return null; |
| 1002 | } |
| 1003 | |
| 1004 | const localPort = address.port; |
| 1005 | const localHost = loopbackUrlHostForAddress(address); |
| 1006 | const route = { |
| 1007 | localPort, |
| 1008 | urlHost: localHost, |
| 1009 | localHost: localHost.replace(/^\[|\]$/gu, ""), |
| 1010 | servePort: config.tailscaleServePort, |
| 1011 | }; |
| 1012 | const holder = yield* tailscaleServeRootHolder({ |
| 1013 | host: route.localHost, |
| 1014 | port: localPort, |
| 1015 | }).pipe(Effect.orElseSucceed(() => "unreadable" as const)); |
| 1016 | if (holder === "other" || holder === "unreadable") { |
| 1017 | yield* Effect.logWarning( |
| 1018 | holder === "other" |
| 1019 | ? "Tailscale Serve left off; its port already serves another server or app" |
| 1020 | : "Tailscale Serve left off; its current routes could not be read", |
| 1021 | { localPort, servePort: config.tailscaleServePort }, |
| 1022 | ); |
| 1023 | return route; |
| 1024 | } |
| 1025 | return yield* ensureTailscaleServe({ |
| 1026 | localPort, |
| 1027 | servePort: config.tailscaleServePort, |
| 1028 | localHost, |
| 1029 | }).pipe( |
| 1030 | Effect.as(route), |
| 1031 | Effect.tap(() => |
| 1032 | Effect.logInfo("Tailscale Serve configured", { |
| 1033 | localPort, |
| 1034 | servePort: config.tailscaleServePort, |
| 1035 | }), |
| 1036 | ), |
| 1037 | Effect.catch((cause) => |
| 1038 | Effect.logWarning( |
| 1039 | cause._tag === "TailscaleCommandExitError" && |
| 1040 | cause.stderrDiagnostic === "unsupported-target" |
| 1041 | ? `Tailscale Serve left off; this Tailscale install can only proxy to localhost, not ${localHost}. Bind --host 127.0.0.1 or 0.0.0.0 instead` |
| 1042 | : "Failed to configure Tailscale Serve", |
| 1043 | { cause, localPort, servePort: config.tailscaleServePort }, |
| 1044 | ).pipe(Effect.as(null)), |
| 1045 | ), |
| 1046 | ); |
| 1047 | }), |
| 1048 | (configured) => |
| 1049 | configured |
| 1050 | ? Effect.all( |
| 1051 | [ |
| 1052 | readTailscaleServeRoutesTo({ |
| 1053 | host: configured.localHost, |
| 1054 | port: configured.localPort, |
| 1055 | }), |
| 1056 | readTailscaleStatus, |
| 1057 | ], |
| 1058 | { concurrency: 2 }, |
| 1059 | ).pipe( |
| 1060 | // Another service may hold the root route by now, or it may sit under a |
| 1061 | // former name, where `off` would act on the current one; only ours goes. |
| 1062 | Effect.map(([routes, status]) => |
| 1063 | routes.some( |
| 1064 | (route) => |
| 1065 | route.servePort === configured.servePort && |
| 1066 | route.mount === "/" && |
| 1067 | route.owner === undefined && |
| 1068 | route.ambiguous === undefined && |
| 1069 | route.host?.toLowerCase() === status.magicDnsName?.toLowerCase(), |
| 1070 | ), |
| 1071 | ), |
| 1072 | Effect.orElseSucceed(() => false), |
| 1073 | Effect.flatMap((ours) => |
| 1074 | ours |
| 1075 | ? disableTailscaleServe({ servePort: configured.servePort }).pipe( |
| 1076 | Effect.tap(() => |
| 1077 | Effect.logInfo("Tailscale Serve disabled", { |
| 1078 | servePort: configured.servePort, |
| 1079 | }), |
| 1080 | ), |
| 1081 | ) |
| 1082 | : Effect.logInfo( |
| 1083 | "Tailscale Serve left on; its root route is not known to be ours", |
| 1084 | { |
| 1085 | servePort: configured.servePort, |
| 1086 | }, |
| 1087 | ), |
| 1088 | ), |
| 1089 | Effect.catch((cause) => |
| 1090 | Effect.logWarning("Failed to disable Tailscale Serve", { |
| 1091 | cause, |
| 1092 | servePort: configured.servePort, |
| 1093 | }), |
| 1094 | ), |
| 1095 | ) |
| 1096 | : Effect.void, |
| 1097 | ).pipe( |
| 1098 | // Startup is not the only time the route can go stale, so whoever finds it on a dead |
| 1099 | // port takes it back. |
| 1100 | Effect.tap((configured) => |
| 1101 | configured === null |
| 1102 | ? Effect.void |
| 1103 | : Effect.sleep("30 seconds").pipe( |
| 1104 | Effect.andThen( |
| 1105 | tailscaleServeRootHolder({ |
| 1106 | host: configured.localHost, |
| 1107 | port: configured.localPort, |
| 1108 | }), |
| 1109 | ), |
| 1110 | Effect.flatMap((holder) => |
| 1111 | holder === "dead" |
| 1112 | ? ensureTailscaleServe({ |
| 1113 | localPort: configured.localPort, |
| 1114 | servePort: configured.servePort, |
| 1115 | localHost: configured.urlHost, |
| 1116 | }).pipe( |
| 1117 | Effect.andThen( |
| 1118 | Effect.logInfo("Tailscale Serve repaired", { |
| 1119 | localPort: configured.localPort, |
| 1120 | servePort: configured.servePort, |
| 1121 | }), |
| 1122 | ), |
| 1123 | ) |
| 1124 | : Effect.void, |
| 1125 | ), |
| 1126 | Effect.ignore, |
| 1127 | Effect.forever, |
| 1128 | Effect.forkScoped, |
| 1129 | ), |
| 1130 | ), |
| 1131 | ), |
| 1132 | ).pipe(Layer.provide(NetService.layer)) |
| 1133 | : Layer.empty; |
| 1134 | const layerCloudDesiredLinkReconcile = Layer.effectDiscard( |
| 1135 | Effect.gen(function* () { |
| 1136 | const cloudLink = yield* CloudLink.CloudLink; |
| 1137 | // CloudLink unlinks on startup when the policy turns Connect off; nothing to restore. |
| 1138 | if (!ManagedLimits.allowsConnect(yield* ManagedPolicy.ManagedPolicy)) { |
| 1139 | yield* Deferred.succeed(cloudLinkParked, undefined).pipe(Effect.orDie); |
| 1140 | return; |
| 1141 | } |
| 1142 | const releaseManagedTunnel = cloudLink.releaseManagedTunnelOnShutdown().pipe( |
| 1143 | Effect.timeout("10 seconds"), |
| 1144 | Effect.tap((released) => |
| 1145 | released ? Effect.logInfo("Released the managed tunnel on shutdown") : Effect.void, |
| 1146 | ), |
| 1147 | Effect.catchCause((cause) => |
| 1148 | Effect.logWarning( |
| 1149 | "Failed to release the managed tunnel on shutdown; the next link reuses it", |
| 1150 | { errors: Cause.prettyErrors(cause).map((error) => error.message) }, |
| 1151 | ), |
| 1152 | ), |
| 1153 | Effect.asVoid, |
| 1154 | ); |
| 1155 | // Trials own cleanup immediately after the old server exits, retaining tunnels for commit/rollback unless explicitly stopped. |
| 1156 | // Other runtimes wait for activation so failed standbys cannot tear down active tunnels. |
| 1157 | const cleanupBeforeActivation = yield* pendingServiceUpdateExists; |
| 1158 | if (cleanupBeforeActivation) { |
| 1159 | yield* Effect.addFinalizer(() => releaseManagedTunnel); |
| 1160 | } |
| 1161 | yield* ServerActivation.forkParked( |
| 1162 | Effect.gen(function* () { |
| 1163 | if (!cleanupBeforeActivation) { |
| 1164 | yield* Effect.addFinalizer(() => releaseManagedTunnel); |
| 1165 | } |
| 1166 | const server = yield* HttpServer.HttpServer; |
| 1167 | const address = server.address; |
| 1168 | if (typeof address === "string" || !("port" in address)) return; |
| 1169 | const localOrigin = `http://${loopbackUrlHostForAddress(address)}:${address.port}`; |
| 1170 | const endpointRuntime = yield* CloudManagedEndpointRuntime.CloudManagedEndpointRuntime; |
| 1171 | const runManagedTunnelRecovery = yield* makeManagedTunnelRecovery({ |
| 1172 | recover: (config: RelayManagedEndpointRuntimeConfig) => |
| 1173 | cloudLink.recoverManagedTunnel(localOrigin, config, { |
| 1174 | retryRuntimeFailures: true, |
| 1175 | }), |
| 1176 | isRetryable: (error) => |
| 1177 | CloudLink.shouldRetryCloudLink(error) && |
| 1178 | error._tag !== "CloudLinkEndpointUnavailableError", |
| 1179 | }); |
| 1180 | const recoverManagedTunnel = (config: RelayManagedEndpointRuntimeConfig) => |
| 1181 | runManagedTunnelRecovery(config).pipe( |
| 1182 | Effect.tap((recovered) => |
| 1183 | recovered ? Effect.logInfo("T3 Connect managed tunnel recovered") : Effect.void, |
| 1184 | ), |
| 1185 | Effect.catchCause((cause) => |
| 1186 | Cause.hasInterrupts(cause) |
| 1187 | ? Effect.interrupt |
| 1188 | : Effect.logWarning("Failed to recover the T3 Connect managed tunnel", { |
| 1189 | cause, |
| 1190 | }), |
| 1191 | ), |
| 1192 | ); |
| 1193 | yield* endpointRuntime.recoveryRequests.pipe( |
| 1194 | Stream.runForEach(recoverManagedTunnel), |
| 1195 | Effect.forkScoped, |
| 1196 | ); |
| 1197 | yield* watchManagedTunnelOrigin({ |
| 1198 | localOrigin, |
| 1199 | readIngressOrigin: endpointRuntime.inspectConnector.pipe( |
| 1200 | Effect.map((connector) => connector?.origin ?? null), |
| 1201 | ), |
| 1202 | // Like startup, a publish-only link never routes the tunnel to this host. |
| 1203 | register: CloudCliState.readCliDesiredLinkMode.pipe( |
| 1204 | Effect.flatMap((mode) => |
| 1205 | mode === "publish_only" |
| 1206 | ? Effect.void |
| 1207 | : cloudLink |
| 1208 | .registerManagedTunnelRecovery(localOrigin) |
| 1209 | .pipe( |
| 1210 | Effect.flatMap((registration) => |
| 1211 | registration.status === "recovery_required" |
| 1212 | ? endpointRuntime.requestRecovery(registration.config) |
| 1213 | : Effect.void, |
| 1214 | ), |
| 1215 | ), |
| 1216 | ), |
| 1217 | ), |
| 1218 | }).pipe(Effect.forkScoped); |
| 1219 | const wantsCliLink = hasCloudPublicConfig |
| 1220 | ? yield* CloudCliState.readCliDesiredCloudLink.pipe( |
| 1221 | Effect.catch((cause) => |
| 1222 | Effect.logWarning("Failed to read the desired T3 Connect link", { cause }).pipe( |
| 1223 | Effect.as(false), |
| 1224 | ), |
| 1225 | ), |
| 1226 | ) |
| 1227 | : false; |
| 1228 | // Recover reads so this fiber still registers and consumes recovery requests. |
| 1229 | const desiredCliLinkMode = wantsCliLink |
| 1230 | ? yield* CloudCliState.readCliDesiredLinkMode.pipe( |
| 1231 | Effect.catch((cause) => |
| 1232 | Effect.logWarning("Failed to read the desired T3 Connect link mode", { |
| 1233 | cause, |
| 1234 | }).pipe(Effect.as("managed" as const)), |
| 1235 | ), |
| 1236 | ) |
| 1237 | : null; |
| 1238 | // Publish-only links must not expose the host through old managed configs. |
| 1239 | const startedConfirmed = |
| 1240 | desiredCliLinkMode === "publish_only" |
| 1241 | ? false |
| 1242 | : yield* cloudLink.startManagedTunnelIfOriginConfirmed(localOrigin).pipe( |
| 1243 | Effect.catch((cause) => |
| 1244 | Effect.logWarning("Failed to start the confirmed T3 Connect tunnel", { |
| 1245 | cause, |
| 1246 | }).pipe(Effect.as(false)), |
| 1247 | ), |
| 1248 | ); |
| 1249 | const startStoredManagedTunnel = cloudLink |
| 1250 | .startManagedTunnelIfOriginConfirmed(localOrigin, { |
| 1251 | requireConfirmedOrigin: false, |
| 1252 | }) |
| 1253 | .pipe( |
| 1254 | Effect.tap((started) => |
| 1255 | started |
| 1256 | ? Effect.logWarning( |
| 1257 | "T3 Connect started the stored tunnel without relay confirmation", |
| 1258 | ) |
| 1259 | : Effect.void, |
| 1260 | ), |
| 1261 | Effect.catch((cause) => |
| 1262 | Effect.logWarning("Failed to start the stored T3 Connect tunnel", { cause }), |
| 1263 | ), |
| 1264 | Effect.asVoid, |
| 1265 | ); |
| 1266 | const registerManagedTunnel = retryManagedTunnelRegistration( |
| 1267 | cloudLink.registerManagedTunnelRecovery(localOrigin, { |
| 1268 | retryRuntimeFailures: true, |
| 1269 | }), |
| 1270 | (error) => |
| 1271 | CloudLink.shouldRetryCloudLink(error) && |
| 1272 | error._tag !== "CloudLinkEndpointUnavailableError", |
| 1273 | startedConfirmed ? Effect.void : startStoredManagedTunnel, |
| 1274 | ).pipe( |
| 1275 | Effect.tap((result) => |
| 1276 | result.status === "ready" |
| 1277 | ? Effect.logInfo("T3 Connect managed tunnel recovery registered") |
| 1278 | : Effect.void, |
| 1279 | ), |
| 1280 | Effect.catchCause((cause) => |
| 1281 | Cause.hasInterrupts(cause) |
| 1282 | ? Effect.interrupt |
| 1283 | : Effect.logWarning("Failed to register T3 Connect managed tunnel recovery", { |
| 1284 | cause, |
| 1285 | }).pipe(Effect.as({ status: "unavailable" as const })), |
| 1286 | ), |
| 1287 | ); |
| 1288 | // Jitter registrations so update waves do not hit the relay simultaneously. |
| 1289 | if (!startedConfirmed && desiredCliLinkMode !== "publish_only") { |
| 1290 | const jitter = yield* Random.nextIntBetween( |
| 1291 | 0, |
| 1292 | Duration.toMillis(MANAGED_TUNNEL_FIRST_REGISTRATION_JITTER), |
| 1293 | ); |
| 1294 | yield* Effect.sleep(Duration.millis(jitter)); |
| 1295 | } |
| 1296 | const registration = |
| 1297 | desiredCliLinkMode === "publish_only" |
| 1298 | ? { status: "not_linked" as const } |
| 1299 | : yield* registerManagedTunnel; |
| 1300 | if (registration.status === "unavailable" && !startedConfirmed) { |
| 1301 | yield* startStoredManagedTunnel; |
| 1302 | } |
| 1303 | const startupAction = managedTunnelStartupAction({ wantsCliLink, registration }); |
| 1304 | if (startupAction.action === "request_recovery") { |
| 1305 | yield* endpointRuntime.requestRecovery(startupAction.config); |
| 1306 | } |
| 1307 | if (startupAction.action === "reconcile_link") { |
| 1308 | const reconciledMode = yield* cloudLink |
| 1309 | .reconcileDesiredLinkIfStillDesired(localOrigin) |
| 1310 | .pipe( |
| 1311 | (reconcile) => |
| 1312 | retryDesiredLinkReconcile(reconcile, CloudLink.shouldRetryCloudLink, (cause) => |
| 1313 | Effect.logWarning( |
| 1314 | "T3 Connect relay is still unavailable; retrying the desired link in the background", |
| 1315 | { cause }, |
| 1316 | ), |
| 1317 | ), |
| 1318 | Effect.tap((mode) => |
| 1319 | mode === null |
| 1320 | ? Effect.void |
| 1321 | : Effect.logInfo("T3 Connect desired link reconciled on startup"), |
| 1322 | ), |
| 1323 | Effect.catch((cause) => |
| 1324 | Effect.logWarning("Failed to reconcile T3 Connect desired link on startup", { |
| 1325 | cause, |
| 1326 | }).pipe(Effect.as(null)), |
| 1327 | ), |
| 1328 | ); |
| 1329 | if (reconciledMode === "managed") { |
| 1330 | const afterReconcile = yield* registerManagedTunnel; |
| 1331 | if (afterReconcile.status === "recovery_required") { |
| 1332 | yield* endpointRuntime.requestRecovery(afterReconcile.config); |
| 1333 | } |
| 1334 | } |
| 1335 | } |
| 1336 | }), |
| 1337 | ); |
| 1338 | yield* Deferred.succeed(cloudLinkParked, undefined).pipe(Effect.orDie); |
| 1339 | }), |
| 1340 | ); |
| 1341 | |
| 1342 | const layerRuntimeServices = ServerRuntimeStartup.layerWithOptions({ |
| 1343 | activate: Deferred.succeed(activation, undefined).pipe(Effect.asVoid), |
| 1344 | abort: (error) => Deferred.die(activation, error).pipe(Effect.asVoid), |
| 1345 | awaitAuxiliaryParked: Effect.all( |
| 1346 | [ |
| 1347 | Deferred.await(runtimeStateParked), |
| 1348 | Deferred.await(cloudLinkParked), |
| 1349 | Deferred.await(routesReady), |
| 1350 | ...(config.tailscaleServeEnabled ? [Deferred.await(tailscaleParked)] : []), |
| 1351 | ], |
| 1352 | { concurrency: "unbounded" }, |
| 1353 | ).pipe(Effect.asVoid), |
| 1354 | }).pipe(Layer.provideMerge(layerRuntimeDependencies), Layer.provide(layerLauncher)); |
| 1355 | |
| 1356 | const layerRoutes = HttpRouter.serve(layerMakeRoutes.pipe(Layer.provide(layerLauncher)), { |
| 1357 | disableLogger: !config.logWebSocketEvents, |
| 1358 | routerConfig: HTTP_ROUTER_CONFIG, |
| 1359 | }).pipe( |
| 1360 | withUntracedRequests, |
| 1361 | withRootRequestSpans, |
| 1362 | Layer.tap(() => Deferred.succeed(routesReady, undefined).pipe(Effect.orDie)), |
| 1363 | ); |
| 1364 | const layerServerApplication = Layer.mergeAll( |
| 1365 | layerRoutes, |
| 1366 | layerHttpListening, |
| 1367 | layerDesktopReadySignal, |
| 1368 | layerRuntimeState.pipe(Layer.provide(layerLauncher)), |
| 1369 | layerTailscaleServe, |
| 1370 | layerCloudDesiredLinkReconcile, |
| 1371 | HeapSnapshot.layer, |
| 1372 | ); |
| 1373 | |
| 1374 | return layerServerApplication.pipe( |
| 1375 | Layer.provide(CloudLink.layer.pipe(Layer.provideMerge(ConnectReachability.layer))), |
| 1376 | Layer.provideMerge(layerRuntimeServices), |
| 1377 | Layer.provideMerge( |
| 1378 | McpSessionRegistry.layer.pipe( |
| 1379 | Layer.provide(ServerEnvironment.layer.pipe(Layer.provide(ServerSecretStore.layer))), |
| 1380 | ), |
| 1381 | ), |
| 1382 | Layer.provide(layerActivation), |
| 1383 | Layer.provideMerge( |
| 1384 | RelayTracing.layerServerRelayBroker.pipe(Layer.provide(ManagedPolicy.layer)), |
| 1385 | ), |
| 1386 | Layer.provideMerge(layerHttpServer), |
| 1387 | Layer.provide(layerApplicationObservability), |
| 1388 | Layer.provideMerge(FetchHttpClient.layer), |
| 1389 | Layer.provide(VcsProcess.layer), |
| 1390 | Layer.provideMerge(AgentScopeLive.layer), |
| 1391 | Layer.provideMerge(layerPlatformServices), |
| 1392 | Layer.provide(Layer.succeed(HostProcess.InvokedAs, invokedAs)), |
| 1393 | ); |
| 1394 | }), |
| 1395 | ).pipe(Layer.provide(ProcessRunner.layer)); |
| 1396 | |
| 1397 | export const runServer = Layer.launch( |
| 1398 | // For the layers above whose spawner requirement is not met by one of them. |
| 1399 | layerMakeServer.pipe(Layer.provide(NonBlockingSpawner.layer.pipe(Layer.provide(layerSpawner)))), |
| 1400 | ); |