Retain Codex interaction callbacks across server restarts
This commit is contained in:
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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"], ¶ms)
|
||||
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
|
||||
}
|
||||
Reference in New Issue
Block a user