Files

267 lines
7.3 KiB
Go

// 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. Positive timeout
// values opt into detached expiry; zero keeps the original upstream connection
// and its live sessions/callbacks until explicitly stopped.
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")
}
// Complete the upstream handshake once before accepting Pipelines clients.
// Reattached clients only initialize their downstream connection.
if err := h.write(upstream, message{"method": json.RawMessage(`"initialized"`)}); err != nil {
return fmt.Errorf("complete Codex App Server initialization: %w", err)
}
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 && ((maxDetached > 0 && time.Since(h.detached) >= maxDetached) || (idle > 0 && 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)
}