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

main
ts 699 lines 25.9 KB
Raw
1 import {
2 CommandId,
3 type OrchestrationProjectShell,
4 ProjectId,
5 type Project,
6 type ProjectCreatePayload,
7 type ProjectUpdatePayload,
8 type ProjectSnapshot,
9 type ThreadId,
10 } from "@t3tools/contracts";
11 import * as HostProcess from "@t3tools/shared/HostProcess";
12 import * as KeyedLock from "@t3tools/shared/KeyedLock";
13 import { isWslSharePath } from "@t3tools/shared/path";
14 import * as Context from "effect/Context";
15 import * as DateTime from "effect/DateTime";
16 import * as Effect from "effect/Effect";
17 import * as FileSystem from "effect/FileSystem";
18 import * as Layer from "effect/Layer";
19 import * as Option from "effect/Option";
20 import * as Result from "effect/Result";
21 import * as Schema from "effect/Schema";
22
23 import { withCommandMetrics } from "../observability/Metrics.ts";
24 import * as EventSink from "../orchestration-v2/EventSink.ts";
25 import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
26 import * as LegacyV1ThreadImporter from "../orchestration-v2/legacy/LegacyV1ThreadImporter.ts";
27 import * as ProjectionStore from "../orchestration-v2/ProjectionStore.ts";
28 import {
29 decodeProjectCommandRejection,
30 encodeProjectCommandRejection,
31 planProjectCommand,
32 type ProjectCommand,
33 } from "../orchestration-v2/ProjectCommands.ts";
34 import * as ProjectStore from "../orchestration-v2/ProjectStore.ts";
35 import * as ThreadCommandExecutor from "../orchestration-v2/ThreadCommandExecutor.ts";
36 import { planThreadDeletion } from "../orchestration-v2/ThreadDeletion.ts";
37 import * as ServerSettings from "../serverSettings.ts";
38 import { deletedProjectOverridePatch } from "../provider/ProjectSettingsOverrideSweep.ts";
39 import { makeIsManagedWorktreePath } from "../worktreesDirectory.ts";
40 import * as ProcessRunner from "../processRunner.ts";
41 import * as ProjectEnrichmentService from "./ProjectEnrichmentService.ts";
42 import { makeIsWorktreeContainer } from "./worktreeContainer.ts";
43 import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";
44
45 export interface ProjectCreateInput extends ProjectCreatePayload {
46 readonly commandId: CommandId;
47 readonly projectId: ProjectId;
48 }
49
50 export interface ProjectUpdateInput extends ProjectUpdatePayload {
51 readonly commandId: CommandId;
52 readonly projectId: ProjectId;
53 }
54
55 export interface ProjectBootstrapInput extends ProjectCreateInput {}
56
57 export interface ProjectDeleteInput {
58 readonly commandId: CommandId;
59 readonly projectId: ProjectId;
60 readonly force?: boolean;
61 }
62
63 export class ProjectNotFoundError extends Schema.TaggedError<ProjectNotFoundError>()(
64 "ProjectNotFoundError",
65 { projectId: ProjectId },
66 ) {
67 override get message(): string {
68 return `Project ${this.projectId} was not found.`;
69 }
70 }
71
72 export class ProjectConflictError extends Schema.TaggedError<ProjectConflictError>()(
73 "ProjectConflictError",
74 {
75 projectId: ProjectId,
76 workspaceRoot: Schema.String,
77 conflictingProjectId: ProjectId,
78 },
79 ) {
80 override get message(): string {
81 return `Workspace ${this.workspaceRoot} already belongs to project ${this.conflictingProjectId}.`;
82 }
83 }
84
85 export class ProjectNotEmptyError extends Schema.TaggedError<ProjectNotEmptyError>()(
86 "ProjectNotEmptyError",
87 { projectId: ProjectId },
88 ) {
89 override get message(): string {
90 return `Project ${this.projectId} is not empty.`;
91 }
92 }
93
94 /** A change the project's rules refuse, such as an invalid script ID: the caller's input is wrong, nothing failed. */
95 export class ProjectInvalidError extends Schema.TaggedError<ProjectInvalidError>()(
96 "ProjectInvalidError",
97 { projectId: ProjectId, detail: Schema.String },
98 ) {
99 override get message(): string {
100 return this.detail;
101 }
102 }
103
104 export class ProjectOperationError extends Schema.TaggedError<ProjectOperationError>()(
105 "ProjectOperationError",
106 {
107 operation: Schema.Literals([
108 "normalize-workspace",
109 "read-project",
110 "list-projects",
111 "list-threads",
112 "delete-thread",
113 "dispatch-project-command",
114 ]),
115 projectId: Schema.optional(ProjectId),
116 workspaceRoot: Schema.optional(Schema.String),
117 cause: Schema.Defect(),
118 },
119 ) {
120 override get message(): string {
121 return `Project operation '${this.operation}' failed${this.projectId === undefined ? "" : ` for ${this.projectId}`}.`;
122 }
123 }
124
125 export type ProjectServiceError =
126 | ProjectNotFoundError
127 | ProjectConflictError
128 | ProjectNotEmptyError
129 | ProjectInvalidError
130 | ProjectOperationError;
131
132 export class ProjectService extends Context.Service<
133 ProjectService,
134 {
135 readonly create: (input: ProjectCreateInput) => Effect.Effect<Project, ProjectServiceError>;
136 readonly bootstrap: (
137 input: ProjectBootstrapInput,
138 ) => Effect.Effect<
139 { readonly project: Project; readonly created: boolean },
140 ProjectServiceError
141 >;
142 readonly update: (input: ProjectUpdateInput) => Effect.Effect<Project, ProjectServiceError>;
143 readonly delete: (input: ProjectDeleteInput) => Effect.Effect<Project, ProjectServiceError>;
144 readonly getById: (
145 projectId: ProjectId,
146 options?: { readonly includeDeleted?: boolean },
147 ) => Effect.Effect<Option.Option<Project>, ProjectOperationError>;
148 readonly getByWorkspaceRoot: (
149 workspaceRoot: string,
150 options?: { readonly includeDeleted?: boolean },
151 ) => Effect.Effect<Option.Option<Project>, ProjectOperationError>;
152 /**
153 * Where to scan `cwd`'s workspace inventory. A thread's removed managed worktree scans its
154 * project, which turn start recreates the worktree from; anything else, or a failure, is `cwd`.
155 */
156 readonly workspaceScanDirectory: (cwd: string) => Effect.Effect<string>;
157 readonly snapshot: Effect.Effect<ProjectSnapshot, ProjectOperationError>;
158 /**
159 * A page of active projects in creation order, each with its repository
160 * identity resolved, so a caller can match projects by repository.
161 */
162 readonly listPage: (input: {
163 readonly cursor: number;
164 readonly limit: number;
165 }) => Effect.Effect<
166 { readonly projects: ReadonlyArray<Project>; readonly nextCursor: number | null },
167 ProjectOperationError
168 >;
169 readonly getShell: (
170 projectId: ProjectId,
171 ) => Effect.Effect<Option.Option<OrchestrationProjectShell>, ProjectOperationError>;
172 readonly listShells: (options?: {
173 readonly projectIds?: ReadonlyArray<ProjectId>;
174 }) => Effect.Effect<ReadonlyArray<OrchestrationProjectShell>, ProjectOperationError>;
175 }
176 >()("t3/project/ProjectService") {}
177
178 export const make = Effect.gen(function* () {
179 const projects = yield* ProjectStore.ProjectStoreV2;
180 const projectEnrichment = yield* ProjectEnrichmentService.ProjectEnrichmentService;
181 const workspacePaths = yield* WorkspacePaths.WorkspacePaths;
182 const threadProjections = yield* ProjectionStore.ProjectionStoreV2;
183 const eventSink = yield* EventSink.EventSinkV2;
184 const idAllocator = yield* IdAllocator.IdAllocatorV2;
185 const legacyImporter = yield* LegacyV1ThreadImporter.LegacyV1ThreadImporter;
186 const threadCommands = yield* ThreadCommandExecutor.ThreadCommandExecutor;
187 const serverSettings = yield* ServerSettings.ServerSettingsService;
188 const fileSystem = yield* FileSystem.FileSystem;
189 const isManagedWorktreePath = yield* makeIsManagedWorktreePath;
190 const isWorktreeContainer = yield* makeIsWorktreeContainer.pipe(
191 Effect.provide(ProcessRunner.layer),
192 );
193 const projectLocks = yield* KeyedLock.make<ProjectId>();
194 const workspaceLocks = yield* KeyedLock.make<string>();
195
196 const toProject = (
197 row: ProjectStore.ProjectRow,
198 enrichment: ProjectEnrichmentService.ProjectEnrichment | null,
199 ): Project => ({
200 id: row.projectId,
201 title: row.title,
202 workspaceRoot: row.workspaceRoot,
203 repositoryIdentity: enrichment?.repositoryIdentity ?? null,
204 faviconPath: row.faviconPath ?? enrichment?.faviconPath ?? null,
205 defaultModelSelection: row.defaultModelSelection,
206 defaultThreadEnvMode: row.defaultThreadEnvMode,
207 autoPull: row.autoPull,
208 projectIcon: row.projectIcon,
209 scripts: row.scripts,
210 pinnedAt: row.pinnedAt,
211 archivedAt: row.archivedAt,
212 createdAt: row.createdAt,
213 updatedAt: row.updatedAt,
214 deletedAt: row.deletedAt,
215 });
216
217 const hydrate = Effect.fn("ProjectService.hydrate")(function* (row: ProjectStore.ProjectRow) {
218 const enrichment =
219 row.deletedAt === null
220 ? yield* projectEnrichment.getAvailable(row.workspaceRoot)
221 : yield* projectEnrichment.peek(row.workspaceRoot);
222 return toProject(row, enrichment);
223 });
224
225 const readRow = (projectId: ProjectId, options?: { readonly includeDeleted?: boolean }) =>
226 projects
227 .get(projectId, options)
228 .pipe(
229 Effect.mapError(
230 (cause) => new ProjectOperationError({ operation: "read-project", projectId, cause }),
231 ),
232 );
233
234 const normalizeWorkspaceRoot = (input: {
235 readonly projectId?: ProjectId;
236 readonly workspaceRoot: string;
237 readonly createIfMissing?: boolean;
238 }) =>
239 workspacePaths
240 .normalizeWorkspaceRoot(input.workspaceRoot, {
241 createIfMissing: input.createIfMissing ?? false,
242 })
243 .pipe(
244 Effect.mapError(
245 (cause) =>
246 new ProjectOperationError({
247 operation: "normalize-workspace",
248 ...(input.projectId === undefined ? {} : { projectId: input.projectId }),
249 workspaceRoot: input.workspaceRoot,
250 cause,
251 }),
252 ),
253 );
254
255 const rejectWorktreeContainer = Effect.fn("ProjectService.rejectWorktreeContainer")(function* (
256 projectId: ProjectId,
257 workspaceRoot: string,
258 ) {
259 if (!(yield* isWorktreeContainer(workspaceRoot))) return;
260 return yield* new ProjectInvalidError({
261 projectId,
262 detail: `${workspaceRoot} holds a repository's worktrees but is not a checkout itself. Add one of its worktrees as the project instead.`,
263 });
264 });
265
266 // Git for Windows can't trust an index written inside the distro and rereads every file across the
267 // share, so git status can hit its timeout. Checked before normalizing, which already stats the share.
268 const rejectWslSharePath = Effect.fn("ProjectService.rejectWslSharePath")(function* (
269 projectId: ProjectId,
270 workspaceRoot: string,
271 ) {
272 if (!isWslSharePath(workspaceRoot) || !(yield* HostProcess.isWindows)) return;
273 return yield* new ProjectInvalidError({
274 projectId,
275 detail: `${workspaceRoot.trim()} is inside WSL. Add it to the WSL backend instead of the Windows one.`,
276 });
277 });
278
279 const commit = Effect.fn("ProjectService.commit")(function* (command: ProjectCommand) {
280 const { projectId } = command;
281 const dispatchError = (cause: unknown) =>
282 new ProjectOperationError({ operation: "dispatch-project-command", projectId, cause });
283 const workspaceRoot = command.type === "project.delete" ? undefined : command.workspaceRoot;
284 const planAndCommit = Effect.gen(function* () {
285 const project = Option.getOrUndefined(yield* readRow(projectId, { includeDeleted: true }));
286 const workspaceOwner =
287 workspaceRoot === undefined
288 ? undefined
289 : Option.getOrUndefined(
290 yield* projects
291 .findActiveByWorkspaceRoot(workspaceRoot)
292 .pipe(Effect.mapError(dispatchError)),
293 );
294 const now = yield* DateTime.now;
295 const eventId = yield* idAllocator.allocate
296 .event({ commandId: command.commandId })
297 .pipe(Effect.mapError(dispatchError));
298 const planned = planProjectCommand({
299 command,
300 state: { project, workspaceOwner },
301 eventId,
302 now,
303 });
304 if (Result.isSuccess(planned)) {
305 const { receipt } = yield* eventSink.commitProjectCommand({
306 commandId: command.commandId,
307 projectId,
308 commandType: command.type,
309 acceptedAt: now,
310 event: planned.success,
311 });
312 return receipt;
313 }
314 return yield* eventSink.commitRejectedProjectCommand({
315 commandId: command.commandId,
316 projectId,
317 commandType: command.type,
318 rejectedAt: now,
319 error: encodeProjectCommandRejection(planned.failure),
320 });
321 });
322 const receipt = yield* projectLocks
323 .withLock(
324 projectId,
325 workspaceRoot === undefined
326 ? planAndCommit
327 : workspaceLocks.withLock(workspaceRoot, planAndCommit),
328 )
329 .pipe(Effect.mapError(dispatchError));
330 if (receipt.projectId !== projectId || receipt.commandType !== command.type) {
331 return yield* dispatchError(
332 `Command ${command.commandId} was already used by ${receipt.commandType} for ${receipt.projectId}.`,
333 );
334 }
335 // Retries re-plan against their own effects; the first receipt determines the outcome.
336 if (receipt.status === "accepted") return;
337 const rejection = Option.getOrUndefined(decodeProjectCommandRejection(receipt.error));
338 switch (rejection?._tag) {
339 case "ProjectWorkspaceConflictError":
340 return yield* new ProjectConflictError({
341 projectId,
342 workspaceRoot: rejection.workspaceRoot,
343 conflictingProjectId: rejection.conflictingProjectId,
344 });
345 case "ProjectCommandMissingProjectError":
346 return yield* new ProjectNotFoundError({ projectId });
347 case "ProjectCommandInvariantError":
348 return yield* new ProjectInvalidError({ projectId, detail: rejection.detail });
349 default:
350 return yield* dispatchError(
351 rejection ?? receipt.error ?? "The command was previously rejected.",
352 );
353 }
354 }, withCommandMetrics);
355
356 const readCommitted = Effect.fn("ProjectService.readCommitted")(function* (projectId: ProjectId) {
357 const row = yield* readRow(projectId, { includeDeleted: true });
358 if (Option.isNone(row)) {
359 return yield* new ProjectOperationError({
360 operation: "read-project",
361 projectId,
362 cause: "The accepted project command did not produce a project row.",
363 });
364 }
365 return yield* hydrate(row.value);
366 });
367
368 const getById: ProjectService["Service"]["getById"] = Effect.fn("ProjectService.getById")(
369 function* (projectId, options) {
370 const row = yield* readRow(projectId, options);
371 return Option.isNone(row) ? Option.none() : Option.some(yield* hydrate(row.value));
372 },
373 );
374
375 const workspaceScanDirectory = Effect.fn("ProjectService.workspaceScanDirectory")(
376 function* (cwd: string) {
377 if (yield* fileSystem.exists(cwd).pipe(Effect.orElseSucceed(() => true))) return cwd;
378 if (!(yield* isManagedWorktreePath(cwd))) return cwd;
379 const snapshot = yield* Effect.flatten(
380 threadProjections.readShellSnapshot({ worktreePath: cwd }),
381 );
382 const thread = [...snapshot.threads, ...snapshot.archivedThreads].find(
383 (candidate) => candidate.branch !== null,
384 );
385 if (thread === undefined) return cwd;
386 return Option.getOrUndefined(yield* readRow(thread.projectId))?.workspaceRoot ?? cwd;
387 },
388 (effect, cwd) => Effect.orElseSucceed(effect, () => cwd),
389 );
390
391 const getByWorkspaceRoot: ProjectService["Service"]["getByWorkspaceRoot"] = Effect.fn(
392 "ProjectService.getByWorkspaceRoot",
393 )(function* (workspaceRoot, options) {
394 const normalized = yield* normalizeWorkspaceRoot({ workspaceRoot });
395 const row = yield* (
396 options?.includeDeleted === true
397 ? projects
398 .list({ includeDeleted: true })
399 .pipe(
400 Effect.map((rows) =>
401 Option.fromUndefinedOr(rows.find((row) => row.workspaceRoot === normalized)),
402 ),
403 )
404 : projects.findActiveByWorkspaceRoot(normalized)
405 ).pipe(
406 Effect.mapError((cause) => new ProjectOperationError({ operation: "list-projects", cause })),
407 );
408 return Option.isNone(row) ? Option.none() : Option.some(yield* hydrate(row.value));
409 });
410
411 const create: ProjectService["Service"]["create"] = Effect.fn("ProjectService.create")(
412 function* (input) {
413 yield* rejectWslSharePath(input.projectId, input.workspaceRoot);
414 const workspaceRoot = yield* normalizeWorkspaceRoot({
415 projectId: input.projectId,
416 workspaceRoot: input.workspaceRoot,
417 createIfMissing: input.createWorkspaceRootIfMissing ?? false,
418 });
419 yield* rejectWorktreeContainer(input.projectId, workspaceRoot);
420 yield* commit({
421 type: "project.create",
422 commandId: input.commandId,
423 projectId: input.projectId,
424 title: input.title,
425 workspaceRoot,
426 ...(input.scripts === undefined ? {} : { scripts: input.scripts }),
427 });
428 yield* projectEnrichment.invalidate([workspaceRoot]);
429 return yield* readCommitted(input.projectId);
430 },
431 );
432
433 const update: ProjectService["Service"]["update"] = Effect.fn("ProjectService.update")(
434 function* (input) {
435 const existing = yield* readRow(input.projectId);
436 if (Option.isNone(existing)) {
437 return yield* new ProjectNotFoundError({ projectId: input.projectId });
438 }
439 const previousRoot = existing.value.workspaceRoot;
440 if (input.workspaceRoot !== undefined && input.workspaceRoot !== previousRoot) {
441 yield* rejectWslSharePath(input.projectId, input.workspaceRoot);
442 }
443 const workspaceRoot =
444 input.workspaceRoot === undefined
445 ? previousRoot
446 : yield* normalizeWorkspaceRoot({
447 projectId: input.projectId,
448 workspaceRoot: input.workspaceRoot,
449 });
450 if (workspaceRoot !== previousRoot) {
451 yield* rejectWorktreeContainer(input.projectId, workspaceRoot);
452 }
453 yield* commit({
454 type: "project.meta.update",
455 commandId: input.commandId,
456 projectId: input.projectId,
457 ...(input.title === undefined ? {} : { title: input.title }),
458 ...(workspaceRoot === previousRoot ? {} : { workspaceRoot }),
459 ...(input.defaultModelSelection === undefined
460 ? {}
461 : { defaultModelSelection: input.defaultModelSelection }),
462 ...(input.autoPull === undefined ? {} : { autoPull: input.autoPull }),
463 ...(input.projectIcon === undefined ? {} : { projectIcon: input.projectIcon }),
464 ...(input.faviconPath === undefined ? {} : { faviconPath: input.faviconPath }),
465 ...(input.defaultThreadEnvMode === undefined
466 ? {}
467 : { defaultThreadEnvMode: input.defaultThreadEnvMode }),
468 ...(input.scripts === undefined ? {} : { scripts: input.scripts }),
469 ...(input.pinned === undefined ? {} : { pinned: input.pinned }),
470 ...(input.archived === undefined ? {} : { archived: input.archived }),
471 });
472 if (workspaceRoot !== previousRoot || input.faviconPath !== undefined) {
473 yield* projectEnrichment.invalidate([previousRoot, workspaceRoot]);
474 }
475 return yield* readCommitted(input.projectId);
476 },
477 );
478
479 const bootstrap: ProjectService["Service"]["bootstrap"] = Effect.fn("ProjectService.bootstrap")(
480 function* (input) {
481 const existing = yield* getByWorkspaceRoot(input.workspaceRoot);
482 if (Option.isSome(existing)) return { project: existing.value, created: false };
483 return { project: yield* create(input), created: true };
484 },
485 );
486
487 const deleteChildThread = Effect.fn("ProjectService.deleteChildThread")(function* (
488 input: ProjectDeleteInput,
489 threadId: ThreadId,
490 ) {
491 yield* legacyImporter.ensureTranscript(threadId);
492 const projection = yield* threadProjections.getThreadRecords(threadId, [
493 "runs",
494 "attempts",
495 "nodes",
496 "runtimeRequests",
497 "subagents",
498 "providerSessions",
499 ]);
500 if (projection.thread.deletedAt !== null || projection.thread.projectId !== input.projectId) {
501 return;
502 }
503 const command = {
504 type: "thread.delete" as const,
505 commandId: CommandId.make(`${input.commandId}:delete-thread:${threadId}`),
506 threadId,
507 };
508 const now = yield* DateTime.now;
509 const plan = yield* planThreadDeletion({
510 command,
511 projection,
512 attachmentIds: yield* threadProjections.getThreadAttachmentIds(threadId),
513 now,
514 idAllocator,
515 });
516 const committed = yield* eventSink.commitCommand({
517 commandId: command.commandId,
518 commandType: command.type,
519 threadId,
520 acceptedAt: now,
521 events: plan.events,
522 effects: plan.effects,
523 });
524 if (
525 committed.receipt.threadId !== command.threadId ||
526 committed.receipt.commandType !== command.type
527 ) {
528 return yield* Effect.fail("The thread deletion command ID belongs to a different command.");
529 }
530 if (committed.receipt.status === "rejected") {
531 return yield* Effect.fail(
532 committed.receipt.error ?? "Thread deletion was previously rejected.",
533 );
534 }
535 });
536
537 const deleteChildThreads = Effect.fn("ProjectService.deleteChildThreads")(function* (
538 input: ProjectDeleteInput,
539 ) {
540 const { projectId } = input;
541 const snapshot = yield* threadProjections
542 .getShellSnapshot({ projectId })
543 .pipe(
544 Effect.mapError(
545 (cause) => new ProjectOperationError({ operation: "list-threads", projectId, cause }),
546 ),
547 );
548 // Newest first: a source deleted while its fork lives keeps the pages that fork shows.
549 const projectThreads = [...snapshot.threads, ...snapshot.archivedThreads].sort(
550 (a, b) => DateTime.toEpochMillis(b.createdAt) - DateTime.toEpochMillis(a.createdAt),
551 );
552 if (projectThreads.length > 0 && input.force !== true) {
553 return yield* new ProjectNotEmptyError({ projectId });
554 }
555 // Delete children durably before the project so a failed cascade can be retried.
556 yield* Effect.forEach(
557 projectThreads,
558 (thread) =>
559 threadCommands
560 .withDeletionLock(threadCommands.withLock(thread.id, deleteChildThread(input, thread.id)))
561 .pipe(
562 Effect.mapError(
563 (cause) =>
564 new ProjectOperationError({ operation: "delete-thread", projectId, cause }),
565 ),
566 ),
567 { concurrency: 1, discard: true },
568 );
569 });
570
571 // Best-effort cleanup releases disabled instances kept alive by overrides; crashes have no replay to revisit deletion.
572 const clearProjectSettingsOverrides = (projectId: ProjectId) =>
573 serverSettings.getSettings.pipe(
574 Effect.flatMap(({ projectSettingsOverrides }) =>
575 serverSettings.updateSettings({
576 projectSettingsOverrides: {
577 [projectId]: deletedProjectOverridePatch(projectSettingsOverrides[projectId]),
578 },
579 }),
580 ),
581 Effect.asVoid,
582 Effect.catchCause((cause) =>
583 Effect.logWarning(
584 `Failed to clear settings overrides for deleted project ${projectId}.`,
585 cause,
586 ),
587 ),
588 );
589
590 const deleteProject: ProjectService["Service"]["delete"] = Effect.fn("ProjectService.delete")(
591 function* (input) {
592 const { projectId } = input;
593 // Read deleted rows so retries replay receipts and other command ids fail as not found.
594 const existing = yield* readRow(projectId, { includeDeleted: true });
595 if (Option.isNone(existing)) {
596 return yield* new ProjectNotFoundError({ projectId });
597 }
598
599 const isFirstDelete = existing.value.deletedAt === null;
600 if (isFirstDelete) {
601 yield* deleteChildThreads(input);
602 }
603 yield* commit({ type: "project.delete", commandId: input.commandId, projectId });
604 if (isFirstDelete) {
605 yield* clearProjectSettingsOverrides(projectId);
606 }
607 yield* projectEnrichment.invalidate([existing.value.workspaceRoot]);
608 return yield* readCommitted(projectId);
609 },
610 );
611
612 const enrichShell = (shell: OrchestrationProjectShell) =>
613 projectEnrichment.getAvailable(shell.workspaceRoot).pipe(
614 Effect.map((enrichment) => ({
615 ...shell,
616 repositoryIdentity: enrichment.repositoryIdentity,
617 })),
618 );
619
620 const getShell: ProjectService["Service"]["getShell"] = Effect.fn("ProjectService.getShell")(
621 function* (projectId) {
622 const shell = yield* projects
623 .getShell(projectId)
624 .pipe(
625 Effect.mapError(
626 (cause) => new ProjectOperationError({ operation: "read-project", projectId, cause }),
627 ),
628 );
629 return Option.isNone(shell) ? shell : Option.some(yield* enrichShell(shell.value));
630 },
631 );
632
633 const listShells: ProjectService["Service"]["listShells"] = Effect.fn(
634 "ProjectService.listShells",
635 )(function* (options) {
636 const shells = yield* projects
637 .listShells(options)
638 .pipe(
639 Effect.mapError(
640 (cause) => new ProjectOperationError({ operation: "list-projects", cause }),
641 ),
642 );
643 return yield* Effect.forEach(shells, enrichShell, { concurrency: 16 });
644 });
645
646 const listRows = projects
647 .list()
648 .pipe(
649 Effect.mapError((cause) => new ProjectOperationError({ operation: "list-projects", cause })),
650 );
651
652 const snapshot = Effect.gen(function* () {
653 const rows = yield* listRows;
654 const hydrated = yield* Effect.forEach(rows, hydrate, { concurrency: 8 });
655 return {
656 projects: hydrated,
657 updatedAt: DateTime.formatIso(yield* DateTime.now),
658 } satisfies ProjectSnapshot;
659 });
660
661 const listPage: ProjectService["Service"]["listPage"] = Effect.fn("ProjectService.listPage")(
662 function* ({ cursor, limit }) {
663 const rows = (yield* listRows).filter((project) => project.deletedAt === null);
664 const projects = yield* Effect.forEach(
665 rows.slice(cursor, cursor + limit),
666 (row) =>
667 hydrate(row).pipe(
668 Effect.filterOrElse(
669 (project) => project.repositoryIdentity !== null,
670 (project) =>
671 projectEnrichment
672 .readRepositoryIdentity(project.workspaceRoot)
673 .pipe(Effect.map((repositoryIdentity) => ({ ...project, repositoryIdentity }))),
674 ),
675 ),
676 { concurrency: 8 },
677 );
678 return { projects, nextCursor: cursor + limit < rows.length ? cursor + limit : null };
679 },
680 );
681
682 return ProjectService.of({
683 create,
684 bootstrap,
685 update,
686 delete: deleteProject,
687 getById,
688 getByWorkspaceRoot,
689 workspaceScanDirectory,
690 snapshot,
691 listPage,
692 getShell,
693 listShells,
694 });
695 });
696
697 export const layer = Layer.effect(ProjectService, make).pipe(
698 Layer.provide(ThreadCommandExecutor.layer),
699 );