server_manager.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/mcp/external_client.h>
#include <entropic/mcp/health_monitor.h>
#include <entropic/mcp/mcp_json_discovery.h>
#include <entropic/mcp/permission_manager.h>
#include <entropic/mcp/server_base.h>
#include <entropic/types/config.h>
 
#include <chrono>
#include <filesystem>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace entropic {
 
struct ServerInfo {
    std::string name;                              
    std::string transport;                         
    std::string url;                               
    std::string command;                           
    std::string status;                            
    std::vector<std::string> tools;                
    std::string source;                            
    std::chrono::system_clock::time_point connected_at; 
    int reconnect_attempts{0};                     
};
 
class ServerManager {
public:
    ServerManager(const PermissionsConfig& permissions,
                  const std::filesystem::path& project_dir);
 
    void register_server(std::unique_ptr<MCPServerBase> server);
 
    void init_builtins(const MCPConfig& mcp_config,
                       const std::vector<std::string>& tier_names,
                       const std::string& data_dir);
 
    void initialize();
 
    std::string list_tools() const;
 
    std::string execute(const std::string& tool_name,
                        const std::string& args_json);
 
    MCPServerBase* get_server(const std::string& name) const;
 
    std::vector<std::string> server_names() const;
 
    const std::filesystem::path& project_dir() const { return project_dir_; }
 
    std::string get_tool_schema(const std::string& tool_name) const;
 
    bool is_explicitly_allowed(const std::string& tool_name,
                               const std::string& args_json) const;
 
    std::string get_permission_pattern(const std::string& tool_name,
                                       const std::string& args_json) const;
 
    bool skip_duplicate_check(const std::string& tool_name) const;
 
    MCPAccessLevel get_required_access_level(
        const std::string& tool_name) const;
 
    void add_permission(const std::string& pattern, bool allow);
 
    void shutdown();
 
    /* ── v1.8.7: External server methods ───────────────── */
 
    std::vector<std::string> connect_external_server(
        const ExternalServerConfig& spec);
 
    std::vector<std::string> connect_external_server(
        const std::string& name,
        const std::string& command = "",
        const std::vector<std::string>& args = {},
        const std::string& url = "");
 
    void disconnect_external_server(const std::string& name);
 
    std::map<std::string, ServerInfo> list_server_info() const;
 
    void process_health_events();
 
    void set_mcp_config(const MCPConfig& config);
 
    void interrupt_external_tools();
 
private:
    static std::string extract_prefix(const std::string& tool_name);
 
    static std::string extract_local_name(const std::string& tool_name);
 
    static std::string args_to_pattern(const std::string& args_json);
 
    PermissionManager permissions_;                                 
    std::filesystem::path project_dir_;                             
    std::map<std::string, std::unique_ptr<MCPServerBase>> servers_; 
 
    /* ── v1.8.7: External server state ─────────────────── */
    std::map<std::string, std::unique_ptr<ExternalMCPClient>> external_clients_; 
    std::map<std::string, ServerInfo> server_info_;                               
    std::unique_ptr<HealthMonitor> health_monitor_;                               
    std::unique_ptr<MCPJsonDiscovery> mcp_json_discovery_;                        
    MCPConfig mcp_config_;                                                        
 
    void initialize_external_servers();
 
    std::string route_tool_call(const std::string& tool_name,
                                 const std::string& args_json);
 
    std::string route_external_call(
        ExternalMCPClient* client,
        const std::string& tool_name,
        const std::string& local_name,
        const std::string& args_json);
 
    void connect_and_register_external(
        const std::string& name,
        std::unique_ptr<ExternalMCPClient> client,
        const std::string& source,
        const std::string& url,
        const std::string& command);
 
    std::unique_ptr<ExternalMCPClient> create_external_client(
        const std::string& name,
        const ExternalServerEntry& entry);
 
    std::unique_ptr<ExternalMCPClient> create_external_client(
        const ExternalServerConfig& config);
 
    static std::unique_ptr<Transport> make_transport(
        const ExternalServerConfig& spec);
 
    static std::string disconnected_error(
        const std::string& tool_name,
        const std::string& server_name);
};
 
} // namespace entropic