package codexhost import ( "context" "encoding/json" "net" "net/http" "os" "path/filepath" "sync" "testing" "time" "github.com/coder/websocket" ) type fakeServer struct { ctx context.Context conn *websocket.Conn mu sync.Mutex received chan message handshakes chan string ready chan struct{} } func testHost(t *testing.T) (*fakeServer, string, context.CancelFunc, <-chan error) { t.Helper() dir, err := os.MkdirTemp("/tmp", "codex-host-test-") if err != nil { t.Fatal(err) } t.Cleanup(func() { os.RemoveAll(dir) }) ctx, cancel := context.WithCancel(context.Background()) t.Cleanup(cancel) fake := &fakeServer{ctx: ctx, received: make(chan message, 64), handshakes: make(chan string, 8), ready: make(chan struct{})} listener, err := net.Listen("unix", filepath.Join(dir, "upstream.sock")) if err != nil { t.Fatal(err) } server := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { conn, err := websocket.Accept(w, r, nil) if err != nil { return } fake.mu.Lock() fake.conn = conn fake.mu.Unlock() close(fake.ready) defer conn.CloseNow() for { _, data, err := conn.Read(ctx) if err != nil { return } var msg message if json.Unmarshal(data, &msg) != nil { return } var method string _ = json.Unmarshal(msg["method"], &method) if method == "initialize" { fake.handshakes <- method fake.send(t, message{"id": msg["id"], "result": json.RawMessage(`{"userAgent":"fixture"}`)}) } else if method == "initialized" { fake.handshakes <- method } else { select { case fake.received <- msg: case <-ctx.Done(): return } } } })} go server.Serve(listener) t.Cleanup(func() { server.Close() fake.mu.Lock() if fake.conn != nil { fake.conn.CloseNow() } fake.mu.Unlock() }) ready := make(chan string, 1) done := make(chan error, 1) go func() { done <- Serve(ctx, Options{Dir: filepath.Join(dir, "private"), Upstream: filepath.Join(dir, "upstream.sock"), Ready: func(socket string) { ready <- socket }}) }() var socket string select { case socket = <-ready: case err := <-done: t.Fatalf("host failed: %v", err) case <-time.After(5 * time.Second): t.Fatal("host did not initialize") } t.Cleanup(func() { cancel() select { case <-done: case <-time.After(5 * time.Second): t.Error("host did not stop") } }) return fake, socket, cancel, done } func (f *fakeServer) send(t *testing.T, msg message) { t.Helper() f.mu.Lock() defer f.mu.Unlock() data, _ := json.Marshal(msg) ctx, cancel := context.WithTimeout(f.ctx, 3*time.Second) defer cancel() if err := f.conn.Write(ctx, websocket.MessageText, data); err != nil { t.Fatal(err) } } func (f *fakeServer) next(t *testing.T) message { t.Helper() select { case msg := <-f.received: return msg case <-time.After(3 * time.Second): t.Fatal("missing upstream request") return nil } } func writeClient(t *testing.T, conn *websocket.Conn, raw string) { t.Helper() ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() if err := conn.Write(ctx, websocket.MessageText, []byte(raw)); err != nil { t.Fatal(err) } } func readClient(t *testing.T, conn *websocket.Conn) message { t.Helper() ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() _, data, err := conn.Read(ctx) if err != nil { t.Fatal(err) } var msg message if err := json.Unmarshal(data, &msg); err != nil { t.Fatal(err) } return msg } func attach(t *testing.T, socket string) *websocket.Conn { t.Helper() ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() conn, err := Dial(ctx, socket) if err != nil { t.Fatal(err) } t.Cleanup(func() { conn.CloseNow() }) writeClient(t, conn, `{"id":1,"method":"initialize","params":{"clientInfo":{"name":"pipelines","version":"0.1"}}}`) if got := readClient(t, conn); string(got["id"]) != "1" || len(got["result"]) == 0 { t.Fatalf("initialize: %s", got) } return conn } func method(msg message) string { var s string; _ = json.Unmarshal(msg["method"], &s); return s } func TestPendingInteractionsRemainAnswerableAcrossClientReplacement(t *testing.T) { fake, socket, _, _ := testHost(t) first := attach(t, socket) fake.send(t, message{"id": json.RawMessage(`7`), "method": json.RawMessage(`"item/commandExecution/requestApproval"`), "params": json.RawMessage(`{"threadId":"thread-a","itemId":"command","command":"pwd"}`)}) fake.send(t, message{"id": json.RawMessage(`"question"`), "method": json.RawMessage(`"item/tool/requestUserInput"`), "params": json.RawMessage(`{"threadId":"thread-a","itemId":"question","questions":[{"id":"q","question":"Continue?"}]}`)}) approval, question := readClient(t, first), readClient(t, first) first.CloseNow() second := attach(t, socket) replay1, replay2 := readClient(t, second), readClient(t, second) replay := map[string]message{string(replay1["id"]): replay1, string(replay2["id"]): replay2} for _, original := range []message{approval, question} { got := replay[string(original["id"])] if string(got["method"]) != string(original["method"]) || string(got["params"]) != string(original["params"]) { t.Fatalf("callback changed: %s vs %s", got, original) } } writeClient(t, second, `{"id":7,"result":{"decision":"accept"}}`) if got := fake.next(t); string(got["id"]) != "7" || string(got["result"]) != `{"decision":"accept"}` { t.Fatalf("approval answer: %s", got) } writeClient(t, second, `{"id":7,"result":{"decision":"decline"}}`) writeClient(t, second, `{"id":"question","result":{"answers":{"q":{"answers":["yes"]}}}}`) if got := fake.next(t); string(got["id"]) != `"question"` { t.Fatalf("duplicate approval reached upstream: %s", got) } writeClient(t, second, `{"id":2,"method":"barrier"}`) if got := fake.next(t); method(got) != "barrier" { t.Fatalf("duplicate question reached upstream: %s", got) } second.CloseNow() third := attach(t, socket) writeClient(t, third, `{"id":2,"method":"last"}`) call := fake.next(t) fake.send(t, message{"id": call["id"], "result": json.RawMessage(`"done"`)}) if got := readClient(t, third); string(got["id"]) != "2" || string(got["result"]) != `"done"` { t.Fatalf("resolved callback was replayed: %s", got) } } func TestOldRPCResponseCannotAnswerNewClientCall(t *testing.T) { fake, socket, _, _ := testHost(t) first := attach(t, socket) writeClient(t, first, `{"id":2,"method":"old"}`) old := fake.next(t) second := attach(t, socket) // closes the obsolete client writeClient(t, second, `{"id":2,"method":"new"}`) fresh := fake.next(t) if string(old["id"]) == string(fresh["id"]) { t.Fatal("client RPC IDs were reused upstream") } fake.send(t, message{"id": old["id"], "result": json.RawMessage(`"old"`)}) fake.send(t, message{"id": fresh["id"], "result": json.RawMessage(`"new"`)}) if got := readClient(t, second); string(got["id"]) != "2" || string(got["result"]) != `"new"` { t.Fatalf("old RPC response crossed client identity: %s", got) } } func TestResolvedNotificationClearsOnlyMatchingThread(t *testing.T) { fake, socket, _, _ := testHost(t) first := attach(t, socket) request := message{"id": json.RawMessage(`3`), "method": json.RawMessage(`"item/commandExecution/requestApproval"`), "params": json.RawMessage(`{"threadId":"owner","itemId":"command"}`)} fake.send(t, request) readClient(t, first) fake.send(t, message{"method": json.RawMessage(`"serverRequest/resolved"`), "params": json.RawMessage(`{"threadId":"foreign","requestId":3}`)}) readClient(t, first) second := attach(t, socket) if got := readClient(t, second); string(got["id"]) != "3" { t.Fatalf("foreign thread resolved callback: %s", got) } fake.send(t, message{"method": json.RawMessage(`"serverRequest/resolved"`), "params": json.RawMessage(`{"threadId":"owner","requestId":3}`)}) readClient(t, second) third := attach(t, socket) writeClient(t, third, `{"id":2,"method":"barrier"}`) call := fake.next(t) fake.send(t, message{"id": call["id"], "result": json.RawMessage(`null`)}) if got := readClient(t, third); len(got["method"]) > 0 { t.Fatalf("resolved callback replayed: %s", got) } } func TestBridgeCompletesUpstreamHandshakeExactlyOnce(t *testing.T) { fake, socket, _, _ := testHost(t) first := attach(t, socket) writeClient(t, first, `{"method":"initialized"}`) writeClient(t, first, `{"method":"initialized"}`) first.CloseNow() second := attach(t, socket) writeClient(t, second, `{"method":"initialized"}`) writeClient(t, second, `{"id":2,"method":"barrier"}`) if got := fake.next(t); method(got) != "barrier" { t.Fatalf("unexpected upstream call: %s", got) } for _, want := range []string{"initialize", "initialized"} { select { case got := <-fake.handshakes: if got != want { t.Fatalf("handshake order: got %s, want %s", got, want) } case <-time.After(time.Second): t.Fatalf("missing upstream %s", want) } } select { case got := <-fake.handshakes: t.Fatalf("upstream handshake repeated after downstream reconnect: %s", got) default: } }