@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 435 lines 15.4 KB
Raw
1 import * as WorktreeBranchSync from "./WorktreeBranchSync.ts";
2 import * as GuestShareService from "../guest/GuestShareService.ts";
3 import * as UsageLimitRecoveryWorker from "./UsageLimitRecoveryWorker.ts";
4 import * as Scheduler from "../scheduling/Scheduler.ts";
5 import * as Layer from "effect/Layer";
6 import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
7 import * as OrchestrationCommandReceipts from "../persistence/OrchestrationCommandReceipts.ts";
8 import * as OrchestrationEventStore from "../persistence/OrchestrationEventStore.ts";
9 import * as McpAppModelContext from "../mcpApps/McpAppModelContext.ts";
10 import * as PreviewAgentActivity from "../preview/PreviewAgentActivity.ts";
11 import * as McpAppRequests from "../mcpApps/McpAppRequests.ts";
12 import * as McpSignIn from "../mcpApps/McpSignIn.ts";
13 import * as ProviderSessionRuntime from "../persistence/ProviderSessionRuntime.ts";
14 import * as TextGeneration from "../textGeneration/TextGeneration.ts";
15 import * as ProviderAuthService from "../provider/ProviderAuthService.ts";
16 import * as ProviderInstallationGate from "../provider/ProviderInstallationGate.ts";
17 import * as AgentSessionImporter from "../project/AgentSessionImporter.ts";
18 import * as AgentSessionScanner from "../project/AgentSessionScanner.ts";
19 import * as ProjectService from "../project/ProjectService.ts";
20 import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.ts";
21 import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts";
22 import * as ScratchThreadPromotion from "../project/ScratchThreadPromotion.ts";
23 import * as CheckpointCaptureService from "./CheckpointCaptureService.ts";
24 import * as CheckpointService from "./CheckpointService.ts";
25 import * as CheckpointRollbackService from "./CheckpointRollbackService.ts";
26 import * as CommandPolicy from "./CommandPolicy.ts";
27 import * as CommandReceiptStore from "./CommandReceiptStore.ts";
28 import * as ContextHandoffService from "./ContextHandoffService.ts";
29 import * as EffectOutbox from "./EffectOutbox.ts";
30 import * as EffectWorker from "./EffectWorker.ts";
31 import * as EventSink from "./EventSink.ts";
32 import * as ThreadViewers from "./ThreadViewers.ts";
33 import * as EventStore from "./EventStore.ts";
34 import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
35 import * as LegacyV1ThreadImporter from "./legacy/LegacyV1ThreadImporter.ts";
36 import * as Orchestrator from "./Orchestrator.ts";
37 import * as ProjectionStore from "./ProjectionStore.ts";
38 import * as ProjectionMaintenance from "./ProjectionMaintenance.ts";
39 import * as ProjectStore from "./ProjectStore.ts";
40 import * as ProviderAdapterRegistry from "./ProviderAdapterRegistry.ts";
41 import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
42 import * as ProviderContinuationService from "./ProviderContinuationService.ts";
43 import * as ThreadTitleRegenerationService from "./ThreadTitleRegenerationService.ts";
44 import * as ProviderEventIngestor from "./ProviderEventIngestor.ts";
45 import * as ThreadCommandExecutor from "./ThreadCommandExecutor.ts";
46 import * as ProviderSessionManager from "./ProviderSessionManager.ts";
47 import * as CommandOutputHub from "./CommandOutputHub.ts";
48 import * as ProviderRuntimeRecoveryService from "./ProviderRuntimeRecoveryService.ts";
49 import * as ProviderSwitchService from "./ProviderSwitchService.ts";
50 import * as ProviderTurnControlService from "./ProviderTurnControlService.ts";
51 import * as ProviderTurnStartService from "./ProviderTurnStartService.ts";
52 import { layerThreadWorktreeRestore } from "../workspace/restoreMissingWorktree.ts";
53 import * as RunExecutionService from "./RunExecutionService.ts";
54 import * as RunFinalizationService from "./RunFinalizationService.ts";
55 import * as ResourceCleanupService from "./ResourceCleanupService.ts";
56 import * as RuntimePolicy from "./RuntimePolicy.ts";
57 import * as RuntimeRequestService from "./RuntimeRequestService.ts";
58 import * as ThreadManagementService from "./ThreadManagementService.ts";
59 import * as ThreadLaunchService from "./ThreadLaunchService.ts";
60 import * as ThreadForkService from "./ThreadForkService.ts";
61 import * as TurnItemPositionStore from "./TurnItemPositionStore.ts";
62 import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
63 import * as SecretRequests from "../secrets/SecretRequests.ts";
64
65 export const layerEventInfrastructure = Layer.mergeAll(
66 OrchestrationEventStore.layer,
67 OrchestrationCommandReceipts.layer,
68 );
69
70 const layerRuntimePolicyProvided = RuntimePolicy.layerFromProjectStore.pipe(
71 Layer.provide(ProjectStore.layer),
72 );
73
74 const layerEventStoreProvided = EventStore.layerFromOrchestrationEventStore.pipe(
75 Layer.provide(layerEventInfrastructure),
76 );
77 const layerCommandReceiptStoreProvided = CommandReceiptStore.layerFromApplicationReceipts.pipe(
78 Layer.provide(layerEventInfrastructure),
79 );
80
81 const layerStores = Layer.mergeAll(
82 layerEventInfrastructure,
83 layerEventStoreProvided,
84 ProjectionStore.layer,
85 ProjectStore.layer,
86 layerCommandReceiptStoreProvided,
87 EffectOutbox.layer,
88 TurnItemPositionStore.layer,
89 );
90
91 // The server provides this same layer to thread subscriptions; memoized, they share one registry.
92 export const layerEventSink = EventSink.layerFromStores.pipe(
93 Layer.provide(Layer.merge(layerStores, ThreadViewers.layer)),
94 );
95 const layerProjectionMaintenanceProvided = ProjectionMaintenance.layer.pipe(
96 Layer.provide(layerStores),
97 );
98 const layerLegacyV1ThreadImporterProvided = LegacyV1ThreadImporter.layer.pipe(
99 Layer.provide(layerEventSink),
100 );
101
102 export const layerProjectService = ProjectService.layer.pipe(
103 Layer.provide(
104 Layer.mergeAll(
105 ProjectStore.layer,
106 ProjectionStore.layer,
107 layerEventSink,
108 IdAllocator.layer,
109 layerLegacyV1ThreadImporterProvided,
110 ),
111 ),
112 );
113
114 const layerProviderEventIngestorProvided = ProviderEventIngestor.layer.pipe(
115 Layer.provide(
116 Layer.mergeAll(
117 layerEventSink,
118 IdAllocator.layer,
119 ProjectionStore.layer,
120 ThreadCommandExecutor.layer,
121 GitVcsDriver.layer,
122 ),
123 ),
124 );
125
126 const layerCheckpointServiceProvided = CheckpointService.layer.pipe(
127 Layer.provide(IdAllocator.layer),
128 );
129 const layerContextHandoffServiceProvided = ContextHandoffService.layer.pipe(
130 Layer.provide(IdAllocator.layer),
131 );
132
133 const layerProviderSwitchServiceProvided = ProviderSwitchService.layer.pipe(
134 Layer.provide(ProviderAdapterRegistry.layerFromProviderInstanceRegistry),
135 );
136
137 const layerCommandOutputHubProvided = CommandOutputHub.layer.pipe(
138 Layer.provide(Layer.merge(layerEventSink, ProjectionStore.layer)),
139 );
140
141 const layerProviderSessionManagerProvided = ProviderSessionManager.layer.pipe(
142 Layer.provide(
143 Layer.mergeAll(
144 layerCommandOutputHubProvided,
145 ProviderAdapterRegistry.layerFromProviderInstanceRegistry,
146 layerEventSink,
147 IdAllocator.layer,
148 layerProviderEventIngestorProvided,
149 ProjectionStore.layer,
150 ProviderInstallationGate.layer,
151 ),
152 ),
153 );
154
155 const layerProviderAuthServiceProvided = ProviderAuthService.layer.pipe(
156 Layer.provide(Layer.merge(ProjectionStore.layer, layerProviderSessionManagerProvided)),
157 );
158
159 const layerRunExecutionServiceProvided = RunExecutionService.layer.pipe(
160 Layer.provide(
161 Layer.mergeAll(
162 McpAppModelContext.layer,
163 PreviewAgentActivity.layer,
164 layerCheckpointServiceProvided,
165 layerEventSink,
166 IdAllocator.layer,
167 layerProviderEventIngestorProvided,
168 TurnItemPositionStore.layer,
169 ThreadCommandExecutor.layer,
170 ),
171 ),
172 );
173
174 const layerProviderTurnStartServiceProvided = ProviderTurnStartService.layer.pipe(
175 Layer.provide(
176 Layer.mergeAll(
177 layerContextHandoffServiceProvided,
178 layerEventSink,
179 IdAllocator.layer,
180 ProjectionStore.layer,
181 layerProviderSessionManagerProvided,
182 layerProviderAuthServiceProvided,
183 layerRunExecutionServiceProvided,
184 layerRuntimePolicyProvided,
185 TurnItemPositionStore.layer,
186 ),
187 ),
188 );
189
190 const layerProviderTurnControlServiceProvided = ProviderTurnControlService.layer.pipe(
191 Layer.provide(
192 Layer.mergeAll(
193 layerEventSink,
194 McpAppModelContext.layer,
195 ProjectionStore.layer,
196 layerProviderSessionManagerProvided,
197 ),
198 ),
199 );
200 const layerRuntimeRequestServiceProvided = RuntimeRequestService.layer.pipe(
201 Layer.provide(Layer.merge(ProjectionStore.layer, layerProviderSessionManagerProvided)),
202 );
203 const layerCheckpointRollbackServiceProvided = CheckpointRollbackService.layer.pipe(
204 Layer.provide(
205 Layer.mergeAll(
206 ProjectStore.layer,
207 layerCheckpointServiceProvided,
208 layerEventSink,
209 IdAllocator.layer,
210 ProjectionStore.layer,
211 layerProviderSessionManagerProvided,
212 ThreadCommandExecutor.layer,
213 layerRuntimePolicyProvided,
214 ),
215 ),
216 );
217 const layerCheckpointCaptureServiceProvided = CheckpointCaptureService.layer.pipe(
218 Layer.provide(
219 Layer.mergeAll(
220 layerCheckpointServiceProvided,
221 layerEventSink,
222 IdAllocator.layer,
223 ProjectionStore.layer,
224 ),
225 ),
226 );
227 const layerRunFinalizationServiceProvided = RunFinalizationService.layer.pipe(
228 Layer.provide(Layer.merge(layerCheckpointCaptureServiceProvided, ProjectionStore.layer)),
229 );
230
231 const layerOrchestratorProvided = Orchestrator.layer.pipe(
232 Layer.provide(
233 Layer.mergeAll(
234 layerCheckpointServiceProvided,
235 CommandPolicy.layer,
236 layerStores,
237 layerEventSink,
238 layerCommandReceiptStoreProvided,
239 layerContextHandoffServiceProvided,
240 IdAllocator.layer,
241 ProjectStore.layer,
242 ProviderAdapterRegistry.layerFromProviderInstanceRegistry,
243 // Reuse the continuation worker's layer reference so memoization shares one request queue.
244 ProviderContinuationRequests.layer,
245 layerProviderEventIngestorProvided,
246 layerRuntimePolicyProvided,
247 layerProviderSessionManagerProvided,
248 layerProviderSwitchServiceProvided,
249 layerRunExecutionServiceProvided,
250 ThreadForkService.layer,
251 ),
252 ),
253 );
254
255 // One scanner serves the wizard's scan and imports, so imports can reuse its candidates.
256 const layerAgentSessionScannerProvided = AgentSessionScanner.layer.pipe(
257 Layer.provide(ProviderSessionRuntime.layer),
258 );
259 const layerAgentSessionImporterProvided = AgentSessionImporter.layer.pipe(
260 Layer.provide(
261 Layer.mergeAll(
262 layerAgentSessionScannerProvided,
263 layerProjectService,
264 layerOrchestratorProvided,
265 layerEventSink,
266 IdAllocator.layer,
267 ProviderSessionRuntime.layer,
268 ProviderAdapterRegistry.layerFromProviderInstanceRegistry,
269 ThreadCommandExecutor.layer,
270 ),
271 ),
272 );
273
274 const layerThreadManagementProvided = ThreadManagementService.layerWithLegacyImporter.pipe(
275 Layer.provide(
276 Layer.mergeAll(
277 layerOrchestratorProvided,
278 layerLegacyV1ThreadImporterProvided,
279 layerCommandReceiptStoreProvided,
280 layerProviderSessionManagerProvided,
281 layerThreadWorktreeRestore,
282 ),
283 ),
284 );
285 export const layerProjectSetupScriptRunner = ProjectSetupScriptRunner.layer.pipe(
286 Layer.provide(layerProjectService),
287 // Whether a thread came from a linked environment, which skips setup.
288 Layer.provide(ProjectionStore.layer),
289 );
290 const layerManagedProjectFoldersProvided = ManagedProjectFolders.layer.pipe(
291 Layer.provide(layerProjectService),
292 );
293 const layerThreadLaunchProvided = ThreadLaunchService.layer.pipe(
294 Layer.provide(
295 Layer.mergeAll(
296 layerProjectSetupScriptRunner,
297 layerManagedProjectFoldersProvided,
298 layerThreadManagementProvided,
299 layerCommandReceiptStoreProvided,
300 layerEventSink,
301 IdAllocator.layer,
302 ).pipe(Layer.provideMerge(layerProjectService)),
303 ),
304 );
305 const layerSecretRequestsProvided = SecretRequests.layer.pipe(
306 Layer.provide(layerThreadManagementProvided),
307 );
308 const layerScheduledTaskProvided = ScheduledTaskService.layer.pipe(
309 Layer.provide(
310 Layer.mergeAll(
311 layerThreadLaunchProvided,
312 layerThreadManagementProvided,
313 layerManagedProjectFoldersProvided,
314 layerSecretRequestsProvided,
315 ),
316 ),
317 );
318 const layerScratchThreadPromotionProvided = ScratchThreadPromotion.layer.pipe(
319 Layer.provide(
320 Layer.mergeAll(
321 layerManagedProjectFoldersProvided,
322 layerThreadManagementProvided,
323 layerScheduledTaskProvided,
324 ).pipe(Layer.provideMerge(layerProjectService)),
325 ),
326 );
327 const layerProviderContinuationWorkerProvided = ProviderContinuationService.layer.pipe(
328 Layer.provide(
329 Layer.mergeAll(
330 ProviderContinuationRequests.layer,
331 layerThreadManagementProvided,
332 IdAllocator.layer,
333 ),
334 ),
335 );
336 const layerThreadTitleRegenerationProvided = ThreadTitleRegenerationService.layer.pipe(
337 Layer.provide(
338 Layer.mergeAll(
339 layerThreadManagementProvided,
340 ProjectStore.layer,
341 TextGeneration.layer.pipe(Layer.provide(ProviderInstallationGate.layer)),
342 ),
343 ),
344 );
345 const layerEffectExecutorProvided = EffectWorker.layerExecutor.pipe(
346 Layer.provide(
347 Layer.mergeAll(
348 layerRunFinalizationServiceProvided,
349 layerCheckpointRollbackServiceProvided,
350 layerProviderSessionManagerProvided,
351 layerProviderTurnControlServiceProvided,
352 layerProviderTurnStartServiceProvided,
353 layerRuntimeRequestServiceProvided,
354 layerThreadTitleRegenerationProvided,
355 layerThreadManagementProvided,
356 ProjectionStore.layer,
357 ),
358 ),
359 );
360 const layerEffectWorkerProvided = EffectWorker.layer.pipe(
361 Layer.provide(Layer.merge(layerStores, layerEffectExecutorProvided)),
362 );
363 const layerProviderRuntimeRecoveryProvided = ProviderRuntimeRecoveryService.layer.pipe(
364 Layer.provide(
365 Layer.mergeAll(
366 layerEffectWorkerProvided,
367 layerStores,
368 layerEventSink,
369 IdAllocator.layer,
370 ProjectionStore.layer,
371 ),
372 ),
373 );
374
375 const layerMcpAppRequestsProvided = McpAppRequests.layer.pipe(
376 Layer.provide(
377 Layer.mergeAll(
378 McpAppModelContext.layer,
379 layerOrchestratorProvided,
380 layerThreadManagementProvided,
381 layerProviderSessionManagerProvided,
382 ),
383 ),
384 );
385
386 const layerMcpSignInProvided = McpSignIn.layer.pipe(
387 Layer.provide(Layer.merge(layerThreadManagementProvided, layerProviderSessionManagerProvided)),
388 );
389
390 export const layer = Layer.mergeAll(
391 layerCommandOutputHubProvided,
392 layerOrchestratorProvided,
393 layerMcpAppRequestsProvided,
394 layerMcpSignInProvided,
395 layerThreadManagementProvided,
396 layerEffectWorkerProvided,
397 layerProviderSessionManagerProvided,
398 layerProviderAuthServiceProvided,
399 layerProviderRuntimeRecoveryProvided,
400 layerProjectionMaintenanceProvided,
401 layerLegacyV1ThreadImporterProvided,
402 );
403
404 export const layerProduction = Layer.mergeAll(
405 WorktreeBranchSync.layer.pipe(
406 Layer.provide(Layer.merge(layerThreadManagementProvided, ProjectionStore.layer)),
407 ),
408 layer,
409 layerManagedProjectFoldersProvided,
410 layerThreadLaunchProvided,
411 layerScheduledTaskProvided,
412 layerScratchThreadPromotionProvided,
413 layerSecretRequestsProvided,
414 GuestShareService.layer.pipe(
415 Layer.provide(Layer.merge(layerOrchestratorProvided, layerCommandOutputHubProvided)),
416 ),
417 UsageLimitRecoveryWorker.layer.pipe(
418 Layer.provide(
419 Layer.mergeAll(
420 ProjectionStore.layer,
421 layerThreadManagementProvided,
422 layerOrchestratorProvided,
423 ),
424 ),
425 ),
426 layerProviderContinuationWorkerProvided,
427 layerAgentSessionScannerProvided,
428 layerAgentSessionImporterProvided,
429 EffectOutbox.layerPruneWorker.pipe(Layer.provide(EffectOutbox.layer)),
430 ).pipe(
431 Layer.provide(ResourceCleanupService.layer.pipe(Layer.provide(layerScheduledTaskProvided))),
432 Layer.provideMerge(layerProjectService),
433 Layer.provide(Scheduler.layer),
434 Layer.provideMerge(layerEventInfrastructure),
435 );