Retain Codex interaction callbacks across server restarts

This commit is contained in:
2026-11-05 14:32:59 +00:00
parent c7e57973a0
commit c2a8f5ff16
20 changed files with 1356 additions and 18 deletions
+86
View File
@@ -0,0 +1,86 @@
package codexhost
import (
"bufio"
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"net"
"os"
"os/exec"
"path/filepath"
"strings"
"syscall"
"time"
)
// Paths identifies a single upstream connection within one server scope.
func Paths(dir, upstream string) (socket, lock string) {
absolute, err := filepath.Abs(upstream)
if err == nil {
upstream = absolute
}
sum := sha256.Sum256([]byte(upstream))
key := hex.EncodeToString(sum[:8])
return filepath.Join(dir, key+".sock"), filepath.Join(dir, key+".lock")
}
func reachable(socket string) bool {
conn, err := net.DialTimeout("unix", socket, 100*time.Millisecond)
if err != nil {
return false
}
conn.Close()
return true
}
// Ensure starts only the private bridge, never Codex itself, when no bridge is
// already serving this upstream/scope. The detached helper survives its parent.
func Ensure(ctx context.Context, binary, dir, upstream string) (string, error) {
if err := EnsureDir(dir); err != nil {
return "", err
}
socket, _ := Paths(dir, upstream)
if reachable(socket) {
return socket, nil
}
logPath := strings.TrimSuffix(socket, ".sock") + ".log"
logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o600)
if err != nil {
return "", err
}
defer logFile.Close()
cmd := exec.Command(binary, "-dir", dir, "-upstream", upstream)
cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
cmd.Stderr = logFile
stdout, err := cmd.StdoutPipe()
if err != nil {
return "", err
}
if err := cmd.Start(); err != nil {
return "", err
}
result := make(chan string, 1)
go func() { line, _ := bufio.NewReader(stdout).ReadString('\n'); result <- strings.TrimSpace(line) }()
timer := time.NewTimer(15 * time.Second)
defer timer.Stop()
failed := func(err error) (string, error) { _ = cmd.Process.Kill(); _ = cmd.Wait(); return "", err }
select {
case <-ctx.Done():
return failed(ctx.Err())
case <-timer.C:
return failed(errors.New("Codex host start timed out"))
case line := <-result:
if line == "ready "+socket {
go func() { _ = cmd.Wait() }()
return socket, nil
}
// A racing server may have won the singleton lock and started the host.
_ = cmd.Wait()
if reachable(socket) {
return socket, nil
}
return "", fmt.Errorf("Codex host did not start (%s); log: %s", line, logPath)
}
}
+260
View File
@@ -0,0 +1,260 @@
// Package codexhost keeps the Codex App Server client connection alive across
// Pipelines restarts. It never starts another Codex daemon. Callback identity
// belongs to this upstream connection, so unanswered requests remain in memory
// here until the next Pipelines client attaches and answers them.
package codexhost
import (
"context"
"encoding/json"
"errors"
"fmt"
"net"
"net/http"
"os"
"path/filepath"
"sync"
"syscall"
"time"
"github.com/coder/websocket"
)
const maxFrame = 16 << 20
const maxPending = 128
const maxPendingBytes = 8 << 20
const maxCalls = 256
type message map[string]json.RawMessage
type downstream struct {
conn *websocket.Conn
ready bool
}
type route struct {
client *downstream
id json.RawMessage
}
type pending struct {
data []byte
thread string
}
type bridge struct {
ctx context.Context
cancel context.CancelFunc
upstream *websocket.Conn
mu sync.Mutex // serializes routing and all websocket writes
active *downstream
next uint64
calls map[string]route
pending map[string]pending
pendingBytes int
initialize message
initialized chan struct{}
detached time.Time
}
// Options describes one private, database-scoped bridge. MaxDetached bounds its
// lifetime without a Pipelines client, even with an unresolved approval.
type Options struct {
Dir, Upstream string
Idle, MaxDetached time.Duration
Ready func(string)
}
// Serve owns one upstream socket and serves replacement downstream clients until
// cancellation, upstream failure or detached expiry. A singleton lock prevents
// competing hosts from taking the same socket path.
func Serve(ctx context.Context, options Options) error {
if err := EnsureDir(options.Dir); err != nil {
return err
}
socket, lockPath := Paths(options.Dir, options.Upstream)
lock, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0o600)
if err != nil {
return err
}
defer lock.Close()
if err := syscall.Flock(int(lock.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil {
return fmt.Errorf("Codex host already owns this scope: %w", err)
}
defer syscall.Flock(int(lock.Fd()), syscall.LOCK_UN)
if err := os.Remove(socket); err != nil && !os.IsNotExist(err) {
return err
}
listener, err := net.Listen("unix", socket)
if err != nil {
return err
}
defer listener.Close()
defer os.Remove(socket)
if err := os.Chmod(socket, 0o600); err != nil {
return err
}
upstream, err := Dial(ctx, options.Upstream)
if err != nil {
return fmt.Errorf("connect Codex App Server: %w", err)
}
defer upstream.CloseNow()
child, cancel := context.WithCancel(ctx)
defer cancel()
h := &bridge{ctx: child, cancel: cancel, upstream: upstream, calls: map[string]route{}, pending: map[string]pending{}, initialized: make(chan struct{}), detached: time.Now()}
go h.readUpstream()
init := message{"id": json.RawMessage(`"host-initialize"`), "method": json.RawMessage(`"initialize"`), "params": json.RawMessage(`{"clientInfo":{"name":"pipelines","title":"Pipelines","version":"0.1"}}`)}
if err := h.write(upstream, init); err != nil {
return err
}
timer := time.NewTimer(10 * time.Second)
defer timer.Stop()
select {
case <-h.initialized:
case <-child.Done():
return errors.New("Codex App Server disconnected during initialization")
case <-timer.C:
return errors.New("Codex App Server initialization timed out")
}
if failure := h.initialize["error"]; len(failure) > 0 && string(failure) != "null" {
return errors.New("Codex App Server refused initialization")
}
server := &http.Server{Handler: http.HandlerFunc(h.accept), ReadHeaderTimeout: 5 * time.Second}
defer server.Close()
go func() { <-child.Done(); _ = server.Close() }()
if options.Idle <= 0 {
options.Idle = 20 * time.Minute
}
if options.MaxDetached <= 0 {
options.MaxDetached = 24 * time.Hour
}
go h.expire(options.Idle, options.MaxDetached)
if options.Ready != nil {
options.Ready(socket)
}
err = server.Serve(listener)
h.mu.Lock()
if h.active != nil {
h.active.conn.CloseNow()
}
h.mu.Unlock()
if err == http.ErrServerClosed {
return nil
}
return err
}
func (h *bridge) write(conn *websocket.Conn, msg message) error {
data, err := json.Marshal(msg)
if err != nil {
return err
}
return h.writeRaw(conn, data)
}
func (h *bridge) writeRaw(conn *websocket.Conn, data []byte) error {
ctx, cancel := context.WithTimeout(h.ctx, 5*time.Second)
defer cancel()
return conn.Write(ctx, websocket.MessageText, data)
}
func (h *bridge) send(client *downstream, msg message) {
if err := h.write(client.conn, msg); err != nil {
client.conn.CloseNow()
}
}
func (h *bridge) accept(w http.ResponseWriter, r *http.Request) {
conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
conn.SetReadLimit(maxFrame)
client := &downstream{conn: conn}
defer conn.CloseNow()
h.mu.Lock()
if h.active != nil {
h.active.conn.CloseNow()
}
// A previous client's in-flight RPC responses are never delivered to its
// replacement, even when both start their request counters at one.
h.calls = map[string]route{}
h.active = client
h.mu.Unlock()
defer func() {
h.mu.Lock()
if h.active == client {
h.active = nil
h.detached = time.Now()
h.calls = map[string]route{}
}
h.mu.Unlock()
}()
for {
_, data, err := conn.Read(h.ctx)
if err != nil {
return
}
var msg message
if json.Unmarshal(data, &msg) != nil {
return
}
h.mu.Lock()
if h.active != client {
h.mu.Unlock()
return
}
err = h.fromClient(client, msg)
h.mu.Unlock()
if err != nil {
return
}
}
}
func (h *bridge) expire(idle, maxDetached time.Duration) {
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for {
select {
case <-h.ctx.Done():
return
case <-ticker.C:
h.mu.Lock()
expired := h.active == nil && (time.Since(h.detached) >= maxDetached || (len(h.pending) == 0 && time.Since(h.detached) >= idle))
h.mu.Unlock()
if expired {
h.cancel()
return
}
}
}
}
// Dial opens a WebSocket over an existing local Unix control socket.
func Dial(ctx context.Context, socket string) (*websocket.Conn, error) {
transport := &http.Transport{DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
return (&net.Dialer{}).DialContext(ctx, "unix", socket)
}}
conn, _, err := websocket.Dial(ctx, "ws://localhost/", &websocket.DialOptions{HTTPClient: &http.Client{Transport: transport}})
if err != nil {
return nil, err
}
conn.SetReadLimit(maxFrame)
return conn, nil
}
func EnsureDir(dir string) error {
if !filepath.IsAbs(dir) {
return errors.New("Codex host directory must be absolute")
}
if err := os.MkdirAll(dir, 0o700); err != nil {
return err
}
info, err := os.Lstat(dir)
if err != nil {
return err
}
if !info.IsDir() || info.Mode()&os.ModeSymlink != 0 {
return errors.New("Codex host directory is not a real directory")
}
if owner, ok := info.Sys().(*syscall.Stat_t); !ok || owner.Uid != uint32(os.Geteuid()) {
return errors.New("Codex host directory has another owner")
}
return os.Chmod(dir, 0o700)
}
+241
View File
@@ -0,0 +1,241 @@
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
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), 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.send(t, message{"id": msg["id"], "result": json.RawMessage(`{"userAgent":"fixture"}`)})
} 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)
}
}
+75
View File
@@ -0,0 +1,75 @@
package codexhost
import (
"context"
"encoding/json"
"fmt"
"os"
"path/filepath"
"testing"
"time"
)
func waitRemoved(t *testing.T, path string) {
t.Helper()
deadline := time.Now().Add(5 * time.Second)
for time.Now().Before(deadline) {
if _, err := os.Stat(path); os.IsNotExist(err) {
return
}
time.Sleep(10 * time.Millisecond)
}
t.Fatalf("host socket was not removed: %s", path)
}
func TestPrivateSingletonScopeAndCleanup(t *testing.T) {
_, socket, cancel, _ := testHost(t)
dir := filepath.Dir(socket)
for path, want := range map[string]os.FileMode{dir: 0o700, socket: 0o600} {
info, err := os.Stat(path)
if err != nil {
t.Fatal(err)
}
if info.Mode().Perm() != want {
t.Fatalf("%s permissions %o, want %o", path, info.Mode().Perm(), want)
}
}
upstream := filepath.Join(filepath.Dir(dir), "upstream.sock")
if err := Serve(context.Background(), Options{Dir: dir, Upstream: upstream}); err == nil {
t.Fatal("second host stole active singleton")
}
other, _ := Paths(dir, upstream+".other")
if other == socket {
t.Fatal("upstream identities share a socket")
}
cancel()
waitRemoved(t, socket)
}
func TestPendingCallbacksAreRetainedWhileDetachedAndBounded(t *testing.T) {
fake, socket, _, _ := testHost(t)
// No downstream is attached while these arrive: they must still be answerable.
for i := 0; i < maxPending; i++ {
fake.send(t, message{"id": json.RawMessage(fmt.Sprint(i)), "method": json.RawMessage(`"item/tool/requestUserInput"`), "params": json.RawMessage(`{"threadId":"thread"}`)})
}
client := attach(t, socket)
for range maxPending {
readClient(t, client)
}
client.CloseNow()
fake.send(t, message{"id": json.RawMessage(`999`), "method": json.RawMessage(`"item/tool/requestUserInput"`), "params": json.RawMessage(`{"threadId":"thread"}`)})
waitRemoved(t, socket)
select {
case got := <-fake.received:
t.Fatalf("host auto-answered on overflow: %s", got)
default:
}
}
func TestEnsureDirRejectsSymlink(t *testing.T) {
dir := t.TempDir()
link := filepath.Join(dir, "link")
if err := os.Symlink(dir, link); err != nil {
t.Fatal(err)
}
if err := EnsureDir(link); err == nil {
t.Fatal("accepted symlink host directory")
}
}
+45
View File
@@ -0,0 +1,45 @@
package codexhost
import (
"context"
"flag"
"fmt"
"os"
"os/signal"
"syscall"
"time"
)
// Main is the detached bridge's command entry point.
func Main(args []string) int {
flags := flag.NewFlagSet("pipelines-codex-host", flag.ContinueOnError)
dir := flags.String("dir", "", "private per-server host directory")
upstream := flags.String("upstream", "", "existing Codex App Server Unix socket")
idle := flags.Duration("idle", 20*time.Minute, "exit after this long detached without pending interactions")
maxDetached := flags.Duration("max-detached", 24*time.Hour, "maximum detached lifetime, including pending interactions")
if err := flags.Parse(args); err != nil {
return 2
}
if *dir == "" || *upstream == "" {
fmt.Fprintln(os.Stderr, "-dir and -upstream are required")
return 2
}
syscall.Umask(0o077)
signal.Ignore(syscall.SIGHUP, syscall.SIGPIPE)
ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer cancel()
err := Serve(ctx, Options{Dir: *dir, Upstream: *upstream, Idle: *idle, MaxDetached: *maxDetached, Ready: func(socket string) {
fmt.Fprintln(os.Stdout, "ready "+socket)
if null, err := os.OpenFile(os.DevNull, os.O_RDWR, 0); err == nil {
_ = syscall.Dup2(int(null.Fd()), 0)
_ = syscall.Dup2(int(null.Fd()), 1)
null.Close()
}
}})
if err != nil {
fmt.Fprintln(os.Stderr, err)
fmt.Fprintln(os.Stdout, "error "+err.Error())
return 1
}
return 0
}
+109
View File
@@ -0,0 +1,109 @@
package codexhost
import (
"context"
"encoding/json"
"net"
"net/http"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/coder/websocket"
"github.com/coder/websocket/wsjson"
)
func TestHostHelperProcess(t *testing.T) {
if os.Getenv("PIPELINES_TEST_CODEX_HOST") != "1" {
return
}
for index, arg := range os.Args {
if arg == "--" {
os.Exit(Main(os.Args[index+1:]))
}
}
os.Exit(2)
}
func TestEnsureSpawnsReusableDetachedHost(t *testing.T) {
dir, err := os.MkdirTemp("/tmp", "codex-host-process-")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { os.RemoveAll(dir) })
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
upstream := filepath.Join(dir, "upstream.sock")
listener, err := net.Listen("unix", upstream)
if err != nil {
t.Fatal(err)
}
var original *websocket.Conn
accepted := make(chan *websocket.Conn, 2)
server := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
accepted <- conn
defer conn.CloseNow()
for {
var msg message
if wsjson.Read(ctx, conn, &msg) != nil {
return
}
if err := wsjson.Write(ctx, conn, message{"id": msg["id"], "result": json.RawMessage(`{}`)}); err != nil {
return
}
}
})}
go server.Serve(listener)
t.Cleanup(func() {
cancel()
server.Close()
if original != nil {
original.CloseNow()
}
})
executable, err := os.Executable()
if err != nil {
t.Fatal(err)
}
wrapper := filepath.Join(dir, "helper")
command := "#!/bin/sh\nexec '" + strings.ReplaceAll(executable, "'", "'\\''") + "' -test.run '^TestHostHelperProcess$' -- \"$@\"\n"
if err := os.WriteFile(wrapper, []byte(command), 0o700); err != nil {
t.Fatal(err)
}
t.Setenv("PIPELINES_TEST_CODEX_HOST", "1")
hostDir := filepath.Join(dir, "private")
startCtx, startCancel := context.WithCancel(context.Background())
socket, err := Ensure(startCtx, wrapper, hostDir, upstream)
if err != nil {
t.Fatal(err)
}
select {
case original = <-accepted:
case <-time.After(3 * time.Second):
t.Fatal("helper did not attach upstream")
}
startCancel() // completion of the launching request must not kill the host
first := attach(t, socket)
first.CloseNow()
reused, err := Ensure(context.Background(), "/missing/helper", hostDir, upstream)
if err != nil || reused != socket {
t.Fatalf("live host was not reused: %s %v", reused, err)
}
second := attach(t, socket)
second.CloseNow()
select {
case extra := <-accepted:
extra.CloseNow()
t.Fatal("reconnect started a second upstream connection")
default:
}
// Closing the existing upstream daemon connection must release the bridge.
original.CloseNow()
waitRemoved(t, socket)
}
+159
View File
@@ -0,0 +1,159 @@
package codexhost
import (
"encoding/json"
"errors"
"fmt"
"log"
"sort"
)
func (h *bridge) fromClient(client *downstream, msg message) error {
var method string
_ = json.Unmarshal(msg["method"], &method)
id := msg["id"]
if len(id) > 256 {
return errors.New("Codex RPC id exceeds bridge limit")
}
if method == "initialize" && len(id) > 0 {
if client.ready {
return errors.New("duplicate initialize")
}
response := message{"id": id}
for key, value := range h.initialize {
if key != "id" {
response[key] = value
}
}
if err := h.write(client.conn, response); err != nil {
return err
}
client.ready = true
keys := make([]string, 0, len(h.pending))
for key := range h.pending {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
if err := h.writeRaw(client.conn, h.pending[key].data); err != nil {
return err
}
}
return nil
}
if !client.ready {
return errors.New("initialize required")
}
if method == "initialized" {
return nil
} // the host initialized upstream once
if method != "" && len(id) > 0 {
if len(h.calls) >= maxCalls {
return errors.New("too many outstanding Codex calls")
}
h.next++
hostID := json.RawMessage(fmt.Sprintf(`"host-%d"`, h.next))
h.calls[string(hostID)] = route{client, id}
msg["id"] = hostID
if err := h.write(h.upstream, msg); err != nil {
h.cancel()
return err
}
return nil
}
if method == "" && len(id) > 0 {
key := string(id)
item, ok := h.pending[key]
if !ok {
return nil
} // stale/duplicate callback response is never replayed
if err := h.write(h.upstream, msg); err != nil {
h.cancel()
return err
}
delete(h.pending, key)
h.pendingBytes -= len(item.data)
return nil
}
if err := h.write(h.upstream, msg); err != nil {
h.cancel()
return err
}
return nil
}
func (h *bridge) readUpstream() {
defer h.cancel()
for {
_, data, err := h.upstream.Read(h.ctx)
if err != nil {
if h.ctx.Err() == nil {
log.Print("Codex App Server connection ended; connection-bound interactions cannot be recovered by a new upstream connection")
}
return
}
var msg message
if json.Unmarshal(data, &msg) != nil {
return
}
h.mu.Lock()
ok := h.fromUpstream(msg, data)
h.mu.Unlock()
if !ok {
log.Print("Codex bridge received invalid or over-budget state; closing rather than auto-answering interactions")
return
}
}
}
func (h *bridge) fromUpstream(msg message, data []byte) bool {
id := msg["id"]
if len(id) > 256 {
return false
}
var method string
_ = json.Unmarshal(msg["method"], &method)
if string(id) == `"host-initialize"` && method == "" {
if h.initialize != nil {
return false
}
h.initialize = msg
close(h.initialized)
return true
}
if len(id) > 0 && method != "" {
key := string(id)
old, exists := h.pending[key]
if (!exists && len(h.pending) >= maxPending) || h.pendingBytes-len(old.data)+len(data) > maxPendingBytes {
return false
}
var params struct {
Thread string `json:"threadId"`
}
_ = json.Unmarshal(msg["params"], &params)
h.pending[key] = pending{append([]byte(nil), data...), params.Thread}
h.pendingBytes += len(data) - len(old.data)
} else if len(id) > 0 {
target, ok := h.calls[string(id)]
delete(h.calls, string(id))
if ok && h.active == target.client && target.client.ready {
msg["id"] = target.id
h.send(target.client, msg)
}
return true
} else if method == "serverRequest/resolved" {
var p struct {
Thread string `json:"threadId"`
ID json.RawMessage `json:"requestId"`
}
if json.Unmarshal(msg["params"], &p) == nil {
if old, ok := h.pending[string(p.ID)]; ok && old.thread == p.Thread {
delete(h.pending, string(p.ID))
h.pendingBytes -= len(old.data)
}
}
}
if h.active != nil && h.active.ready {
h.send(h.active, msg)
}
return true
}