Files
pipelines/internal/codex/hosted_test.go
T

195 lines
5.6 KiB
Go

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)
}
}