discovery_policy.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/mcp/mcp_json_discovery.h>
#include <entropic/types/config.h>
 
#include <algorithm>
#include <filesystem>
#include <string>
#include <vector>
 
#include <nlohmann/json.hpp>
 
namespace entropic {
 
enum class McpJsonConfigVerdict {
    disabled,  
    enabled,   
    ask        
};
 
inline McpJsonConfigVerdict mcpjson_config_verdict(const std::string& name,
                                                   const MCPConfig& cfg) {
    auto named = [&name](const std::vector<std::string>& list) {
        return std::find(list.begin(), list.end(), name) != list.end();
    };
    if (named(cfg.disabled_mcpjson_servers)) {
        return McpJsonConfigVerdict::disabled;
    }
    const bool on = cfg.enable_all_project_mcp_servers
                 || named(cfg.enabled_mcpjson_servers);
    return on ? McpJsonConfigVerdict::enabled : McpJsonConfigVerdict::ask;
}
 
inline std::string arg_after(const std::vector<std::string>& args,
                             const std::string& flag) {
    auto it = std::find(args.begin(), args.end(), flag);
    return (it == args.end() || it + 1 == args.end()) ? std::string{} : *(it + 1);
}
 
inline bool is_entropic_bridge(const ExternalServerConfig& cfg) {
    const bool cmd = std::filesystem::path(cfg.command).filename() == "entropic";
    const bool sub = std::find(cfg.args.begin(), cfg.args.end(), "mcp-bridge")
                     != cfg.args.end();
    return cfg.transport == "stdio" && cmd && sub;
}
 
inline bool launches_own_bridge(const ExternalServerConfig& cfg,
                                const std::filesystem::path& own_socket,
                                const std::filesystem::path& spawn_root) {
    namespace fs = std::filesystem;
    bool self = false;
    if (!own_socket.empty() && is_entropic_bridge(cfg)) {
        const auto sock = arg_after(cfg.args, "--socket");
        auto dir = arg_after(cfg.args, "--project-dir");
        if (dir.empty()) {
            dir = cfg.working_dir.empty() ? spawn_root.string() : cfg.working_dir;
        }
        const fs::path target = !sock.empty()
            ? fs::path(sock) : compute_socket_path(fs::weakly_canonical(dir));
        self = fs::weakly_canonical(target) == fs::weakly_canonical(own_socket);
    }
    return self;
}
 
inline std::string discovered_server_json(const ExternalServerConfig& cfg,
                                          const std::filesystem::path& root) {
    nlohmann::json j;
    j["name"] = cfg.name;
    j["transport"] = cfg.transport;
    j["command"] = cfg.command;
    j["args"] = cfg.args;
    j["url"] = cfg.url;
    j["root"] = cfg.working_dir.empty() ? root.string() : cfg.working_dir;
    return j.dump();
}
 
}  // namespace entropic