@pi-in-go/pigpen-acp 0.1.0

package/extensions/acp/cmd/pig-acp/internal/jsonrpc/bench_test.go

@@ -0,0 +1,24 @@
+package jsonrpc
+
+import (
+	"io"
+	"testing"
+)
+
+// One session/update notification written through the connection's queue and writer goroutine.
+//
+//	go test -run xxx -bench . -benchmem
+func BenchmarkNotify(b *testing.B) {
+	pr, pw := io.Pipe()
+	defer pw.Close()
+	c := New(pr, io.Discard, func(*Request) (any, error) { return nil, nil })
+	params := map[string]any{"sessionId": "s1", "update": map[string]any{"sessionUpdate": "agent_message_chunk", "content": map[string]any{"type": "text", "text": "some streamed text from the model"}}}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if err := c.Notify("session/update", params); err != nil {
+			b.Fatal(err)
+		}
+	}
+	c.Drain(0)
+}

package/extensions/acp/cmd/pig-acp/internal/jsonrpc/jsonrpc.go

@@ -0,0 +1,302 @@
+// Package jsonrpc is newline-delimited JSON-RPC 2.0 over a pair of streams, the transport
+// ACP uses on stdio (ndJsonStream and Connection of @agentclientprotocol/sdk).
+package jsonrpc
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"sync"
+	"time"
+)
+
+// Error is a JSON-RPC error object.
+type Error struct {
+	Code    int
+	Message string
+	Data    any
+}
+
+func (e *Error) Error() string { return e.Message }
+
+// Coded is implemented by errors that carry a JSON-RPC code (acp.RequestError does).
+type Coded interface {
+	error
+	RPCError() (code int, message string, data any)
+}
+
+// Request is an incoming request or notification.
+type Request struct {
+	Method string
+	Params json.RawMessage
+	// Notification is true when the message has no id.
+	Notification bool
+	after        []func()
+}
+
+// AfterResponse runs fn once the response to this request has been queued for writing, so
+// anything fn sends follows the response on the wire.
+func (r *Request) AfterResponse(fn func()) { r.after = append(r.after, fn) }
+
+// Handler serves one incoming message. For a notification the result is dropped.
+type Handler func(req *Request) (any, error)
+
+// maxLine bounds one message (an embedded image can be many megabytes).
+const maxLine = 64 << 20
+
+// Conn is one JSON-RPC connection. Outgoing messages go through an unbounded FIFO queue and a
+// single writer goroutine, so a slow or stalled peer never blocks the agent, lines never
+// interleave, and the order in which messages were queued is the order on the wire.
+type Conn struct {
+	h Handler
+
+	mu      sync.Mutex
+	queue   [][]byte
+	wake    chan struct{}
+	failed  bool
+	writing bool
+	active  int
+	nextID  int64
+	pending map[string]chan message
+
+	done     chan struct{}
+	doneOnce sync.Once
+}
+
+type message struct {
+	ID     json.RawMessage `json:"id,omitempty"`
+	Method string          `json:"method,omitempty"`
+	Params json.RawMessage `json:"params,omitempty"`
+	Result json.RawMessage `json:"result,omitempty"`
+	Error  *wireError      `json:"error,omitempty"`
+}
+
+type wireError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	Data    any    `json:"data,omitempty"`
+}
+
+// ErrClosed is returned when the connection can no longer carry messages.
+var ErrClosed = errors.New("jsonrpc: connection closed")
+
+// New starts reading from r and writing to w; every incoming message runs h on its own goroutine.
+func New(r io.Reader, w io.Writer, h Handler) *Conn {
+	c := &Conn{h: h, wake: make(chan struct{}, 1), pending: map[string]chan message{}, done: make(chan struct{})}
+	go c.writeLoop(w)
+	go c.readLoop(r)
+	return c
+}
+
+func (c *Conn) closeDone() {
+	c.doneOnce.Do(func() {
+		close(c.done)
+		c.mu.Lock()
+		for id, ch := range c.pending {
+			close(ch)
+			delete(c.pending, id)
+		}
+		c.mu.Unlock()
+	})
+}
+
+func (c *Conn) writeLoop(w io.Writer) {
+	for {
+		c.mu.Lock()
+		if len(c.queue) == 0 {
+			c.mu.Unlock()
+			<-c.wake
+			continue
+		}
+		line := c.queue[0]
+		c.queue = c.queue[1:]
+		c.writing = true
+		c.mu.Unlock()
+		_, err := w.Write(line)
+		c.mu.Lock()
+		c.writing = false
+		c.mu.Unlock()
+		if err != nil {
+			c.mu.Lock()
+			c.failed = true
+			c.queue = nil
+			c.mu.Unlock()
+			c.closeDone()
+			return
+		}
+	}
+}
+
+func (c *Conn) enqueue(v any) error {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+	c.mu.Lock()
+	if c.failed {
+		c.mu.Unlock()
+		return ErrClosed
+	}
+	c.queue = append(c.queue, append(b, '\n'))
+	c.mu.Unlock()
+	select {
+	case c.wake <- struct{}{}:
+	default:
+	}
+	return nil
+}
+
+func (c *Conn) readLoop(r io.Reader) {
+	br := bufio.NewReaderSize(r, 1<<20)
+	for {
+		line, err := readLine(br)
+		if len(bytes.TrimSpace(line)) > 0 {
+			var m message
+			if json.Unmarshal(line, &m) == nil {
+				c.dispatch(m)
+			}
+		}
+		if err != nil {
+			c.closeDone()
+			return
+		}
+	}
+}
+
+func readLine(br *bufio.Reader) ([]byte, error) {
+	var out []byte
+	for {
+		part, err := br.ReadSlice('\n')
+		out = append(out, part...)
+		if len(out) > maxLine {
+			return nil, io.ErrShortBuffer
+		}
+		if err == bufio.ErrBufferFull {
+			continue
+		}
+		return out, err
+	}
+}
+
+func (c *Conn) dispatch(m message) {
+	if m.Method == "" {
+		if len(m.ID) == 0 {
+			return
+		}
+		c.mu.Lock()
+		ch, ok := c.pending[string(m.ID)]
+		delete(c.pending, string(m.ID))
+		c.mu.Unlock()
+		if ok {
+			ch <- m
+		}
+		return
+	}
+	notification := len(m.ID) == 0
+	c.mu.Lock()
+	c.active++
+	c.mu.Unlock()
+	go c.serve(m, notification)
+}
+
+func (c *Conn) serve(m message, notification bool) {
+	defer func() {
+		c.mu.Lock()
+		c.active--
+		c.mu.Unlock()
+	}()
+	req := &Request{Method: m.Method, Params: m.Params, Notification: notification}
+	res, err := c.call(req)
+	if notification {
+		return
+	}
+	resp := map[string]any{"jsonrpc": "2.0", "id": m.ID}
+	if err != nil {
+		resp["error"] = toWireError(err)
+	} else {
+		resp["result"] = res
+	}
+	_ = c.enqueue(resp)
+	for _, fn := range req.after {
+		fn()
+	}
+}
+
+func (c *Conn) call(req *Request) (res any, err error) {
+	defer func() {
+		if p := recover(); p != nil {
+			res, err = nil, fmt.Errorf("panic: %v", p)
+		}
+	}()
+	return c.h(req)
+}
+
+func toWireError(err error) *wireError {
+	var coded Coded
+	if errors.As(err, &coded) {
+		code, msg, data := coded.RPCError()
+		return &wireError{Code: code, Message: msg, Data: data}
+	}
+	return &wireError{Code: -32603, Message: "Internal error", Data: map[string]any{"details": err.Error()}}
+}
+
+// Call sends a request and decodes its result into result (may be nil).
+func (c *Conn) Call(method string, params, result any) error {
+	c.mu.Lock()
+	c.nextID++
+	id := c.nextID
+	key := fmt.Sprint(id)
+	ch := make(chan message, 1)
+	select {
+	case <-c.done:
+		c.mu.Unlock()
+		return ErrClosed
+	default:
+	}
+	c.pending[key] = ch
+	c.mu.Unlock()
+	if err := c.enqueue(map[string]any{"jsonrpc": "2.0", "id": id, "method": method, "params": params}); err != nil {
+		c.mu.Lock()
+		delete(c.pending, key)
+		c.mu.Unlock()
+		return err
+	}
+	m, ok := <-ch
+	if !ok {
+		return ErrClosed
+	}
+	if m.Error != nil {
+		return &Error{Code: m.Error.Code, Message: m.Error.Message, Data: m.Error.Data}
+	}
+	if result != nil && len(m.Result) > 0 {
+		return json.Unmarshal(m.Result, result)
+	}
+	return nil
+}
+
+// Notify sends a notification.
+func (c *Conn) Notify(method string, params any) error {
+	return c.enqueue(map[string]any{"jsonrpc": "2.0", "method": method, "params": params})
+}
+
+// Done is closed when the input ends or a write fails for good.
+func (c *Conn) Done() <-chan struct{} { return c.done }
+
+// Drain waits until every request being served has been answered and every queued message has been
+// written, or until timeout. It lets a client that closes its output right after sending a request
+// (a one-shot script) still receive the answer.
+func (c *Conn) Drain(timeout time.Duration) {
+	deadline := time.Now().Add(timeout)
+	for time.Now().Before(deadline) {
+		c.mu.Lock()
+		idle := c.active == 0 && len(c.queue) == 0 && !c.writing || c.failed
+		c.mu.Unlock()
+		if idle {
+			return
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+}

package/extensions/acp/cmd/pig-acp/internal/jsonrpc/jsonrpc_test.go

@@ -0,0 +1,320 @@
+package jsonrpc
+
+import (
+	"bufio"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// peer is the client end of a Conn under test.
+type peer struct {
+	toConn   *io.PipeWriter
+	fromConn *bufio.Scanner
+	conn     *Conn
+}
+
+func newPeer(t *testing.T, h Handler) *peer {
+	t.Helper()
+	inR, inW := io.Pipe()
+	outR, outW := io.Pipe()
+	p := &peer{toConn: inW, fromConn: bufio.NewScanner(outR)}
+	p.fromConn.Buffer(make([]byte, 1<<20), 1<<26)
+	p.conn = New(inR, outW, h)
+	t.Cleanup(func() { inW.Close(); outR.Close() })
+	return p
+}
+
+func (p *peer) send(t *testing.T, v any) {
+	t.Helper()
+	var line string
+	if s, ok := v.(string); ok {
+		line = s
+	} else {
+		b, _ := json.Marshal(v)
+		line = string(b)
+	}
+	done := make(chan error, 1)
+	go func() { _, err := p.toConn.Write([]byte(line + "\n")); done <- err }()
+	select {
+	case err := <-done:
+		if err != nil {
+			t.Fatal(err)
+		}
+	case <-time.After(3 * time.Second):
+		p.toConn.CloseWithError(io.ErrClosedPipe)
+		t.Fatal("the connection does not read its input")
+	}
+}
+
+func (p *peer) recv(t *testing.T) map[string]any {
+	t.Helper()
+	done := make(chan map[string]any, 1)
+	go func() {
+		if !p.fromConn.Scan() {
+			done <- nil
+			return
+		}
+		var m map[string]any
+		if err := json.Unmarshal(p.fromConn.Bytes(), &m); err != nil {
+			t.Errorf("output %q is not JSON: %v", p.fromConn.Text(), err)
+		}
+		done <- m
+	}()
+	select {
+	case m := <-done:
+		return m
+	case <-time.After(5 * time.Second):
+		t.Fatal("no message from the connection")
+		return nil
+	}
+}
+
+type coded struct {
+	code int
+	msg  string
+	data any
+}
+
+func (c coded) Error() string                { return c.msg }
+func (c coded) RPCError() (int, string, any) { return c.code, c.msg, c.data }
+
+func TestConn(t *testing.T) {
+	t.Run("answers a request with its result and the same id", func(t *testing.T) {
+		p := newPeer(t, func(r *Request) (any, error) { return map[string]any{"echo": r.Method}, nil })
+		p.send(t, map[string]any{"jsonrpc": "2.0", "id": 7, "method": "ping", "params": map[string]any{}})
+		m := p.recv(t)
+		if m["jsonrpc"] != "2.0" || m["id"] != float64(7) {
+			t.Fatalf("response = %v", m)
+		}
+		if r, _ := m["result"].(map[string]any); r["echo"] != "ping" {
+			t.Errorf("result = %v", m["result"])
+		}
+	})
+
+	t.Run("keeps string ids and answers a null result as null", func(t *testing.T) {
+		p := newPeer(t, func(*Request) (any, error) { return nil, nil })
+		p.send(t, map[string]any{"jsonrpc": "2.0", "id": "abc", "method": "m"})
+		m := p.recv(t)
+		if m["id"] != "abc" {
+			t.Fatalf("response = %v", m)
+		}
+		if v, ok := m["result"]; !ok || v != nil {
+			t.Errorf("result = %v (present %v), want null", v, ok)
+		}
+	})
+
+	t.Run("maps a coded error to code, message and data", func(t *testing.T) {
+		p := newPeer(t, func(*Request) (any, error) { return nil, coded{-32602, "Invalid params: x", map[string]any{"k": 1}} })
+		p.send(t, map[string]any{"jsonrpc": "2.0", "id": 1, "method": "m"})
+		e, _ := p.recv(t)["error"].(map[string]any)
+		if e["code"] != float64(-32602) || e["message"] != "Invalid params: x" {
+			t.Fatalf("error = %v", e)
+		}
+		if d, _ := e["data"].(map[string]any); d["k"] != float64(1) {
+			t.Errorf("data = %v", e["data"])
+		}
+	})
+
+	t.Run("maps any other error to Internal error with the details", func(t *testing.T) {
+		p := newPeer(t, func(*Request) (any, error) { return nil, errors.New("boom") })
+		p.send(t, map[string]any{"jsonrpc": "2.0", "id": 1, "method": "m"})
+		e, _ := p.recv(t)["error"].(map[string]any)
+		if e["code"] != float64(-32603) || e["message"] != "Internal error" {
+			t.Fatalf("error = %v", e)
+		}
+		if d, _ := e["data"].(map[string]any); d["details"] != "boom" {
+			t.Errorf("data = %v", e["data"])
+		}
+	})
+
+	t.Run("skips a line that is not JSON and keeps serving", func(t *testing.T) {
+		p := newPeer(t, func(*Request) (any, error) { return "ok", nil })
+		p.send(t, "this is not json")
+		p.send(t, map[string]any{"jsonrpc": "2.0", "id": 2, "method": "m"})
+		if m := p.recv(t); m["id"] != float64(2) || m["result"] != "ok" {
+			t.Fatalf("response = %v", m)
+		}
+	})
+
+	t.Run("does not answer a notification", func(t *testing.T) {
+		got := make(chan string, 1)
+		p := newPeer(t, func(r *Request) (any, error) {
+			if r.Method == "session/cancel" {
+				if !r.Notification {
+					t.Error("Notification flag not set")
+				}
+				got <- r.Method
+			}
+			return "ignored", nil
+		})
+		p.send(t, map[string]any{"jsonrpc": "2.0", "method": "session/cancel", "params": map[string]any{"sessionId": "s"}})
+		if m := <-got; m != "session/cancel" {
+			t.Fatalf("method = %q", m)
+		}
+		p.send(t, map[string]any{"jsonrpc": "2.0", "id": 1, "method": "after"})
+		if m := p.recv(t); m["id"] != float64(1) {
+			t.Fatalf("the first output was %v, not the answer to the request", m)
+		}
+	})
+
+	t.Run("a slow request does not block a later one", func(t *testing.T) {
+		release := make(chan struct{})
+		p := newPeer(t, func(r *Request) (any, error) {
+			if r.Method == "slow" {
+				<-release
+			}
+			return r.Method, nil
+		})
+		p.send(t, map[string]any{"jsonrpc": "2.0", "id": 1, "method": "slow"})
+		p.send(t, map[string]any{"jsonrpc": "2.0", "id": 2, "method": "fast"})
+		if m := p.recv(t); m["id"] != float64(2) {
+			t.Fatalf("first response = %v", m)
+		}
+		close(release)
+		if m := p.recv(t); m["id"] != float64(1) {
+			t.Fatalf("second response = %v", m)
+		}
+	})
+
+	t.Run("delivers the request params untouched", func(t *testing.T) {
+		got := make(chan string, 1)
+		p := newPeer(t, func(r *Request) (any, error) { got <- string(r.Params); return nil, nil })
+		p.send(t, `{"jsonrpc":"2.0","id":1,"method":"m","params":{"a":[1,2,{"b":null}]}}`)
+		if s := <-got; s != `{"a":[1,2,{"b":null}]}` {
+			t.Errorf("params = %s", s)
+		}
+	})
+
+	t.Run("correlates an outgoing request with its response", func(t *testing.T) {
+		p := newPeer(t, func(*Request) (any, error) { return nil, nil })
+		type res struct {
+			Outcome string `json:"outcome"`
+		}
+		done := make(chan error, 1)
+		var out res
+		go func() { done <- p.conn.Call("session/request_permission", map[string]any{"sessionId": "s"}, &out) }()
+		req := p.recv(t)
+		if req["method"] != "session/request_permission" || req["jsonrpc"] != "2.0" {
+			t.Fatalf("request = %v", req)
+		}
+		p.send(t, map[string]any{"jsonrpc": "2.0", "id": req["id"], "result": map[string]any{"outcome": "selected"}})
+		if err := <-done; err != nil || out.Outcome != "selected" {
+			t.Fatalf("err=%v out=%+v", err, out)
+		}
+	})
+
+	t.Run("an error response to an outgoing request is returned as *Error", func(t *testing.T) {
+		p := newPeer(t, func(*Request) (any, error) { return nil, nil })
+		done := make(chan error, 1)
+		go func() { done <- p.conn.Call("x", nil, nil) }()
+		req := p.recv(t)
+		p.send(t, map[string]any{"jsonrpc": "2.0", "id": req["id"], "error": map[string]any{"code": -32601, "message": "nope"}})
+		var e *Error
+		if err := <-done; !errors.As(err, &e) || e.Code != -32601 || e.Message != "nope" {
+			t.Fatalf("err = %v", err)
+		}
+	})
+
+	t.Run("closing the input fails pending requests and closes Done", func(t *testing.T) {
+		p := newPeer(t, func(*Request) (any, error) { return nil, nil })
+		done := make(chan error, 1)
+		go func() { done <- p.conn.Call("x", nil, nil) }()
+		p.recv(t)
+		p.toConn.Close()
+		select {
+		case err := <-done:
+			if err == nil {
+				t.Error("pending request succeeded")
+			}
+		case <-time.After(5 * time.Second):
+			t.Fatal("pending request never failed")
+		}
+		select {
+		case <-p.conn.Done():
+		case <-time.After(5 * time.Second):
+			t.Fatal("Done never closed")
+		}
+	})
+
+	t.Run("serializes concurrent writes into whole lines", func(t *testing.T) {
+		p := newPeer(t, func(*Request) (any, error) { return nil, nil })
+		var wg sync.WaitGroup
+		for i := 0; i < 200; i++ {
+			wg.Add(1)
+			go func(i int) {
+				defer wg.Done()
+				_ = p.conn.Notify("session/update", map[string]any{"sessionId": "s", "n": i, "pad": strings.Repeat("x", 4096)})
+			}(i)
+		}
+		seen := map[float64]bool{}
+		for i := 0; i < 200; i++ {
+			m := p.recv(t)
+			seen[m["params"].(map[string]any)["n"].(float64)] = true
+		}
+		wg.Wait()
+		if len(seen) != 200 {
+			t.Errorf("saw %d distinct notifications", len(seen))
+		}
+	})
+
+	t.Run("accepts a very large message", func(t *testing.T) {
+		got := make(chan int, 1)
+		p := newPeer(t, func(r *Request) (any, error) { got <- len(r.Params); return nil, nil })
+		big := strings.Repeat("y", 8<<20)
+		p.send(t, fmt.Sprintf(`{"jsonrpc":"2.0","id":1,"method":"m","params":{"blob":%q}}`, big))
+		if n := <-got; n < 8<<20 {
+			t.Errorf("params length %d", n)
+		}
+	})
+
+	t.Run("runs AfterResponse hooks after the response was written", func(t *testing.T) {
+		order := make(chan string, 2)
+		p := newPeer(t, func(r *Request) (any, error) {
+			r.AfterResponse(func() { order <- "hook" })
+			return "done", nil
+		})
+		p.send(t, map[string]any{"jsonrpc": "2.0", "id": 1, "method": "m"})
+		select {
+		case <-order:
+			// The hook may only run once the response is on the wire; reading it now proves it was written.
+		case <-time.After(5 * time.Second):
+			t.Fatal("hook never ran")
+		}
+		if m := p.recv(t); m["result"] != "done" {
+			t.Fatalf("response = %v", m)
+		}
+	})
+}
+
+// failingWriter is a stdout that was destroyed (test/unit/stdout-destroyed-does-not-crash.test.ts).
+type failingWriter struct{}
+
+func (failingWriter) Write([]byte) (int, error) { return 0, io.ErrClosedPipe }
+
+func TestDestroyedOutput(t *testing.T) {
+	tw(t, "unit/stdout-destroyed-does-not-crash", "stdout writer: resolves even if stdout is destroyed", func(t *testing.T) {
+		in, _ := io.Pipe()
+		c := New(in, failingWriter{}, func(*Request) (any, error) { return nil, nil })
+		done := make(chan struct{})
+		go func() {
+			_ = c.Notify("session/update", map[string]any{"sessionId": "s"})
+			close(done)
+		}()
+		select {
+		case <-done:
+		case <-time.After(5 * time.Second):
+			t.Fatal("Notify blocked on a destroyed output")
+		}
+		select {
+		case <-c.Done():
+		case <-time.After(5 * time.Second):
+			t.Fatal("a failed write did not end the connection")
+		}
+	})
+}

package/extensions/acp/cmd/pig-acp/internal/jsonrpc/twin_test.go

@@ -0,0 +1,28 @@
+package jsonrpc
+
+// Twin helpers for a port whose original has tests. Every upstream test case gets one
+// tw(...) call carrying the upstream title unchanged, or one tskip(...) with the reason it
+// cannot be ported. `pigeq twins check` reads these calls and fails on a missing title, an
+// unknown one (a misspelling) or one reason shared by many skips.
+//
+//	pigeq twins list --tests <upstream>/test > port/upstream-tests.json
+//	pigeq twins check --ledger port/upstream-tests.json --go extensions/<name> [--files a,b]
+//
+// Copy this file into the port as twin_test.go and replace jsonrpc with the package name (in
+// an external test package use `jsonrpc_test`). A parametrized upstream title (it contains
+// `${`) is twinned once, with the template text unchanged.
+
+import "testing"
+
+// tw runs one exact twin: file is the upstream test file (its name without .test.mjs), title
+// the upstream test title, unchanged.
+func tw(t *testing.T, file, title string, fn func(t *testing.T)) {
+	t.Helper()
+	t.Run(title, fn)
+}
+
+// tskip records a named gap: the upstream case has no Go twin, with its own reason.
+func tskip(t *testing.T, file, title, reason string) {
+	t.Helper()
+	t.Run(title, func(t *testing.T) { t.Skip(reason) })
+}

package/extensions/acp/cmd/pig-acp/internal/pirpc/kill_unix.go

@@ -0,0 +1,19 @@
+//go:build !windows
+
+package pirpc
+
+import (
+	"os/exec"
+	"syscall"
+	"time"
+)
+
+// terminate asks the child to stop (SIGTERM, like the original) and kills it if it lingers.
+func terminate(cmd *exec.Cmd) {
+	if cmd.Process == nil {
+		return
+	}
+	_ = cmd.Process.Signal(syscall.SIGTERM)
+	proc := cmd.Process
+	time.AfterFunc(5*time.Second, func() { _ = proc.Kill() })
+}

package/extensions/acp/cmd/pig-acp/internal/pirpc/kill_windows.go

@@ -0,0 +1,11 @@
+//go:build windows
+
+package pirpc
+
+import "os/exec"
+
+func terminate(cmd *exec.Cmd) {
+	if cmd.Process != nil {
+		_ = cmd.Process.Kill()
+	}
+}