Skip to content

Commit e3f2cda

Browse files
fix(mcp): close project operation races
1 parent 93b2157 commit e3f2cda

6 files changed

Lines changed: 257 additions & 29 deletions

‎apps/server/src/mcp/OrchestratorMcpService.test.ts‎

Lines changed: 47 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,9 @@ import {
1313
type OrchestrationV2ThreadProjection,
1414
} from "@t3tools/contracts";
1515
import * as DateTime from "effect/DateTime";
16+
import * as Deferred from "effect/Deferred";
1617
import * as Effect from "effect/Effect";
18+
import * as Fiber from "effect/Fiber";
1719
import * as Layer from "effect/Layer";
1820
import * as Option from "effect/Option";
1921
import * as Ref from "effect/Ref";
@@ -97,10 +99,25 @@ describe("OrchestratorMcpService", () => {
9799
visibleTurnItems: [],
98100
updatedAt: now,
99101
};
100-
const archivedParent = {
102+
const replacementRunId = RunId.make("run:mcp-create-admission-parent-replacement");
103+
const replacementNodeId = NodeId.make("node:mcp-create-admission-parent-replacement");
104+
const replacedParentRun = {
101105
...activeParent,
102-
thread: { ...activeParent.thread, archivedAt: now },
103-
} as OrchestrationV2ThreadProjection;
106+
runs: [
107+
{
108+
...activeParent.runs[0]!,
109+
status: "completed" as const,
110+
completedAt: now,
111+
},
112+
{
113+
...activeParent.runs[0]!,
114+
id: replacementRunId,
115+
ordinal: 2,
116+
userMessageId: MessageId.make("message:mcp-create-admission-parent-replacement"),
117+
rootNodeId: replacementNodeId,
118+
},
119+
],
120+
} satisfies OrchestrationV2ThreadProjection;
104121
const provider = {
105122
instanceId: providerInstanceId,
106123
driver: ProviderDriverKind.make("codex"),
@@ -115,14 +132,21 @@ describe("OrchestratorMcpService", () => {
115132
skills: [],
116133
} satisfies ServerProvider;
117134
const projectionReads = yield* Ref.make(0);
135+
const currentParent = yield* Ref.make<OrchestrationV2ThreadProjection>(activeParent);
136+
const admissionEntered = yield* Deferred.make<void>();
137+
const allowAdmission = yield* Deferred.make<void>();
118138
const dependencies = Layer.mergeAll(
119139
NodeServices.layer,
120140
Layer.mock(ThreadManagementService)({
121141
getThreadProjection: () =>
122-
Ref.updateAndGet(projectionReads, (count) => count + 1).pipe(
123-
Effect.map((count) => (count === 1 ? activeParent : archivedParent)),
142+
Ref.update(projectionReads, (count) => count + 1).pipe(
143+
Effect.andThen(Ref.get(currentParent)),
144+
),
145+
withProjectCreationAdmission: (_input, effect) =>
146+
Deferred.succeed(admissionEntered, undefined).pipe(
147+
Effect.andThen(Deferred.await(allowAdmission)),
148+
Effect.andThen(effect(Option.none())),
124149
),
125-
withProjectCreationAdmission: (_input, effect) => effect(Option.none()),
126150
dispatch: () => Effect.die("dispatch must not run after parent admission fails"),
127151
}),
128152
Layer.mock(ProviderRegistry)({ getProviders: Effect.succeed([provider]) }),
@@ -138,14 +162,23 @@ describe("OrchestratorMcpService", () => {
138162
};
139163

140164
const error = yield* Effect.gen(function* () {
141-
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
142-
return yield* service
143-
.createThreads(scope, {
144-
clientRequestId: "parent-admission-failure",
145-
threads: [{ title: "Must not be created" }],
146-
})
147-
.pipe(Effect.flip);
148-
}).pipe(Effect.provide(OrchestratorMcpService.layer.pipe(Layer.provide(dependencies))));
165+
const creation = yield* Effect.gen(function* () {
166+
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
167+
return yield* service
168+
.createThreads(scope, {
169+
clientRequestId: "parent-admission-failure",
170+
threads: [{ title: "Must not be created" }],
171+
})
172+
.pipe(Effect.flip);
173+
}).pipe(
174+
Effect.provide(OrchestratorMcpService.layer.pipe(Layer.provide(dependencies))),
175+
Effect.forkChild({ startImmediately: true }),
176+
);
177+
yield* Deferred.await(admissionEntered);
178+
yield* Ref.set(currentParent, replacedParentRun);
179+
yield* Deferred.succeed(allowAdmission, undefined);
180+
return yield* Fiber.join(creation);
181+
}).pipe(Effect.ensuring(Deferred.succeed(allowAdmission, undefined)));
149182

150183
assert.equal(error.code, "parent_not_active");
151184
assert.equal(

‎apps/server/src/mcp/OrchestratorMcpService.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1467,6 +1467,7 @@ const make = Effect.gen(function* () {
14671467
freshParent.thread.deletedAt !== null ||
14681468
freshParent.thread.archivedAt !== null ||
14691469
freshParentRun === undefined ||
1470+
freshParentRun.id !== parentRun.id ||
14701471
freshParentRun.rootNodeId === null ||
14711472
freshParentRun.providerInstanceId !== scope.providerInstanceId
14721473
) {

‎apps/server/src/mcp/ProjectMcpService.test.ts‎

Lines changed: 97 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -465,6 +465,103 @@ it.effect("clones before registration and requires explicit cascading for nonemp
465465
}),
466466
);
467467

468+
it.effect("reports an overlapping completed deletion as an idempotent result", () =>
469+
Effect.gen(function* () {
470+
const projectId = ProjectId.make("project:mcp:overlapping-delete");
471+
const project = makeProject({
472+
id: projectId,
473+
title: "Overlapping deletion",
474+
workspaceRoot: "/work/overlapping-delete",
475+
});
476+
const projectState = yield* Ref.make<Project>(project);
477+
const deleteAttempts = yield* Ref.make(0);
478+
const firstDeleteEntered = yield* Deferred.make<void>();
479+
const secondDeleteEntered = yield* Deferred.make<void>();
480+
const allowFirstDelete = yield* Deferred.make<void>();
481+
const firstDeleteFinished = yield* Deferred.make<void>();
482+
const projectService = ProjectService.ProjectService.of({
483+
create: () => Effect.die("unused"),
484+
bootstrap: () => Effect.die("unused"),
485+
update: () => Effect.die("unused"),
486+
delete: () => Effect.die("unused"),
487+
deleteDetailed: ({ projectId: deletedProjectId }) =>
488+
Effect.gen(function* () {
489+
const attempt = yield* Ref.updateAndGet(deleteAttempts, (count) => count + 1);
490+
if (attempt === 1) {
491+
yield* Deferred.succeed(firstDeleteEntered, undefined);
492+
yield* Deferred.await(allowFirstDelete);
493+
const deleted = { ...project, deletedAt: now } satisfies Project;
494+
yield* Ref.set(projectState, deleted);
495+
yield* Deferred.succeed(firstDeleteFinished, undefined);
496+
return { project: deleted, deletedThreadCount: 2 };
497+
}
498+
yield* Deferred.succeed(secondDeleteEntered, undefined);
499+
yield* Deferred.await(firstDeleteFinished);
500+
return yield* new ProjectService.ProjectNotFoundError({
501+
projectId: deletedProjectId,
502+
});
503+
}).pipe(Effect.ensuring(Deferred.succeed(firstDeleteFinished, undefined))),
504+
getById: (_projectId, options) =>
505+
Ref.get(projectState).pipe(
506+
Effect.map((current) =>
507+
current.deletedAt !== null && options?.includeDeleted !== true
508+
? Option.none()
509+
: Option.some(current),
510+
),
511+
),
512+
getByWorkspaceRoot: () => Effect.die("unused"),
513+
snapshot: Effect.die("unused"),
514+
});
515+
const testLayer = ProjectMcp.layer.pipe(
516+
Layer.provide(Layer.succeed(ProjectService.ProjectService, projectService)),
517+
Layer.provide(Layer.mock(T3ProjectFileLoader.T3ProjectFileLoader)({})),
518+
Layer.provide(ServerSettingsService.layerTest({})),
519+
Layer.provide(Layer.mock(SourceControlRepositoryService.SourceControlRepositoryService)({})),
520+
Layer.provide(Layer.mock(ThreadManagement.ThreadManagementService)({})),
521+
Layer.provide(NodeServices.layer),
522+
);
523+
524+
yield* Effect.gen(function* () {
525+
const service = yield* ProjectMcp.ProjectMcpService;
526+
const first = yield* service
527+
.delete(scope, {
528+
projectId,
529+
cascadeThreads: true,
530+
clientRequestId: "overlapping-delete-first",
531+
})
532+
.pipe(Effect.forkChild({ startImmediately: true }));
533+
yield* Deferred.await(firstDeleteEntered);
534+
const second = yield* service
535+
.delete(scope, {
536+
projectId,
537+
cascadeThreads: true,
538+
clientRequestId: "overlapping-delete-second",
539+
})
540+
.pipe(Effect.forkChild({ startImmediately: true }));
541+
yield* Deferred.await(secondDeleteEntered);
542+
yield* Deferred.succeed(allowFirstDelete, undefined);
543+
544+
expect(yield* Fiber.join(first)).toMatchObject({
545+
projectId,
546+
deleted: true,
547+
alreadyDeleted: false,
548+
deletedThreadCount: 2,
549+
});
550+
expect(yield* Fiber.join(second)).toMatchObject({
551+
projectId,
552+
deleted: true,
553+
alreadyDeleted: true,
554+
deletedThreadCount: 0,
555+
});
556+
expect(yield* Ref.get(deleteAttempts)).toBe(2);
557+
}).pipe(
558+
Effect.provide(testLayer),
559+
Effect.ensuring(Deferred.succeed(allowFirstDelete, undefined)),
560+
Effect.ensuring(Deferred.succeed(firstDeleteFinished, undefined)),
561+
);
562+
}),
563+
);
564+
468565
it.effect("serializes delegated thread admission with cascading project deletion", () =>
469566
Effect.gen(function* () {
470567
const projectId = ProjectId.make("project:mcp:delete-delegate-race");

‎apps/server/src/mcp/ProjectMcpService.ts‎

Lines changed: 35 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -412,25 +412,51 @@ const make = Effect.gen(function* () {
412412
...(input.cascadeThreads === true ? { force: true } : {}),
413413
})
414414
.pipe(
415+
Effect.map((result) => ({ type: "deleted" as const, result })),
416+
Effect.catchTag("ProjectNotFoundError", (notFound) =>
417+
projects.getById(input.projectId, { includeDeleted: true }).pipe(
418+
redactOperationFailure(
419+
"read-project-after-overlapping-delete",
420+
"Unable to confirm the project deletion.",
421+
),
422+
Effect.flatMap((reloaded) =>
423+
Option.isSome(reloaded) && reloaded.value.deletedAt !== null
424+
? Effect.succeed({ type: "already_deleted" as const, project: reloaded.value })
425+
: Effect.fail(notFound),
426+
),
427+
),
428+
),
415429
Effect.tapError(() =>
416430
Effect.logWarning("Project MCP operation failed.", { operation: "delete-project" }),
417431
),
418432
Effect.mapError((error) =>
419-
error._tag === "ProjectNotEmptyError"
420-
? failure(
421-
"project_not_empty",
422-
`Project '${input.projectId}' is not empty. Retry with cascadeThreads=true to delete its thread records first. Workspace files will remain untouched.`,
423-
)
424-
: error._tag === "ProjectNotFoundError"
425-
? failure("project_not_found", `Project '${input.projectId}' was not found.`)
426-
: failure("operation_failed", "Unable to delete the requested project."),
433+
error._tag === "ProjectMcpFailure"
434+
? error
435+
: error._tag === "ProjectNotEmptyError"
436+
? failure(
437+
"project_not_empty",
438+
`Project '${input.projectId}' is not empty. Retry with cascadeThreads=true to delete its thread records first. Workspace files will remain untouched.`,
439+
)
440+
: error._tag === "ProjectNotFoundError"
441+
? failure("project_not_found", `Project '${input.projectId}' was not found.`)
442+
: failure("operation_failed", "Unable to delete the requested project."),
427443
),
428444
);
445+
if (deletion.type === "already_deleted") {
446+
return {
447+
projectId: input.projectId,
448+
deleted: true,
449+
alreadyDeleted: true,
450+
deletedThreadCount: 0,
451+
workspaceRoot: deletion.project.workspaceRoot,
452+
workspaceFilesDeleted: false,
453+
} satisfies ProjectMcpDeleteResult;
454+
}
429455
return {
430456
projectId: input.projectId,
431457
deleted: true,
432458
alreadyDeleted: false,
433-
deletedThreadCount: deletion.deletedThreadCount,
459+
deletedThreadCount: deletion.result.deletedThreadCount,
434460
workspaceRoot: project.workspaceRoot,
435461
workspaceFilesDeleted: false,
436462
} satisfies ProjectMcpDeleteResult;

‎apps/server/src/sourceControl/SourceControlRepositoryService.test.ts‎

Lines changed: 65 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -365,10 +365,75 @@ it.effect("recovers a real completed clone after a lost result and rejects unsaf
365365

366366
yield* initializeRepository(sourcePath, "source");
367367
yield* initializeRepository(otherSourcePath, "other source");
368+
yield* fs.writeFileString(`${sourcePath}/CHANGELOG.md`, "second source commit");
369+
yield* git.execute({ operation: "test.add.second", cwd: sourcePath, args: ["add", "."] });
370+
yield* git.execute({
371+
operation: "test.commit.second",
372+
cwd: sourcePath,
373+
args: ["commit", "-m", "second"],
374+
});
368375

369376
const cloned = yield* service.cloneRepository({ remoteUrl: sourcePath, destinationPath });
370377
assert.strictEqual(cloned.cwd, destinationPath);
371378

379+
const headCommit = (yield* git.execute({
380+
operation: "test.read.head",
381+
cwd: destinationPath,
382+
args: ["rev-parse", "HEAD"],
383+
})).stdout.trim();
384+
const previousCommit = (yield* git.execute({
385+
operation: "test.read.previous",
386+
cwd: destinationPath,
387+
args: ["rev-parse", "HEAD^"],
388+
})).stdout.trim();
389+
yield* git
390+
.execute({
391+
operation: "test.remove.remote.head",
392+
cwd: destinationPath,
393+
args: ["symbolic-ref", "-d", "refs/remotes/origin/HEAD"],
394+
})
395+
.pipe(Effect.ignore);
396+
const existingRemoteRefs = (yield* git.execute({
397+
operation: "test.list.remote.refs",
398+
cwd: destinationPath,
399+
args: ["for-each-ref", "--format=%(refname)", "refs/remotes/origin"],
400+
})).stdout
401+
.split("\n")
402+
.map((line) => line.trim())
403+
.filter((line) => line.length > 0);
404+
yield* Effect.forEach(
405+
existingRemoteRefs,
406+
(refName) =>
407+
git.execute({
408+
operation: "test.remove.remote.ref",
409+
cwd: destinationPath,
410+
args: ["update-ref", "-d", refName],
411+
}),
412+
{ discard: true },
413+
);
414+
const noiseRefCommands = Array.from(
415+
{ length: 1_700 },
416+
(_, index) =>
417+
`create refs/remotes/origin/noise-${index.toString().padStart(4, "0")} ${previousCommit}`,
418+
);
419+
yield* git.execute({
420+
operation: "test.create.many.remote.refs",
421+
cwd: destinationPath,
422+
args: ["update-ref", "--stdin"],
423+
stdin: [...noiseRefCommands, `create refs/remotes/origin/zzzz-match ${headCommit}`, ""].join(
424+
"\n",
425+
),
426+
});
427+
const oversizedInventory = yield* git
428+
.execute({
429+
operation: "test.verify.old.remote-ref-boundary",
430+
cwd: destinationPath,
431+
args: ["for-each-ref", "--format=%(objectname)", "refs/remotes/origin"],
432+
maxOutputBytes: 64 * 1024,
433+
})
434+
.pipe(Effect.flip);
435+
assert.instanceOf(oversizedInventory, GitCommandError);
436+
372437
// Simulate the caller losing the successful clone result before project registration.
373438
const recovered = yield* service.cloneRepository({ remoteUrl: sourcePath, destinationPath });
374439
assert.strictEqual(recovered.cwd, destinationPath);

‎apps/server/src/sourceControl/SourceControlRepositoryService.ts‎

Lines changed: 12 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -224,19 +224,25 @@ export const make = Effect.gen(function* () {
224224
);
225225
if (headCommit === null) return false;
226226

227-
const remoteCommits = yield* git
227+
const remoteCommit = yield* git
228228
.execute({
229229
operation: "SourceControlRepositoryService.cloneRepository.verifyRemoteRefs",
230230
cwd: destinationPath,
231-
args: ["for-each-ref", "--format=%(objectname)", "refs/remotes/origin"],
231+
args: [
232+
"for-each-ref",
233+
"--count=1",
234+
"--format=%(objectname)",
235+
`--points-at=${headCommit}`,
236+
"refs/remotes/origin",
237+
],
232238
timeoutMs: 5_000,
233-
maxOutputBytes: 64 * 1024,
239+
maxOutputBytes: 1024,
234240
})
235241
.pipe(
236-
Effect.map((result) => new Set(result.stdout.split("\n").map((line) => line.trim()))),
237-
Effect.orElseSucceed(() => new Set<string>()),
242+
Effect.map((result) => result.stdout.trim() || null),
243+
Effect.orElseSucceed(() => null),
238244
);
239-
if (!remoteCommits.has(headCommit)) return false;
245+
if (remoteCommit !== headCommit) return false;
240246

241247
return yield* git
242248
.execute({

0 commit comments

Comments
 (0)