Files
llmgw/internal/store/mcp.go
T
Ilker ManapandClaude Opus 5.5 6dfdfbf2fe The store keeps the company's MCP servers, and which tools a scope may call
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>
2026-10-20 10:36:08 +02:00

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
}