2026-11-20 05:41:16 +00:00
package app
import (
"context"
"errors"
"fmt"
"gitea.maximumdirect.net/eric/narratio/internal/artifacts"
"gitea.maximumdirect.net/eric/narratio/internal/config"
"go.maximumdirect.net/commandkit"
)
type restoreCommandInput struct {
Selection configurationSelection
PreviousSession string
DryRun , Force , IncludeAudio bool
}
type restoreCommandReport struct {
Campaign string ` json:"campaign" `
SessionID string ` json:"session_id" `
RunID string ` json:"run_id" `
DryRun bool ` json:"dry_run" `
Complete bool ` json:"complete" `
Status string ` json:"status" `
Downloaded int ` json:"downloaded" `
Conflicts int ` json:"conflicts" `
Actions [ ] restoreCommandAction ` json:"actions" `
}
type restoreCommandAction struct {
Kind string ` json:"kind" `
LocalPath string ` json:"local_path" `
RemoteKey string ` json:"remote_key" `
Status string ` json:"status" `
Reason string ` json:"reason,omitempty" `
Error string ` json:"error,omitempty" `
}
func restoreSession ( ctx context . Context , cfg * config . Config , opts RestorePlanOptions , deps commandDependencies ) ( public * restoreCommandReport , resultErr error ) {
diagnostic , resultErr := restoreSessionState ( ctx , cfg , opts , normalizeCommandDependencies ( deps ) )
if diagnostic == nil {
return nil , resultErr
}
public = & restoreCommandReport { Campaign : diagnostic . Campaign , SessionID : diagnostic . SessionID , RunID : diagnostic . RunID , DryRun : opts . DryRun , Complete : ! opts . DryRun && resultErr == nil && diagnostic . Status == "succeeded" , Status : diagnostic . Status , Downloaded : diagnostic . Execution . Downloaded , Conflicts : diagnostic . Plan . Conflicts , Actions : [ ] restoreCommandAction { } }
for _ , action := range diagnostic . Actions {
public . Actions = append ( public . Actions , restoreCommandAction { Kind : action . Kind , LocalPath : action . LocalRelativePath , RemoteKey : action . RemoteKey , Status : action . Status , Reason : action . Reason , Error : action . Error } )
}
return public , resultErr
}
func restoreSessionState ( ctx context . Context , cfg * config . Config , opts RestorePlanOptions , deps commandDependencies ) ( diagnostic * RestoreReport , resultErr error ) {
if err := config . Validate ( cfg ) ; err != nil {
return diagnostic , fmt . Errorf ( "restore: %w" , err )
}
objectStore , err := newCommandObjectStoreWithDependencies ( ctx , cfg , nil , deps )
if err != nil {
return diagnostic , fmt . Errorf ( "restore: %w" , err )
}
current , err := deps . discoverRemoteCurrentState ( ctx , cfg , objectStore )
if err != nil {
return diagnostic , fmt . Errorf ( "restore: %w" , err )
}
if opts . DryRun {
plan , err := deps . buildRestorePlan ( ctx , cfg , current , objectStore , RestorePlanOptions {
IncludeAudio : opts . IncludeAudio ,
Force : opts . Force ,
DryRun : true ,
} )
if err != nil {
return diagnostic , fmt . Errorf ( "restore: %w" , err )
}
report , err := newRestoreReport ( current , plan , RestorePlanOptions {
IncludeAudio : opts . IncludeAudio ,
Force : opts . Force ,
DryRun : true ,
} )
if err != nil {
return diagnostic , fmt . Errorf ( "restore: %w" , err )
}
diagnostic = report
return diagnostic , nil
}
artifactStore := artifacts . NewLocalStore ( cfg . Pipeline . Workspace . Root )
if _ , err := artifactStore . EnsureLayoutFor ( cfg . Session . Campaign , cfg . Session . SessionID ) ; err != nil {
return diagnostic , fmt . Errorf ( "restore: prepare workdir: %w" , err )
}
lock , err := artifactStore . AcquireSessionLockForContext ( ctx , cfg . Session . Campaign , cfg . Session . SessionID )
if err != nil {
return diagnostic , fmt . Errorf ( "restore: acquire session lock: %w" , err )
}
defer func ( ) {
if releaseErr := artifactStore . ReleaseSessionLock ( lock ) ; releaseErr != nil {
if resultErr == nil {
resultErr = fmt . Errorf ( "restore: release session lock: %w" , releaseErr )
} else {
resultErr = errors . Join ( resultErr , fmt . Errorf ( "restore: release session lock: %w" , releaseErr ) )
}
}
} ( )
// Classification and installation share the same transition lock as a
// runner. This prevents a runner from making reuse decisions against state
// that restore is about to replace.
plan , err := deps . buildRestorePlan ( ctx , cfg , current , objectStore , RestorePlanOptions {
IncludeAudio : opts . IncludeAudio ,
Force : opts . Force ,
} )
if err != nil {
return diagnostic , fmt . Errorf ( "restore: %w" , err )
}
report , err := newRestoreReport ( current , plan , RestorePlanOptions {
IncludeAudio : opts . IncludeAudio ,
Force : opts . Force ,
} )
if err != nil {
return diagnostic , fmt . Errorf ( "restore: %w" , err )
}
diagnostic = report
if plan . ConflictCount > 0 {
conflictErr := fmt . Errorf ( "restore conflict: %d conflicting path(s); --force can replace eligible regular files but not unresolved conflicts (download=%d skip_same=%d conflicts=%d)" , plan . ConflictCount , plan . DownloadCount , plan . SkipSameCount , plan . ConflictCount )
report . setFailed ( conflictErr )
_ , reportErr := persistRestoreReport ( artifactStore , cfg , report )
return diagnostic , errors . Join ( conflictErr , reportErr )
}
if err := writeRestoreMarker ( artifactStore . SessionPathsFor ( cfg . Session . Campaign , cfg . Session . SessionID ) ) ; err != nil {
return diagnostic , fmt . Errorf ( "restore: mark incomplete restore: %w" , err )
}
result , err := deps . executeRestorePlan ( ctx , cfg , current , plan , report , objectStore )
2026-11-20 05:53:49 +00:00
err = errors . Join ( err , ctx . Err ( ) )
2026-11-20 05:41:16 +00:00
if err != nil {
report . setFailed ( err )
if _ , reportErr := persistRestoreReport ( artifactStore , cfg , report ) ; reportErr != nil {
return diagnostic , fmt . Errorf ( "restore: execute plan and persist report: %w" , errors . Join ( err , reportErr ) )
}
return diagnostic , fmt . Errorf ( "restore: execute plan: %w" , err )
}
if result == nil {
return diagnostic , fmt . Errorf ( "restore execution returned no result" )
}
report . Execution . Downloaded = result . DownloadedCount
report . setSucceeded ( )
if err := clearRestoreMarker ( artifactStore . SessionPathsFor ( cfg . Session . Campaign , cfg . Session . SessionID ) ) ; err != nil {
return diagnostic , fmt . Errorf ( "restore: clear incomplete restore marker: %w" , err )
}
if _ , err := persistRestoreReport ( artifactStore , cfg , report ) ; err != nil {
return diagnostic , fmt . Errorf ( "restore: write report: %w" , err )
}
return diagnostic , nil
}
func restoreCommand ( deps commandDependencies ) commandkit . Command {
common := newConfigurationFlags ( func ( input * * restoreCommandInput ) * configurationSelection { return & ( * input ) . Selection } )
return commandkit . NewCommand ( commandkit . CommandSpec [ * restoreCommandInput ] { Name : "restore" , Summary : "Restore the committed remote session snapshot." , NewInput : func ( ) * restoreCommandInput { return & restoreCommandInput { } } ,
Flags : [ ] commandkit . Flag [ * restoreCommandInput ] { common . Config , common . Overlay , common . Campaign , common . CampaignFile , common . SessionFile , common . PartyFile , common . SecretsDir ,
commandkit . ValueFlag ( commandkit . FlagMeta { Name : "previous-session-id" , Usage : "Assert the previous session identity." } , nil , stringValue , func ( input * * restoreCommandInput , value commandkit . Supplied [ string ] ) {
( * input ) . PreviousSession = value . Value
} ) ,
commandkit . BoolFlag ( commandkit . FlagMeta { Name : "dry-run" , Usage : "Preview restore actions without writing local files." } , false , func ( input * * restoreCommandInput , value commandkit . Supplied [ bool ] ) { ( * input ) . DryRun = value . Value } ) ,
commandkit . BoolFlag ( commandkit . FlagMeta { Name : "force" , Usage : "Replace eligible conflicting regular files." } , false , func ( input * * restoreCommandInput , value commandkit . Supplied [ bool ] ) { ( * input ) . Force = value . Value } ) ,
commandkit . BoolFlag ( commandkit . FlagMeta { Name : "include-audio" , Usage : "Include session audio objects." } , false , func ( input * * restoreCommandInput , value commandkit . Supplied [ bool ] ) {
( * input ) . IncludeAudio = value . Value
} ) ,
} ,
Arguments : [ ] commandkit . Argument [ * restoreCommandInput ] { commandkit . ValueArgument ( commandkit . ArgumentMeta { Name : "SESSION" , Usage : "Session identity." } , true , stringValue , func ( input * * restoreCommandInput , value commandkit . Supplied [ string ] ) {
( * input ) . Selection . Session = value
} ) } ,
CheckInput : func ( input * restoreCommandInput ) error { return checkConfigurationSelection ( input . Selection ) } ,
Run : func ( invocation commandkit . Invocation , input * restoreCommandInput ) commandkit . Outcome {
2026-11-20 05:59:09 +00:00
report , err := restoreSelectedSession ( invocation . Context , input , withCommandReporting ( deps , invocation ) )
2026-11-20 05:41:16 +00:00
if report != nil {
err = errors . Join ( err , invocation . Reporter ( ) . Report ( commandkit . Report { Value : report } ) )
}
return operationOutcome ( err )
} ,
} )
}
func restoreSelectedSession ( ctx context . Context , input * restoreCommandInput , deps commandDependencies ) ( report * restoreCommandReport , err error ) {
deps = normalizeCommandDependencies ( deps )
deps . secretsBootstrap = & secretsBootstrap { }
acquired := newConfigurationAcquisition ( input . Selection , deps )
acquired . previousSessionID = input . PreviousSession
defer func ( ) {
err = errors . Join ( err , acquired . Close ( ) )
if report != nil && err != nil {
report . Complete = false
}
} ( )
cfg , err := acquired . Domain ( ctx )
if err != nil {
return nil , err
}
return restoreSession ( ctx , cfg , RestorePlanOptions { DryRun : input . DryRun , Force : input . Force , IncludeAudio : input . IncludeAudio } , deps )
}