This follows on from #30027, which added `api.CreateChatAsUser`, and does the same for sending a message to a chat and interrupting it. These aren't new endpoints, they're Go methods for code running inside coderd (say, a Slack bot) that needs to keep a conversation going in a chat it created, without an API key. Nothing calls them yet. We'll move the bodies of `POST /api/v2/chats/{chat}/messages` and `POST /api/v2/chats/{chat}/interrupt` into functions that both the handlers and `api.SendChatMessageAsUser` / `api.InterruptChatAsUser` call. The caller passes a user ID, and the call runs with that user's own roles, so it can't do anything that user couldn't already do over the API. The endpoints' behaviour doesn't change.
300 lines
10 KiB
Go
300 lines
10 KiB
Go
package coderd
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"maps"
|
|
"net/http"
|
|
"net/netip"
|
|
"net/url"
|
|
"regexp"
|
|
"slices"
|
|
"strings"
|
|
|
|
"github.com/google/uuid"
|
|
"golang.org/x/net/http/httpguts"
|
|
"golang.org/x/xerrors"
|
|
|
|
"github.com/coder/coder/v2/coderd/database/db2sdk"
|
|
"github.com/coder/coder/v2/coderd/httpapi/httperror"
|
|
"github.com/coder/coder/v2/codersdk"
|
|
"github.com/coder/safedial"
|
|
)
|
|
|
|
var inlineMCPServerSlugPattern = regexp.MustCompile(fmt.Sprintf(`^[A-Za-z0-9][A-Za-z0-9_-]{0,%d}$`, codersdk.MaxInlineMCPServerSlugBytes-1))
|
|
|
|
func chatCallerSuppliedToolsDisabledError() error {
|
|
return httperror.NewResponseError(http.StatusForbidden, codersdk.Response{
|
|
Message: "Caller-supplied tools are disabled on this deployment.",
|
|
Detail: "The server runs with --disable-chat-caller-supplied-tools. Remove unsafe_dynamic_tools and inline_mcp_servers from the request.",
|
|
})
|
|
}
|
|
|
|
func inlineMCPServersExperimentRequiredError() error {
|
|
return httperror.NewResponseError(http.StatusForbidden, codersdk.Response{
|
|
Message: "Inline MCP servers are not enabled on this deployment.",
|
|
Detail: fmt.Sprintf("Enable the %s experiment.", codersdk.ExperimentChatInlineMCPServers),
|
|
})
|
|
}
|
|
|
|
func inlineMCPServersInvalidError(validations []codersdk.ValidationError) error {
|
|
return httperror.NewResponseError(http.StatusBadRequest, codersdk.Response{
|
|
Message: "Invalid inline_mcp_servers.",
|
|
Validations: validations,
|
|
})
|
|
}
|
|
|
|
// chatInlineMCPServers returns the inline MCP servers declared on a chat,
|
|
// without header values.
|
|
func (api *API) chatInlineMCPServers(ctx context.Context, chatID uuid.UUID) ([]codersdk.InlineMCPServer, error) {
|
|
rows, err := api.Database.GetChatMCPServersByChatID(ctx, chatID)
|
|
if err != nil {
|
|
return nil, xerrors.Errorf("get chat MCP servers: %w", err)
|
|
}
|
|
servers := make([]codersdk.InlineMCPServer, 0, len(rows))
|
|
for _, row := range rows {
|
|
server, err := db2sdk.InlineMCPServer(row)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
servers = append(servers, server)
|
|
}
|
|
return servers, nil
|
|
}
|
|
|
|
func validateInlineMCPServers(
|
|
servers []codersdk.InlineMCPServerRequest,
|
|
allowedIPRanges []netip.Prefix,
|
|
) []codersdk.ValidationError {
|
|
if len(servers) > codersdk.MaxInlineMCPServers {
|
|
return []codersdk.ValidationError{{
|
|
Field: "inline_mcp_servers",
|
|
Detail: fmt.Sprintf("must contain at most %d servers", codersdk.MaxInlineMCPServers),
|
|
}}
|
|
}
|
|
|
|
if inlineMCPServersSize(servers) > codersdk.MaxInlineMCPServersBytes {
|
|
return []codersdk.ValidationError{{
|
|
Field: "inline_mcp_servers",
|
|
Detail: fmt.Sprintf(
|
|
"total size must not exceed %d bytes",
|
|
codersdk.MaxInlineMCPServersBytes,
|
|
),
|
|
}}
|
|
}
|
|
|
|
seenSlugs := make(map[string]struct{}, len(servers))
|
|
var validations []codersdk.ValidationError
|
|
for i, server := range servers {
|
|
slugField := fmt.Sprintf("inline_mcp_servers[%d].slug", i)
|
|
if !inlineMCPServerSlugPattern.MatchString(server.Slug) {
|
|
validations = append(validations, codersdk.ValidationError{
|
|
Field: slugField,
|
|
Detail: fmt.Sprintf(
|
|
"must be 1 to %d ASCII letters, numbers, underscores, or hyphens, and must start with a letter or number",
|
|
codersdk.MaxInlineMCPServerSlugBytes,
|
|
),
|
|
})
|
|
} else if _, ok := seenSlugs[server.Slug]; ok {
|
|
validations = append(validations, codersdk.ValidationError{
|
|
Field: slugField,
|
|
Detail: "must be unique within inline_mcp_servers",
|
|
})
|
|
} else {
|
|
seenSlugs[server.Slug] = struct{}{}
|
|
}
|
|
|
|
if urlValidation := validateInlineMCPServerURL(i, server.URL, allowedIPRanges); urlValidation != nil {
|
|
validations = append(validations, *urlValidation)
|
|
}
|
|
|
|
if len(server.Headers) > codersdk.MaxInlineMCPServerHeaders {
|
|
validations = append(validations, codersdk.ValidationError{
|
|
Field: fmt.Sprintf("inline_mcp_servers[%d].headers", i),
|
|
Detail: fmt.Sprintf(
|
|
"must contain at most %d headers",
|
|
codersdk.MaxInlineMCPServerHeaders,
|
|
),
|
|
})
|
|
}
|
|
// Header names are case-insensitive identifiers: the transport
|
|
// canonicalizes them on the wire, so two spellings of one name
|
|
// would collide nondeterministically. Track the first spelling
|
|
// of each canonical name and reject repeats.
|
|
seen := make(map[string]string, len(server.Headers))
|
|
for _, name := range slices.Sorted(maps.Keys(server.Headers)) {
|
|
field := fmt.Sprintf("inline_mcp_servers[%d].headers[%s]", i, name)
|
|
value := server.Headers[name]
|
|
canonical := http.CanonicalHeaderKey(name)
|
|
switch {
|
|
case seen[canonical] != "":
|
|
validations = append(validations, codersdk.ValidationError{
|
|
Field: field,
|
|
Detail: fmt.Sprintf("header name duplicates %q; header names are case-insensitive", seen[canonical]),
|
|
})
|
|
case len(name) > codersdk.MaxInlineMCPServerHeaderNameBytes:
|
|
validations = append(validations, codersdk.ValidationError{
|
|
Field: field,
|
|
Detail: fmt.Sprintf("header name must not exceed %d bytes", codersdk.MaxInlineMCPServerHeaderNameBytes),
|
|
})
|
|
case !httpguts.ValidHeaderFieldName(name):
|
|
validations = append(validations, codersdk.ValidationError{
|
|
Field: field,
|
|
Detail: "header name is invalid",
|
|
})
|
|
case inlineMCPHeaderReserved(name):
|
|
validations = append(validations, codersdk.ValidationError{
|
|
Field: field,
|
|
Detail: "header name is reserved",
|
|
})
|
|
case len(value) > codersdk.MaxInlineMCPServerHeaderValueBytes:
|
|
validations = append(validations, codersdk.ValidationError{
|
|
Field: field,
|
|
Detail: fmt.Sprintf("header value must not exceed %d bytes", codersdk.MaxInlineMCPServerHeaderValueBytes),
|
|
})
|
|
case !httpguts.ValidHeaderFieldValue(value):
|
|
validations = append(validations, codersdk.ValidationError{
|
|
Field: field,
|
|
Detail: "header value is invalid",
|
|
})
|
|
}
|
|
seen[canonical] = name
|
|
}
|
|
|
|
if len(server.ToolAllowList) > 0 && len(server.ToolDenyList) > 0 {
|
|
validations = append(validations, codersdk.ValidationError{
|
|
Field: fmt.Sprintf("inline_mcp_servers[%d].tool_deny_list", i),
|
|
Detail: "cannot be combined with tool_allow_list",
|
|
})
|
|
}
|
|
validations = append(validations, validateInlineMCPToolFilter(i, "tool_allow_list", server.ToolAllowList)...)
|
|
validations = append(validations, validateInlineMCPToolFilter(i, "tool_deny_list", server.ToolDenyList)...)
|
|
}
|
|
return validations
|
|
}
|
|
|
|
func validateInlineMCPServerURL(
|
|
index int,
|
|
rawURL string,
|
|
allowedIPRanges []netip.Prefix,
|
|
) *codersdk.ValidationError {
|
|
field := fmt.Sprintf("inline_mcp_servers[%d].url", index)
|
|
invalid := func(detail string) *codersdk.ValidationError {
|
|
return &codersdk.ValidationError{Field: field, Detail: detail}
|
|
}
|
|
if len(rawURL) == 0 {
|
|
return invalid("is required")
|
|
}
|
|
if len(rawURL) > codersdk.MaxInlineMCPServerURLBytes {
|
|
return invalid(fmt.Sprintf("must not exceed %d bytes", codersdk.MaxInlineMCPServerURLBytes))
|
|
}
|
|
parsed, err := url.Parse(rawURL)
|
|
if err != nil {
|
|
return invalid("must be a valid URL")
|
|
}
|
|
if parsed.Scheme != "http" && parsed.Scheme != "https" {
|
|
return invalid("scheme must be http or https")
|
|
}
|
|
if parsed.Host == "" {
|
|
return invalid("host is required")
|
|
}
|
|
if parsed.User != nil {
|
|
return invalid("must not contain userinfo")
|
|
}
|
|
if parsed.RawQuery != "" || parsed.ForceQuery {
|
|
return invalid("must not contain a query string")
|
|
}
|
|
if parsed.Fragment != "" {
|
|
return invalid("must not contain a fragment")
|
|
}
|
|
ip, err := netip.ParseAddr(parsed.Hostname())
|
|
isIPLiteral := err == nil
|
|
if isIPLiteral && safedial.CheckAddr(ip, safedial.WithAllowedPrefixes(allowedIPRanges...)) != nil {
|
|
return invalid("host is in a private or reserved IP range")
|
|
}
|
|
// Plaintext is only allowed to an IP literal the operator allowlisted.
|
|
// Hostnames resolve at connect time, so they cannot be trusted here.
|
|
inAllowedRange := isIPLiteral && slices.ContainsFunc(allowedIPRanges, func(prefix netip.Prefix) bool {
|
|
return prefix.Contains(ip.Unmap())
|
|
})
|
|
if parsed.Scheme == "http" && !inAllowedRange {
|
|
return invalid("must use https, or http to an IP literal in an allowed private range")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateInlineMCPToolFilter(index int, name string, values []string) []codersdk.ValidationError {
|
|
field := fmt.Sprintf("inline_mcp_servers[%d].%s", index, name)
|
|
if len(values) > codersdk.MaxInlineMCPServerToolFilters {
|
|
return []codersdk.ValidationError{{
|
|
Field: field,
|
|
Detail: fmt.Sprintf("must contain at most %d tool names", codersdk.MaxInlineMCPServerToolFilters),
|
|
}}
|
|
}
|
|
seen := make(map[string]struct{}, len(values))
|
|
var validations []codersdk.ValidationError
|
|
for i, value := range values {
|
|
itemField := fmt.Sprintf("%s[%d]", field, i)
|
|
_, duplicate := seen[value]
|
|
switch {
|
|
case value == "":
|
|
validations = append(validations, codersdk.ValidationError{Field: itemField, Detail: "tool name must not be empty"})
|
|
case len(value) > codersdk.MaxInlineMCPServerToolNameBytes:
|
|
validations = append(validations, codersdk.ValidationError{
|
|
Field: itemField,
|
|
Detail: fmt.Sprintf("tool name must not exceed %d bytes", codersdk.MaxInlineMCPServerToolNameBytes),
|
|
})
|
|
case strings.ContainsRune(value, '\x00'):
|
|
validations = append(validations, codersdk.ValidationError{Field: itemField, Detail: "tool name must not contain null bytes"})
|
|
case duplicate:
|
|
validations = append(validations, codersdk.ValidationError{Field: itemField, Detail: "tool name must be unique within the list"})
|
|
default:
|
|
seen[value] = struct{}{}
|
|
}
|
|
}
|
|
return validations
|
|
}
|
|
|
|
func inlineMCPServersSize(servers []codersdk.InlineMCPServerRequest) int {
|
|
total := 0
|
|
for _, server := range servers {
|
|
total += len(server.Slug) + len(server.URL)
|
|
for name, value := range server.Headers {
|
|
total += len(name) + len(value)
|
|
}
|
|
for _, name := range server.ToolAllowList {
|
|
total += len(name)
|
|
}
|
|
for _, name := range server.ToolDenyList {
|
|
total += len(name)
|
|
}
|
|
}
|
|
return total
|
|
}
|
|
|
|
func inlineMCPHeaderReserved(name string) bool {
|
|
canonical := strings.ToLower(http.CanonicalHeaderKey(name))
|
|
if strings.HasPrefix(canonical, "proxy-") || strings.HasPrefix(canonical, "x-coder-") {
|
|
return true
|
|
}
|
|
switch canonical {
|
|
case "host",
|
|
"content-length",
|
|
"connection",
|
|
"transfer-encoding",
|
|
"trailer",
|
|
"upgrade",
|
|
"te",
|
|
"keep-alive",
|
|
"accept",
|
|
"accept-encoding",
|
|
"content-type",
|
|
"last-event-id",
|
|
"mcp-protocol-version",
|
|
"mcp-session-id":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|