Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

agent: disconnect previews sweep sandboxes a killed magpie left (#3136)

vincente50d73aa3621
diff --git a/internal/agent/preview.go b/internal/agent/preview.go
index bb74cb78d..fa8edd1d1 100644
--- a/internal/agent/preview.go
+++ b/internal/agent/preview.go
@@ -6,6 +6,7 @@ import (
"errors"
"fmt"
"io/fs"
+ "log"
"os"
"path/filepath"
"regexp"
@@ -116,11 +117,12 @@ func DisconnectPreview(a *Agent, exe string) ([]FileChange, error) {
if !ok || !ok2 {
return nil, errors.New("the agent's files are outside home")
}
+ sweepPreviews()
tmp, err := os.MkdirTemp("", "magpie-preview-")
if err != nil {
return nil, err
}
- defer os.RemoveAll(tmp)
+ defer removePreview(tmp)
tmp, _ = filepath.EvalSymlinks(tmp)
// the agent's folder: its files, copied; its folders aren't its config
before := map[string][]byte{}
@@ -199,6 +201,40 @@ func DisconnectPreview(a *Agent, exe string) ([]FileChange, error) {
return changes, nil
}
+// previewStale is how old a sandbox in the temporary dir must be for the
+// sweep to take it: a live preview lasts seconds (the dry run is bounded
+// at 20 seconds), so an hour-old one is a sandbox an earlier magpie was
+// killed holding (#3136).
+const previewStale = time.Hour
+
+// sweepPreviews removes sandboxes an earlier magpie was killed holding,
+// as sweepCursorSnaps does for its magpie-cursor-* copies.
+func sweepPreviews() {
+ old, _ := filepath.Glob(filepath.Join(os.TempDir(), "magpie-preview-*"))
+ for _, d := range old {
+ if fi, err := os.Stat(d); err == nil && fi.IsDir() && time.Since(fi.ModTime()) > previewStale {
+ removePreview(d)
+ }
+ }
+}
+
+// removePreview removes a sandbox, retrying while processes of the dry run
+// are still letting go of files in it (Windows keeps a file locked until
+// the last holder is out), and says so when it still could not.
+var previewRemoveAll = os.RemoveAll
+
+func removePreview(dir string) error {
+ var err error
+ for try := 0; try < 5; try++ {
+ if err = previewRemoveAll(dir); err == nil {
+ return nil
+ }
+ time.Sleep(time.Duration(try+1) * 100 * time.Millisecond)
+ }
+ log.Printf("agent: removing disconnect-preview sandbox %s: %v", dir, err)
+ return err
+}
+
// sortTail sorts all but the first name.
func sortTail(names []string) {
for i := 2; i < len(names); i++ {
diff --git a/internal/agent/preview_sweep_test.go b/internal/agent/preview_sweep_test.go
new file mode 100644
index 000000000..5626b49ff
--- /dev/null
+++ b/internal/agent/preview_sweep_test.go
@@ -0,0 +1,79 @@
+package agent
+
+import (
+ "errors"
+ "os"
+ "path/filepath"
+ "testing"
+ "time"
+)
+
+// TestDisconnectPreviewSweepsStaleSandboxes: a sandbox an earlier magpie
+// was killed holding (#3136) is gone after the next preview, and a sandbox
+// a live preview could be using is left alone.
+func TestDisconnectPreviewSweepsStaleSandboxes(t *testing.T) {
+ // a temp dir of the test's own: the sweep never reaches the real one
+ tmp, err := filepath.EvalSymlinks(t.TempDir())
+ if err != nil {
+ t.Fatal(err)
+ }
+ for _, k := range []string{"TMPDIR", "TMP", "TEMP"} {
+ t.Setenv(k, tmp)
+ }
+ stale := filepath.Join(tmp, "magpie-preview-sweeptest-stale")
+ fresh := filepath.Join(tmp, "magpie-preview-sweeptest-fresh")
+ for _, d := range []string{stale, fresh} {
+ if err := os.MkdirAll(d, 0o700); err != nil {
+ t.Fatal(err)
+ }
+ }
+ old := time.Now().Add(-2 * time.Hour)
+ if err := os.Chtimes(stale, old, old); err != nil {
+ t.Fatal(err)
+ }
+
+ home, _ := codexHome(t, "", "model = \"gpt-5.4\"\n")
+ a := codex(home)
+ if err := a.Apply("model", "fake/m1"); err != nil {
+ t.Fatal(err)
+ }
+ exe, err := os.Executable()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := DisconnectPreview(a, exe); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := os.Stat(stale); !os.IsNotExist(err) {
+ t.Fatalf("a stale sandbox is still there after a preview: %v", err)
+ }
+ if _, err := os.Stat(fresh); err != nil {
+ t.Fatalf("a fresh sandbox was swept: %v", err)
+ }
+}
+
+// TestRemovePreviewRetriesWhileFilesAreHeld: a removal that fails while the
+// dry run's processes still hold files is retried until it succeeds, and a
+// removal that never succeeds is reported, not dropped (#3136).
+func TestRemovePreviewRetriesWhileFilesAreHeld(t *testing.T) {
+ dir := t.TempDir()
+ real := previewRemoveAll
+ var calls int
+ previewRemoveAll = func(string) error {
+ calls++
+ if calls < 3 {
+ return errors.New("file in use")
+ }
+ return real(dir)
+ }
+ t.Cleanup(func() { previewRemoveAll = real })
+ if err := removePreview(dir); err != nil {
+ t.Fatalf("removePreview gave up: %v", err)
+ }
+ if calls != 3 {
+ t.Fatalf("removePreview tried %d times, want 3", calls)
+ }
+ if _, err := os.Stat(dir); !os.IsNotExist(err) {
+ t.Fatalf("sandbox still there after removePreview: %v", err)
+ }
+}