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";
1819import { symlinksSupported } from "@t3tools/shared/testing/symlinks" ;
1920import * as Layer from "effect/Layer" ;
2021
22+ import * as GitWorkflow from "../git/GitWorkflowService.ts" ;
2123import { withWorkspaceLease } from "../workspace/workspaceLease.ts" ;
2224import { ProviderWorkspaceMissingError } from "../provider/Errors.ts" ;
2325import { 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+
390499it . effect . each ( [
391500 { restoreFiles : true , shared : "none" } ,
392501 { restoreFiles : false , shared : "root" } ,
0 commit comments