Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

fix(workspace): restore snapshots over empty dirs and preserve git-tracked excluded paths (#989)

crispinhu274bcd9fbb04f3
diff --git a/internal/engine/browser.go b/internal/engine/browser.go
index ff8a8566..f9b34be0 100644
--- a/internal/engine/browser.go
+++ b/internal/engine/browser.go
@@ -88,6 +88,9 @@ func (e *Engine) ensureRunBrowser(ctx context.Context, run domain.Run) error {
if _, err := e.PrepareConversationWorkspace(ctx, run.ID, token); err != nil {
return err
}
+ if latest, ok := e.repo.RunState(run.ID); ok {
+ run = latest
+ }
ctx = WithConversationWorkspaceToken(ctx, token, run.ID)
}
env, err := e.acquireConversationEnvironment(ctx, run)
diff --git a/internal/engine/conversation_workspace.go b/internal/engine/conversation_workspace.go
index 59a6db63..e3b50ff7 100644
--- a/internal/engine/conversation_workspace.go
+++ b/internal/engine/conversation_workspace.go
@@ -12,6 +12,7 @@ import (
"agentflow/internal/domain"
"agentflow/internal/gitwork"
"agentflow/internal/repo"
+ "agentflow/internal/runtime"
)
const ConversationWorkspaceIdleTTL = time.Hour
@@ -285,10 +286,24 @@ func (e *Engine) ensureConversationWorkspace(ctx context.Context, id, token stri
}
root := e.sandboxes.RunWorkspace(id)
if info, statErr := os.Lstat(root); statErr == nil && info.IsDir() && !e.foreignWorkspaceBind(run) {
- if err = e.verifyStoredCheckpoint(ctx, id); err != nil {
+ hasContent, contentErr := runtime.WorkspaceDirHasContent(root)
+ if contentErr != nil {
+ return contentErr
+ }
+ if hasContent {
+ if err = e.verifyStoredCheckpoint(ctx, id); err != nil {
+ return err
+ }
+ return e.repo.RestoreCheckpointWorkspaceBinding(id, token, e.workspaceHost, e.sandboxes.Root(), time.Now().UTC())
+ }
+ // An empty or .agentflow-only directory created before restoration
+ // holds no user files; tear down any container bound to its old inode
+ // so restoreConversationCheckpoint can atomically replace it and the
+ // next container bind sees the restored files.
+ if err = e.releaseRunEnvironment(id, false); err != nil {
return err
}
- return e.repo.RestoreCheckpointWorkspaceBinding(id, token, e.workspaceHost, e.sandboxes.Root(), time.Now().UTC())
+ e.sandboxes.DiscardRunContainer(ctx, id)
}
if err = e.restoreConversationCheckpoint(ctx, run, root); err != nil {
return err
diff --git a/internal/engine/conversation_workspace_test.go b/internal/engine/conversation_workspace_test.go
index a8212211..e1ff3113 100644
--- a/internal/engine/conversation_workspace_test.go
+++ b/internal/engine/conversation_workspace_test.go
@@ -504,3 +504,107 @@ func TestConversationWorkspaceRetriesFailedSaveBeforeIdleReclamation(t *testing.
t.Fatal("retry reclaimed active conversation files", err)
}
}
+
+func TestConversationWorkspaceRestoresOverPrecreatedEmptyAndAgentFlowDirectory(t *testing.T) {
+ t.Parallel()
+ for _, mode := range []string{"empty", "agentflow-only"} {
+ t.Run(mode, func(t *testing.T) {
+ e, id := checkpointFixture(t)
+ e.reconcileTerminalWorkspaceCleanup()
+ r, _ := e.repo.RunState(id)
+ if r.WorkspaceCleanedAt.IsZero() {
+ t.Fatal("precondition: workspace not reclaimed")
+ }
+ root := e.RunWorkspace(id)
+ if err := os.MkdirAll(root, 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if mode == "agentflow-only" {
+ if err := os.MkdirAll(filepath.Join(root, ".agentflow", "hooks"), 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(root, ".agentflow", "hooks", "pre.json"), []byte("{}"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ }
+
+ token, err := e.BeginConversationWorkspaceUse(id)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := e.EnsureConversationWorkspace(context.Background(), id, token); err != nil {
+ t.Fatal(err)
+ }
+ defer e.EndConversationWorkspaceUse(context.Background(), id, token)
+
+ body, err := os.ReadFile(filepath.Join(root, "README.md"))
+ if err != nil || string(body) != "uncommitted" {
+ t.Fatalf("snapshot not unpacked over %s directory: %q (%v)", mode, body, err)
+ }
+ r, _ = e.repo.RunState(id)
+ if !r.WorkspaceCleanedAt.IsZero() {
+ t.Fatal("cleanup marker not cleared after restore")
+ }
+ })
+ }
+}
+
+func TestAcquireConversationEnvironmentRefusesUnrestoredReclaimedWorkspace(t *testing.T) {
+ t.Parallel()
+ e, id := checkpointFixture(t)
+ e.reconcileTerminalWorkspaceCleanup()
+ if _, err := os.Lstat(e.RunWorkspace(id)); !os.IsNotExist(err) {
+ t.Fatalf("precondition: reclaimed dir still exists: %v", err)
+ }
+ if _, err := e.EnsureWorkspaceReady(context.Background(), id); err == nil {
+ t.Fatal("EnsureWorkspaceReady succeeded on unrestored reclaimed workspace")
+ }
+ if _, err := os.Lstat(e.RunWorkspace(id)); !os.IsNotExist(err) {
+ t.Fatalf("EnsureWorkspaceReady pre-created empty dir before snapshot restore: %v", err)
+ }
+}
+
+func TestEnsureRunBrowserRestoresReclaimedWorkspaceWithStaleRun(t *testing.T) {
+ bin := t.TempDir()
+ chromium := filepath.Join(bin, "chromium")
+ script := `#!/bin/sh
+profile=
+for arg in "$@"; do
+ case "$arg" in --user-data-dir=*) profile="${arg#*=}";; esac
+done
+mkdir -p "$profile"
+printf '9224\n/devtools/browser/stale\n' > "$profile/DevToolsActivePort"
+exec sleep 30
+`
+ if err := os.WriteFile(chromium, []byte(script), 0o755); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(bin, "playwright-mcp"), []byte("#!/bin/sh\nexit 0\n"), 0o755); err != nil {
+ t.Fatal(err)
+ }
+ t.Setenv("AGENTFLOW_CHROMIUM", chromium)
+ t.Setenv("PATH", bin+string(os.PathListSeparator)+os.Getenv("PATH"))
+
+ e, id := checkpointFixture(t)
+ t.Cleanup(func() {
+ _, _ = runtime.HandleBrowser(context.Background(), id, domain.BrowserRequest{Operation: "stop"})
+ _ = e.releaseRunEnvironment(id, true)
+ })
+ e.reconcileTerminalWorkspaceCleanup()
+ staleRun, ok := e.repo.RunState(id)
+ if !ok || staleRun.WorkspaceCleanedAt.IsZero() {
+ t.Fatalf("precondition: expected reclaimed run, got %+v (ok=%v)", staleRun, ok)
+ }
+
+ if err := e.ensureRunBrowser(context.Background(), staleRun); err != nil {
+ t.Fatalf("ensureRunBrowser with stale reclaimed run failed: %v", err)
+ }
+ body, err := os.ReadFile(filepath.Join(e.RunWorkspace(id), "README.md"))
+ if err != nil || string(body) != "uncommitted" {
+ t.Fatalf("restored README.md = %q (%v)", body, err)
+ }
+ fresh, _ := e.repo.RunState(id)
+ if !fresh.WorkspaceCleanedAt.IsZero() {
+ t.Fatal("cleanup marker not cleared after ensureRunBrowser restore")
+ }
+}
diff --git a/internal/engine/workspace_checkpoint_stream.go b/internal/engine/workspace_checkpoint_stream.go
index 231019ad..df718309 100644
--- a/internal/engine/workspace_checkpoint_stream.go
+++ b/internal/engine/workspace_checkpoint_stream.go
@@ -38,7 +38,7 @@ func (e *Engine) saveConversationWorkspace(ctx context.Context, run domain.Run,
if reason != "" {
return fmt.Errorf("%s", reason)
}
- err = runtime.CreateWorkspaceCheckpointTo(root, workspaceCheckpointContextWriter{ctx, file})
+ err = runtime.CreateWorkspaceCheckpointToContext(ctx, root, workspaceCheckpointContextWriter{ctx, file})
if os.IsNotExist(err) && run.WorkspaceHost == "" {
if err = file.Truncate(0); err != nil {
return err
@@ -216,6 +216,14 @@ func (e *Engine) restoreOrReuseRemoteConversationCheckpoint(ctx context.Context,
}
} else {
err = workspaceCheckpointResponseError(probe)
+ if err == nil {
+ var status struct {
+ Empty bool `json:"empty"`
+ }
+ if len(probe.Payload) > 0 && json.Unmarshal(probe.Payload, &status) == nil && status.Empty {
+ err = os.ErrNotExist
+ }
+ }
}
if err == nil {
return e.verifyStoredCheckpoint(ctx, run.ID)
diff --git a/internal/engine/workspace_checkpoint_transport.go b/internal/engine/workspace_checkpoint_transport.go
index 6b94aa7e..3e21cb7f 100644
--- a/internal/engine/workspace_checkpoint_transport.go
+++ b/internal/engine/workspace_checkpoint_transport.go
@@ -8,6 +8,7 @@ import (
"fmt"
"io"
"net/http"
+ "os"
"strings"
"time"
@@ -238,7 +239,14 @@ func (e *Engine) HandleWorkspaceCheckpoint(w http.ResponseWriter, r *http.Reques
result = runtime.WorkspaceCheckpointStatus(root)
}
} else if transfer {
- result = e.checkpointTransfers.Handle(r.Context(), root, request)
+ if request.Operation == domain.RunnerWorkspaceOperationCheckpointCommit {
+ if err := e.discardEmptyWorkspaceContainer(r.Context(), run.ID, root); err != nil {
+ result.Error = err.Error()
+ }
+ }
+ if result.Error == "" {
+ result = e.checkpointTransfers.Handle(r.Context(), root, request)
+ }
} else if request.Operation == domain.RunnerWorkspaceOperationReclaim {
meta, saved := e.repo.WorkspaceCheckpoint(run.ID)
if !saved || meta.SavedAt == nil || meta.Error != "" || run.WorkspaceCleanedAt.IsZero() || request.CheckpointLease == "" || meta.LeaseToken != request.CheckpointLease || meta.LeaseUntil == nil || !meta.LeaseUntil.After(time.Now()) {
@@ -258,12 +266,14 @@ func (e *Engine) HandleWorkspaceCheckpoint(w http.ResponseWriter, r *http.Reques
result.Payload, _ = json.Marshal(map[string]any{"restoredArtifacts": restored})
}
} else if request.Operation == domain.RunnerWorkspaceOperationCheckpoint {
- archive, err := runtime.CreateWorkspaceCheckpoint(root)
+ archive, err := runtime.CreateWorkspaceCheckpointContext(r.Context(), root)
if err != nil {
result.Error = err.Error()
} else {
result.Payload, _ = json.Marshal(map[string]any{"checkpoint": archive})
}
+ } else if err := e.discardEmptyWorkspaceContainer(r.Context(), run.ID, root); err != nil {
+ result.Error = err.Error()
} else if err := runtime.RestoreWorkspaceCheckpoint(root, request.Checkpoint); err != nil {
result.Error = err.Error()
} else {
@@ -273,3 +283,19 @@ func (e *Engine) HandleWorkspaceCheckpoint(w http.ResponseWriter, r *http.Reques
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(result)
}
+
+func (e *Engine) discardEmptyWorkspaceContainer(ctx context.Context, runID, root string) error {
+ info, err := os.Lstat(root)
+ if err != nil || !info.IsDir() {
+ return nil
+ }
+ hasContent, err := runtime.WorkspaceDirHasContent(root)
+ if err != nil || hasContent {
+ return nil
+ }
+ if err := e.releaseRunEnvironment(runID, false); err != nil {
+ return err
+ }
+ e.sandboxes.DiscardRunContainer(ctx, runID)
+ return nil
+}
diff --git a/internal/engine/workspace_preparation.go b/internal/engine/workspace_preparation.go
index 32303593..ba6843d3 100644
--- a/internal/engine/workspace_preparation.go
+++ b/internal/engine/workspace_preparation.go
@@ -32,9 +32,17 @@ func (e *Engine) workspaceSandboxProfile(run domain.Run) (domain.SandboxProfile,
// lease. The workspace-use lease fences cleanup; the sandbox's workspace flock
// fences another process. An active local scheduler shares its existing handle.
func (e *Engine) acquireConversationEnvironment(ctx context.Context, run domain.Run) (*runEnvironment, error) {
+ if latest, ok := e.repo.RunState(run.ID); ok {
+ run = latest
+ }
if e.foreignWorkspaceBind(run) || e.defaultExecutionRunner(run) != "" {
return nil, fmt.Errorf("工作区属于其他执行实例")
}
+ if !run.WorkspaceCleanedAt.IsZero() {
+ if meta, saved := e.repo.WorkspaceCheckpoint(run.ID); saved && meta.SavedAt != nil {
+ return nil, fmt.Errorf("工作区已回收,请先恢复快照后再打开环境")
+ }
+ }
e.runEnvMu.Lock()
defer e.runEnvMu.Unlock()
if env := e.runEnvs[run.ID]; env != nil {
@@ -333,6 +341,9 @@ func (e *Engine) PrepareNodeWorkspace(ctx context.Context, run domain.Run, env *
// contract as SOP execution. The pool owns the PTY, the Engine owns the sandbox.
func (e *Engine) HandleWorkspaceTerminal(ctx context.Context, id string, pool *runtime.TerminalPool, scope string, req domain.WorkspaceTerminalRequest, actorID int64) (runtime.TerminalResult, error) {
if req.Operation == "open" {
+ if err := e.RestoreConversationWorkspaceIfNeeded(ctx, id); err != nil {
+ return runtime.TerminalResult{}, err
+ }
if _, err := e.EnsureWorkspaceReady(ctx, id); err != nil {
return runtime.TerminalResult{}, err
}
diff --git a/internal/engine/workspace_restore_retry_test.go b/internal/engine/workspace_restore_retry_test.go
index 1b2f8e56..3a1afb54 100644
--- a/internal/engine/workspace_restore_retry_test.go
+++ b/internal/engine/workspace_restore_retry_test.go
@@ -263,3 +263,70 @@ func TestConversationWorkspaceRunnerReusesSurvivingDirectory(t *testing.T) {
})
}
}
+
+func TestConversationWorkspaceRemoteAndRunnerRestoreOverEmptyDirectory(t *testing.T) {
+ t.Parallel()
+ for _, target := range []string{"runner-empty", "runner-agentflow-only", "foreign-worker-empty", "foreign-worker-agentflow-only"} {
+ t.Run(target, func(t *testing.T) {
+ worker, controller, id := remoteWorkspaceRestoreFixture(t, "sqlite")
+ root := worker.RunWorkspace(id)
+ if err := os.MkdirAll(root, 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if strings.HasSuffix(target, "agentflow-only") {
+ if err := os.MkdirAll(filepath.Join(root, ".agentflow", "hooks"), 0o700); err != nil {
+ t.Fatal(err)
+ }
+ }
+ restores := 0
+ if strings.HasPrefix(target, "runner-") {
+ run, _ := worker.repo.RunState(id)
+ run.ExecutionContext.ExecutionMode = domain.ExecutionModeRunner
+ run.ExecutionContext.ExecutionRunnerID = "restore-runner"
+ if err := worker.repo.PutRun(run); err != nil {
+ t.Fatal(err)
+ }
+ controller.WorkspaceCheckpointTransport = func(_ context.Context, _ domain.Run, request domain.RunnerWorkspaceRequest) (domain.RunnerWorkspaceResponse, error) {
+ if request.Operation == domain.RunnerWorkspaceOperationCheckpointStatus {
+ return runtime.WorkspaceCheckpointStatus(root), nil
+ }
+ if request.Operation == domain.RunnerWorkspaceOperationRestore {
+ restores++
+ if err := runtime.RestoreWorkspaceCheckpoint(root, request.Checkpoint); err != nil {
+ return domain.RunnerWorkspaceResponse{Error: err.Error()}, nil
+ }
+ return domain.RunnerWorkspaceResponse{Payload: json.RawMessage(`{"restored":true}`)}, nil
+ }
+ return domain.RunnerWorkspaceResponse{Error: "unexpected operation " + request.Operation}, nil
+ }
+ } else {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.Method == http.MethodPost {
+ var body domain.RunnerWorkspaceRequest
+ raw, _ := io.ReadAll(r.Body)
+ _ = json.Unmarshal(raw, &body)
+ if body.Operation == domain.RunnerWorkspaceOperationRestore || body.Operation == domain.RunnerWorkspaceOperationCheckpointCommit {
+ restores++
+ }
+ r.Body = io.NopCloser(bytes.NewReader(raw))
+ }
+ worker.HandleWorkspaceCheckpoint(w, r)
+ }))
+ defer server.Close()
+ if err := worker.repo.HeartbeatEngineInstance(repo.EngineInstance{InstanceID: worker.workspaceHost, Role: "worker", WorkspaceHost: worker.workspaceHost, ControlURL: server.URL}, time.Minute); err != nil {
+ t.Fatal(err)
+ }
+ }
+ if err := controller.RestoreConversationWorkspaceIfNeeded(context.Background(), id); err != nil {
+ t.Fatal(err)
+ }
+ if restores != 1 {
+ t.Fatalf("restores = %d, want 1", restores)
+ }
+ body, err := os.ReadFile(filepath.Join(root, "README.md"))
+ if err != nil || string(body) != "saved changes" {
+ t.Fatalf("remote restore lost files: %q (%v)", body, err)
+ }
+ })
+ }
+}
diff --git a/internal/runner/workspace.go b/internal/runner/workspace.go
index 04d2fb42..6e24221f 100644
--- a/internal/runner/workspace.go
+++ b/internal/runner/workspace.go
@@ -143,6 +143,11 @@ func (d *Daemon) readRunnerWorkspace(ctx context.Context, request domain.RunnerW
return workspaceBusyResponse("workspace is still in use")
}
defer gate.Unlock()
+ if request.Operation == domain.RunnerWorkspaceOperationCheckpointCommit {
+ if hasContent, err := runtime.WorkspaceDirHasContent(root); err == nil && !hasContent {
+ d.closeRunSandboxes(ctx, request.RunID)
+ }
+ }
}
return d.checkpointTransfers.Handle(ctx, root, request)
}
@@ -155,6 +160,9 @@ func (d *Daemon) readRunnerWorkspace(ctx context.Context, request domain.RunnerW
return workspaceBusyResponse("workspace is still in use")
}
defer gate.Unlock()
+ if hasContent, err := runtime.WorkspaceDirHasContent(root); err == nil && !hasContent {
+ d.closeRunSandboxes(ctx, request.RunID)
+ }
if err := runtime.RestoreWorkspaceCheckpoint(root, request.Checkpoint); err != nil {
return runnerWorkspaceError(err)
}
@@ -213,7 +221,7 @@ func (d *Daemon) readRunnerWorkspace(ctx context.Context, request domain.RunnerW
return workspaceBusyResponse("workspace is still in use")
}
defer gate.Unlock()
- archive, err := runtime.CreateWorkspaceCheckpoint(root)
+ archive, err := runtime.CreateWorkspaceCheckpointContext(ctx, root)
if err != nil {
return runnerWorkspaceError(err)
}
diff --git a/internal/runner/workspace_preparation_test.go b/internal/runner/workspace_preparation_test.go
index 2a38f018..f565f5f7 100644
--- a/internal/runner/workspace_preparation_test.go
+++ b/internal/runner/workspace_preparation_test.go
@@ -648,3 +648,43 @@ func TestRunnerConcurrentEditSharesOnlyTheAgentFence(t *testing.T) {
}
gate.Unlock()
}
+
+func TestRunnerCheckpointStatusAndRestoreOverEmptyDirectory(t *testing.T) {
+ d, request, root := runnerPreparationFixture(t)
+ defer d.closeAllRunSandboxes(context.Background())
+
+ src := t.TempDir()
+ if err := os.WriteFile(filepath.Join(src, "restored.txt"), []byte("from-checkpoint"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ archive, err := runtime.CreateWorkspaceCheckpoint(src)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if err := os.MkdirAll(filepath.Join(root, ".agentflow", "hooks"), 0o700); err != nil {
+ t.Fatal(err)
+ }
+ status := d.readRunnerWorkspace(context.Background(), domain.RunnerWorkspaceRequest{
+ RunID: request.RunID,
+ WorkspaceLayout: domain.RunnerWorkspaceLayoutShared,
+ Operation: domain.RunnerWorkspaceOperationCheckpointStatus,
+ })
+ if status.Status != 200 || !strings.Contains(string(status.Payload), `"empty":true`) {
+ t.Fatalf("status = %+v payload=%s", status, status.Payload)
+ }
+
+ restored := d.readRunnerWorkspace(context.Background(), domain.RunnerWorkspaceRequest{
+ RunID: request.RunID,
+ WorkspaceLayout: domain.RunnerWorkspaceLayoutShared,
+ Operation: domain.RunnerWorkspaceOperationRestore,
+ Checkpoint: archive,
+ })
+ if restored.Status != 200 || restored.Error != "" {
+ t.Fatalf("restore = %+v", restored)
+ }
+ got, err := os.ReadFile(filepath.Join(root, "restored.txt"))
+ if err != nil || string(got) != "from-checkpoint" {
+ t.Fatalf("restored.txt = %q (%v)", got, err)
+ }
+}
diff --git a/internal/runtime/executor_cases_test.go b/internal/runtime/executor_cases_test.go
index 2fb2962e..79819b72 100644
--- a/internal/runtime/executor_cases_test.go
+++ b/internal/runtime/executor_cases_test.go
@@ -175,8 +175,16 @@ func TestCheckpointValidationStatusAndBounds(t *testing.T) {
t.Fatal("invalid checkpoint accepted")
}
root := t.TempDir()
- if response := WorkspaceCheckpointStatus(root); response.Status != 200 {
- t.Fatalf("status=%+v", response)
+ if response := WorkspaceCheckpointStatus(root); response.Status != 200 || !strings.Contains(string(response.Payload), `"empty":true`) {
+ t.Fatalf("empty status=%+v payload=%s", response, response.Payload)
+ }
+ _ = os.MkdirAll(filepath.Join(root, ".agentflow", "hooks"), 0o700)
+ if response := WorkspaceCheckpointStatus(root); response.Status != 200 || !strings.Contains(string(response.Payload), `"empty":true`) {
+ t.Fatalf("runtime-only status=%+v payload=%s", response, response.Payload)
+ }
+ _ = os.WriteFile(filepath.Join(root, "real.txt"), []byte("x"), 0o600)
+ if response := WorkspaceCheckpointStatus(root); response.Status != 200 || !strings.Contains(string(response.Payload), `"empty":false`) {
+ t.Fatalf("populated status=%+v payload=%s", response, response.Payload)
}
missing := filepath.Join(root, "missing")
if response := WorkspaceCheckpointStatus(missing); response.Status != 404 {
diff --git a/internal/runtime/workspace_checkpoint.go b/internal/runtime/workspace_checkpoint.go
index 408eb6aa..78d607d6 100644
--- a/internal/runtime/workspace_checkpoint.go
+++ b/internal/runtime/workspace_checkpoint.go
@@ -4,13 +4,17 @@ import (
"archive/tar"
"bytes"
"compress/gzip"
+ "context"
"fmt"
"io"
"io/fs"
"os"
+ "os/exec"
+ pathpkg "path"
"path/filepath"
"slices"
"strings"
+ "time"
)
// Checkpoints exclude execution credentials and reproducible dependency caches.
@@ -22,15 +26,44 @@ const WorkspaceCheckpointMaxBytes = 12 << 20
const WorkspaceCheckpointArchiveMaxBytes = 512 << 20
const WorkspaceCheckpointChunkBytes = 4 << 20
const workspaceCheckpointExpandedMax = 2 << 30
+const checkpointGitOutputMaxBytes = 16 << 20
+
+var checkpointGitIndexTimeout = 15 * time.Second
// checkpointRestoreExcludedNames are path components a restored archive must
-// never contain.
-var checkpointRestoreExcludedNames = []string{".agentflow", "node_modules", ".cache", "__pycache__"}
+// never contain (and never capture, even if committed inside a repository).
+var checkpointRestoreExcludedNames = []string{".agentflow"}
+
+// checkpointExcludedNames are skipped when capturing unless preserved as
+// Git-tracked repository files (except checkpointRestoreExcludedNames).
+var checkpointExcludedNames = append(slices.Clone(checkpointRestoreExcludedNames), "node_modules", ".cache", "__pycache__", ".zvec-grep")
-// checkpointExcludedNames are skipped when capturing. Older valid archives can
-// contain .zvec-grep, so it is excluded from new captures only and must not
-// make those existing snapshots unrestorable.
-var checkpointExcludedNames = append(slices.Clone(checkpointRestoreExcludedNames), ".zvec-grep")
+// WorkspaceDirHasContent reports whether root already holds user or repository
+// files on disk. An empty directory or one containing only the platform's
+// runtime .agentflow directory holds no user workspace data.
+func WorkspaceDirHasContent(root string) (bool, error) {
+ info, err := os.Lstat(root)
+ if os.IsNotExist(err) {
+ return false, nil
+ }
+ if err != nil {
+ return false, err
+ }
+ if !info.IsDir() {
+ return false, fmt.Errorf("workspace is not a directory")
+ }
+ entries, err := os.ReadDir(root)
+ if err != nil {
+ return false, err
+ }
+ for _, entry := range entries {
+ if entry.Name() == ".agentflow" && entry.IsDir() {
+ continue
+ }
+ return true, nil
+ }
+ return false, nil
+}
func checkpointPathHasComponent(path string, names []string) bool {
for _, part := range strings.Split(filepath.ToSlash(path), "/") {
@@ -57,8 +90,12 @@ func checkpointPath(path string) (string, error) {
return clean, nil
}
func CreateWorkspaceCheckpoint(root string) ([]byte, error) {
+ return CreateWorkspaceCheckpointContext(context.Background(), root)
+}
+
+func CreateWorkspaceCheckpointContext(ctx context.Context, root string) ([]byte, error) {
var buffer bytes.Buffer
- err := CreateWorkspaceCheckpointTo(root, &checkpointBoundedWriter{writer: &buffer, left: WorkspaceCheckpointMaxBytes})
+ err := CreateWorkspaceCheckpointToContext(ctx, root, &checkpointBoundedWriter{writer: &buffer, left: WorkspaceCheckpointMaxBytes})
if err != nil {
return nil, err
}
@@ -66,6 +103,13 @@ func CreateWorkspaceCheckpoint(root string) ([]byte, error) {
}
func CreateWorkspaceCheckpointTo(root string, destination io.Writer) error {
+ return CreateWorkspaceCheckpointToContext(context.Background(), root, destination)
+}
+
+func CreateWorkspaceCheckpointToContext(ctx context.Context, root string, destination io.Writer) error {
+ if ctx == nil {
+ ctx = context.Background()
+ }
info, err := os.Lstat(root)
if err != nil {
return err
@@ -85,18 +129,24 @@ func CreateWorkspaceCheckpointTo(root string, destination io.Writer) error {
writer := tar.NewWriter(&checkpointBoundedWriter{writer: zipped, left: workspaceCheckpointExpandedMax})
var expanded int64
entries := 0
+ tracker := &checkpointGitTracker{ctx: ctx, root: root, base: base}
err = fs.WalkDir(base.FS(), ".", func(path string, entry fs.DirEntry, walkErr error) error {
if walkErr != nil {
return walkErr
}
+ if ctxErr := ctx.Err(); ctxErr != nil {
+ return ctxErr
+ }
if path == "." {
return nil
}
if checkpointExcluded(path) {
- if entry.IsDir() {
- return fs.SkipDir
+ if checkpointRestoreExcluded(path) || !tracker.keeps(path, entry.IsDir()) {
+ if entry.IsDir() {
+ return fs.SkipDir
+ }
+ return nil
}
- return nil
}
entries++
if entries > 100000 {
@@ -184,6 +234,232 @@ func copyCheckpointFile(base *os.Root, writer io.Writer, path string, size int64
return closeErr
}
+type checkpointGitIndex struct {
+ files map[string]bool
+ dirs map[string]bool
+}
+
+type checkpointLimitedBuffer struct {
+ buf bytes.Buffer
+ limit int
+ overflow bool
+}
+
+func (b *checkpointLimitedBuffer) Write(p []byte) (int, error) {
+ if b.buf.Len()+len(p) > b.limit {
+ b.overflow = true
+ return 0, fmt.Errorf("git output exceeds limit")
+ }
+ return b.buf.Write(p)
+}
+
+// checkpointGitTracker lazily indexes Git-tracked files matching
+// checkpointExcludedNames per repository inside root, so tracked files (such
+// as committed web/*/node_modules assets) survive snapshots while untracked
+// dependency installs are still skipped.
+type checkpointGitTracker struct {
+ ctx context.Context
+ root string
+ base *os.Root
+ repoFlags map[string]bool
+ indexes map[string]*checkpointGitIndex
+}
+
+func (t *checkpointGitTracker) keeps(rel string, isDir bool) bool {
+ repoRel, ok := t.findRepo(pathpkg.Dir(filepath.ToSlash(rel)))
+ if !ok {
+ return false
+ }
+ idx := t.repoIndex(repoRel)
+ if idx == nil || len(idx.files) == 0 {
+ return false
+ }
+ repoFile := filepath.ToSlash(rel)
+ if repoRel != "." {
+ repoFile = strings.TrimPrefix(repoFile, repoRel+"/")
+ }
+ if isDir {
+ return idx.dirs[repoFile] || idx.files[repoFile]
+ }
+ return idx.files[repoFile]
+}
+
+func (t *checkpointGitTracker) findRepo(startDir string) (string, bool) {
+ if t.repoFlags == nil {
+ t.repoFlags = map[string]bool{}
+ }
+ for dir := pathpkg.Clean(startDir); ; dir = pathpkg.Dir(dir) {
+ if isRepo, checked := t.repoFlags[dir]; checked {
+ if isRepo {
+ return dir, true
+ }
+ } else {
+ gitPath := ".git"
+ if dir != "." {
+ gitPath = pathpkg.Join(dir, ".git")
+ }
+ // Submodules and linked worktrees use a regular .git file (already
+ // rejected when referencing external metadata), so only
+ // self-contained .git directories are indexed here.
+ info, err := t.base.Lstat(filepath.FromSlash(gitPath))
+ isRepo = err == nil && info.IsDir()
+ t.repoFlags[dir] = isRepo
+ if isRepo {
+ return dir, true
+ }
+ }
+ if dir == "." || dir == "/" || dir == "" {
+ return "", false
+ }
+ }
+}
+
+func (t *checkpointGitTracker) repoIndex(repoRel string) *checkpointGitIndex {
+ if t.indexes == nil {
+ t.indexes = map[string]*checkpointGitIndex{}
+ }
+ if idx, cached := t.indexes[repoRel]; cached {
+ return idx
+ }
+ idx := &checkpointGitIndex{}
+ t.indexes[repoRel] = idx
+ if indexInfo, statErr := t.base.Lstat(filepath.FromSlash(pathpkg.Join(repoRel, ".git/index"))); statErr == nil {
+ if !indexInfo.Mode().IsRegular() {
+ return idx
+ }
+ } else if !os.IsNotExist(statErr) {
+ return idx
+ }
+ repoAbs := t.root
+ if repoRel != "." {
+ repoAbs = filepath.Join(t.root, filepath.FromSlash(repoRel))
+ }
+ parentCtx := t.ctx
+ if parentCtx == nil {
+ parentCtx = context.Background()
+ }
+ cmdCtx, cancel := context.WithTimeout(parentCtx, checkpointGitIndexTimeout)
+ defer cancel()
+ // Pin git-dir/work-tree and disable executable repo config keys, matching
+ // gitwork.checkoutGit so scanning a sandbox-controlled repo stays safe.
+ cmd := exec.CommandContext(cmdCtx, "git",
+ "--git-dir="+filepath.Join(repoAbs, ".git"),
+ "--work-tree="+repoAbs,
+ "-c", "safe.directory=*",
+ "-c", "core.fsmonitor=",
+ "-c", "core.hooksPath="+os.DevNull,
+ "-c", "core.pager=cat",
+ "-c", "core.editor=true",
+ "-c", "core.askPass=",
+ "-c", "credential.helper=",
+ "ls-files", "-z", "--",
+ )
+ cmd.WaitDelay = time.Second
+ cmd.Dir = repoAbs
+ env := make([]string, 0, len(os.Environ())+7)
+ for _, entry := range os.Environ() {
+ name, _, _ := strings.Cut(entry, "=")
+ switch name {
+ case "GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_OBJECT_DIRECTORY", "GIT_ALTERNATE_OBJECT_DIRECTORIES", "GIT_COMMON_DIR", "GIT_CONFIG_PARAMETERS", "GIT_CONFIG_COUNT":
+ continue
+ }
+ env = append(env, entry)
+ }
+ cmd.Env = append(env,
+ "GIT_CONFIG_NOSYSTEM=1",
+ "GIT_CONFIG_GLOBAL="+os.DevNull,
+ "GIT_TERMINAL_PROMPT=0",
+ "GIT_OPTIONAL_LOCKS=0",
+ "GIT_PAGER=cat",
+ "GIT_ASKPASS=",
+ "SSH_ASKPASS=",
+ )
+ out := &checkpointLimitedBuffer{limit: checkpointGitOutputMaxBytes}
+ cmd.Stdout = out
+ if err := cmd.Run(); err != nil || out.overflow || out.buf.Len() == 0 {
+ return idx
+ }
+ idx.files = map[string]bool{}
+ idx.dirs = map[string]bool{}
+ for _, raw := range bytes.Split(out.buf.Bytes(), []byte{0}) {
+ if len(raw) == 0 {
+ continue
+ }
+ p := filepath.ToSlash(string(raw))
+ if !checkpointExcluded(p) || checkpointRestoreExcluded(p) {
+ continue
+ }
+ idx.files[p] = true
+ for dir := pathpkg.Dir(p); dir != "." && dir != ""; dir = pathpkg.Dir(dir) {
+ if idx.dirs[dir] {
+ break
+ }
+ idx.dirs[dir] = true
+ }
+ }
+ return idx
+}
+
+func ensureReplaceableWorkspaceTarget(root string) (bool, error) {
+ info, err := os.Lstat(root)
+ if os.IsNotExist(err) {
+ return false, nil
+ }
+ if err != nil {
+ return false, err
+ }
+ if !info.IsDir() {
+ return false, fmt.Errorf("workspace already exists; refusing to overwrite")
+ }
+ hasContent, err := WorkspaceDirHasContent(root)
+ if err != nil {
+ return false, err
+ }
+ if hasContent {
+ return false, fmt.Errorf("workspace already exists; refusing to overwrite")
+ }
+ return true, nil
+}
+
+func replaceRestoredWorkspace(stage, root string) error {
+ return replaceRestoredWorkspaceWithRaceHook(stage, root, nil)
+}
+
+func replaceRestoredWorkspaceWithRaceHook(stage, root string, beforeRename func()) error {
+ exists, err := ensureReplaceableWorkspaceTarget(root)
+ if err != nil {
+ return err
+ }
+ if !exists {
+ return os.Rename(stage, root)
+ }
+ if beforeRename != nil {
+ beforeRename()
+ }
+ backupParent, err := os.MkdirTemp(filepath.Dir(root), ".workspace-replace-")
+ if err != nil {
+ return err
+ }
+ defer os.RemoveAll(backupParent)
+ backup := filepath.Join(backupParent, "prev")
+ if err := os.Rename(root, backup); err != nil {
+ return err
+ }
+ hasContent, err := WorkspaceDirHasContent(backup)
+ if err != nil || hasContent {
+ _ = os.Rename(backup, root)
+ if err != nil {
+ return err
+ }
+ return fmt.Errorf("workspace already exists; refusing to overwrite")
+ }
+ if err := os.Rename(stage, root); err != nil {
+ _ = os.Rename(backup, root)
+ return err
+ }
+ return nil
+}
+
func RestoreWorkspaceCheckpoint(root string, content []byte) error {
if len(content) == 0 || len(content) > WorkspaceCheckpointMaxBytes {
return fmt.Errorf("invalid workspace checkpoint size")
@@ -192,9 +468,8 @@ func RestoreWorkspaceCheckpoint(root string, content []byte) error {
}
func RestoreWorkspaceCheckpointFrom(root string, source io.Reader) error {
- if _, err := os.Lstat(root); err == nil {
- return fmt.Errorf("workspace already exists; refusing to overwrite")
- } else if !os.IsNotExist(err) {
+ root = filepath.Clean(root)
+ if _, err := ensureReplaceableWorkspaceTarget(root); err != nil {
return err
}
if err := os.MkdirAll(filepath.Dir(root), 0700); err != nil {
@@ -254,7 +529,7 @@ func RestoreWorkspaceCheckpointFrom(root string, source io.Reader) error {
if limited.N == 0 || compressed.N == 0 {
return fmt.Errorf("checkpoint expanded size exceeds limit")
}
- return os.Rename(stage, root)
+ return replaceRestoredWorkspace(stage, root)
}
// restoreCheckpointEntry materializes one validated tar entry at path inside
diff --git a/internal/runtime/workspace_checkpoint_excluded_test.go b/internal/runtime/workspace_checkpoint_excluded_test.go
index ab1c9b96..55f496bc 100644
--- a/internal/runtime/workspace_checkpoint_excluded_test.go
+++ b/internal/runtime/workspace_checkpoint_excluded_test.go
@@ -9,9 +9,10 @@ func TestCheckpointExclusionNames(t *testing.T) {
}{
{"src/main.go", false, false},
{".agentflow", true, true},
- {"a/node_modules/x.js", true, true},
- {"pkg/.cache/blob", true, true},
- {"py/__pycache__/m.pyc", true, true},
+ {"repo/.agentflow/token", true, true},
+ {"a/node_modules/x.js", true, false},
+ {"pkg/.cache/blob", true, false},
+ {"py/__pycache__/m.pyc", true, false},
{".zvec-grep/index", true, false},
{"deep/.zvec-grep", true, false},
{".cache2/file", false, false},
@@ -29,7 +30,7 @@ func TestCheckpointExclusionNames(t *testing.T) {
}
func TestCheckpointExcludedNamesDoNotAliasRestoreNames(t *testing.T) {
- if len(checkpointRestoreExcludedNames) != 4 || len(checkpointExcludedNames) != 5 {
+ if len(checkpointRestoreExcludedNames) != 1 || len(checkpointExcludedNames) != 5 {
t.Fatalf("unexpected exclusion lists: restore=%v capture=%v", checkpointRestoreExcludedNames, checkpointExcludedNames)
}
}
diff --git a/internal/runtime/workspace_checkpoint_test.go b/internal/runtime/workspace_checkpoint_test.go
index dbc73460..4977faa0 100644
--- a/internal/runtime/workspace_checkpoint_test.go
+++ b/internal/runtime/workspace_checkpoint_test.go
@@ -4,9 +4,14 @@ import (
"archive/tar"
"bytes"
"compress/gzip"
+ "context"
+ "errors"
"os"
+ "os/exec"
"path/filepath"
+ "strings"
"testing"
+ "time"
)
func TestWorkspaceCheckpointRoundTrip(t *testing.T) {
@@ -164,3 +169,290 @@ func TestWorkspaceCheckpointRestoreNeverWritesThroughExternalSymlinks(t *testing
})
}
}
+
+func TestWorkspaceCheckpointPreservesTrackedFilesUnderExcludedDirsWhileSkippingUntracked(t *testing.T) {
+ root := t.TempDir()
+ repoDir := filepath.Join(root, "repo")
+ if err := os.MkdirAll(repoDir, 0o700); err != nil {
+ t.Fatal(err)
+ }
+ git := func(dir string, args ...string) string {
+ t.Helper()
+ cmd := exec.Command("git", append([]string{"-c", "core.hooksPath=/dev/null", "-C", dir}, args...)...)
+ cmd.Env = append(os.Environ(),
+ "GIT_CONFIG_GLOBAL=/dev/null",
+ "GIT_CONFIG_NOSYSTEM=1",
+ "GIT_AUTHOR_NAME=Checkpoint Test",
+ "GIT_COMMITTER_NAME=Checkpoint Test",
+ )
+ out, err := cmd.CombinedOutput()
+ if err != nil {
+ t.Fatalf("git %v: %s %v", args, out, err)
+ }
+ return string(out)
+ }
+ write := func(rel, body string) {
+ t.Helper()
+ full := filepath.Join(root, filepath.FromSlash(rel))
+ if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(full, []byte(body), 0o644); err != nil {
+ t.Fatal(err)
+ }
+ }
+
+ git(repoDir, "init", "-q", "-b", "main")
+ write("repo/web/vscode-web/node_modules/@microsoft/1ds/dist/ms.core.min.js", "v1\n")
+ write("repo/web/vscode-web/node_modules/pkg/target.txt", "target\n")
+ write("repo/assets/.cache/manifest.json", "{\"ok\":true}\n")
+ write("repo/py/__pycache__/keep.pyc", "pyc-tracked")
+ write("repo/.agentflow/committed-secret", "must-never-capture")
+ if err := os.Symlink("../pkg/target.txt", filepath.Join(repoDir, "web/vscode-web/node_modules/@microsoft/link")); err != nil {
+ t.Fatal(err)
+ }
+ git(repoDir, "add", "-f",
+ "web/vscode-web/node_modules/@microsoft/1ds/dist/ms.core.min.js",
+ "web/vscode-web/node_modules/pkg/target.txt",
+ "web/vscode-web/node_modules/@microsoft/link",
+ "assets/.cache/manifest.json",
+ "py/__pycache__/keep.pyc",
+ ".agentflow/committed-secret",
+ )
+ git(repoDir, "commit", "-qm", "track vendored assets")
+
+ // Unstaged edit and staged new file inside node_modules must keep their live contents.
+ write("repo/web/vscode-web/node_modules/@microsoft/1ds/dist/ms.core.min.js", "v2-modified\n")
+ write("repo/web/vscode-web/node_modules/staged.js", "staged\n")
+ git(repoDir, "add", "-f", "web/vscode-web/node_modules/staged.js")
+
+ // Untracked dependencies/caches inside the same repo and workspace must stay excluded.
+ write("repo/chatbot/node_modules/huge/index.js", "npm-dep\n")
+ write("repo/web/vscode-web/node_modules/untracked/dep.js", "untracked-dep\n")
+ write("repo/assets/.cache/ephemeral.bin", "tmp")
+ write("repo/py/__pycache__/ephemeral.pyc", "tmp")
+ write("repo/.zvec-grep/index", "idx")
+ write(".agentflow/auth/token", "host-secret")
+
+ archive, err := CreateWorkspaceCheckpoint(root)
+ if err != nil {
+ t.Fatal(err)
+ }
+ dest := filepath.Join(t.TempDir(), "restored")
+ if err := RestoreWorkspaceCheckpoint(dest, archive); err != nil {
+ t.Fatal(err)
+ }
+
+ wantPreserved := map[string]string{
+ "repo/web/vscode-web/node_modules/@microsoft/1ds/dist/ms.core.min.js": "v2-modified\n",
+ "repo/web/vscode-web/node_modules/pkg/target.txt": "target\n",
+ "repo/web/vscode-web/node_modules/staged.js": "staged\n",
+ "repo/assets/.cache/manifest.json": "{\"ok\":true}\n",
+ "repo/py/__pycache__/keep.pyc": "pyc-tracked",
+ }
+ for rel, want := range wantPreserved {
+ got, err := os.ReadFile(filepath.Join(dest, filepath.FromSlash(rel)))
+ if err != nil || string(got) != want {
+ t.Fatalf("restored %s = %q (%v), want %q", rel, got, err, want)
+ }
+ }
+ if link, err := os.Readlink(filepath.Join(dest, "repo/web/vscode-web/node_modules/@microsoft/link")); err != nil || link != "../pkg/target.txt" {
+ t.Fatalf("restored symlink = %q (%v)", link, err)
+ }
+ for _, excluded := range []string{
+ "repo/chatbot/node_modules",
+ "repo/web/vscode-web/node_modules/untracked",
+ "repo/assets/.cache/ephemeral.bin",
+ "repo/py/__pycache__/ephemeral.pyc",
+ "repo/.zvec-grep",
+ "repo/.agentflow",
+ ".agentflow",
+ } {
+ if _, err := os.Lstat(filepath.Join(dest, filepath.FromSlash(excluded))); !os.IsNotExist(err) {
+ t.Fatalf("untracked or secret path %s should not be restored", excluded)
+ }
+ }
+ status := git(filepath.Join(dest, "repo"), "status", "--short")
+ for _, line := range strings.Split(strings.TrimSpace(status), "\n") {
+ if strings.HasPrefix(strings.TrimSpace(line), "D ") && !strings.Contains(line, ".agentflow/") {
+ t.Fatalf("restored repo has missing tracked file %q\nfull status:\n%s", line, status)
+ }
+ }
+}
+
+func TestRestoreWorkspaceCheckpointReplacesEmptyAndRuntimeOnlyDirectoryAtomically(t *testing.T) {
+ src := t.TempDir()
+ if err := os.WriteFile(filepath.Join(src, "app.txt"), []byte("restored"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ archive, err := CreateWorkspaceCheckpoint(src)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ t.Run("empty-dir", func(t *testing.T) {
+ dest := filepath.Join(t.TempDir(), "ws")
+ if err := os.MkdirAll(dest, 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if err := RestoreWorkspaceCheckpoint(dest, archive); err != nil {
+ t.Fatal(err)
+ }
+ got, err := os.ReadFile(filepath.Join(dest, "app.txt"))
+ if err != nil || string(got) != "restored" {
+ t.Fatalf("restored app.txt = %q (%v)", got, err)
+ }
+ })
+
+ t.Run("agentflow-only-dir", func(t *testing.T) {
+ dest := filepath.Join(t.TempDir(), "ws")
+ if err := os.MkdirAll(filepath.Join(dest, ".agentflow", "hooks"), 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(dest, ".agentflow", "hooks", "pre.json"), []byte("{}"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ if err := RestoreWorkspaceCheckpoint(dest, archive); err != nil {
+ t.Fatal(err)
+ }
+ got, err := os.ReadFile(filepath.Join(dest, "app.txt"))
+ if err != nil || string(got) != "restored" {
+ t.Fatalf("restored app.txt = %q (%v)", got, err)
+ }
+ if _, err := os.Lstat(filepath.Join(dest, ".agentflow")); !os.IsNotExist(err) {
+ t.Fatalf("stale .agentflow should have been replaced, stat err=%v", err)
+ }
+ })
+
+ t.Run("corrupt-archive-preserves-target", func(t *testing.T) {
+ dest := filepath.Join(t.TempDir(), "ws")
+ marker := filepath.Join(dest, ".agentflow", "hooks", "pre.json")
+ if err := os.MkdirAll(filepath.Dir(marker), 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(marker, []byte("keep"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ if err := RestoreWorkspaceCheckpoint(dest, []byte("not-gzip")); err == nil {
+ t.Fatal("corrupt archive accepted")
+ }
+ got, err := os.ReadFile(marker)
+ if err != nil || string(got) != "keep" {
+ t.Fatalf("corrupt archive altered target: %q (%v)", got, err)
+ }
+ })
+
+ t.Run("real-file-refuses-overwrite", func(t *testing.T) {
+ dest := filepath.Join(t.TempDir(), "ws")
+ if err := os.MkdirAll(dest, 0o700); err != nil {
+ t.Fatal(err)
+ }
+ existing := filepath.Join(dest, "surviving.txt")
+ if err := os.WriteFile(existing, []byte("survive"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ if err := RestoreWorkspaceCheckpoint(dest, archive); err == nil {
+ t.Fatal("existing workspace overwritten")
+ }
+ got, err := os.ReadFile(existing)
+ if err != nil || string(got) != "survive" {
+ t.Fatalf("surviving file altered: %q (%v)", got, err)
+ }
+ })
+}
+
+func TestCheckpointGitTrackerTimeoutsDegradeToUntracked(t *testing.T) {
+ root := t.TempDir()
+ repo := filepath.Join(root, "repo")
+ if err := os.MkdirAll(filepath.Join(repo, ".git"), 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(repo, ".git", "HEAD"), []byte("ref: refs/heads/main\n"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(repo, ".git", "index"), []byte{}, 0o600); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.MkdirAll(filepath.Join(repo, "node_modules", "pkg"), 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(repo, "node_modules", "pkg", "index.js"), []byte("tracked"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(repo, "app.txt"), []byte("app"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+
+ bin := t.TempDir()
+ fakeGit := filepath.Join(bin, "git")
+ if err := os.WriteFile(fakeGit, []byte("#!/bin/sh\nsleep 10\n"), 0o755); err != nil {
+ t.Fatal(err)
+ }
+ t.Setenv("PATH", bin+string(os.PathListSeparator)+os.Getenv("PATH"))
+ prevTimeout := checkpointGitIndexTimeout
+ checkpointGitIndexTimeout = 100 * time.Millisecond
+ t.Cleanup(func() { checkpointGitIndexTimeout = prevTimeout })
+
+ archive, err := CreateWorkspaceCheckpointContext(context.Background(), root)
+ if err != nil {
+ t.Fatalf("CreateWorkspaceCheckpointContext failed: %v", err)
+ }
+ dest := filepath.Join(t.TempDir(), "restored")
+ if err := RestoreWorkspaceCheckpoint(dest, archive); err != nil {
+ t.Fatalf("RestoreWorkspaceCheckpoint failed: %v", err)
+ }
+ if got, err := os.ReadFile(filepath.Join(dest, "repo", "app.txt")); err != nil || string(got) != "app" {
+ t.Fatalf("expected repo/app.txt restored, got %q (%v)", got, err)
+ }
+ if _, err := os.Lstat(filepath.Join(dest, "repo", "node_modules", "pkg", "index.js")); !os.IsNotExist(err) {
+ t.Fatalf("expected timed-out git index lookup to degrade and skip node_modules, err=%v", err)
+ }
+}
+
+func TestCheckpointGitTrackerOverflowAndContextCancel(t *testing.T) {
+ buf := &checkpointLimitedBuffer{limit: 4}
+ if _, err := buf.Write([]byte("hello")); err == nil || !buf.overflow {
+ t.Fatalf("expected overflow error, overflow=%v err=%v", buf.overflow, err)
+ }
+
+ root := t.TempDir()
+ if err := os.WriteFile(filepath.Join(root, "a.txt"), []byte("data"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ ctx, cancel := context.WithCancel(context.Background())
+ cancel()
+ if _, err := CreateWorkspaceCheckpointContext(ctx, root); !errors.Is(err, context.Canceled) {
+ t.Fatalf("expected context.Canceled, got %v", err)
+ }
+}
+
+func TestReplaceRestoredWorkspaceRollsBackOnConcurrentWrite(t *testing.T) {
+ parent := t.TempDir()
+ root := filepath.Join(parent, "ws")
+ stage := filepath.Join(parent, "stage")
+ if err := os.MkdirAll(filepath.Join(root, ".agentflow"), 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.MkdirAll(stage, 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(stage, "from-snapshot.txt"), []byte("snap"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+
+ err := replaceRestoredWorkspaceWithRaceHook(stage, root, func() {
+ _ = os.WriteFile(filepath.Join(root, "raced.txt"), []byte("concurrent"), 0o600)
+ })
+ if err == nil || !strings.Contains(err.Error(), "refusing to overwrite") {
+ t.Fatalf("expected refusing to overwrite error, got %v", err)
+ }
+ got, readErr := os.ReadFile(filepath.Join(root, "raced.txt"))
+ if readErr != nil || string(got) != "concurrent" {
+ t.Fatalf("concurrent file was not preserved after rollback: %q (%v)", got, readErr)
+ }
+ if _, snapErr := os.Lstat(filepath.Join(root, "from-snapshot.txt")); !os.IsNotExist(snapErr) {
+ t.Fatalf("stage snapshot leaked into target after rollback: %v", snapErr)
+ }
+}
diff --git a/internal/runtime/workspace_checkpoint_transfer.go b/internal/runtime/workspace_checkpoint_transfer.go
index 4a7c6860..dad472b7 100644
--- a/internal/runtime/workspace_checkpoint_transfer.go
+++ b/internal/runtime/workspace_checkpoint_transfer.go
@@ -46,7 +46,12 @@ func WorkspaceCheckpointStatus(root string) domain.RunnerWorkspaceResponse {
if !info.IsDir() {
return domain.RunnerWorkspaceResponse{Status: 409, Error: "workspace is not a directory"}
}
- return domain.RunnerWorkspaceResponse{Status: 200, Payload: json.RawMessage(`{"exists":true}`)}
+ hasContent, err := WorkspaceDirHasContent(root)
+ if err != nil {
+ return domain.RunnerWorkspaceResponse{Status: 409, Error: err.Error()}
+ }
+ payload, _ := json.Marshal(map[string]bool{"exists": true, "empty": !hasContent})
+ return domain.RunnerWorkspaceResponse{Status: 200, Payload: payload}
}
func (p *CheckpointTransfers) Sweep(now time.Time) {
@@ -134,7 +139,7 @@ func (p *CheckpointTransfers) handle(ctx context.Context, root string, req domai
item.info.ID = hex.EncodeToString(raw)
if op == domain.RunnerWorkspaceOperationCheckpointExport {
hash := sha256.New()
- if err = CreateWorkspaceCheckpointTo(root, checkpointContextWriter{ctx, io.MultiWriter(f, hash)}); err != nil {
+ if err = CreateWorkspaceCheckpointToContext(ctx, root, checkpointContextWriter{ctx, io.MultiWriter(f, hash)}); err != nil {
return nil, err
}
stat, err := f.Stat()
diff --git a/internal/runtime/workspace_checkpoint_unix_test.go b/internal/runtime/workspace_checkpoint_unix_test.go
new file mode 100644
index 00000000..c3596cc7
--- /dev/null
+++ b/internal/runtime/workspace_checkpoint_unix_test.go
@@ -0,0 +1,51 @@
+//go:build unix
+
+package runtime
+
+import (
+ "context"
+ "os"
+ "path/filepath"
+ "strings"
+ "syscall"
+ "testing"
+ "time"
+)
+
+func TestCreateWorkspaceCheckpointRejectsGitIndexFIFOImmediately(t *testing.T) {
+ root := t.TempDir()
+ repo := filepath.Join(root, "repo")
+ if err := os.MkdirAll(filepath.Join(repo, ".cache"), 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(repo, ".cache", "x"), []byte("cache"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.MkdirAll(filepath.Join(repo, ".git"), 0o700); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(filepath.Join(repo, ".git", "HEAD"), []byte("ref: refs/heads/main\n"), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ indexPath := filepath.Join(repo, ".git", "index")
+ if err := syscall.Mkfifo(indexPath, 0o600); err != nil {
+ t.Fatalf("mkfifo: %v", err)
+ }
+
+ ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+ defer cancel()
+ done := make(chan error, 1)
+ go func() {
+ _, err := CreateWorkspaceCheckpointContext(ctx, root)
+ done <- err
+ }()
+
+ select {
+ case err := <-done:
+ if err == nil || !strings.Contains(err.Error(), "unsupported checkpoint file") {
+ t.Fatalf("expected unsupported checkpoint file error, got %v", err)
+ }
+ case <-time.After(2 * time.Second):
+ t.Fatal("CreateWorkspaceCheckpointContext hung on FIFO .git/index")
+ }
+}