195 lines
5.6 KiB
Go
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)
|
|
}
|
|
}
|