Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
46 changes: 23 additions & 23 deletions cmd/restish-mcp/mcp_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -693,37 +693,37 @@ func TestServeStdioInvalidRequests(t *testing.T) {
}
}

func TestReadFrameHeaderLimits(t *testing.T) {
func TestReadFrameLineLimits(t *testing.T) {
t.Run("oversized line", func(t *testing.T) {
input := strings.Repeat("X", maxRPCHeaderLineBytes+1) + "\r\n\r\n"
input := strings.Repeat("X", maxRPCPayloadBytes+1) + "\n"
_, err := readFrame(bufio.NewReader(strings.NewReader(input)))
if err == nil || !strings.Contains(err.Error(), "header line exceeds") {
t.Fatalf("err = %v, want header line limit", err)
if err == nil || !strings.Contains(err.Error(), "message exceeds") {
t.Fatalf("err = %v, want message size limit", err)
}
})

t.Run("oversized preamble", func(t *testing.T) {
var input strings.Builder
for input.Len() <= maxRPCHeaderBytes {
input.WriteString("X-Test: ")
input.WriteString(strings.Repeat("a", 512))
input.WriteString("\r\n")
t.Run("payload accepted within line limits", func(t *testing.T) {
got, err := readFrame(bufio.NewReader(strings.NewReader("{}\n")))
if err != nil {
t.Fatalf("readFrame: %v", err)
}
if string(got) != "{}" {
t.Fatalf("payload = %q", got)
}
})

t.Run("blank lines are skipped", func(t *testing.T) {
got, err := readFrame(bufio.NewReader(strings.NewReader("\n\n{}\n")))
if err != nil {
t.Fatalf("readFrame: %v", err)
}
input.WriteString("\r\n")
_, err := readFrame(bufio.NewReader(strings.NewReader(input.String())))
if err == nil || !strings.Contains(err.Error(), "headers exceed") {
t.Fatalf("err = %v, want total header limit", err)
if string(got) != "{}" {
t.Fatalf("payload = %q", got)
}
})

t.Run("payload accepted within header limits", func(t *testing.T) {
payload := []byte("{}")
var input bytes.Buffer
input.WriteString("Content-Length: 2\r\n")
input.WriteString(strings.Repeat("X-Test: a\r\n", 10))
input.WriteString("\r\n")
input.Write(payload)
got, err := readFrame(bufio.NewReader(&input))
t.Run("trailing message without newline", func(t *testing.T) {
got, err := readFrame(bufio.NewReader(strings.NewReader("{}")))
if err != nil {
t.Fatalf("readFrame: %v", err)
}
Expand All @@ -734,7 +734,7 @@ func TestReadFrameHeaderLimits(t *testing.T) {
}

func TestServeStdioWritesFramingError(t *testing.T) {
input := strings.Repeat("X", maxRPCHeaderLineBytes+1) + "\r\n\r\n"
input := strings.Repeat("X", maxRPCPayloadBytes+1) + "\n"
var stdout bytes.Buffer
err := (&Server{}).ServeStdio(strings.NewReader(input), &stdout)
if err == nil {
Expand Down
88 changes: 30 additions & 58 deletions cmd/restish-mcp/server.go
Original file line number Diff line number Diff line change
Expand Up @@ -7,16 +7,13 @@ import (
"errors"
"fmt"
"io"
"strconv"
"strings"
"unicode/utf8"
)

// maxRPCPayloadBytes caps the Content-Length accepted from an MCP client to
// prevent memory exhaustion. Matches the CBOR plugin protocol limit.
// maxRPCPayloadBytes caps the size of a single NDJSON message accepted from
// an MCP client to prevent memory exhaustion. Matches the CBOR plugin
// protocol limit.
const maxRPCPayloadBytes = 64 << 20 // 64 MiB
const maxRPCHeaderLineBytes = 8 << 10
const maxRPCHeaderBytes = 16 << 10

type Server struct {
Tools []*Tool
Expand Down Expand Up @@ -269,62 +266,37 @@ func marshalPretty(v any) string {
return fmt.Sprint(v)
}

// readFrame reads one newline-delimited JSON-RPC message from the MCP stdio
// transport (spec revision 2025-06-18 and later: messages are single-line
// JSON objects separated by '\n'). Blank lines are skipped.
func readFrame(r *bufio.Reader) ([]byte, error) {
length := -1
totalHeaderBytes := 0
for {
line, n, err := readHeaderLine(r)
if err != nil {
if errors.Is(err, io.EOF) && line == "" {
return nil, io.EOF
var line []byte
for {
frag, err := r.ReadSlice('\n')
line = append(line, frag...)
if len(line) > maxRPCPayloadBytes {
return nil, fmt.Errorf("MCP message exceeds %d bytes", maxRPCPayloadBytes)
}
return nil, err
}
totalHeaderBytes += n
if totalHeaderBytes > maxRPCHeaderBytes {
return nil, fmt.Errorf("MCP frame headers exceed %d bytes", maxRPCHeaderBytes)
}
line = strings.TrimRight(line, "\r\n")
if line == "" {
break
}
if strings.HasPrefix(strings.ToLower(line), "content-length:") {
value := strings.TrimSpace(line[len("content-length:"):])
n, err := strconv.Atoi(value)
if err != nil {
return nil, fmt.Errorf("invalid content-length %q", value)
if err == nil {
break
}
if n < 0 || n > maxRPCPayloadBytes {
return nil, fmt.Errorf("content-length %d out of range (max %d)", n, maxRPCPayloadBytes)
if errors.Is(err, bufio.ErrBufferFull) {
continue
}
length = n
}
}
if length < 0 {
return nil, errors.New("missing Content-Length header")
}
payload := make([]byte, length)
if _, err := io.ReadFull(r, payload); err != nil {
return nil, err
}
return payload, nil
}

func readHeaderLine(r *bufio.Reader) (string, int, error) {
var line []byte
for {
frag, err := r.ReadSlice('\n')
line = append(line, frag...)
if len(line) > maxRPCHeaderLineBytes {
return string(line), len(line), fmt.Errorf("MCP frame header line exceeds %d bytes", maxRPCHeaderLineBytes)
}
if err == nil {
return string(line), len(line), nil
if errors.Is(err, io.EOF) {
if len(bytes.TrimSpace(line)) == 0 {
return nil, io.EOF
}
break
}
return nil, err
}
if errors.Is(err, bufio.ErrBufferFull) {
line = bytes.TrimSpace(line)
if len(line) == 0 {
continue
}
return string(line), len(line), err
return line, nil
}
}

Expand All @@ -337,9 +309,9 @@ func writeRPC(w io.Writer, resp rpcResponse) error {
}

func writeFrame(w io.Writer, payload []byte) error {
var buf bytes.Buffer
fmt.Fprintf(&buf, "Content-Length: %d\r\n\r\n", len(payload))
buf.Write(payload)
_, err := w.Write(buf.Bytes())
buf := make([]byte, 0, len(payload)+1)
buf = append(buf, payload...)
buf = append(buf, '\n')
_, err := w.Write(buf)
return err
}
5 changes: 5 additions & 0 deletions internal/cli/command_plugin_handlers.go
Original file line number Diff line number Diff line change
Expand Up @@ -103,6 +103,11 @@ func (c *CLI) handleCommandPluginMessage(cmd *cobra.Command, requestCtx context.
}
if len(msg.Data) > 0 {
_, _ = c.Stdout.Write(msg.Data)
// Passthrough stdio commands (e.g. `restish mcp serve`) need each
// chunk flushed immediately: when stdout is not a terminal the CLI
// wraps it in a buffered writer that otherwise flushes only on
// exit, stalling interactive protocols like MCP.
_ = c.flushStdout()
}
case pluginwire.MsgTypeStderrData:
var msg pluginwire.StderrDataMsg
Expand Down
44 changes: 8 additions & 36 deletions internal/cli/mcp_plugin_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,6 @@ import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"net/http/httptest"
"os"
Expand Down Expand Up @@ -206,55 +205,28 @@ func writeMCPFrame(t *testing.T, buf *bytes.Buffer, msg map[string]any) {
if err != nil {
t.Fatalf("marshal frame: %v", err)
}
fmt.Fprintf(buf, "Content-Length: %d\r\n\r\n", len(data))
buf.Write(data)
buf.WriteByte('\n')
}

func readMCPResponses(t *testing.T, data []byte) []map[string]any {
t.Helper()
var out []map[string]any
reader := bufio.NewReader(bytes.NewReader(data))
for {
payload, err := readMCPFrame(reader)
if err != nil {
line, err := reader.ReadBytes('\n')
if err != nil && len(line) == 0 {
break
}
line = bytes.TrimSpace(line)
if len(line) == 0 {
continue
}
var msg map[string]any
if err := json.Unmarshal(payload, &msg); err != nil {
if err := json.Unmarshal(line, &msg); err != nil {
t.Fatalf("unmarshal MCP response: %v", err)
}
out = append(out, msg)
}
return out
}

func readMCPFrame(r *bufio.Reader) ([]byte, error) {
length := -1
for {
line, err := r.ReadString('\n')
if err != nil {
return nil, err
}
line = strings.TrimRight(line, "\r\n")
if line == "" {
break
}
if strings.HasPrefix(strings.ToLower(line), "content-length:") {
var n int
if _, err := fmt.Sscanf(line, "Content-Length: %d", &n); err != nil {
if _, err := fmt.Sscanf(line, "content-length: %d", &n); err != nil {
return nil, err
}
}
length = n
}
}
if length < 0 {
return nil, fmt.Errorf("missing content-length")
}
payload := make([]byte, length)
if _, err := io.ReadFull(r, payload); err != nil {
return nil, err
}
return payload, nil
}