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 }