plugin_server.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/mcp/plugin_server.h>
#include <entropic/types/logging.h>
 
#include <dlfcn.h>
 
#include <utility>
 
static auto logger = entropic::log::get("mcp.plugin");
 
namespace entropic {
 
PluginServer::PluginServer(void* handle, std::filesystem::path path)
    : handle_(handle), path_(std::move(path)) {}
 
PluginServer::~PluginServer() {
    if (instance_ != nullptr && destroy_fn_ != nullptr) {
        destroy_fn_(instance_);
        instance_ = nullptr;
    }
    if (handle_ != nullptr) {
        dlclose(handle_);
        handle_ = nullptr;
    }
}
 
entropic_error_t PluginServer::load(const std::filesystem::path& path,
                                    std::unique_ptr<PluginServer>& out) {
    // RTLD_LOCAL keeps plugin symbols out of the global namespace so two
    // plugins exporting the same entry-point names cannot collide.
    dlerror();  // clear any stale error before the call
    void* handle = dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL);
    if (handle == nullptr) {
        const char* err = dlerror();
        logger->error("Plugin load failed: dlopen('{}'): {}", path.string(),
                      (err != nullptr) ? err : "unknown error");
        return ENTROPIC_ERROR_PLUGIN_LOAD_FAILED;
    }
 
    // Adopt the handle immediately so every failure path below closes it.
    std::unique_ptr<PluginServer> plugin(new PluginServer(handle, path));
    auto rc = plugin->resolve_and_init();
    if (rc != ENTROPIC_OK) {
        return rc;
    }
 
    logger->info("Loaded MCP plugin '{}' from {}", plugin->name_,
                 path.string());
    out = std::move(plugin);
    return ENTROPIC_OK;
}
 
entropic_error_t PluginServer::resolve_and_init() {
    auto rc = resolve_and_check_version();
    if (rc != ENTROPIC_OK) {
        return rc;
    }
    return create_instance();
}
 
entropic_error_t PluginServer::create_instance() {
    instance_ = create_fn_();
    if (instance_ == nullptr) {
        logger->error("Plugin load failed: entropic_create_server() returned "
                      "NULL for {}", path_.string());
        return ENTROPIC_ERROR_PLUGIN_LOAD_FAILED;
    }
 
    const char* raw_name = name_fn_(instance_);
    name_ = (raw_name != nullptr) ? raw_name : "";
    if (name_.empty()) {
        logger->error("Plugin load failed: entropic_mcp_server_name() gave an "
                      "empty name for {} — the name is the tool-routing "
                      "prefix and cannot be blank", path_.string());
        return ENTROPIC_ERROR_PLUGIN_LOAD_FAILED;
    }
    return ENTROPIC_OK;
}
 
entropic_error_t PluginServer::resolve_and_check_version() {
    if (!resolve_symbols()) {
        return ENTROPIC_ERROR_PLUGIN_LOAD_FAILED;
    }
 
    const int reported = version_fn_();
    if (reported != ENTROPIC_MCP_PLUGIN_API_VERSION) {
        logger->error("Plugin version mismatch for {}: plugin reports API "
                      "version {}, this engine implements {}. Rebuild the "
                      "plugin against matching entropic headers.",
                      path_.string(), reported,
                      ENTROPIC_MCP_PLUGIN_API_VERSION);
        return ENTROPIC_ERROR_PLUGIN_VERSION_MISMATCH;
    }
    return ENTROPIC_OK;
}
 
bool PluginServer::resolve_symbols() {
    // Both halves run unconditionally: a plugin missing several entry points
    // should be told about all of them in one build/run cycle.
    const bool factory_ok = resolve_factory_symbols();
    const bool instance_ok = resolve_instance_symbols();
    return factory_ok && instance_ok;
}
 
void* PluginServer::resolve_one(const char* symbol_name, bool& ok) const {
    // The void*-to-function-pointer round trip is the POSIX dlsym idiom;
    // conditionally-supported in ISO C++ but well-defined on every platform
    // this engine targets.
    void* addr = dlsym(handle_, symbol_name);
    if (addr == nullptr) {
        logger->error("Plugin {}: missing required entry point '{}'",
                      path_.string(), symbol_name);
        ok = false;
    }
    return addr;
}
 
bool PluginServer::resolve_factory_symbols() {
    bool ok = true;
    version_fn_ = reinterpret_cast<version_fn_t>(
        resolve_one("entropic_plugin_api_version", ok));
    create_fn_ = reinterpret_cast<create_fn_t>(
        resolve_one("entropic_create_server", ok));
    name_fn_ = reinterpret_cast<name_fn_t>(
        resolve_one("entropic_mcp_server_name", ok));
    free_fn_ = reinterpret_cast<free_fn_t>(
        resolve_one("entropic_free", ok));
    return ok;
}
 
bool PluginServer::resolve_instance_symbols() {
    bool ok = true;
    list_tools_fn_ = reinterpret_cast<list_tools_fn_t>(
        resolve_one("entropic_mcp_server_list_tools", ok));
    execute_fn_ = reinterpret_cast<execute_fn_t>(
        resolve_one("entropic_mcp_server_execute", ok));
    configure_fn_ = reinterpret_cast<configure_fn_t>(
        resolve_one("entropic_mcp_server_configure", ok));
    set_dir_fn_ = reinterpret_cast<set_dir_fn_t>(
        resolve_one("entropic_mcp_server_set_working_dir", ok));
    destroy_fn_ = reinterpret_cast<destroy_fn_t>(
        resolve_one("entropic_mcp_server_destroy", ok));
    return ok;
}
 
std::string PluginServer::take_string(char* raw) const {
    if (raw == nullptr) {
        return {};
    }
    std::string copy;
    try {
        copy.assign(raw);
    } catch (...) {
        free_fn_(raw);
        throw;
    }
    free_fn_(raw);
    return copy;
}
 
std::string PluginServer::list_tools() const {
    std::lock_guard<std::mutex> lock(call_mutex_);
    auto tools = take_string(list_tools_fn_(instance_));
    return tools.empty() ? "[]" : tools;
}
 
std::string PluginServer::execute(const std::string& tool_name,
                                  const std::string& args_json) {
    std::lock_guard<std::mutex> lock(call_mutex_);
    return take_string(
        execute_fn_(instance_, tool_name.c_str(), args_json.c_str()));
}
 
entropic_error_t PluginServer::configure(const std::string& config_json) {
    std::lock_guard<std::mutex> lock(call_mutex_);
    return configure_fn_(instance_, config_json.c_str());
}
 
entropic_error_t PluginServer::set_working_dir(const std::string& dir) {
    std::lock_guard<std::mutex> lock(call_mutex_);
    return set_dir_fn_(instance_, dir.c_str());
}
 
} // namespace entropic