Skip to content

Commit 254eca7

Browse files
committed
fix(server): restore cleaned worktrees before checkpoint rollback
1 parent fa441e3 commit 254eca7

2 files changed

Lines changed: 217 additions & 90 deletions

File tree

‎apps/server/src/orchestration-v2/CheckpointRollbackService.test.ts‎

Lines changed: 166 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@ import {
44
CheckpointId,
55
CheckpointScopeId,
66
type OrchestrationV2ThreadProjection,
7+
ProjectId,
78
ProviderInstanceId,
89
ProviderSessionId,
910
ProviderThreadId,
@@ -18,6 +19,7 @@ import * as Option from "effect/Option";
1819
import { symlinksSupported } from "@t3tools/shared/testing/symlinks";
1920
import * as Layer from "effect/Layer";
2021

22+
import * as GitWorkflow from "../git/GitWorkflowService.ts";
2123
import { withWorkspaceLease } from "../workspace/workspaceLease.ts";
2224
import { ProviderWorkspaceMissingError } from "../provider/Errors.ts";
2325
import { resolveCodexRollbackTurnCount } from "./Adapters/CodexAdapterV2.ts";
@@ -40,6 +42,7 @@ const checkpointRollbackServiceLayer = CheckpointRollbackService.layer.pipe(
4042
Layer.provide(
4143
Layer.mergeAll(
4244
NodeServices.layer,
45+
Layer.mock(GitWorkflow.GitWorkflowService)({}),
4346
Layer.mock(ProjectStore.ProjectStoreV2)({ get: () => Effect.succeed(unrelatedProject) }),
4447
),
4548
),
@@ -267,7 +270,7 @@ it.effect("rejects a rollback when provider selection changed before execution",
267270
}).pipe(Effect.provide(testLayer));
268271
});
269272

270-
it.effect.each(["normal", "cleanup-first", "rollback-first"])("locks rollback with %s", (order) => {
273+
it.effect("rejects an unavailable rollback target before opening a session", () => {
271274
const threadId = ThreadId.make("thread:rollback-provider-turn-unavailable");
272275
const providerThreadId = ProviderThreadId.make(
273276
"provider-thread:rollback-provider-turn-unavailable",
@@ -279,22 +282,11 @@ it.effect.each(["normal", "cleanup-first", "rollback-first"])("locks rollback wi
279282
const scopeId = CheckpointScopeId.make("checkpoint-scope:rollback-provider-turn-unavailable");
280283
const providerInstanceId = ProviderInstanceId.make("provider_rollback_provider_turn_unavailable");
281284
const restore = vi.fn(() => Effect.die("checkpoint restore must not run"));
282-
const release = Deferred.makeUnsafe<void>();
283-
const openEntered = Deferred.makeUnsafe<void>();
284-
let checkoutExists = true;
285-
let cleanupEntered = false;
286-
const open = vi.fn(() =>
287-
Effect.gen(function* () {
288-
if (!checkoutExists)
289-
return yield* new ProviderWorkspaceMissingError({ threadId, cwd: process.cwd() });
290-
yield* Deferred.succeed(openEntered, undefined);
291-
if (order === "rollback-first") yield* Deferred.await(release);
292-
return {} as never;
293-
}),
294-
);
285+
const open = vi.fn(() => Effect.die("provider session open must not run"));
295286
const projection = {
296287
thread: {
297-
worktreePath: process.cwd(),
288+
worktreePath: "/tmp/missing-invalid-rollback-worktree",
289+
branch: "feature/rollback",
298290
activeProviderThreadId: providerThreadId,
299291
modelSelection: { instanceId: providerInstanceId, model: "test-model" },
300292
},
@@ -334,49 +326,10 @@ it.effect.each(["normal", "cleanup-first", "rollback-first"])("locks rollback wi
334326

335327
return Effect.gen(function* () {
336328
const service = yield* CheckpointRollbackService.CheckpointRollbackServiceV2;
337-
const execute = service
338-
.execute({
339-
threadId,
340-
providerThreadId,
341-
checkpointId,
342-
scopeId,
343-
restoreFiles: false,
344-
})
329+
const error = yield* service
330+
.execute({ threadId, providerThreadId, checkpointId, scopeId, restoreFiles: false })
345331
.pipe(Effect.flip);
346-
const cleanupEffect = withWorkspaceLease(
347-
process.cwd(),
348-
Effect.gen(function* () {
349-
cleanupEntered = true;
350-
if (order === "cleanup-first") yield* Deferred.await(release);
351-
checkoutExists = false;
352-
}),
353-
);
354-
const cleanup =
355-
order === "cleanup-first"
356-
? yield* cleanupEffect.pipe(Effect.forkChild({ startImmediately: true }))
357-
: undefined;
358-
const rollback = yield* execute.pipe(Effect.forkChild({ startImmediately: true }));
359-
if (order === "cleanup-first") assert.equal(open.mock.calls.length, 0);
360-
if (order === "rollback-first") yield* Deferred.await(openEntered);
361-
const laterCleanup =
362-
order === "rollback-first"
363-
? yield* cleanupEffect.pipe(Effect.forkChild({ startImmediately: true }))
364-
: undefined;
365-
if (order === "rollback-first") assert.isFalse(cleanupEntered);
366-
yield* Deferred.succeed(release, undefined);
367-
if (cleanup !== undefined) yield* Fiber.join(cleanup);
368-
const error = yield* Fiber.join(rollback);
369-
if (laterCleanup !== undefined) {
370-
yield* Fiber.join(laterCleanup);
371-
assert.isTrue(cleanupEntered);
372-
}
373-
if (order === "cleanup-first") {
374-
assert.equal(error.reason, "unexpected-failure");
375-
assert.instanceOf(error.cause, ProviderWorkspaceMissingError);
376-
assert.equal(restore.mock.calls.length, 0);
377-
return;
378-
}
379-
332+
assert.equal(open.mock.calls.length, 0);
380333
assert.equal(error.reason, "provider-turn-unavailable");
381334
assert.equal(
382335
error.message,
@@ -387,6 +340,162 @@ it.effect.each(["normal", "cleanup-first", "rollback-first"])("locks rollback wi
387340
}).pipe(Effect.provide(testLayer));
388341
});
389342

343+
it.effect.each([
344+
{ order: "normal", restoreFiles: true },
345+
{ order: "cleanup-first", restoreFiles: true },
346+
{ order: "cleanup-first", restoreFiles: false },
347+
{ order: "rollback-first", restoreFiles: true },
348+
])("locks rollback with %s", ({ order, restoreFiles }) =>
349+
Effect.gen(function* () {
350+
const fileSystem = yield* FileSystem.FileSystem;
351+
const path = yield* Path.Path;
352+
const workspaceRoot = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-rollback-" });
353+
const worktreePath = path.join(workspaceRoot, "worktree");
354+
yield* fileSystem.makeDirectory(worktreePath);
355+
const threadId = ThreadId.make("rollback-worktree");
356+
const projectId = ProjectId.make("rollback-worktree-project");
357+
const providerThreadId = ProviderThreadId.make("rollback-worktree-provider-thread");
358+
const providerSessionId = ProviderSessionId.make("rollback-worktree-provider-session");
359+
const providerInstanceId = ProviderInstanceId.make("rollback-worktree-provider-instance");
360+
const checkpointId = CheckpointId.make("rollback-worktree-checkpoint");
361+
const scopeId = CheckpointScopeId.make("rollback-worktree-scope");
362+
const branch = "feature/rollback";
363+
const release = Deferred.makeUnsafe<void>();
364+
const openEntered = Deferred.makeUnsafe<void>();
365+
const calls: string[] = [];
366+
let cleanupEntered = false;
367+
const providerThread = { id: providerThreadId, providerSessionId, providerInstanceId };
368+
const projection = {
369+
thread: {
370+
id: threadId,
371+
projectId,
372+
worktreePath,
373+
branch,
374+
activeProviderThreadId: providerThreadId,
375+
modelSelection: { instanceId: providerInstanceId, model: "test-model" },
376+
},
377+
providerThreads: [providerThread],
378+
providerSessions: [],
379+
checkpoints: [{ id: checkpointId, scopeId, status: "ready", appRunOrdinal: 0 }],
380+
checkpointScopes: [{ id: scopeId, cwd: worktreePath }],
381+
runs: [],
382+
attempts: [],
383+
nodes: [],
384+
providerTurns: [],
385+
} as unknown as OrchestrationV2ThreadProjection;
386+
const testLayer = CheckpointRollbackService.layer.pipe(
387+
Layer.provide(
388+
Layer.mergeAll(
389+
NodeServices.layer,
390+
Layer.mock(ProjectStore.ProjectStoreV2)({
391+
get: (id) => {
392+
assert.equal(id, projectId);
393+
return Effect.succeed(Option.some({ workspaceRoot } as never));
394+
},
395+
}),
396+
Layer.mock(GitWorkflow.GitWorkflowService)({
397+
pruneWorktrees: (input) =>
398+
Effect.sync(() => {
399+
assert.deepEqual(input, { cwd: workspaceRoot });
400+
calls.push("prune");
401+
}),
402+
createWorktree: (input) =>
403+
Effect.gen(function* () {
404+
assert.deepEqual(input, {
405+
cwd: workspaceRoot,
406+
refName: branch,
407+
path: worktreePath,
408+
});
409+
calls.push("create");
410+
yield* fileSystem.makeDirectory(worktreePath);
411+
return {} as never;
412+
}),
413+
}),
414+
Layer.mock(CheckpointService.CheckpointServiceV2)({
415+
restore: () =>
416+
Effect.gen(function* () {
417+
assert.isTrue(yield* fileSystem.exists(worktreePath));
418+
calls.push("files");
419+
}),
420+
}),
421+
Layer.mock(EventSink.EventSinkV2)({
422+
write: () =>
423+
Effect.sync(() => {
424+
calls.push("projection");
425+
return [];
426+
}),
427+
}),
428+
IdAllocator.layer,
429+
Layer.mock(ProjectionStore.ProjectionStoreV2)({
430+
getThreadRecords: () => Effect.succeed(projection),
431+
getShellSnapshot: () =>
432+
Effect.succeed({
433+
schemaVersion: 1,
434+
snapshotSequence: 0,
435+
threads: [],
436+
archivedThreads: [],
437+
}),
438+
}),
439+
Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({
440+
open: () =>
441+
Effect.gen(function* () {
442+
if (!(yield* fileSystem.exists(worktreePath))) {
443+
return yield* new ProviderWorkspaceMissingError({ threadId, cwd: worktreePath });
444+
}
445+
calls.push("session");
446+
yield* Deferred.succeed(openEntered, undefined);
447+
if (order === "rollback-first") yield* Deferred.await(release);
448+
return {} as never;
449+
}),
450+
}),
451+
Layer.mock(RuntimePolicy.RuntimePolicyV2)({ resolve: () => Effect.succeed({} as never) }),
452+
),
453+
),
454+
);
455+
yield* Effect.gen(function* () {
456+
const service = yield* CheckpointRollbackService.CheckpointRollbackServiceV2;
457+
const cleanupEffect = withWorkspaceLease(
458+
worktreePath,
459+
Effect.gen(function* () {
460+
cleanupEntered = true;
461+
if (order === "cleanup-first") yield* Deferred.await(release);
462+
yield* fileSystem.remove(worktreePath, { recursive: true });
463+
calls.push("cleanup");
464+
}),
465+
);
466+
const cleanup =
467+
order === "cleanup-first"
468+
? yield* cleanupEffect.pipe(Effect.forkChild({ startImmediately: true }))
469+
: undefined;
470+
const rollback = yield* service
471+
.execute({ threadId, providerThreadId, checkpointId, scopeId, restoreFiles })
472+
.pipe(Effect.forkChild({ startImmediately: true }));
473+
if (order === "cleanup-first") assert.deepEqual(calls, []);
474+
if (order === "rollback-first") yield* Deferred.await(openEntered);
475+
const laterCleanup =
476+
order === "rollback-first"
477+
? yield* cleanupEffect.pipe(Effect.forkChild({ startImmediately: true }))
478+
: undefined;
479+
if (order === "rollback-first") assert.isFalse(cleanupEntered);
480+
yield* Deferred.succeed(release, undefined);
481+
if (cleanup !== undefined) yield* Fiber.join(cleanup);
482+
yield* Fiber.join(rollback);
483+
if (laterCleanup !== undefined) yield* Fiber.join(laterCleanup);
484+
const rollbackCalls = restoreFiles
485+
? ["session", "files", "projection"]
486+
: ["session", "projection"];
487+
assert.deepEqual(
488+
calls,
489+
order === "cleanup-first"
490+
? ["cleanup", "prune", "create", ...rollbackCalls]
491+
: order === "rollback-first"
492+
? [...rollbackCalls, "cleanup"]
493+
: rollbackCalls,
494+
);
495+
}).pipe(Effect.provide(testLayer));
496+
}).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
497+
);
498+
390499
it.effect.each([
391500
{ restoreFiles: true, shared: "none" },
392501
{ restoreFiles: false, shared: "root" },

0 commit comments

Comments
 (0)