Files
coder/coderd/x/chatd/mcpclient/coder_headers_test.go
T
Ethan 016df8cbab feat(coderd/x/chatd/mcpclient): add hardened connect path for inline MCP servers (#29518)
Third PR in the inline MCP servers stack, on top of
https://github.com/coder/coder/pull/29517. This adds the `mcpclient`
side that chatd will use to talk to servers a chat owner declared by
value on the chat. Nothing in chatd calls the new functions yet.

`mcpclient` now owns its input type. `ConnectAll` and the new
`ConnectInline` both take `[]mcpclient.Server`, and `ServerFromConfig`
converts an org-configured row at the boundary, so a caller never has to
fake a `database.MCPServerConfig` for a server that has no row. The org
path behaves as before with two exceptions: `connectAllWithHooks` no
longer skips disabled servers (the call site in `generation_preparer.go`
filters them), and a `custom_headers` row with malformed JSON or an
unknown auth type used to connect without those headers, whereas now
conversion fails and the caller skips the server with a warning.

Org-configured servers were set up by an admin, so we don't put many
limits on them. Inline ones are supplied by whoever created the chat, so
`ConnectInline` treats the server as untrusted. HTTP response bodies are
capped at 1 MiB, a server can expose at most 64 tools with each
definition under 64 KiB and 256 KiB in total, and tool results are
capped at 256 KiB. If a server blows the tool caps we skip the whole
server rather than hand the model a partial tool set, and an oversized
result comes back to the model as a tool error rather than being
truncated silently. Everything the server sends that we log or hand to
the model (tool names, descriptions, schemas, results, connect errors)
has the values in `Server.SensitiveValues` replaced with `[REDACTED]`;
chatd sets that to the URL and header values. Header names aren't
redacted, as they're public and short enough that redacting them would
rewrite ordinary text. For the same reason the redactor ignores anything
shorter than `MinSensitiveValueBytes` (8), and #29546 rejects header
values that short at the API. The slug is caller-supplied too, so it
also goes through the redactor wherever it lands in a tool name, connect
summary or log field.

`AppendInline` merges the resulting tools into an existing tool list
with the existing names winning, so an inline server can't shadow a
builtin or org-configured tool. Collisions are logged once per server
with the `config_id`.

Lastly, every `tools/call` (for both kinds of server) now carries the
model's tool call ID in `_meta` under `com.coder/tool_call_id`. It's a
correlation ID that's stable across chatd retries of the same call, so a
server can use it to dedupe if it wants to. We make no other idempotency
promise.


Part of CODAGT-1131
2026-09-25 18:51:54 +10:00

502 lines
15 KiB
Go

package mcpclient_test
import (
"context"
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"sync"
"testing"
"time"
"charm.land/fantasy"
"github.com/google/uuid"
"github.com/modelcontextprotocol/go-sdk/mcp"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/xerrors"
"cdr.dev/slog/v3/sloggers/slogtest"
"github.com/coder/coder/v2/coderd/database"
"github.com/coder/coder/v2/coderd/x/chatd/chatprovider"
"github.com/coder/coder/v2/coderd/x/chatd/mcpclient"
)
// newHeaderRecordingServer creates a streamable HTTP MCP server with a
// single "ping" tool. Every request's headers are appended to the
// returned slice so tests can assert which headers were forwarded.
func newHeaderRecordingServer(t *testing.T) (*httptest.Server, *sync.Mutex, *[]http.Header) {
t.Helper()
var (
mu sync.Mutex
headers []http.Header
)
ts := newTestMCPServer(t, testTool{
tool: &mcp.Tool{
Name: "ping",
Description: "records the request headers",
InputSchema: map[string]any{"type": "object"},
},
handler: func(_ context.Context, req *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
mu.Lock()
headers = append(headers, req.Extra.Header.Clone())
mu.Unlock()
return textToolResult("ok"), nil
},
})
return ts, &mu, &headers
}
type recordedMCPRequest struct {
method string
rpcMethod string
err error
}
func newSigningTestMCPServer(t *testing.T, signingSecret string) (*httptest.Server, <-chan recordedMCPRequest) {
t.Helper()
srv := mcp.NewServer(&mcp.Implementation{Name: "signed", Version: "1.0.0"}, nil)
tool := makeTool("ping")
srv.AddTool(tool.tool, tool.handler)
mcpHandler := mcp.NewStreamableHTTPHandler(func(*http.Request) *mcp.Server { return srv }, nil)
recorded := make(chan recordedMCPRequest, 16)
handler := http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
body, err := io.ReadAll(r.Body)
if err == nil {
err = verifyMCPRequestSignature(r, body, signingSecret)
}
var rpcRequest struct {
ID json.RawMessage `json:"id"`
Method string `json:"method"`
}
if r.Method == http.MethodPost {
if decodeErr := json.Unmarshal(body, &rpcRequest); err == nil && decodeErr != nil {
err = decodeErr
}
}
recorded <- recordedMCPRequest{method: r.Method, rpcMethod: rpcRequest.Method, err: err}
if err != nil {
http.Error(rw, err.Error(), http.StatusUnauthorized)
return
}
r.Body = io.NopCloser(strings.NewReader(string(body)))
mcpHandler.ServeHTTP(rw, r)
})
server := httptest.NewServer(handler)
t.Cleanup(server.Close)
return server, recorded
}
func verifyMCPRequestSignature(r *http.Request, body []byte, signingSecret string) error {
timestamp := r.Header.Get(mcpclient.HeaderCoderSignatureTimestamp)
signature := r.Header.Get(mcpclient.HeaderCoderSignature)
if signingSecret == "" {
if timestamp != "" || signature != "" {
return xerrors.New("unexpected MCP signature headers")
}
return nil
}
if timestamp == "" || signature == "" {
return xerrors.New("missing MCP signature headers")
}
unixSeconds, err := strconv.ParseInt(timestamp, 10, 64)
if err != nil {
return xerrors.Errorf("parse MCP signature timestamp: %w", err)
}
if time.Since(time.Unix(unixSeconds, 0)).Abs() > 5*time.Minute {
return xerrors.New("MCP signature timestamp is outside the allowed window")
}
bodyHash := sha256.Sum256(body)
canonical := strings.Join([]string{
"v1",
timestamp,
strings.ToUpper(r.Method),
r.URL.RequestURI(),
hex.EncodeToString(bodyHash[:]),
"owner=" + r.Header.Get(chatprovider.HeaderCoderOwnerID),
"chat=" + r.Header.Get(chatprovider.HeaderCoderChatID),
"subchat=" + r.Header.Get(chatprovider.HeaderCoderSubchatID),
"workspace=" + r.Header.Get(chatprovider.HeaderCoderWorkspaceID),
}, "\n")
mac := hmac.New(sha256.New, []byte(signingSecret))
_, _ = mac.Write([]byte(canonical))
expected := "v1=" + hex.EncodeToString(mac.Sum(nil))
if !hmac.Equal([]byte(expected), []byte(signature)) {
return xerrors.New("invalid MCP request signature")
}
return nil
}
func TestConnectAll_RequestSigning(t *testing.T) {
t.Parallel()
const signingSecret = "0123456789abcdef0123456789abcdef"
tests := []struct {
name string
forwardHeaders bool
signingSecret string
expectedSigningSecret string
}{
{name: "enabled", forwardHeaders: true, signingSecret: signingSecret, expectedSigningSecret: signingSecret},
{name: "forwarding disabled", forwardHeaders: false, signingSecret: signingSecret},
{name: "secret empty", forwardHeaders: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
ctx := t.Context()
logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: true})
server, recorded := newSigningTestMCPServer(t, tt.expectedSigningSecret)
cfg := makeConfig("signed", server.URL+"/api/mcp?x=1")
cfg.ForwardCoderHeaders = tt.forwardHeaders
cfg.SigningSecret = tt.signingSecret
coderHeaders := chatprovider.CoderHeaders(database.Chat{
ID: uuid.New(),
OwnerID: uuid.New(),
})
tools, _, cleanup := mcpclient.ConnectAll(
ctx, logger, []mcpclient.Server{cfg}, nil, uuid.Nil, nil,
coderHeaders, testMCPHTTPClient(nil),
)
t.Cleanup(cleanup)
require.Len(t, tools, 1)
_, err := tools[0].Run(ctx, fantasy.ToolCall{
ID: "call-1", Name: "signed__ping", Input: "{}",
})
require.NoError(t, err)
expected := map[string]bool{
"server/discover": false,
"initialize": false,
"notifications/initialized": false,
"GET": false,
"tools/list": false,
"tools/call": false,
}
deadline := time.NewTimer(5 * time.Second)
defer deadline.Stop()
for {
complete := true
for _, seen := range expected {
complete = complete && seen
}
if complete {
break
}
select {
case request := <-recorded:
require.NoError(t, request.err)
key := request.rpcMethod
if request.method == http.MethodGet {
key = http.MethodGet
}
_, ok := expected[key]
require.Truef(t, ok, "unexpected MCP request %q", key)
expected[key] = true
case <-deadline.C:
require.FailNow(t, "timed out waiting for MCP requests", "%v", expected)
}
}
})
}
}
// TestConnectAll_ForwardCoderHeaders_DefaultOff is a regression guard
// that the Coder identity headers are NOT sent when the option is
// left at its default (false).
func TestConnectAll_ForwardCoderHeaders_DefaultOff(t *testing.T) {
t.Parallel()
ctx := t.Context()
logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: true})
ts, mu, recorded := newHeaderRecordingServer(t)
cfg := makeConfig("no-hdr", ts.URL)
assert.False(t, cfg.ForwardCoderHeaders, "default must be false")
coderHeaders := map[string]string{
chatprovider.HeaderCoderOwnerID: uuid.NewString(),
chatprovider.HeaderCoderChatID: uuid.NewString(),
chatprovider.HeaderCoderWorkspaceID: uuid.NewString(),
}
tools, _, cleanup := mcpclient.ConnectAll(
ctx, logger, []mcpclient.Server{cfg}, nil, uuid.Nil, nil,
coderHeaders, testMCPHTTPClient(nil),
)
t.Cleanup(cleanup)
require.Len(t, tools, 1)
_, err := tools[0].Run(ctx, fantasy.ToolCall{
ID: "call-1", Name: "no-hdr__ping", Input: "{}",
})
require.NoError(t, err)
mu.Lock()
defer mu.Unlock()
require.NotEmpty(t, *recorded)
for _, h := range *recorded {
assert.Empty(t, h.Get(chatprovider.HeaderCoderOwnerID))
assert.Empty(t, h.Get(chatprovider.HeaderCoderChatID))
assert.Empty(t, h.Get(chatprovider.HeaderCoderSubchatID))
assert.Empty(t, h.Get(chatprovider.HeaderCoderWorkspaceID))
}
}
// TestConnectAll_ForwardCoderHeaders_Enabled verifies that when the
// option is enabled, the Coder identity headers are forwarded on every
// outgoing MCP request, including the subchat and workspace headers.
func TestConnectAll_ForwardCoderHeaders_Enabled(t *testing.T) {
t.Parallel()
ctx := t.Context()
logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: true})
ts, mu, recorded := newHeaderRecordingServer(t)
ownerID := uuid.New()
chatID := uuid.New()
workspaceID := uuid.New()
subchatID := uuid.New()
cfg := makeConfig("hdr", ts.URL)
cfg.ForwardCoderHeaders = true
// Subchat headers: parent's chat ID lives in X-Coder-Chat-Id, the
// subchat's own ID lives in X-Coder-Subchat-Id.
coderHeaders := chatprovider.CoderHeaders(database.Chat{
ID: subchatID,
OwnerID: ownerID,
ParentChatID: uuid.NullUUID{UUID: chatID, Valid: true},
WorkspaceID: uuid.NullUUID{UUID: workspaceID, Valid: true},
})
tools, _, cleanup := mcpclient.ConnectAll(
ctx, logger, []mcpclient.Server{cfg}, nil, uuid.Nil, nil,
coderHeaders, testMCPHTTPClient(nil),
)
t.Cleanup(cleanup)
require.Len(t, tools, 1)
_, err := tools[0].Run(ctx, fantasy.ToolCall{
ID: "call-1", Name: "hdr__ping", Input: "{}",
})
require.NoError(t, err)
mu.Lock()
defer mu.Unlock()
require.NotEmpty(t, *recorded)
last := (*recorded)[len(*recorded)-1]
assert.Equal(t, ownerID.String(), last.Get(chatprovider.HeaderCoderOwnerID))
assert.Equal(t, chatID.String(), last.Get(chatprovider.HeaderCoderChatID))
assert.Equal(t, subchatID.String(), last.Get(chatprovider.HeaderCoderSubchatID))
assert.Equal(t, workspaceID.String(), last.Get(chatprovider.HeaderCoderWorkspaceID))
}
// TestConnectAll_ForwardCoderHeaders_RootChat verifies that for a root
// chat (no parent), the chat's own ID is forwarded as
// X-Coder-Chat-Id and the X-Coder-Subchat-Id header is absent.
func TestConnectAll_ForwardCoderHeaders_RootChat(t *testing.T) {
t.Parallel()
ctx := t.Context()
logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: true})
ts, mu, recorded := newHeaderRecordingServer(t)
ownerID := uuid.New()
chatID := uuid.New()
cfg := makeConfig("hdr-root", ts.URL)
cfg.ForwardCoderHeaders = true
coderHeaders := chatprovider.CoderHeaders(database.Chat{
ID: chatID,
OwnerID: ownerID,
})
tools, _, cleanup := mcpclient.ConnectAll(
ctx, logger, []mcpclient.Server{cfg}, nil, uuid.Nil, nil,
coderHeaders, testMCPHTTPClient(nil),
)
t.Cleanup(cleanup)
require.Len(t, tools, 1)
_, err := tools[0].Run(ctx, fantasy.ToolCall{
ID: "call-1", Name: "hdr-root__ping", Input: "{}",
})
require.NoError(t, err)
mu.Lock()
defer mu.Unlock()
require.NotEmpty(t, *recorded)
last := (*recorded)[len(*recorded)-1]
assert.Equal(t, ownerID.String(), last.Get(chatprovider.HeaderCoderOwnerID))
assert.Equal(t, chatID.String(), last.Get(chatprovider.HeaderCoderChatID))
assert.Empty(t, last.Get(chatprovider.HeaderCoderSubchatID))
assert.Empty(t, last.Get(chatprovider.HeaderCoderWorkspaceID))
}
// TestConnectAll_ForwardCoderHeaders_WithAPIKeyAuth verifies that the
// api_key auth header is preserved when Coder identity headers are
// forwarded alongside.
func TestConnectAll_ForwardCoderHeaders_WithAPIKeyAuth(t *testing.T) {
t.Parallel()
ctx := t.Context()
logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: true})
ts, mu, recorded := newHeaderRecordingServer(t)
ownerID := uuid.New()
chatID := uuid.New()
cfg := makeConfig("hdr-apikey", ts.URL)
cfg.Headers = map[string]string{"X-Api-Key": "sekret"}
cfg.ForwardCoderHeaders = true
coderHeaders := chatprovider.CoderHeaders(database.Chat{
ID: chatID,
OwnerID: ownerID,
})
tools, _, cleanup := mcpclient.ConnectAll(
ctx, logger, []mcpclient.Server{cfg}, nil, uuid.Nil, nil,
coderHeaders, testMCPHTTPClient(nil),
)
t.Cleanup(cleanup)
require.Len(t, tools, 1)
_, err := tools[0].Run(ctx, fantasy.ToolCall{
ID: "call-1", Name: "hdr-apikey__ping", Input: "{}",
})
require.NoError(t, err)
mu.Lock()
defer mu.Unlock()
require.NotEmpty(t, *recorded)
last := (*recorded)[len(*recorded)-1]
assert.Equal(t, "sekret", last.Get("X-Api-Key"))
assert.Equal(t, ownerID.String(), last.Get(chatprovider.HeaderCoderOwnerID))
assert.Equal(t, chatID.String(), last.Get(chatprovider.HeaderCoderChatID))
}
// TestConnectAll_ForwardCoderHeaders_WithOAuth2 verifies that the
// oauth2 Authorization header is preserved when Coder identity
// headers are forwarded alongside, and that auth wins on a conflict.
func TestConnectAll_ForwardCoderHeaders_WithOAuth2(t *testing.T) {
t.Parallel()
ctx := t.Context()
logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: true})
ts, mu, recorded := newHeaderRecordingServer(t)
cfgID := uuid.New()
cfg := makeConfig("hdr-oauth", ts.URL)
cfg.ID = cfgID
cfg.UserAuth = mcpclient.UserAuthOAuth2
cfg.ForwardCoderHeaders = true
token := database.MCPServerUserToken{
MCPServerConfigID: cfgID,
AccessToken: "oauth-token-xyz",
TokenType: "Bearer",
}
// Intentionally include an Authorization key to verify the auth
// header wins on conflict.
ownerID := uuid.NewString()
coderHeaders := map[string]string{
"Authorization": "Bearer should-be-overridden",
chatprovider.HeaderCoderOwnerID: ownerID,
}
tools, _, cleanup := mcpclient.ConnectAll(
ctx, logger,
[]mcpclient.Server{cfg},
[]database.MCPServerUserToken{token},
uuid.Nil, nil,
coderHeaders, testMCPHTTPClient(nil),
)
t.Cleanup(cleanup)
require.Len(t, tools, 1)
_, err := tools[0].Run(ctx, fantasy.ToolCall{
ID: "call-1", Name: "hdr-oauth__ping", Input: "{}",
})
require.NoError(t, err)
mu.Lock()
defer mu.Unlock()
require.NotEmpty(t, *recorded)
last := (*recorded)[len(*recorded)-1]
assert.Equal(t, "Bearer oauth-token-xyz", last.Get("Authorization"))
assert.Equal(t, ownerID, last.Get(chatprovider.HeaderCoderOwnerID))
}
// TestConnectAll_ForwardCoderHeaders_WithCustomHeaders verifies that
// custom_headers admin-configured values are preserved when Coder
// identity headers are forwarded alongside, including the case where
// the admin configures a custom header whose name only differs from a
// Coder identity header by case. Conflict detection is case-
// insensitive because http.Header.Set canonicalizes header names.
func TestConnectAll_ForwardCoderHeaders_WithCustomHeaders(t *testing.T) {
t.Parallel()
ctx := t.Context()
logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: true})
ts, mu, recorded := newHeaderRecordingServer(t)
ownerID := uuid.New()
chatID := uuid.New()
cfg := makeConfig("hdr-custom", ts.URL)
// Include both an unrelated custom header AND a case-variant of
// X-Coder-Owner-Id to exercise the case-insensitive conflict
// check. The admin-configured value MUST win.
cfg.Headers = map[string]string{
"X-Tenant": "acme",
"x-coder-owner-id": "admin-controlled",
}
cfg.ForwardCoderHeaders = true
coderHeaders := chatprovider.CoderHeaders(database.Chat{
ID: chatID,
OwnerID: ownerID,
})
tools, _, cleanup := mcpclient.ConnectAll(
ctx, logger, []mcpclient.Server{cfg}, nil, uuid.Nil, nil,
coderHeaders, testMCPHTTPClient(nil),
)
t.Cleanup(cleanup)
require.Len(t, tools, 1)
_, err := tools[0].Run(ctx, fantasy.ToolCall{
ID: "call-1", Name: "hdr-custom__ping", Input: "{}",
})
require.NoError(t, err)
mu.Lock()
defer mu.Unlock()
require.NotEmpty(t, *recorded)
last := (*recorded)[len(*recorded)-1]
assert.Equal(t, "acme", last.Get("X-Tenant"))
// The admin's case-variant header must win, because HTTP header
// names are case-insensitive at the transport level.
assert.Equal(t, "admin-controlled", last.Get(chatprovider.HeaderCoderOwnerID))
assert.Equal(t, chatID.String(), last.Get(chatprovider.HeaderCoderChatID))
}