Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

server.ts

1,234 lines53.9 KB

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