@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 03:37 UTC

main
ts 1,400 lines 62.3 KB
Raw
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 );