package codex import ( "context" "encoding/json" "net" "net/http" "os" "path/filepath" "sync" "sync/atomic" "testing" "time" "git.a-wan.net/alan/pipelines/internal/codexhost" "git.a-wan.net/alan/pipelines/internal/protocol" "github.com/coder/websocket" "github.com/coder/websocket/wsjson" ) // Exercise the actual adapter's approval/form maps across a complete Chat // replacement, not merely a proxy socket reconnect. func TestHostedDetachRetainsAnswerableInteractions(t *testing.T) { dir, err := os.MkdirTemp("/tmp", "codex-adapter-host-") if err != nil { t.Fatal(err) } t.Cleanup(func() { os.RemoveAll(dir) }) t.Setenv("CODEX_HOME", dir) if err := os.MkdirAll(filepath.Dir(DefaultSocketPath()), 0o700); err != nil { t.Fatal(err) } ctx, cancel := context.WithCancel(context.Background()) t.Cleanup(cancel) listener, err := net.Listen("unix", DefaultSocketPath()) if err != nil { t.Fatal(err) } var mu sync.Mutex var upstream *websocket.Conn var initialized atomic.Int32 var handshakeCompleted atomic.Int32 responses := make(chan rpcMessage, 8) readyUpstream := make(chan struct{}) server := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { conn, err := websocket.Accept(w, r, nil) if err != nil { return } mu.Lock() upstream = conn mu.Unlock() close(readyUpstream) defer conn.CloseNow() for { var msg rpcMessage if wsjson.Read(ctx, conn, &msg) != nil { return } if msg.Method == "" { responses <- msg continue } if msg.Method == "initialize" { initialized.Add(1) } if msg.Method == "initialized" { handshakeCompleted.Add(1) continue } mu.Lock() err = wsjson.Write(ctx, conn, map[string]any{"id": msg.ID, "result": map[string]any{}}) mu.Unlock() if err != nil { return } } })} go server.Serve(listener) t.Cleanup(func() { server.Close() mu.Lock() if upstream != nil { upstream.CloseNow() } mu.Unlock() }) hostDir := filepath.Join(dir, "private") ready := make(chan string, 1) done := make(chan error, 1) go func() { done <- codexhost.Serve(ctx, codexhost.Options{Dir: hostDir, Upstream: DefaultSocketPath(), Ready: func(socket string) { ready <- socket }}) }() select { case <-ready: case err := <-done: t.Fatalf("host start: %v", err) case <-time.After(5 * time.Second): t.Fatal("host not ready") } t.Cleanup(func() { cancel() select { case <-done: case <-time.After(5 * time.Second): t.Error("host did not close") } }) hostConfig.Lock() oldDir, oldBinary := hostConfig.dir, hostConfig.binary hostConfig.dir, hostConfig.binary = hostDir, "unused-existing-host" hostConfig.Unlock() t.Cleanup(func() { hostConfig.Lock(); hostConfig.dir, hostConfig.binary = oldDir, oldBinary; hostConfig.Unlock() }) before, err := Open(ctx) if err != nil { t.Fatal(err) } t.Cleanup(before.Close) send := func(raw string) { t.Helper() mu.Lock() defer mu.Unlock() if err := upstream.Write(ctx, websocket.MessageText, []byte(raw)); err != nil { t.Fatal(err) } } send(`{"id":7,"method":"item/commandExecution/requestApproval","params":{"threadId":"thread-a","itemId":"command","command":"pwd"}}`) send(`{"id":8,"method":"item/tool/requestUserInput","params":{"threadId":"thread-a","itemId":"question","questions":[{"id":"q","question":"Continue?","isOther":true}]}}`) wait := func(c *Chat) { t.Helper() deadline := time.Now().Add(3 * time.Second) for time.Now().Before(deadline) { permissions, pErr := c.Permissions(ctx, "thread-a") forms, fErr := c.Forms(ctx, "thread-a") if pErr == nil && fErr == nil && len(permissions) == 1 && len(forms) == 1 { return } time.Sleep(5 * time.Millisecond) } t.Fatal("pending interactions did not arrive") } wait(before) before.Detach() // Default lifetime is unbounded: keep the original upstream callback identity // even across more than one host expiry tick while Pipelines is down. time.Sleep(1200 * time.Millisecond) after, err := Open(ctx) if err != nil { t.Fatal(err) } t.Cleanup(after.Close) wait(after) permissions, _ := after.Permissions(ctx, "thread-a") if err := after.Reply(ctx, protocol.ChatReplyRequest{SessionID: "thread-a", RequestID: permissions[0].RequestID, Decision: protocol.ChatDecisionOnce}); err != nil { t.Fatal(err) } if err := after.Answer(ctx, protocol.ChatAnswerRequest{SessionID: "thread-a", FormID: "question", Answers: map[string]any{"q": "yes"}}); err != nil { t.Fatal(err) } seen := map[string]bool{} for range 2 { select { case msg := <-responses: seen[string(msg.ID)] = true case <-time.After(3 * time.Second): t.Fatal("answer did not reach original upstream connection") } } if !seen["7"] || !seen["8"] { t.Fatalf("callback identities changed: %+v", seen) } if initialized.Load() != 1 || handshakeCompleted.Load() != 1 { t.Fatalf("upstream handshake counts: initialize=%d initialized=%d", initialized.Load(), handshakeCompleted.Load()) } if err := after.Answer(ctx, protocol.ChatAnswerRequest{SessionID: "thread-a", FormID: "question", Answers: map[string]any{"q": "no"}}); err == nil { t.Fatal("question was answered twice") } // Reattach again and use an RPC response as a read-loop barrier: resolved // callbacks must not return in the new adapter's maps. after.Detach() third, err := Open(ctx) if err != nil { t.Fatal(err) } t.Cleanup(third.Close) if _, err := third.call(ctx, "fixture/barrier", json.RawMessage(`{}`)); err != nil { t.Fatal(err) } permissions, _ = third.Permissions(ctx, "thread-a") forms, _ := third.Forms(ctx, "thread-a") if len(permissions) != 0 || len(forms) != 0 { t.Fatalf("resolved interactions replayed: %+v %+v", permissions, forms) } }