CI / test (push) Successful in 9m47s
- 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>
157 lines
5.0 KiB
Go
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
|
|
}
|