Sprint 1: Add McpServer.cpp — working HTTP server with MCP JSON-RPC

Source/McpServer.cpp

@@ -0,0 +1,260 @@
+#include "McpServer.h"
+
+// httplib must be included in exactly ONE .cpp file
+#define CPPHTTPLIB_THREAD_POOL_COUNT 2
+#include "httplib.h"
+#include "json.hpp"
+
+using json = nlohmann::json;
+
+McpServer::McpServer(int port)
+    : server(std::make_unique<httplib::Server>()), port(port)
+{
+    setupRoutes();
+}
+
+McpServer::~McpServer()
+{
+    stop();
+}
+
+void McpServer::setupRoutes()
+{
+    // Single MCP endpoint — all JSON-RPC goes through here
+    server->Post("/mcp", [this](const httplib::Request& req, httplib::Response& res) {
+        res.set_header("Access-Control-Allow-Origin", "http://localhost");
+
+        try {
+            auto body = json::parse(req.body);
+            std::string method = body.value("method", "");
+            std::string responseStr;
+
+            if (method == "initialize") {
+                responseStr = handleInitialize(req.body);
+            }
+            else if (method == "notifications/initialized") {
+                // Notification — no response needed
+                initialized = true;
+                res.status = 204;
+                return;
+            }
+            else if (method == "tools/list") {
+                responseStr = handleToolsList();
+            }
+            else if (method == "tools/call") {
+                responseStr = handleToolsCall(req.body);
+            }
+            else {
+                json errResponse = {
+                    {"jsonrpc", "2.0"},
+                    {"id", body.value("id", json(nullptr))},
+                    {"error", {{"code", -32601}, {"message", "Method not found"}}}
+                };
+                responseStr = errResponse.dump();
+            }
+
+            if (!responseStr.empty()) {
+                res.set_content(responseStr, "application/json");
+            }
+        }
+        catch (const json::exception& e) {
+            json errResponse = {
+                {"jsonrpc", "2.0"},
+                {"id", nullptr},
+                {"error", {{"code", -32700}, {"message", "Parse error"}}}
+            };
+            res.set_content(errResponse.dump(), "application/json");
+        }
+    });
+
+    // Health check — quick way to verify server is alive
+    server->Get("/health", [this](const httplib::Request&, httplib::Response& res) {
+        json health = {{"status", "ok"}, {"port", port}, {"initialized", initialized}};
+        res.set_content(health.dump(), "application/json");
+    });
+
+    // CORS preflight
+    server->Options("/mcp", [](const httplib::Request&, httplib::Response& res) {
+        res.set_header("Access-Control-Allow-Origin", "http://localhost");
+        res.set_header("Access-Control-Allow-Methods", "POST, OPTIONS");
+        res.set_header("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
+        res.status = 204;
+    });
+}
+
+void McpServer::start()
+{
+    if (running.load()) return;
+
+    serverThread = std::thread([this]() {
+        running.store(true);
+        server->listen("127.0.0.1", port);
+        running.store(false);
+    });
+
+    // Wait until server is actually ready
+    server->wait_until_ready();
+}
+
+void McpServer::stop()
+{
+    if (server && server->is_running()) {
+        server->stop();
+    }
+    if (serverThread.joinable()) {
+        serverThread.join();
+    }
+    running.store(false);
+}
+
+bool McpServer::isRunning() const
+{
+    return running.load();
+}
+
+void McpServer::serverThreadFunc()
+{
+    server->listen("127.0.0.1", port);
+}
+
+// --- MCP Protocol Handlers ---
+
+std::string McpServer::handleInitialize(const std::string& requestBody)
+{
+    auto body = json::parse(requestBody);
+
+    // Generate session ID
+    sessionId = "pb-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count());
+
+    json response = {
+        {"jsonrpc", "2.0"},
+        {"id", body.value("id", json(nullptr))},
+        {"result", {
+            {"protocolVersion", "2025-06-18"},
+            {"capabilities", {
+                {"tools", {{"listChanged", false}}}
+            }},
+            {"serverInfo", {
+                {"name", "PluginBridge"},
+                {"version", "0.1.0"}
+            }}
+        }}
+    };
+
+    return response.dump();
+}
+
+std::string McpServer::handleToolsList()
+{
+    json response = {
+        {"jsonrpc", "2.0"},
+        {"id", 1},
+        {"result", {
+            {"tools", json::array({
+                {
+                    {"name", "list_plugins"},
+                    {"description", "List all loaded plugin instances"},
+                    {"inputSchema", {{"type", "object"}, {"properties", json::object()}}}
+                },
+                {
+                    {"name", "search_param"},
+                    {"description", "Search plugin parameters by keyword"},
+                    {"inputSchema", {
+                        {"type", "object"},
+                        {"properties", {
+                            {"plugin", {{"type", "string"}, {"description", "Plugin name"}}},
+                            {"keyword", {{"type", "string"}, {"description", "Search term"}}}
+                        }},
+                        {"required", json::array({"plugin", "keyword"})}
+                    }}
+                },
+                {
+                    {"name", "get_params"},
+                    {"description", "Get current values for parameter IDs"},
+                    {"inputSchema", {
+                        {"type", "object"},
+                        {"properties", {
+                            {"plugin", {{"type", "string"}}},
+                            {"ids", {{"type", "array"}, {"items", {{"type", "integer"}}}}}
+                        }},
+                        {"required", json::array({"plugin", "ids"})}
+                    }}
+                },
+                {
+                    {"name", "set_params"},
+                    {"description", "Set parameter values by ID (batch)"},
+                    {"inputSchema", {
+                        {"type", "object"},
+                        {"properties", {
+                            {"plugin", {{"type", "string"}}},
+                            {"values", {{"type", "object"}, {"description", "param_id → value (0.0-1.0)"}}}
+                        }},
+                        {"required", json::array({"plugin", "values"})}
+                    }}
+                },
+                {
+                    {"name", "get_analysis"},
+                    {"description", "Get real-time audio analysis (LUFS, bands, stereo)"},
+                    {"inputSchema", {{"type", "object"}, {"properties", json::object()}}}
+                }
+            })}
+        }}
+    };
+
+    return response.dump();
+}
+
+std::string McpServer::handleToolsCall(const std::string& requestBody)
+{
+    auto body = json::parse(requestBody);
+    std::string toolName = body["params"]["name"];
+
+    json result;
+
+    if (toolName == "list_plugins") {
+        // Sprint 1: no plugins loaded yet
+        result = {
+            {"content", json::array({{{"type", "text"}, {"text", "[]"}}})},
+            {"isError", false}
+        };
+    }
+    else if (toolName == "search_param") {
+        result = {
+            {"content", json::array({{{"type", "text"}, {"text", "no plugin loaded"}}})},
+            {"isError", true}
+        };
+    }
+    else if (toolName == "get_params") {
+        result = {
+            {"content", json::array({{{"type", "text"}, {"text", "no plugin loaded"}}})},
+            {"isError", true}
+        };
+    }
+    else if (toolName == "set_params") {
+        result = {
+            {"content", json::array({{{"type", "text"}, {"text", "no plugin loaded"}}})},
+            {"isError", true}
+        };
+    }
+    else if (toolName == "get_analysis") {
+        // Sprint 1: stub response
+        result = {
+            {"content", json::array({{{"type", "text"}, {"text", "silent"}}})},
+            {"isError", false}
+        };
+    }
+    else {
+        result = {
+            {"content", json::array({{{"type", "text"}, {"text", "unknown tool: " + toolName}}})},
+            {"isError", true}
+        };
+    }
+
+    json response = {
+        {"jsonrpc", "2.0"},
+        {"id", body.value("id", json(nullptr))},
+        {"result", result}
+    };
+
+    return response.dump();
+}