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

main
ts 626 lines 23.8 KB
Raw
1 import * as OtelEnvironment from "@t3tools/shared/otelEnvironment";
2 import { DEFAULT_SIGNAL_EXPORT } from "@t3tools/shared/observability";
3 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
4 import * as NodeServices from "@effect/platform-node/NodeServices";
5 import type {
6 ManagedPolicyDocument,
7 ProviderDriverKind,
8 ProviderReplayTranscript,
9 } from "@t3tools/contracts";
10 import * as Effect from "effect/Effect";
11 import * as FileSystem from "effect/FileSystem";
12 import * as Layer from "effect/Layer";
13 import * as Path from "effect/Path";
14 import * as PlatformError from "effect/PlatformError";
15 import type * as Scope from "effect/Scope";
16 import type * as SqlClient from "effect/sql/SqlClient";
17 import type { MigrationError } from "effect/sql/Migrator";
18 import type { SqlError } from "effect/sql/SqlError";
19
20 import * as CheckpointStore from "../../checkpointing/CheckpointStore.ts";
21 import * as ServerConfig from "../../config.ts";
22 import * as SqlitePersistence from "../../persistence/Sqlite.ts";
23 import * as ServerSettings from "../../serverSettings.ts";
24 import * as ManagedPolicy from "../../policy/ManagedPolicy.ts";
25 import * as ThreadManagementService from "../ThreadManagementService.ts";
26 import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
27 import * as McpSessionRegistryTestkit from "../../mcp/McpSessionRegistry.testkit.ts";
28 import * as VcsDriverRegistry from "../../vcs/VcsDriverRegistry.ts";
29 import * as GitVcsDriver from "../../vcs/GitVcsDriver.ts";
30 import * as VcsProcess from "../../vcs/VcsProcess.ts";
31 import * as CheckpointCaptureService from "../CheckpointCaptureService.ts";
32 import * as CheckpointService from "../CheckpointService.ts";
33 import * as CheckpointRollbackService from "../CheckpointRollbackService.ts";
34 import * as CommandPolicy from "../CommandPolicy.ts";
35 import * as CommandReceiptStore from "../CommandReceiptStore.ts";
36 import * as ContextHandoffService from "../ContextHandoffService.ts";
37 import * as EffectOutbox from "../EffectOutbox.ts";
38 import * as EffectWorker from "../EffectWorker.ts";
39 import * as EventSink from "../EventSink.ts";
40 import * as ThreadViewers from "../ThreadViewers.ts";
41 import * as EventStore from "../EventStore.ts";
42 import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
43 import * as Orchestrator from "../Orchestrator.ts";
44 import * as ProjectionStore from "../ProjectionStore.ts";
45 import * as ProjectStore from "../ProjectStore.ts";
46 import * as ProviderAdapterRegistry from "../ProviderAdapterRegistry.ts";
47 import * as ProviderAuthService from "../../provider/ProviderAuthService.ts";
48 import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
49 import * as ProviderContinuationService from "../ProviderContinuationService.ts";
50 import * as ProviderEventIngestor from "../ProviderEventIngestor.ts";
51 import * as ProviderInstallationGate from "../../provider/ProviderInstallationGate.ts";
52 import * as ProviderInstanceRegistry from "../../provider/ProviderInstanceRegistry.ts";
53 import * as ProviderRuntimeRecoveryService from "../ProviderRuntimeRecoveryService.ts";
54 import * as ProviderSessionManager from "../ProviderSessionManager.ts";
55 import * as CommandOutputRecorder from "./CommandOutputRecorder.ts";
56 import * as ProviderSwitchService from "../ProviderSwitchService.ts";
57 import * as ProviderTurnControlService from "../ProviderTurnControlService.ts";
58 import * as ProviderTurnStartService from "../ProviderTurnStartService.ts";
59 import * as ProviderTurnStartServiceTestkit from "../ProviderTurnStartService.testkit.ts";
60 import * as McpAppModelContext from "../../mcpApps/McpAppModelContext.ts";
61 import * as PreviewAgentActivity from "../../preview/PreviewAgentActivity.ts";
62 import * as RunExecutionService from "../RunExecutionService.ts";
63 import * as RunFinalizationService from "../RunFinalizationService.ts";
64 import * as ThreadTitleRegenerationService from "../ThreadTitleRegenerationService.ts";
65 import * as RuntimePolicy from "../RuntimePolicy.ts";
66 import * as TurnItemPositionStore from "../TurnItemPositionStore.ts";
67 import * as RuntimeRequestService from "../RuntimeRequestService.ts";
68 import * as ThreadCommandExecutor from "../ThreadCommandExecutor.ts";
69 import * as ThreadForkService from "../ThreadForkService.ts";
70 import {
71 runOrchestratorV2Scenario,
72 type OrchestratorV2ScenarioStepError,
73 type OrchestratorV2Scenario,
74 type OrchestratorV2ScenarioResult,
75 } from "./OrchestratorScenario.ts";
76 import {
77 makeProviderReplayGate,
78 type ProviderReplayGate,
79 } from "@t3tools/provider-testing/replayGate";
80
81 export function makeReplayServerConfig(
82 scenario: string,
83 ): Effect.Effect<
84 ServerConfig.ServerConfig["Service"],
85 PlatformError.PlatformError,
86 FileSystem.FileSystem | Path.Path | Scope.Scope
87 > {
88 const safeScenario = scenario.replace(/[^a-z0-9_-]+/gi, "-");
89 return Effect.gen(function* () {
90 const fs = yield* FileSystem.FileSystem;
91 const path = yield* Path.Path;
92 const baseDir = yield* fs.makeTempDirectoryScoped({
93 prefix: `t3-orchestration-v2-replay-${safeScenario}-`,
94 });
95 const stateDir = path.join(baseDir, "userdata");
96 const logsDir = path.join(stateDir, "logs");
97 const providerLogsDir = path.join(logsDir, "provider");
98 const terminalLogsDir = path.join(logsDir, "terminals");
99 const attachmentsDir = path.join(stateDir, "attachments");
100 const environmentThemesDir = path.join(stateDir, "themes");
101 const worktreesDir = path.join(baseDir, "worktrees");
102 const providerStatusCacheDir = path.join(baseDir, "caches");
103
104 for (const directory of [
105 stateDir,
106 logsDir,
107 providerLogsDir,
108 terminalLogsDir,
109 attachmentsDir,
110 environmentThemesDir,
111 worktreesDir,
112 providerStatusCacheDir,
113 ]) {
114 yield* fs.makeDirectory(directory, { recursive: true });
115 }
116
117 return {
118 logLevel: "Error",
119 traceMinLevel: "Info",
120 traceTimingEnabled: true,
121 traceBatchWindowMs: 200,
122 traceMaxBytes: 10 * 1024 * 1024,
123 traceMaxFiles: 10,
124 otelEnvironment: OtelEnvironment.none,
125 otlpTracesUrl: undefined,
126 otlpMetricsUrl: undefined,
127 otlpLogsUrl: undefined,
128 otlpTracesExport: DEFAULT_SIGNAL_EXPORT,
129 otlpMetricsExport: DEFAULT_SIGNAL_EXPORT,
130 otlpLogsExport: DEFAULT_SIGNAL_EXPORT,
131 mode: "web",
132 port: 0,
133 host: undefined,
134 cwd: process.cwd(),
135 baseDir,
136 staticDir: undefined,
137 devUrl: undefined,
138 devAllowedOrigins: [],
139 noBrowser: false,
140 startupPresentation: "browser",
141 tailscaleServeEnabled: false,
142 tailscaleServePort: 443,
143 desktopBootstrapToken: undefined,
144 autoBootstrapProjectFromCwd: false,
145 logWebSocketEvents: false,
146 stateDir,
147 dbPath: path.join(stateDir, "state.sqlite"),
148 keybindingsConfigPath: path.join(stateDir, "keybindings.json"),
149 settingsPath: path.join(stateDir, "settings.json"),
150 providerStatusCacheDir,
151 worktreesDir,
152 worktreeCheckoutCacheDir: path.join(providerStatusCacheDir, "worktree-checkouts"),
153 attachmentsDir,
154 browserArtifactsDir: path.join(stateDir, "browser-artifacts"),
155 environmentThemesDir,
156 logsDir,
157 serverLogPath: path.join(logsDir, "server.log"),
158 serverTracePath: path.join(logsDir, "server.trace.ndjson"),
159 providerLogsDir,
160 providerEventLogPath: path.join(providerLogsDir, "events.log"),
161 terminalLogsDir,
162 anonymousIdPath: path.join(stateDir, "anonymous-id"),
163 environmentIdPath: path.join(stateDir, "environment-id"),
164 serverRuntimeStatePath: path.join(stateDir, "server-runtime.json"),
165 secretsDir: path.join(stateDir, "secrets"),
166 };
167 });
168 }
169
170 export interface OrchestratorV2ProviderReplayScenario<
171 Transcript extends ProviderReplayTranscript = ProviderReplayTranscript,
172 > extends OrchestratorV2Scenario {
173 readonly transcript: Transcript;
174 readonly runtimePolicyOverride?: RuntimePolicy.RuntimePolicyV2Override;
175 }
176
177 export interface OrchestratorV2ProviderReplayHarness<
178 Transcript extends ProviderReplayTranscript = ProviderReplayTranscript,
179 Error = never,
180 > {
181 readonly driver: ProviderDriverKind;
182 readonly decodeTranscript: (
183 transcript: ProviderReplayTranscript,
184 ) => Effect.Effect<Transcript, Error>;
185 readonly makeProviderAdapterRegistryLayer: (
186 transcript: Transcript,
187 options?: { readonly replayGate?: ProviderReplayGate },
188 ) => Layer.Layer<
189 ProviderAdapterRegistry.ProviderAdapterRegistryV2,
190 Error,
191 McpProviderSessions.McpProviderSessions
192 >;
193 }
194
195 export function runOrchestratorV2ProviderReplayScenario<
196 Transcript extends ProviderReplayTranscript,
197 Error,
198 >(
199 scenario: OrchestratorV2ProviderReplayScenario<Transcript>,
200 harness: OrchestratorV2ProviderReplayHarness<Transcript, Error>,
201 options: {
202 readonly databaseLayer?: Layer.Layer<
203 SqlClient.SqlClient,
204 MigrationError | PlatformError.PlatformError | SqlError
205 >;
206 readonly runEffectWorker?: boolean;
207 readonly runContinuationWorker?: boolean;
208 readonly recoverOnStartup?: boolean;
209 readonly continueThreadsAfterServerUpdate?: boolean;
210 readonly managedPolicy?: ManagedPolicyDocument;
211 readonly providerInstances?: Partial<
212 ProviderInstanceRegistry.ProviderInstanceRegistry["Service"]
213 >;
214 } = {},
215 ): Effect.Effect<
216 OrchestratorV2ScenarioResult,
217 | Orchestrator.OrchestratorV2Error
218 | OrchestratorV2ScenarioStepError
219 | Error
220 | MigrationError
221 | PlatformError.PlatformError
222 | SqlError,
223 never
224 > {
225 const replayGate = makeProviderReplayGate(
226 scenario.steps?.flatMap((step) =>
227 step.type === "release_replay_gate" || step.type === "release_replay_gate_after_waiting"
228 ? [step.label]
229 : [],
230 ) ?? [],
231 );
232 const layer = layerProviderReplay(scenario, harness, {
233 ...options,
234 replayGate,
235 });
236
237 return Effect.gen(function* () {
238 const result = yield* runOrchestratorV2Scenario(scenario, { replayGate });
239 const recorder = yield* CommandOutputRecorder.CommandOutputRecorder;
240 return { ...result, commandOutput: yield* recorder.snapshot };
241 }).pipe(Effect.provide(layer));
242 }
243
244 export function layerProviderReplay<Transcript extends ProviderReplayTranscript, Error>(
245 scenario: OrchestratorV2ProviderReplayScenario<Transcript>,
246 harness: OrchestratorV2ProviderReplayHarness<Transcript, Error>,
247 options: {
248 readonly databaseLayer?: Layer.Layer<
249 SqlClient.SqlClient,
250 MigrationError | PlatformError.PlatformError | SqlError
251 >;
252 readonly runEffectWorker?: boolean;
253 readonly runContinuationWorker?: boolean;
254 readonly recoverOnStartup?: boolean;
255 readonly continueThreadsAfterServerUpdate?: boolean;
256 readonly managedPolicy?: ManagedPolicyDocument;
257 readonly replayGate?: ProviderReplayGate;
258 readonly providerInstances?: Partial<
259 ProviderInstanceRegistry.ProviderInstanceRegistry["Service"]
260 >;
261 } = {},
262 ): Layer.Layer<
263 | Orchestrator.OrchestratorV2
264 | EffectWorker.OrchestrationEffectWorkerV2
265 | EventSink.EventSinkV2
266 | CommandOutputRecorder.CommandOutputRecorder
267 | ProviderSessionManager.ProviderSessionManagerV2,
268 Error | MigrationError | PlatformError.PlatformError | SqlError
269 > {
270 const layerRegistry = harness.makeProviderAdapterRegistryLayer(
271 scenario.transcript,
272 options.replayGate === undefined ? {} : { replayGate: options.replayGate },
273 );
274 return layerWithRegistry(scenario, layerRegistry, options);
275 }
276
277 export function layerWithRegistry<Error>(
278 scenario: Pick<OrchestratorV2ProviderReplayScenario, "name" | "runtimePolicyOverride">,
279 registryLayer: Layer.Layer<
280 ProviderAdapterRegistry.ProviderAdapterRegistryV2,
281 Error,
282 McpProviderSessions.McpProviderSessions
283 >,
284 options: {
285 readonly databaseLayer?: Layer.Layer<
286 SqlClient.SqlClient,
287 MigrationError | PlatformError.PlatformError | SqlError
288 >;
289 readonly runEffectWorker?: boolean;
290 readonly runContinuationWorker?: boolean;
291 readonly recoverOnStartup?: boolean;
292 readonly continueThreadsAfterServerUpdate?: boolean;
293 /** Lets a test hold a projection read open to order concurrent dispatches. */
294 readonly wrapProjectionStore?: (
295 store: ProjectionStore.ProjectionStoreV2Shape,
296 ) => ProjectionStore.ProjectionStoreV2Shape;
297 readonly managedPolicy?: ManagedPolicyDocument;
298 /** The instances the ingestor reads snapshots from, such as an endpoint behind a hub. */
299 readonly providerInstances?: Partial<
300 ProviderInstanceRegistry.ProviderInstanceRegistry["Service"]
301 >;
302 } = {},
303 ): Layer.Layer<
304 | Orchestrator.OrchestratorV2
305 | EffectOutbox.EffectOutboxV2
306 | EffectWorker.OrchestrationEffectWorkerV2
307 | EventSink.EventSinkV2
308 | ProviderSessionManager.ProviderSessionManagerV2
309 | CommandOutputRecorder.CommandOutputRecorder
310 | ThreadCommandExecutor.ThreadCommandExecutor,
311 Error | MigrationError | PlatformError.PlatformError | SqlError
312 > {
313 const layerServerConfig = Layer.effect(
314 ServerConfig.ServerConfig,
315 makeReplayServerConfig(scenario.name).pipe(Effect.orDie),
316 ).pipe(Layer.provide(NodeServices.layer));
317 const layerRuntimeBase =
318 scenario.runtimePolicyOverride === undefined
319 ? RuntimePolicy.layer
320 : RuntimePolicy.layerWithOverride(scenario.runtimePolicyOverride).pipe(
321 Layer.provide(RuntimePolicy.layer),
322 );
323 const layerDatabase = options.databaseLayer ?? SqlitePersistence.layerMemory;
324 // Share one continuation queue across adapters, orchestrator, and worker through layer memoization.
325 const layerContinuationRequests =
326 options.runContinuationWorker === true ? ProviderContinuationRequests.layer : Layer.empty;
327 const layerProvidedRegistry = registryLayer.pipe(
328 Layer.provide(Layer.merge(layerContinuationRequests, McpProviderSessions.layer)),
329 );
330 const layerServerSettings = Layer.unwrap(
331 Effect.map(ManagedPolicy.fromDocument("/test/policy.json", options.managedPolicy), (policy) =>
332 ServerSettings.layerTest(
333 {
334 responseStreamingMode: "turn",
335 ...(options.continueThreadsAfterServerUpdate === undefined
336 ? {}
337 : { continueThreadsAfterServerUpdate: options.continueThreadsAfterServerUpdate }),
338 },
339 policy.summary,
340 ),
341 ),
342 ).pipe(Layer.orDie);
343 const layerEffectOutboxProvided = EffectOutbox.layer.pipe(Layer.provide(layerDatabase));
344 const wrapProjectionStore = options.wrapProjectionStore;
345 const layerProjectionStore =
346 wrapProjectionStore === undefined
347 ? ProjectionStore.layer
348 : Layer.effect(
349 ProjectionStore.ProjectionStoreV2,
350 Effect.gen(function* () {
351 return wrapProjectionStore(yield* ProjectionStore.ProjectionStoreV2);
352 }),
353 ).pipe(Layer.provide(ProjectionStore.layer));
354 const layerStores = Layer.mergeAll(
355 EventStore.layer,
356 layerProjectionStore,
357 ProjectStore.layer,
358 CommandReceiptStore.layer,
359 layerEffectOutboxProvided,
360 TurnItemPositionStore.layer,
361 ).pipe(Layer.provide(layerDatabase));
362 const layerEventSinkProvided = EventSink.layerFromStores.pipe(
363 Layer.provide(Layer.mergeAll(layerStores, layerDatabase, ThreadViewers.layer)),
364 );
365 const layerRuntime = RuntimePolicy.layerEnforcingCeiling.pipe(
366 Layer.provide(Layer.merge(layerRuntimeBase, layerServerSettings)),
367 );
368 const layerCommandReceiptStoreProvided = CommandReceiptStore.layer.pipe(
369 Layer.provide(layerDatabase),
370 );
371 const layerProviderEventIngestorProvided = ProviderEventIngestor.layer.pipe(
372 Layer.provide(
373 Layer.mergeAll(
374 Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)(
375 options.providerInstances ?? { getInstance: () => Effect.undefined },
376 ),
377 layerStores,
378 layerEventSinkProvided,
379 IdAllocator.layer,
380 ThreadCommandExecutor.layer,
381 GitVcsDriver.layer.pipe(
382 Layer.provide(layerServerConfig),
383 Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
384 ),
385 ),
386 ),
387 );
388 const layerVcsDriverRegistry = VcsDriverRegistry.layer.pipe(
389 Layer.provide(VcsProcess.layer),
390 Layer.provide(layerServerConfig),
391 Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
392 );
393 const layerCheckpointStore = CheckpointStore.layer.pipe(
394 Layer.provide(layerVcsDriverRegistry),
395 Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
396 );
397 const layerCheckpointServiceProvided = CheckpointService.layer.pipe(
398 Layer.provide(Layer.mergeAll(layerCheckpointStore, IdAllocator.layer)),
399 );
400 const layerContextHandoffServiceProvided = ContextHandoffService.layer.pipe(
401 Layer.provide(IdAllocator.layer),
402 );
403 const layerPersistence = Layer.mergeAll(
404 layerStores,
405 layerEventSinkProvided,
406 layerCommandReceiptStoreProvided,
407 IdAllocator.layer,
408 layerProviderEventIngestorProvided,
409 );
410 const layerCommandOutputHubProvided = CommandOutputRecorder.layer.pipe(
411 Layer.provide(Layer.merge(layerEventSinkProvided, layerStores)),
412 );
413 const layerProviderSessionManagerProvided = ProviderSessionManager.layerWithOptions({
414 configureMcp: false,
415 }).pipe(
416 Layer.provide(
417 Layer.mergeAll(
418 layerCommandOutputHubProvided,
419 layerProvidedRegistry,
420 layerEventSinkProvided,
421 IdAllocator.layer,
422 McpProviderSessions.layer,
423 McpSessionRegistryTestkit.layer,
424 layerProviderEventIngestorProvided,
425 layerStores,
426 ProviderInstallationGate.layer,
427 ),
428 ),
429 );
430 const layerProviderSwitchServiceProvided = ProviderSwitchService.layer.pipe(
431 Layer.provide(layerProvidedRegistry),
432 );
433 const layerRunExecutionServiceProvided = RunExecutionService.layer.pipe(
434 Layer.provide(
435 Layer.mergeAll(
436 McpAppModelContext.layerEmpty,
437 PreviewAgentActivity.layer,
438 layerCheckpointServiceProvided,
439 layerEventSinkProvided,
440 IdAllocator.layer,
441 layerProviderEventIngestorProvided,
442 layerServerSettings,
443 layerStores,
444 ThreadCommandExecutor.layer,
445 ),
446 ),
447 );
448 const layerProviderTurnStartServiceProvided = ProviderTurnStartService.layer.pipe(
449 Layer.provide(
450 Layer.mergeAll(
451 layerContextHandoffServiceProvided,
452 layerEventSinkProvided,
453 IdAllocator.layer,
454 layerStores,
455 layerProviderSessionManagerProvided,
456 Layer.mock(ProviderAuthService.ProviderAuthService)({
457 tryHandlePromptCommand: () => Effect.succeed(false),
458 }),
459 layerRunExecutionServiceProvided,
460 layerRuntime,
461 layerServerConfig,
462 layerServerSettings,
463 ),
464 ),
465 );
466 const layerProviderTurnControlServiceProvided = ProviderTurnControlService.layer.pipe(
467 Layer.provide(
468 Layer.mergeAll(
469 layerEventSinkProvided,
470 McpAppModelContext.layerEmpty,
471 layerStores,
472 layerProviderSessionManagerProvided,
473 ),
474 ),
475 );
476 const layerRuntimeRequestServiceProvided = RuntimeRequestService.layer.pipe(
477 Layer.provide(Layer.merge(layerStores, layerProviderSessionManagerProvided)),
478 );
479 const layerCheckpointRollbackServiceProvided = CheckpointRollbackService.layer.pipe(
480 Layer.provide(
481 Layer.mergeAll(
482 layerCheckpointServiceProvided,
483 layerEventSinkProvided,
484 IdAllocator.layer,
485 layerStores,
486 layerProviderSessionManagerProvided,
487 ThreadCommandExecutor.layer,
488 layerRuntime,
489 layerServerConfig,
490 layerServerSettings,
491 ),
492 ),
493 );
494 const layerCheckpointCaptureServiceProvided = CheckpointCaptureService.layer.pipe(
495 Layer.provide(
496 Layer.mergeAll(
497 layerCheckpointServiceProvided,
498 layerEventSinkProvided,
499 IdAllocator.layer,
500 layerStores,
501 ),
502 ),
503 );
504 const layerRunFinalizationServiceProvided = RunFinalizationService.layer.pipe(
505 Layer.provide(Layer.merge(layerCheckpointCaptureServiceProvided, layerStores)),
506 );
507 const layerThreadTitleRegenerationTest = Layer.succeed(
508 ThreadTitleRegenerationService.ThreadTitleRegenerationService,
509 ThreadTitleRegenerationService.ThreadTitleRegenerationService.of({
510 execute: Effect.fn("ThreadTitleRegenerationService.execute")(function () {
511 return Effect.void;
512 }),
513 }),
514 );
515 const layerOrchestratorProvided = Orchestrator.layer.pipe(
516 Layer.provide(
517 Layer.mergeAll(
518 layerCheckpointServiceProvided,
519 CommandPolicy.layer,
520 layerContextHandoffServiceProvided,
521 layerPersistence,
522 layerProvidedRegistry,
523 layerContinuationRequests,
524 layerRuntime,
525 layerProviderSessionManagerProvided,
526 layerProviderSwitchServiceProvided,
527 layerRunExecutionServiceProvided,
528 layerServerSettings,
529 ThreadForkService.layer,
530 ),
531 ),
532 );
533 const layerThreadManagementProvided = Layer.unwrap(
534 Effect.gen(function* () {
535 const orchestrator = yield* Orchestrator.OrchestratorV2;
536 return Layer.mock(ThreadManagementService.ThreadManagementService)({
537 dispatch: orchestrator.dispatch,
538 getThreadRecords: orchestrator.getThreadRecords,
539 getThreadProjection: orchestrator.getThreadProjection,
540 recoverDelegatedTask: orchestrator.recoverDelegatedTask,
541 cancelDelegatedTask: orchestrator.cancelDelegatedTask,
542 delegatedTaskResultPending: orchestrator.delegatedTaskResultPending,
543 streamStoredEventsFrom: orchestrator.streamStoredEventsFrom,
544 });
545 }),
546 ).pipe(Layer.provide(layerOrchestratorProvided));
547 const layerContinuationWorkerProvided =
548 options.runContinuationWorker === true
549 ? ProviderContinuationService.layer.pipe(
550 Layer.provide(
551 Layer.mergeAll(
552 layerContinuationRequests,
553 layerThreadManagementProvided,
554 IdAllocator.layer,
555 ),
556 ),
557 )
558 : Layer.empty;
559 const layerEffectExecutorProvided = EffectWorker.layerExecutor.pipe(
560 Layer.provide(
561 Layer.mergeAll(
562 layerRunFinalizationServiceProvided,
563 layerCheckpointRollbackServiceProvided,
564 layerProviderSessionManagerProvided,
565 layerProviderTurnControlServiceProvided,
566 layerProviderTurnStartServiceProvided,
567 layerRuntimeRequestServiceProvided,
568 layerThreadTitleRegenerationTest,
569 layerServerSettings,
570 layerThreadManagementProvided,
571 layerStores,
572 ),
573 ),
574 );
575 const layerEffectWorkerProvided = EffectWorker.layer.pipe(
576 Layer.provide(Layer.merge(layerStores, layerEffectExecutorProvided)),
577 );
578 const layerReplayRuntime = Layer.mergeAll(
579 layerEffectOutboxProvided,
580 layerOrchestratorProvided,
581 layerProviderSessionManagerProvided,
582 layerEffectWorkerProvided,
583 layerEventSinkProvided,
584 layerContinuationWorkerProvided,
585 layerCommandOutputHubProvided,
586 ThreadCommandExecutor.layer,
587 ).pipe(
588 Layer.provide(ProviderTurnStartServiceTestkit.layer),
589 Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
590 );
591
592 if (options.runEffectWorker === false) {
593 return layerReplayRuntime;
594 }
595 // Build recovery before runtime so it commits before the effect worker claims work.
596 const layerStartupRecovery: Layer.Layer<
597 never,
598 MigrationError | PlatformError.PlatformError | SqlError
599 > =
600 options.recoverOnStartup === true
601 ? Layer.effectDiscard(
602 ProviderRuntimeRecoveryService.ProviderRuntimeRecoveryService.use(
603 (recovery) => recovery.recover,
604 ).pipe(Effect.orDie),
605 ).pipe(
606 Layer.provide(ProviderRuntimeRecoveryService.layer),
607 Layer.provide(
608 Layer.mergeAll(
609 layerStores,
610 layerEventSinkProvided,
611 IdAllocator.layer,
612 layerServerSettings,
613 ),
614 ),
615 )
616 : Layer.empty;
617 return Layer.effect(
618 Orchestrator.OrchestratorV2,
619 Effect.gen(function* () {
620 const orchestrator = yield* Orchestrator.OrchestratorV2;
621 yield* orchestrator.recoverDelegatedTasks;
622 yield* EffectWorker.runDaemon.pipe(Effect.forkScoped);
623 return orchestrator;
624 }),
625 ).pipe(Layer.provideMerge(layerReplayRuntime), Layer.provide(layerStartupRecovery));
626 }