mcp_servers holds each server: its address, headers, and secret references for the headers that carry credentials. limits gains allowed_tools, patterns such as jira.* resolved down the tenancy tree; unlike models, a tool no level grants is not granted. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
105 lines
3.3 KiB
Go
105 lines
3.3 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"time"
|
|
)
|
|
|
|
// 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
|
|
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, 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`,
|
|
m.Name, m.URL, m.Description, string(h), string(r), boolInt(m.Enabled), m.Timeout.Milliseconds(),
|
|
m.CreatedAt.UnixMilli(), m.CreatedBy)
|
|
return err
|
|
}
|
|
|
|
// 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, 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, 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 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, &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
|
|
}
|