Files
llmgw/internal/store/mcp.go
T
Ilker ManapandClaude Opus 5.5 b986ea180d
CI / test (push) Successful in 9m47s
Fixes from review: setup's memory check, MCP secrets, VS Code, bandwidth
- server init run again on a machine already set up is not refused its
  memory (the docs fix a certificate with --host so), and judges count
  only when one will be installed (judgeComes: not without a mirror, nor
  from a bundle without it).
- A server's sealed secrets that it no longer reads are removed when it is
  put or deleted; replacing a credential replaces every header it was
  sent, rather than adding one beside the old.
- llmgw.gatewayUrl is a machine setting and restricted in untrusted
  workspaces: a cloned repository's settings cannot send a sign-in to
  another gateway.
- The bandwidth buffer is at least eight times the CPU's last cache and at
  most a quarter of free memory, else nothing is measured until there is
  room; a registration carries the figure measured so far.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 08:23:00 +01:00

157 lines
5.0 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"regexp"
"time"
)
// mcpServerName is what a server may be called: its tools are name.tool, so
// no dot, and short enough to read in a tool list.
var mcpServerName = regexp.MustCompile(`^[a-z][a-z0-9_-]{0,31}$`)
// ValidMCPServerName reports whether a name can be a server's.
func ValidMCPServerName(name string) bool { return mcpServerName.MatchString(name) }
// MCPServer is one of the company's MCP servers, served through llmgw's
// /mcp under its name: its tools are name.tool there.
type MCPServer struct {
Name string
URL string
Description string
// Headers are sent as written; HeaderRefs name a secret to read for
// each header (a file, env:, vault: or store:), so no token is stored
// in this row.
Headers map[string]string
HeaderRefs map[string]string
Enabled bool
// Timeout bounds one call; zero is the gateway's default.
Timeout time.Duration
// RatePerMinute is how many calls a minute one caller may make to its
// tools; zero is no limit of its own.
RatePerMinute int
CreatedAt time.Time
CreatedBy string
}
// PutMCPServer adds a server, or replaces the one of that name.
func (s *DB) PutMCPServer(ctx context.Context, m MCPServer) error {
h, err := json.Marshal(nonNil(m.Headers))
if err != nil {
return err
}
r, err := json.Marshal(nonNil(m.HeaderRefs))
if err != nil {
return err
}
if m.CreatedAt.IsZero() {
m.CreatedAt = time.Now()
}
_, err = s.db.ExecContext(ctx,
`INSERT INTO mcp_servers (name, url, description, headers, header_refs, enabled, timeout_ms, rate_per_minute, created_at, created_by)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT (name) DO UPDATE SET
url = excluded.url, description = excluded.description, headers = excluded.headers,
header_refs = excluded.header_refs, enabled = excluded.enabled, timeout_ms = excluded.timeout_ms,
rate_per_minute = excluded.rate_per_minute`,
m.Name, m.URL, m.Description, string(h), string(r), boolInt(m.Enabled), m.Timeout.Milliseconds(), m.RatePerMinute,
m.CreatedAt.UnixMilli(), m.CreatedBy)
if err != nil {
return err
}
return s.pruneMCPSecrets(ctx, m.Name, m.HeaderRefs)
}
// pruneMCPSecrets removes the server's sealed secrets its headers no longer
// read: a credential replaced under another header, or every one of a
// server removed, is not left at rest.
func (s *DB) pruneMCPSecrets(ctx context.Context, name string, refs map[string]string) error {
prefix := "mcp/" + name + "/"
rows, err := s.db.QueryContext(ctx,
`SELECT name FROM cluster_secrets WHERE substr(name, 1, ?) = ?`, len(prefix), prefix)
if err != nil {
return err
}
var stale []string
for rows.Next() {
var n string
if err := rows.Scan(&n); err != nil {
rows.Close()
return err
}
used := false
for _, ref := range refs {
used = used || ref == "store:"+n
}
if !used {
stale = append(stale, n)
}
}
rows.Close()
if err := rows.Err(); err != nil {
return err
}
for _, n := range stale {
if _, err := s.db.ExecContext(ctx, `DELETE FROM cluster_secrets WHERE name = ?`, n); err != nil {
return err
}
}
return nil
}
// MCPServers are every server registered, by name.
func (s *DB) MCPServers(ctx context.Context) ([]MCPServer, error) {
return queryAll(ctx, s.db, `SELECT name, url, description, headers, header_refs, enabled, timeout_ms, rate_per_minute, created_at, created_by
FROM mcp_servers ORDER BY name`, nil, scanMCPServer)
}
// MCPServer is the server of that name, ErrNotFound when there is none.
func (s *DB) MCPServer(ctx context.Context, name string) (MCPServer, error) {
list, err := queryAll(ctx, s.db, `SELECT name, url, description, headers, header_refs, enabled, timeout_ms, rate_per_minute, created_at, created_by
FROM mcp_servers WHERE name = ?`, []any{name}, scanMCPServer)
if err != nil {
return MCPServer{}, err
}
if len(list) == 0 {
return MCPServer{}, ErrNotFound
}
return list[0], nil
}
// DeleteMCPServer removes a server; ErrNotFound when there was none.
func (s *DB) DeleteMCPServer(ctx context.Context, name string) error {
res, err := s.db.ExecContext(ctx, `DELETE FROM mcp_servers WHERE name = ?`, name)
if err != nil {
return err
}
if n, _ := res.RowsAffected(); n == 0 {
return ErrNotFound
}
return s.pruneMCPSecrets(ctx, name, nil)
}
func scanMCPServer(rows *sql.Rows) (MCPServer, error) {
var m MCPServer
var headers, refs string
var enabled int
var timeoutMs, created int64
if err := rows.Scan(&m.Name, &m.URL, &m.Description, &headers, &refs, &enabled, &timeoutMs, &m.RatePerMinute, &created, &m.CreatedBy); err != nil {
return m, err
}
m.Enabled, m.Timeout, m.CreatedAt = enabled != 0, time.Duration(timeoutMs)*time.Millisecond, time.UnixMilli(created)
if err := errors.Join(json.Unmarshal([]byte(headers), &m.Headers), json.Unmarshal([]byte(refs), &m.HeaderRefs)); err != nil {
return m, err
}
return m, nil
}
func nonNil(m map[string]string) map[string]string {
if m == nil {
return map[string]string{}
}
return m
}