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/plugin_server.h>
#include <entropic/mcp/server_base.h>
#include <entropic/mcp/servers/filesystem.h>
#include <entropic/mcp/tool_root_lock.h>
#include <entropic/types/config.h>
 
#include <nlohmann/json_fwd.hpp>
 
#include <chrono>
#include <filesystem>
#include <map>
#include <shared_mutex>
#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,
                       const std::vector<std::string>&
                           require_context_tiers = {});
 
    entropic_error_t load_plugins(const MCPConfig& mcp_config);
 
    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;
 
    bool set_outside_root_approver(OutsideRootApprover fn, void* user_data);
 
    using DiscoveredServerApprover = bool (*)(const std::string& context_json,
                                              void* user_data);
 
    void set_discovered_server_approver(DiscoveredServerApprover fn,
                                        void* user_data);
 
    void set_own_bridge_socket(const std::filesystem::path& socket);
 
    std::size_t release_session(const std::string& key);
 
    std::vector<std::string> server_names() const;
 
    const std::filesystem::path& project_dir() const { return project_dir_; }
 
    size_t set_working_dir_all(const std::filesystem::path& dir);
 
    size_t enter_working_dir(const std::filesystem::path& dir);
 
    size_t leave_working_dir(const std::filesystem::path& dir);
 
    std::vector<std::string> external_tools_without_readonly_hint(
        const std::vector<std::string>& allowed) const;
 
    static std::vector<std::string> tools_without_readonly_hint(
        const std::string& tools_json,
        const std::vector<std::string>& allowed);
 
    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();
 
    void clear_external_tool_interrupts();
 
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_;                             
    DiscoveredServerApprover discovered_approver_ = nullptr;        
    void* discovered_approver_ud_ = nullptr;                        
    std::filesystem::path own_bridge_socket_;                       
    std::map<std::string, std::unique_ptr<MCPServerBase>> servers_; 
 
    std::unique_ptr<ToolRootLock> root_lock_ =
        std::make_unique<ToolRootLock>();
 
    static std::string route_plugin_call(PluginServer& plugin,
                                         const std::string& local_name,
                                         const std::string& args_json);
 
    std::string plugin_tool_schema(const std::string& prefix,
                                   const std::string& local_name) const;
 
    std::string route_external_or_unknown(const std::string& prefix,
                                          const std::string& tool_name,
                                          const std::string& local_name,
                                          const std::string& args_json);
 
    void append_plugin_tools(nlohmann::json& all) const;
 
    void append_external_tools(nlohmann::json& all) const;
 
    /* ── gh#133 (v2.10.1): dlopen plugin state ─────────── */
    std::map<std::string, std::unique_ptr<PluginServer>> plugin_servers_; 
 
    /* ── v1.8.7: External server state ─────────────────── */
    std::map<std::string, std::shared_ptr<ExternalMCPClient>> external_clients_;
    std::map<std::string, ServerInfo> server_info_;  
 
    std::unique_ptr<std::shared_mutex> external_mutex_ =
        std::make_unique<std::shared_mutex>();
 
    std::vector<std::pair<std::string, std::shared_ptr<ExternalMCPClient>>>
    external_snapshot() const;
 
    std::shared_ptr<ExternalMCPClient> find_external(const std::string& name) const;
    std::unique_ptr<HealthMonitor> health_monitor_;                               
    std::unique_ptr<MCPJsonDiscovery> mcp_json_discovery_;                        
    MCPConfig mcp_config_;                                                        
 
    void initialize_external_servers();
 
    void connect_declared_servers();
 
    void connect_discovered_servers();
 
    bool admit_discovered(const ExternalServerConfig& cfg) const;
 
    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);
 
    std::shared_ptr<ExternalMCPClient> 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);
 
    std::unique_ptr<Transport> make_transport(
        const ExternalServerConfig& spec) const;
 
    static std::string disconnected_error(
        const std::string& tool_name,
        const std::string& server_name);
};
 
} // namespace entropic