vikingowl
3c875276c9
Implemented full security remediation following Universal Security Pilot protocol: - W1: Enforced SecureProvider at router and engine boundaries to prevent bypasses. - W1: Implemented path-sensitive policy for MCP tools. - W2: Added SHA256 hash verification for SLM downloads (llamafile). - W3: Enhanced secret redaction for private keys (full body) and high-entropy strings. - W4: Fixed symlink-based filesystem sandbox escapes in paths and grep. - W4: Documented CLI agent trust boundaries. Also added 'agy' (Antigravity) as a subprocess CLI provider with plain-text JSON schema support.
113 lines
3.0 KiB
Go
113 lines
3.0 KiB
Go
package mcp
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log/slog"
|
|
|
|
"somegit.dev/Owlibou/gnoma/internal/tool"
|
|
)
|
|
|
|
// Manager coordinates multiple MCP server lifecycles and tool registration.
|
|
type Manager struct {
|
|
clients map[string]*Client
|
|
logger *slog.Logger
|
|
}
|
|
|
|
// NewManager creates an MCP manager.
|
|
func NewManager(logger *slog.Logger) *Manager {
|
|
return &Manager{
|
|
clients: make(map[string]*Client),
|
|
logger: logger,
|
|
}
|
|
}
|
|
|
|
// StartAll starts all configured MCP servers, discovers tools, and registers
|
|
// them in the tool registry. Servers start sequentially to simplify error handling.
|
|
func (m *Manager) StartAll(ctx context.Context, servers []ServerConfig, registry *tool.Registry) error {
|
|
for _, srv := range servers {
|
|
client, err := m.startServer(ctx, srv)
|
|
if err != nil {
|
|
if shutdownErr := m.Shutdown(); shutdownErr != nil {
|
|
m.logger.Warn("partial shutdown after server-start failure",
|
|
"failed_server", srv.Name, "shutdown_error", shutdownErr)
|
|
}
|
|
return fmt.Errorf("mcp server %q: %w", srv.Name, err)
|
|
}
|
|
|
|
tools, err := client.ListTools(ctx)
|
|
if err != nil {
|
|
if shutdownErr := m.Shutdown(); shutdownErr != nil {
|
|
m.logger.Warn("partial shutdown after list-tools failure",
|
|
"failed_server", srv.Name, "shutdown_error", shutdownErr)
|
|
}
|
|
return fmt.Errorf("mcp server %q: list tools: %w", srv.Name, err)
|
|
}
|
|
|
|
m.registerTools(srv, tools, client, registry)
|
|
m.clients[srv.Name] = client
|
|
|
|
m.logger.Info("mcp server started",
|
|
"name", srv.Name,
|
|
"tools", len(tools),
|
|
"replace", srv.ReplaceDefault,
|
|
)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Shutdown gracefully stops all MCP server processes.
|
|
func (m *Manager) Shutdown() error {
|
|
var firstErr error
|
|
for name, client := range m.clients {
|
|
if err := client.Close(); err != nil && firstErr == nil {
|
|
firstErr = fmt.Errorf("mcp shutdown %q: %w", name, err)
|
|
}
|
|
}
|
|
m.clients = make(map[string]*Client)
|
|
return firstErr
|
|
}
|
|
|
|
func (m *Manager) startServer(ctx context.Context, srv ServerConfig) (*Client, error) {
|
|
tr := NewTransport(srv.Command, srv.Args, srv.Env, m.logger)
|
|
|
|
if err := tr.Start(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
client := NewClient(tr, m.logger)
|
|
|
|
initCtx, cancel := context.WithTimeout(ctx, srv.Timeout)
|
|
defer cancel()
|
|
|
|
if err := client.Initialize(initCtx); err != nil {
|
|
if closeErr := tr.Close(); closeErr != nil {
|
|
m.logger.Warn("transport close after init failure", "error", closeErr)
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return client, nil
|
|
}
|
|
|
|
func (m *Manager) registerTools(srv ServerConfig, tools []MCPTool, client *Client, registry *tool.Registry) {
|
|
for _, mt := range tools {
|
|
policy := srv.ToolPolicy[mt.Name]
|
|
adapter := NewAdapter(srv.Name, mt, client, policy)
|
|
|
|
// Explicit mapping: if this MCP tool name has a replace_default entry,
|
|
// register it under the built-in's name instead of mcp__{server}__{tool}.
|
|
if builtinName, ok := srv.ReplaceDefault[mt.Name]; ok {
|
|
adapter.SetOverrideName(builtinName)
|
|
}
|
|
|
|
registry.Register(adapter)
|
|
m.logger.Debug("mcp tool registered",
|
|
"name", adapter.Name(),
|
|
"server", srv.Name,
|
|
"mcp_name", mt.Name,
|
|
)
|
|
}
|
|
}
|