server_manager.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/mcp/server_manager.h>
 
#include "discovery_policy.h"
#include <entropic/mcp/servers/bash.h>
#include <entropic/mcp/servers/diagnostics.h>
#include <entropic/mcp/servers/entropic_server.h>
#include <entropic/mcp/servers/filesystem.h>
#include <entropic/mcp/servers/git.h>
#include <entropic/mcp/servers/web.h>
#include <entropic/mcp/transport_stdio.h>
#include <entropic/mcp/transport_sse.h>
#include <entropic/types/logging.h>
 
#include <nlohmann/json.hpp>
 
#include <algorithm>
 
static auto logger = entropic::log::get("mcp.server_manager");
 
namespace entropic {
 
ServerManager::ServerManager(
    const PermissionsConfig& permissions,
    const std::filesystem::path& project_dir)
    : permissions_(permissions.allow, permissions.deny),
      project_dir_(project_dir) {}
 
void ServerManager::init_builtins(
    const MCPConfig& mcp,
    const std::vector<std::string>& tier_names,
    const std::string& data_dir,
    const std::vector<std::string>& require_context_tiers) {
    if (mcp.enable_entropic) {
        register_server(std::make_unique<EntropicServer>(
            tier_names, data_dir, require_context_tiers));
    }
    if (mcp.enable_filesystem) {
        register_server(std::make_unique<FilesystemServer>(
            project_dir_, mcp.filesystem, data_dir));
    }
    if (mcp.enable_bash) {
        register_server(std::make_unique<BashServer>(
            project_dir_, data_dir, mcp.bash.timeout_seconds));
    }
    if (mcp.enable_git) {
        register_server(std::make_unique<GitServer>(
            project_dir_, data_dir));
    }
    if (mcp.enable_diagnostics) {
        register_server(std::make_unique<DiagnosticsServer>(
            project_dir_, data_dir));
    }
    if (mcp.enable_web) {
        register_server(std::make_unique<WebServer>(data_dir));
    }
}
 
entropic_error_t ServerManager::load_plugins(const MCPConfig& mcp) {
    auto first_error = ENTROPIC_OK;
 
    for (const auto& path : mcp.plugins) {
        std::unique_ptr<PluginServer> plugin;
        auto rc = PluginServer::load(path, plugin);
        if (rc != ENTROPIC_OK) {
            // Keep going: attempting every path diagnoses a whole broken
            // config in one run instead of one entry per restart.
            first_error = (first_error == ENTROPIC_OK) ? rc : first_error;
            continue;
        }
 
        auto name = plugin->name();
        if (servers_.count(name) > 0 || find_external(name) ||
            plugin_servers_.count(name) > 0) {
            logger->error("Plugin '{}' from {} collides with an already "
                          "registered server of the same name — refusing to "
                          "shadow it", name, path.string());
            first_error = (first_error == ENTROPIC_OK)
                              ? ENTROPIC_ERROR_PLUGIN_LOAD_FAILED
                              : first_error;
            continue;
        }
 
        plugin->set_working_dir(project_dir_.string());
        plugin_servers_[name] = std::move(plugin);
        logger->info("Registered plugin server: {}", name);
    }
 
    return first_error;
}
 
void ServerManager::register_server(
    std::unique_ptr<MCPServerBase> server) {
    auto name = server->name();
    if (servers_.count(name) > 0) {
        logger->warn("Server '{}' already registered — replacing",
                     name);
    }
    servers_[name] = std::move(server);
    logger->info("Registered server: {}", name);
}
 
void ServerManager::initialize() {
    logger->info("Initializing {} in-process MCP servers",
                 servers_.size());
    for (auto& [name, server] : servers_) {
        logger->info("Server '{}' ready", name);
    }
 
    initialize_external_servers();
}
 
static void append_prefixed_tools(const std::string& tools_json,
                                  const std::string& prefix,
                                  nlohmann::json& all) {
    auto tools = nlohmann::json::parse(tools_json);
    for (auto& tool : tools) {
        std::string orig_name = tool.at("name");
        tool["name"] = prefix + "." + orig_name;
        all.push_back(std::move(tool));
    }
}
 
void ServerManager::append_plugin_tools(nlohmann::json& all) const {
    for (const auto& [name, plugin] : plugin_servers_) {
        try {
            append_prefixed_tools(plugin->list_tools(), name, all);
        } catch (const std::exception& e) {
            logger->error("Plugin '{}' returned an unusable tool list: {} — "
                          "its tools are unavailable this session", name,
                          e.what());
        }
    }
}
 
void ServerManager::append_external_tools(nlohmann::json& all) const {
    for (const auto& [name, client] : external_snapshot()) {
        if (!client->is_connected()) {
            continue;
        }
        auto tools = nlohmann::json::parse(client->list_tools());
        for (auto& tool : tools) {
            all.push_back(std::move(tool));
        }
    }
}
 
size_t ServerManager::set_working_dir_all(
        const std::filesystem::path& dir) {
    std::lock_guard<ToolRootLock> exclusive(*root_lock_);
    size_t moved = 0;
    for (const auto& [name, server] : servers_) {
        if (server->set_working_dir(dir.string())) { ++moved; }
    }
    for (const auto& [name, plugin] : plugin_servers_) {
        if (plugin->set_working_dir(dir.string()) == ENTROPIC_OK) {
            ++moved;
        }
    }
    logger->info("Tool working dir → {} ({} servers moved)",
                 dir.string(), moved);
    return moved;
}
 
size_t ServerManager::enter_working_dir(const std::filesystem::path& dir) {
    root_lock_->lock();
    auto moved = set_working_dir_all(dir);
    logger->info("Tool root lock HELD for sandbox {} — other sessions' "
                 "in-process dispatch on this server set waits until "
                 "restore", dir.string());
    return moved;
}
 
size_t ServerManager::leave_working_dir(const std::filesystem::path& dir) {
    if (!root_lock_->owned_by_this_thread()) {
        logger->error("leave_working_dir({}) from a thread that holds no "
                      "sandbox root lock — refusing, nothing moved",
                      dir.string());
        return 0;
    }
    auto moved = set_working_dir_all(dir);
    root_lock_->unlock();
    logger->info("Tool root lock released on restore to {}", dir.string());
    return moved;
}
 
static bool tool_is_read_only(const nlohmann::json& tool) {
    if (!tool.is_object() || !tool.contains("annotations")) {
        return false;
    }
    const auto& ann = tool["annotations"];
    return ann.is_object() && ann.value("readOnlyHint", false);
}
 
std::vector<std::string> ServerManager::tools_without_readonly_hint(
        const std::string& tools_json,
        const std::vector<std::string>& allowed) {
    std::vector<std::string> unsafe;
    auto tools = nlohmann::json::parse(tools_json, nullptr, false);
    if (!tools.is_array()) { return unsafe; }
    for (const auto& tool : tools) {
        auto full = tool.value("name", std::string{});
        bool visible = allowed.empty()
            || std::find(allowed.begin(), allowed.end(), full)
                   != allowed.end();
        if (visible && !full.empty() && !tool_is_read_only(tool)) {
            unsafe.push_back(full);
        }
    }
    return unsafe;
}
 
std::vector<std::string>
ServerManager::external_tools_without_readonly_hint(
        const std::vector<std::string>& allowed) const {
    std::vector<std::string> unsafe;
    for (const auto& [name, client] : external_snapshot()) {
        if (!client->is_connected()) { continue; }
        auto found = tools_without_readonly_hint(
            client->list_tools(), allowed);
        unsafe.insert(unsafe.end(), found.begin(), found.end());
    }
    return unsafe;
}
 
std::string ServerManager::list_tools() const {
    auto all = nlohmann::json::array();
 
    // In-process servers
    for (const auto& [name, server] : servers_) {
        append_prefixed_tools(server->list_tools(), name, all);
    }
 
    append_plugin_tools(all);     // gh#133 (v2.10.1)
    append_external_tools(all);
 
    logger->info("Tool list: {} tools from {} server(s) + {} plugin(s) + "
                 "{} external", all.size(), servers_.size(),
                 plugin_servers_.size(), external_snapshot().size());
    return all.dump();
}
 
std::string ServerManager::execute(
    const std::string& tool_name,
    const std::string& args_json) {
 
    // Check permissions first
    auto pattern = tool_name + ":" + args_to_pattern(args_json);
    if (permissions_.is_denied(tool_name, pattern)) {
        logger->warn("Permission denied: {}", tool_name);
        nlohmann::json resp;
        resp["result"] = "Error: Permission denied for " + tool_name;
        resp["directives"] = nlohmann::json::array();
        return resp.dump();
    }
 
    return route_tool_call(tool_name, args_json);
}
 
MCPServerBase* ServerManager::get_server(const std::string& name) const {
    auto it = servers_.find(name);
    return (it != servers_.end()) ? it->second.get() : nullptr;
}
 
bool ServerManager::set_outside_root_approver(OutsideRootApprover fn,
                                              void* user_data) {
    ToolRootShared root(*root_lock_, "set_outside_root_approver");
    auto* fs_server = dynamic_cast<FilesystemServer*>(
        get_server("filesystem"));
    if (fs_server != nullptr) {
        fs_server->set_outside_root_approver(fn, user_data);
    }
    return fs_server != nullptr;
}
 
std::size_t ServerManager::release_session(const std::string& key) {
    std::size_t released = 0;
    for (const auto& [name, server] : servers_) {
        auto* owner = dynamic_cast<SessionStateOwner*>(server.get());
        if (owner != nullptr && owner->release_session(key)) {
            ++released;
        }
    }
    logger->info("Released session '{}' tool state on {} server(s)",
                 key, released);
    return released;
}
 
std::vector<std::string> ServerManager::server_names() const {
    std::vector<std::string> names;
    for (const auto& [name, _] : servers_) {
        names.push_back(name);
    }
    for (const auto& [name, _] : plugin_servers_) {  // gh#133 (v2.10.1)
        names.push_back(name);
    }
    for (const auto& [name, _] : external_snapshot()) {
        names.push_back(name);
    }
    return names;
}
 
std::string ServerManager::get_tool_schema(
    const std::string& tool_name) const {
    auto prefix = extract_prefix(tool_name);
    auto local_name = extract_local_name(tool_name);
    auto it = servers_.find(prefix);
    if (it != servers_.end()) {
        auto* tool = it->second->registry().get_tool(local_name);
        return (tool != nullptr) ? tool->definition().input_schema
                                 : std::string{};
    }
    // gh#133 (v2.10.1): without this a plugin's declared inputSchema would be
    // invisible to ToolExecutor::check_schema, which skips validation on an
    // empty schema — plugin tools would silently forgo the argument checking
    // every built-in server's tools get.
    return plugin_tool_schema(prefix, local_name);
}
 
std::string ServerManager::plugin_tool_schema(
    const std::string& prefix,
    const std::string& local_name) const {
 
    auto it = plugin_servers_.find(prefix);
    if (it == plugin_servers_.end()) {
        return "";
    }
    try {
        auto tools = nlohmann::json::parse(it->second->list_tools());
        for (const auto& tool : tools) {
            if (tool.value("name", std::string{}) == local_name) {
                return tool.value("inputSchema",
                                  nlohmann::json::object()).dump();
            }
        }
    } catch (const std::exception& e) {
        logger->error("Plugin '{}': cannot read schema for tool '{}': {}",
                      prefix, local_name, e.what());
    }
    return "";
}
 
std::string ServerManager::route_tool_call(
    const std::string& tool_name,
    const std::string& args_json) {
 
    auto prefix = extract_prefix(tool_name);
    auto local_name = extract_local_name(tool_name);
 
    // Try in-process server first
    auto it = servers_.find(prefix);
    if (it != servers_.end()) {
        ToolRootShared root(*root_lock_, tool_name);
        return it->second->execute(local_name, args_json);
    }
 
    // gh#133 (v2.10.1): try a loaded plugin
    auto plug_it = plugin_servers_.find(prefix);
    if (plug_it != plugin_servers_.end()) {
        ToolRootShared root(*root_lock_, tool_name);
        return route_plugin_call(*plug_it->second, local_name, args_json);
    }
 
    return route_external_or_unknown(prefix, tool_name, local_name, args_json);
}
 
std::string ServerManager::route_external_or_unknown(
    const std::string& prefix,
    const std::string& tool_name,
    const std::string& local_name,
    const std::string& args_json) {
 
    // gh#171: our own reference keeps the client alive for the whole call,
    // even if a disconnect removes it from the registry meanwhile.
    if (auto client = find_external(prefix)) {
        return route_external_call(client.get(), tool_name, local_name,
                                   args_json);
    }
 
    logger->warn("Unknown server: {}", prefix);
    nlohmann::json resp;
    resp["result"] = "Error: Unknown server '" + prefix + "'";
    resp["directives"] = nlohmann::json::array();
    return resp.dump();
}
 
std::string ServerManager::route_external_call(
    ExternalMCPClient* client,
    const std::string& tool_name,
    const std::string& local_name,
    const std::string& args_json) {
 
    if (!client->is_connected()) {
        auto prefix = extract_prefix(tool_name);
        return disconnected_error(tool_name, prefix);
    }
    return client->execute(local_name, args_json);
}
 
std::string ServerManager::route_plugin_call(
    PluginServer& plugin,
    const std::string& local_name,
    const std::string& args_json) {
 
    std::string raw;
    try {
        raw = plugin.execute(local_name, args_json);
        auto parsed = nlohmann::json::parse(raw);
        if (!parsed.is_object() || !parsed.contains("result")) {
            throw std::runtime_error("missing 'result' field");
        }
        return raw;
    } catch (const std::exception& e) {
        logger->error("Plugin '{}' returned an invalid response for tool "
                      "'{}': {} — raw response: {}",
                      plugin.name(), local_name, e.what(), raw);
        nlohmann::json resp;
        resp["result"] = "Error: plugin '" + plugin.name() +
                         "' returned an invalid response: " + e.what();
        resp["directives"] = nlohmann::json::array();
        return resp.dump();
    }
}
 
bool ServerManager::is_explicitly_allowed(
    const std::string& tool_name,
    const std::string& args_json) const {
    auto pattern = tool_name + ":" + args_to_pattern(args_json);
    return permissions_.is_allowed(tool_name, pattern);
}
 
std::string ServerManager::get_permission_pattern(
    const std::string& tool_name,
    const std::string& args_json) const {
    auto prefix = extract_prefix(tool_name);
    auto it = servers_.find(prefix);
    if (it != servers_.end()) {
        return it->second->get_permission_pattern(
            tool_name, args_json);
    }
    return tool_name;
}
 
bool ServerManager::skip_duplicate_check(
    const std::string& tool_name) const {
    auto prefix = extract_prefix(tool_name);
    auto it = servers_.find(prefix);
    if (it != servers_.end()) {
        auto local = extract_local_name(tool_name);
        return it->second->skip_duplicate_check(local);
    }
    return false;
}
 
MCPAccessLevel ServerManager::get_required_access_level(
    const std::string& tool_name) const {
    auto prefix = extract_prefix(tool_name);
    auto it = servers_.find(prefix);
    if (it != servers_.end()) {
        auto local = extract_local_name(tool_name);
        auto* tool = it->second->registry().get_tool(local);
        if (tool != nullptr) {
            return tool->required_access_level();
        }
    }
    return MCPAccessLevel::WRITE;  // Safe default
}
 
void ServerManager::add_permission(
    const std::string& pattern, bool allow) {
    permissions_.add_permission(pattern, allow);
}
 
void ServerManager::shutdown() {
    // Stop health monitor first
    if (health_monitor_) {
        health_monitor_->stop();
    }
 
    // Disconnect external clients — taken out under the lock, disconnected
    // after it (gh#171: never I/O while holding external_mutex_).
    std::map<std::string, std::shared_ptr<ExternalMCPClient>> clients;
    {
        std::unique_lock<std::shared_mutex> lock(*external_mutex_);
        clients.swap(external_clients_);
        server_info_.clear();
    }
    for (auto& [name, client] : clients) {
        client->disconnect();
    }
 
    // gh#133 (v2.10.1): destroy plugin instances and dlclose their libraries
    // before the in-process servers, so nothing can call into an unmapped .so.
    logger->info("Unloading {} MCP plugin(s)", plugin_servers_.size());
    plugin_servers_.clear();
 
    // Destroy in-process servers
    logger->info("Shutting down {} MCP servers", servers_.size());
    servers_.clear();
}
 
std::string ServerManager::extract_prefix(
    const std::string& tool_name) {
    auto dot = tool_name.find('.');
    if (dot == std::string::npos) {
        return tool_name;
    }
    return tool_name.substr(0, dot);
}
 
std::string ServerManager::extract_local_name(
    const std::string& tool_name) {
    auto dot = tool_name.find('.');
    if (dot == std::string::npos) {
        return tool_name;
    }
    return tool_name.substr(dot + 1);
}
 
std::string ServerManager::args_to_pattern(
    const std::string& args_json) {
    if (args_json.empty() || args_json == "{}") {
        return "*";
    }
    try {
        auto j = nlohmann::json::parse(args_json);
        if (j.is_object() && !j.empty()) {
            auto first = j.begin();
            if (first->is_string()) {
                return first->get<std::string>();
            }
        }
    } catch (...) {
        // Parse failure — treat as wildcard
    }
    return "*";
}
 
// ── v1.8.7: External server methods ─────────────────────
 
void ServerManager::set_mcp_config(const MCPConfig& config) {
    mcp_config_ = config;
}
 
void ServerManager::interrupt_external_tools() {
    for (auto& [_, client] : external_snapshot()) {
        if (client) { client->interrupt(); }
    }
}
 
void ServerManager::clear_external_tool_interrupts() {
    for (auto& [_, client] : external_snapshot()) {
        if (client) { client->clear_interrupt(); }
    }
}
 
void ServerManager::initialize_external_servers() {
    connect_declared_servers();
    connect_discovered_servers();
 
    health_monitor_ = std::make_unique<HealthMonitor>(
        ReconnectPolicy(mcp_config_.reconnect),
        mcp_config_.health_check_interval_ms);
    for (auto& [name, client] : external_clients_) {
        health_monitor_->watch(name, client.get());
    }
    if (!external_clients_.empty()) {
        health_monitor_->start();
    }
    logger->info("External MCP: {} servers connected",
                 external_clients_.size());
}
 
void ServerManager::connect_declared_servers() {
    for (const auto& [name, entry] : mcp_config_.external_servers) {
        ExternalServerConfig probe;
        probe.name = name;
        probe.transport = entry.command.empty() ? "sse" : "stdio";
        probe.command = entry.command;
        probe.args = entry.args;
        if (launches_own_bridge(probe, own_bridge_socket_, project_dir_)) {
            logger->warn("[mcp] declared server '{}' would connect to this "
                         "handle's own bridge ({}) — refused (gh#200)",
                         name, own_bridge_socket_.string());
            continue;
        }
        auto client = create_external_client(name, entry);
        connect_and_register_external(name, std::move(client),
                                      "config", entry.url, entry.command);
    }
}
 
void ServerManager::connect_discovered_servers() {
    mcp_json_discovery_ = std::make_unique<MCPJsonDiscovery>(project_dir_);
    std::set<std::string> existing;
    for (const auto& [name, _] : servers_) { existing.insert(name); }
    for (const auto& [name, _] : external_clients_) { existing.insert(name); }
 
    for (const auto& cfg : mcp_json_discovery_->discover(existing)) {
        if (!admit_discovered(cfg)) { continue; }
        auto client = create_external_client(cfg);
        connect_and_register_external(cfg.name, std::move(client),
                                      "mcp_json", cfg.url, cfg.command);
    }
}
 
bool ServerManager::admit_discovered(const ExternalServerConfig& cfg) const {
    const char* why = nullptr;
    if (launches_own_bridge(cfg, own_bridge_socket_, project_dir_)) {
        why = "it would connect to this handle's own bridge (gh#200)";
    } else {
        switch (mcpjson_config_verdict(cfg.name, mcp_config_)) {
        case McpJsonConfigVerdict::disabled:
            why = "it is listed in mcp.disabled_mcpjson_servers";
            break;
        case McpJsonConfigVerdict::enabled:
            break;
        case McpJsonConfigVerdict::ask:
            if (discovered_approver_ == nullptr) {
                why = "it is not enabled and no PRE_MCP_SERVER_CONNECT hook "
                      "is registered to approve it";
            } else if (!discovered_approver_(
                           discovered_server_json(cfg, project_dir_),
                           discovered_approver_ud_)) {
                why = "the PRE_MCP_SERVER_CONNECT hook refused it";
            }
            break;
        }
    }
    if (why != nullptr) {
        logger->info("[mcp] discovered server '{}' not connected: {}",
                     cfg.name, why);
    }
    return why == nullptr;
}
 
void ServerManager::set_discovered_server_approver(
    DiscoveredServerApprover fn, void* user_data) {
    discovered_approver_ = fn;
    discovered_approver_ud_ = user_data;
}
 
void ServerManager::set_own_bridge_socket(const std::filesystem::path& socket) {
    own_bridge_socket_ = socket;
}
 
std::shared_ptr<ExternalMCPClient>
ServerManager::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) {
 
    ServerInfo info;
    info.name = name;
    info.transport = url.empty() ? "stdio" : "sse";
    info.url = url;
    info.command = command;
    info.source = source;
    info.status = "disconnected";
 
    bool ok = client->connect();
    if (ok) {
        info.status = "connected";
        info.connected_at = std::chrono::system_clock::now();
    } else {
        info.status = "error";
        logger->error("Failed to connect external server '{}'", name);
    }
 
    // gh#171: the connect above ran with no lock; registration re-checks the
    // name under it, because another thread may have registered it meanwhile.
    std::shared_ptr<ExternalMCPClient> shared = std::move(client);
    bool inserted = false;
    {
        std::unique_lock<std::shared_mutex> lock(*external_mutex_);
        inserted = external_clients_.emplace(name, shared).second;
        if (inserted) { server_info_[name] = info; }
    }
    if (!inserted) {
        logger->warn("External server '{}' was registered concurrently — "
                     "refusing the second connection", name);
        shared->disconnect();
        shared.reset();
    }
    return shared;
}
 
std::unique_ptr<Transport> ServerManager::make_transport(
    const ExternalServerConfig& spec) const {
    bool prefer_sse = (spec.transport == "sse")
        || (!spec.url.empty() && spec.command.empty());
    if (prefer_sse) {
        return std::make_unique<SSETransport>(spec.url);
    }
    // gh#19 (v2.1.5): pass the registered server name as the display
    // label so child stderr lines and lifecycle logs identify the
    // server, not the resolved spawn command (which collides when
    // multiple servers share an entrypoint like /usr/bin/env python).
    auto transport = std::make_unique<StdioTransport>(
        spec.name, spec.command, spec.args, spec.env,
        /*default_timeout_ms=*/30000U);
    // gh#166 (v2.13.0): spawn the child IN the repository its tools are
    // supposed to serve. An explicit spec value wins; otherwise the
    // manager's own root, which for a workspace is the workspace root.
    transport->set_working_dir(spec.working_dir.empty()
                                   ? project_dir_.string()
                                   : spec.working_dir);
    return transport;
}
 
std::vector<std::string> ServerManager::connect_external_server(
    const ExternalServerConfig& spec) {
 
    if (servers_.count(spec.name) > 0 || find_external(spec.name)) {
        logger->warn("Server '{}' already registered", spec.name);
        return {};
    }
 
    auto client = create_external_client(spec);  // gh#175: one factory
 
    // gh#171: the registered client comes back from registration rather than
    // being re-read with operator[], which INSERTED, unlocked, on a miss.
    auto registered = connect_and_register_external(
        spec.name, std::move(client), "runtime", spec.url, spec.command);
    if (!registered) { return {}; }
    if (health_monitor_) {
        health_monitor_->watch(spec.name, registered.get());
    }
 
    // Parse tool names from cached list
    std::vector<std::string> tool_names;
    auto tools_json = registered->list_tools();
    try {
        auto tools = nlohmann::json::parse(tools_json);
        for (const auto& t : tools) {
            tool_names.push_back(t["name"].get<std::string>());
        }
    } catch (...) {}
 
    return tool_names;
}
 
std::vector<std::string> ServerManager::connect_external_server(
    const std::string& name,
    const std::string& command,
    const std::vector<std::string>& args,
    const std::string& url) {
    ExternalServerConfig spec;
    spec.name = name;
    spec.command = command;
    spec.args = args;
    spec.url = url;
    return connect_external_server(spec);
}
 
void ServerManager::disconnect_external_server(
    const std::string& name) {
 
    std::shared_ptr<ExternalMCPClient> client;
    {
        std::unique_lock<std::shared_mutex> lock(*external_mutex_);
        auto it = external_clients_.find(name);
        if (it != external_clients_.end()) {
            client = std::move(it->second);
            external_clients_.erase(it);
            server_info_.erase(name);
        }
    }
    if (!client) {
        logger->warn("External server '{}' not found", name);
        return;
    }
    if (health_monitor_) {
        health_monitor_->unwatch(name);
    }
    // gh#171: a call already routed to this client still holds its own
    // reference; the client is destroyed when the last one drops.
    client->disconnect();
 
    logger->info("External server '{}' disconnected", name);
}
 
std::map<std::string, ServerInfo>
ServerManager::list_server_info() const {
    std::map<std::string, ServerInfo> result;
    {
        std::shared_lock<std::shared_mutex> lock(*external_mutex_);
        result = server_info_;
    }
 
    // Add in-process servers
    for (const auto& [name, _] : servers_) {
        if (result.count(name) == 0) {
            ServerInfo info;
            info.name = name;
            info.transport = "in_process";
            info.status = "connected";
            info.source = "builtin";
            result[name] = info;
        }
    }
 
    // gh#133 (v2.10.1): plugins report their own transport so `entropic
    // inspect` distinguishes them from builtins and external processes.
    for (const auto& [name, plugin] : plugin_servers_) {
        if (result.count(name) == 0) {
            ServerInfo info;
            info.name = name;
            info.transport = "plugin";
            info.status = "connected";
            info.source = "plugin";
            info.command = plugin->path().string();
            result[name] = info;
        }
    }
    return result;
}
 
void ServerManager::process_health_events() {
    if (health_monitor_) {
        health_monitor_->process_events();
    }
}
 
static std::string expand_workspace_root(std::string s, const std::string& root) {
    static const std::string key = "${ENTROPIC_WORKSPACE_ROOT}";
    for (auto p = s.find(key); p != std::string::npos;
         p = s.find(key, p + root.size())) {
        s.replace(p, key.size(), root);
    }
    return s;
}
 
std::unique_ptr<ExternalMCPClient>
ServerManager::create_external_client(
    const std::string& name,
    const ExternalServerEntry& entry) {
    const auto root = project_dir_.string();
    ExternalServerConfig spec;
    spec.name = name;
    spec.command = entry.command;
    for (const auto& a : entry.args) { spec.args.push_back(expand_workspace_root(a, root)); }
    for (const auto& [k, v] : entry.env) { spec.env[k] = expand_workspace_root(v, root); }
    spec.url = entry.url;
    spec.transport = entry.url.empty() ? "stdio" : "sse";
    return create_external_client(spec);
}
 
std::unique_ptr<ExternalMCPClient>
ServerManager::create_external_client(
    const ExternalServerConfig& config) {
    auto client = std::make_unique<ExternalMCPClient>(
        config.name, make_transport(config));
    // gh#175: mcp.server_timeout_seconds bounds bring-up. Every client is
    // built here — declared, discovered and runtime — so none can miss it.
    client->set_init_timeout_ms(
        static_cast<uint32_t>(mcp_config_.server_timeout_seconds) * 1000u);
    return client;
}
 
std::string ServerManager::disconnected_error(
    const std::string& tool_name,
    const std::string& server_name) {
 
    nlohmann::json resp;
    resp["result"] = "Server '" + server_name +
                     "' is disconnected. Tool '" + tool_name +
                     "' is unavailable. Use a different approach "
                     "or try again later.";
    resp["directives"] = nlohmann::json::array();
    resp["is_error"] = true;
    return resp.dump();
}
 
std::vector<std::pair<std::string, std::shared_ptr<ExternalMCPClient>>>
ServerManager::external_snapshot() const {
    std::shared_lock<std::shared_mutex> lock(*external_mutex_);
    return {external_clients_.begin(), external_clients_.end()};
}
 
std::shared_ptr<ExternalMCPClient>
ServerManager::find_external(const std::string& name) const {
    std::shared_lock<std::shared_mutex> lock(*external_mutex_);
    auto it = external_clients_.find(name);
    return it == external_clients_.end() ? nullptr : it->second;
}
 
} // namespace entropic