Sprint 2: Update McpServer.cpp \u2014 wire all 5 MCP tools to HostedPluginManager

Source/McpServer.cpp

@@ -1,14 +1,17 @@
 #include "McpServer.h"
+#include "HostedPluginManager.h"
 
-// httplib must be included in exactly ONE .cpp file
+// httplib included in exactly ONE .cpp
 #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)
+McpServer::McpServer(int port, HostedPluginManager& pluginManager)
+    : server(std::make_unique<httplib::Server>()),
+      port(port),
+      pluginManager(pluginManager)
 {
     setupRoutes();
 }
@@ -20,7 +23,7 @@ McpServer::~McpServer()
 
 void McpServer::setupRoutes()
 {
-    // Single MCP endpoint — all JSON-RPC goes through here
+    // Single MCP endpoint
     server->Post("/mcp", [this](const httplib::Request& req, httplib::Response& res) {
         res.set_header("Access-Control-Allow-Origin", "http://localhost");
 
@@ -33,13 +36,12 @@ void McpServer::setupRoutes()
                 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();
+                responseStr = handleToolsList(req.body);
             }
             else if (method == "tools/call") {
                 responseStr = handleToolsCall(req.body);
@@ -53,11 +55,10 @@ void McpServer::setupRoutes()
                 responseStr = errResponse.dump();
             }
 
-            if (!responseStr.empty()) {
+            if (!responseStr.empty())
                 res.set_content(responseStr, "application/json");
-            }
         }
-        catch (const json::exception& e) {
+        catch (const json::exception&) {
             json errResponse = {
                 {"jsonrpc", "2.0"},
                 {"id", nullptr},
@@ -67,9 +68,15 @@ void McpServer::setupRoutes()
         }
     });
 
-    // Health check — quick way to verify server is alive
+    // Health check
     server->Get("/health", [this](const httplib::Request&, httplib::Response& res) {
-        json health = {{"status", "ok"}, {"port", port}, {"initialized", initialized}};
+        json health = {
+            {"status", "ok"},
+            {"port", port},
+            {"initialized", initialized},
+            {"plugin", pluginManager.isLoaded() ? pluginManager.getPluginName().toStdString() : "none"},
+            {"params", pluginManager.getParameterCount()}
+        };
         res.set_content(health.dump(), "application/json");
     });
 
@@ -92,18 +99,15 @@ void McpServer::start()
         running.store(false);
     });
 
-    // Wait until server is actually ready
     server->wait_until_ready();
 }
 
 void McpServer::stop()
 {
-    if (server && server->is_running()) {
+    if (server && server->is_running())
         server->stop();
-    }
-    if (serverThread.joinable()) {
+    if (serverThread.joinable())
         serverThread.join();
-    }
     running.store(false);
 }
 
@@ -112,18 +116,11 @@ 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 = {
@@ -131,39 +128,35 @@ std::string McpServer::handleInitialize(const std::string& requestBody)
         {"id", body.value("id", json(nullptr))},
         {"result", {
             {"protocolVersion", "2025-06-18"},
-            {"capabilities", {
-                {"tools", {{"listChanged", false}}}
-            }},
-            {"serverInfo", {
-                {"name", "PluginBridge"},
-                {"version", "0.1.0"}
-            }}
+            {"capabilities", {{"tools", {{"listChanged", false}}}}},
+            {"serverInfo", {{"name", "PluginBridge"}, {"version", "0.2.0"}}}
         }}
     };
-
     return response.dump();
 }
 
-std::string McpServer::handleToolsList()
+std::string McpServer::handleToolsList(const std::string& requestBody)
 {
+    auto body = json::parse(requestBody);
+
     json response = {
         {"jsonrpc", "2.0"},
-        {"id", 1},
+        {"id", body.value("id", json(nullptr))},
         {"result", {
             {"tools", json::array({
                 {
                     {"name", "list_plugins"},
-                    {"description", "List all loaded plugin instances"},
+                    {"description", "List loaded plugin instances"},
                     {"inputSchema", {{"type", "object"}, {"properties", json::object()}}}
                 },
                 {
                     {"name", "search_param"},
-                    {"description", "Search plugin parameters by keyword"},
+                    {"description", "Search plugin parameters by keyword. Returns matching param IDs and values."},
                     {"inputSchema", {
                         {"type", "object"},
                         {"properties", {
                             {"plugin", {{"type", "string"}, {"description", "Plugin name"}}},
-                            {"keyword", {{"type", "string"}, {"description", "Search term"}}}
+                            {"keyword", {{"type", "string"}, {"description", "Search term (e.g. 'band 1', 'gain', 'cutoff')"}}}
                         }},
                         {"required", json::array({"plugin", "keyword"})}
                     }}
@@ -182,79 +175,145 @@ std::string McpServer::handleToolsList()
                 },
                 {
                     {"name", "set_params"},
-                    {"description", "Set parameter values by ID (batch)"},
+                    {"description", "Set parameter values by ID (batch). Values are 0.0-1.0 normalized."},
                     {"inputSchema", {
                         {"type", "object"},
                         {"properties", {
                             {"plugin", {{"type", "string"}}},
-                            {"values", {{"type", "object"}, {"description", "param_id → value (0.0-1.0)"}}}
+                            {"values", {{"type", "object"}, {"description", "Map of param_index (string) to value (0.0-1.0)"}}}
                         }},
                         {"required", json::array({"plugin", "values"})}
                     }}
                 },
                 {
                     {"name", "get_analysis"},
-                    {"description", "Get real-time audio analysis (LUFS, bands, stereo)"},
+                    {"description", "Get real-time audio analysis (LUFS, frequency bands, stereo width)"},
                     {"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"];
+    auto params = body["params"];
+    std::string toolName = params["name"];
+    auto args = params.value("arguments", json::object());
 
-    json result;
+    std::string resultText;
+    bool isError = false;
 
     if (toolName == "list_plugins") {
-        // Sprint 1: no plugins loaded yet
-        result = {
-            {"content", json::array({{{"type", "text"}, {"text", "[]"}}})},
-            {"isError", false}
-        };
+        resultText = toolListPlugins();
     }
     else if (toolName == "search_param") {
-        result = {
-            {"content", json::array({{{"type", "text"}, {"text", "no plugin loaded"}}})},
-            {"isError", true}
-        };
+        resultText = toolSearchParam(
+            args.value("plugin", ""),
+            args.value("keyword", ""));
     }
     else if (toolName == "get_params") {
-        result = {
-            {"content", json::array({{{"type", "text"}, {"text", "no plugin loaded"}}})},
-            {"isError", true}
-        };
+        resultText = toolGetParams(
+            args.value("plugin", ""),
+            args.value("ids", json::array()).dump());
     }
     else if (toolName == "set_params") {
-        result = {
-            {"content", json::array({{{"type", "text"}, {"text", "no plugin loaded"}}})},
-            {"isError", true}
-        };
+        resultText = toolSetParams(
+            args.value("plugin", ""),
+            args.value("values", json::object()).dump());
     }
     else if (toolName == "get_analysis") {
-        // Sprint 1: stub response
-        result = {
-            {"content", json::array({{{"type", "text"}, {"text", "silent"}}})},
-            {"isError", false}
-        };
+        resultText = toolGetAnalysis();
     }
     else {
-        result = {
-            {"content", json::array({{{"type", "text"}, {"text", "unknown tool: " + toolName}}})},
-            {"isError", true}
-        };
+        resultText = "unknown tool: " + toolName;
+        isError = true;
     }
 
     json response = {
         {"jsonrpc", "2.0"},
         {"id", body.value("id", json(nullptr))},
-        {"result", result}
+        {"result", {
+            {"content", json::array({{{"type", "text"}, {"text", resultText}}})},
+            {"isError", isError}
+        }}
     };
-
     return response.dump();
 }
+
+// --- Tool Implementations ---
+
+std::string McpServer::toolListPlugins()
+{
+    if (!pluginManager.isLoaded())
+        return "[]";
+
+    json result = json::array({pluginManager.getPluginName().toStdString()});
+    return result.dump();
+}
+
+std::string McpServer::toolSearchParam(const std::string& /*plugin*/, const std::string& keyword)
+{
+    if (!pluginManager.isLoaded())
+        return "no plugin loaded";
+
+    auto results = pluginManager.searchParams(juce::String(keyword));
+
+    if (results.empty())
+        return "no matches for '" + keyword + "'";
+
+    // Compact output: [{id, name, value}]
+    json output = json::array();
+    for (auto& p : results)
+    {
+        output.push_back({
+            {"i", p.index},
+            {"n", p.name.toStdString()},
+            {"v", std::round(p.value * 1000.0f) / 1000.0f},
+            {"t", p.displayText.toStdString()}
+        });
+    }
+    return output.dump();
+}
+
+std::string McpServer::toolGetParams(const std::string& /*plugin*/, const std::string& idsJson)
+{
+    if (!pluginManager.isLoaded())
+        return "no plugin loaded";
+
+    auto idsArray = json::parse(idsJson);
+    std::vector<int> ids;
+    for (auto& id : idsArray)
+        ids.push_back(id.get<int>());
+
+    auto results = pluginManager.getParams(ids);
+
+    // Compact: {id: value, id: value}
+    json output = json::object();
+    for (auto& [idx, val] : results)
+        output[std::to_string(idx)] = std::round(val * 1000.0f) / 1000.0f;
+
+    return output.dump();
+}
+
+std::string McpServer::toolSetParams(const std::string& /*plugin*/, const std::string& valuesJson)
+{
+    if (!pluginManager.isLoaded())
+        return "no plugin loaded";
+
+    auto valuesObj = json::parse(valuesJson);
+    std::map<int, float> values;
+    for (auto& [key, val] : valuesObj.items())
+        values[std::stoi(key)] = val.get<float>();
+
+    bool ok = pluginManager.setParams(values);
+    return ok ? "ok" : "error";
+}
+
+std::string McpServer::toolGetAnalysis()
+{
+    // Sprint 4: will return real analysis
+    return "silent";
+}