Cleanup: Remove old in-process Source/ files (replaced by Source/Plugin/ and Source/Helper/)

Source/AudioAnalyser.cpp

@@ -1,7 +0,0 @@
-#include "AudioAnalyser.h"
-
-// Phase 2: Full implementation with:
-// - prepareToPlay(sampleRate, blockSize)
-// - processBlock(buffer) — called from audio thread
-// - getCompactAnalysis() — thread-safe query from HTTP thread
-// - LUFS (Ebu128LoudnessMeter), FFT bands, stereo width, True Peak

Source/AudioAnalyser.h

@@ -1,11 +0,0 @@
-#pragma once
-
-// Phase 2 stub — will be implemented in Sprint 4
-// Real-time audio analysis: LUFS, FFT bands, stereo width, True Peak
-
-class AudioAnalyser
-{
-public:
-    AudioAnalyser() = default;
-    ~AudioAnalyser() = default;
-};

Source/HostedPluginManager.cpp

@@ -1,268 +0,0 @@
-#include "HostedPluginManager.h"
-
-HostedPluginManager::HostedPluginManager()
-{
-    #if JUCE_PLUGINHOST_VST3
-    formatManager.addFormat(new juce::VST3PluginFormat());
-    #endif
-    #if JUCE_PLUGINHOST_AU
-    formatManager.addFormat(new juce::AudioUnitPluginFormat());
-    #endif
-}
-
-HostedPluginManager::~HostedPluginManager()
-{
-    unloadPlugin();
-}
-
-bool HostedPluginManager::validatePluginFile(const juce::File& pluginFile)
-{
-    // Use a child process to test if the plugin can be loaded without crashing
-    // The child process runs: pluginval-style check — just tries to dlopen the binary
-    // If the child crashes, we know the plugin is unsafe to load in-process
-    
-    juce::ChildProcess validator;
-    
-    // Use macOS 'file' command on the binary inside the bundle to verify it's a valid Mach-O
-    // This doesn't execute plugin code, just validates the binary exists and is loadable
-    juce::File binary;
-    if (pluginFile.getFileExtension() == ".vst3")
-        binary = pluginFile.getChildFile("Contents/MacOS")
-                     .findChildFiles(juce::File::findFiles, false).getFirst();
-    else
-        binary = pluginFile.getChildFile("Contents/MacOS")
-                     .findChildFiles(juce::File::findFiles, false).getFirst();
-    
-    if (!binary.exists())
-        return false;
-    
-    // Quick validation: check binary is valid Mach-O using 'file' command
-    if (!validator.start("file " + binary.getFullPathName().quoted()))
-        return false;
-    
-    validator.waitForProcessToFinish(2000); // 2 second timeout
-    auto output = validator.readAllProcessOutput();
-    
-    // If it contains "Mach-O" it's at least a valid binary
-    return output.contains("Mach-O");
-}
-
-void HostedPluginManager::loadPlugin(const juce::File& pluginFile,
-                                      double sampleRate, int blockSize)
-{
-    unloadPlugin();
-
-    currentSampleRate = sampleRate;
-    currentBlockSize = blockSize;
-
-    // Quick sanity check — is this even a valid plugin bundle?
-    if (!validatePluginFile(pluginFile))
-    {
-        DBG("PluginBridge: Invalid plugin binary: " + pluginFile.getFullPathName());
-        lastError = "Invalid plugin binary";
-        return;
-    }
-
-    juce::OwnedArray<juce::PluginDescription> typesFound;
-
-    // Install signal handler to catch SIGABRT from misbehaving plugins
-    // Note: this won't fully prevent crashes from plugins that call abort()
-    // but gives us a fighting chance with ObjC exceptions
-    
-    for (int i = 0; i < formatManager.getNumFormats(); ++i)
-    {
-        auto* format = formatManager.getFormat(i);
-        
-        // Only try the format that matches the file extension
-        bool isVST3 = pluginFile.getFileExtension() == ".vst3";
-        bool isAU = pluginFile.getFileExtension() == ".component";
-        
-        if (isVST3 && format->getName() != "VST3") continue;
-        if (isAU && format->getName() != "AudioUnit") continue;
-        
-        format->findAllTypesForFile(typesFound, pluginFile.getFullPathName());
-        if (typesFound.size() > 0)
-            break;
-    }
-
-    if (typesFound.isEmpty())
-    {
-        DBG("PluginBridge: No plugin found in file: " + pluginFile.getFullPathName());
-        lastError = "Plugin not recognized";
-        return;
-    }
-
-    auto desc = *typesFound[0];
-
-    // Create instance asynchronously (safer — allows message loop to run)
-    formatManager.createPluginInstanceAsync(desc, sampleRate, blockSize,
-        [this, pluginFile](std::unique_ptr<juce::AudioPluginInstance> instance,
-                           const juce::String& error)
-        {
-            if (instance == nullptr)
-            {
-                DBG("PluginBridge: Failed to create plugin: " + error);
-                lastError = error;
-                return;
-            }
-
-            instance->enableAllBuses();
-
-            auto layout = juce::AudioProcessor::BusesLayout();
-            layout.inputBuses.add(juce::AudioChannelSet::stereo());
-            layout.outputBuses.add(juce::AudioChannelSet::stereo());
-
-            if (instance->checkBusesLayoutSupported(layout))
-                instance->setBusesLayout(layout);
-
-            instance->prepareToPlay(currentSampleRate, currentBlockSize);
-
-            {
-                const juce::ScopedLock sl(pluginLock);
-                hostedPlugin = std::move(instance);
-                loadedPluginPath = pluginFile.getFullPathName();
-                lastError.clear();
-            }
-
-            DBG("PluginBridge: Loaded plugin: " + getPluginName()
-                + " (" + juce::String(getParameterCount()) + " params)");
-        });
-}
-
-void HostedPluginManager::unloadPlugin()
-{
-    const juce::ScopedLock sl(pluginLock);
-    if (hostedPlugin)
-    {
-        hostedPlugin->releaseResources();
-        hostedPlugin.reset();
-        loadedPluginPath.clear();
-    }
-}
-
-bool HostedPluginManager::isLoaded() const
-{
-    return hostedPlugin != nullptr;
-}
-
-juce::String HostedPluginManager::getPluginName() const
-{
-    if (hostedPlugin)
-        return hostedPlugin->getName();
-    return {};
-}
-
-void HostedPluginManager::prepareToPlay(double sampleRate, int blockSize)
-{
-    currentSampleRate = sampleRate;
-    currentBlockSize = blockSize;
-
-    const juce::ScopedLock sl(pluginLock);
-    if (hostedPlugin)
-        hostedPlugin->prepareToPlay(sampleRate, blockSize);
-}
-
-void HostedPluginManager::processBlock(juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midi)
-{
-    const juce::ScopedLock sl(pluginLock);
-    if (hostedPlugin)
-        hostedPlugin->processBlock(buffer, midi);
-}
-
-void HostedPluginManager::releaseResources()
-{
-    const juce::ScopedLock sl(pluginLock);
-    if (hostedPlugin)
-        hostedPlugin->releaseResources();
-}
-
-// --- Parameter Surface ---
-
-int HostedPluginManager::getParameterCount() const
-{
-    if (hostedPlugin)
-        return hostedPlugin->getParameters().size();
-    return 0;
-}
-
-std::vector<HostedPluginManager::ParamInfo> HostedPluginManager::searchParams(
-    const juce::String& keyword) const
-{
-    std::vector<ParamInfo> results;
-    if (!hostedPlugin) return results;
-
-    auto& params = hostedPlugin->getParameters();
-    auto keywordLower = keyword.toLowerCase();
-
-    for (int i = 0; i < params.size(); ++i)
-    {
-        auto* param = params[i];
-        auto name = param->getName(128);
-
-        if (name.toLowerCase().contains(keywordLower))
-        {
-            ParamInfo info;
-            info.index = i;
-            info.name = name;
-            info.value = param->getValue();
-            info.displayText = param->getText(param->getValue(), 64);
-            info.automatable = param->isAutomatable();
-
-            if (auto* hosted = dynamic_cast<juce::AudioPluginInstance::HostedParameter*>(param))
-                info.id = hosted->getParameterID();
-            else
-                info.id = juce::String(i);
-
-            results.push_back(info);
-        }
-
-        if (results.size() >= 20)
-            break;
-    }
-
-    return results;
-}
-
-std::vector<std::pair<int, float>> HostedPluginManager::getParams(
-    const std::vector<int>& indices) const
-{
-    std::vector<std::pair<int, float>> results;
-    if (!hostedPlugin) return results;
-
-    auto& params = hostedPlugin->getParameters();
-
-    for (int idx : indices)
-    {
-        if (idx >= 0 && idx < params.size())
-            results.push_back({idx, params[idx]->getValue()});
-    }
-
-    return results;
-}
-
-bool HostedPluginManager::setParams(const std::map<int, float>& values)
-{
-    if (!hostedPlugin) return false;
-
-    auto& params = hostedPlugin->getParameters();
-
-    for (auto& [idx, val] : values)
-    {
-        if (idx >= 0 && idx < params.size())
-        {
-            auto* param = params[idx];
-            float clampedVal = juce::jlimit(0.0f, 1.0f, val);
-
-            param->beginChangeGesture();
-            param->setValueNotifyingHost(clampedVal);
-            param->endChangeGesture();
-        }
-    }
-
-    return true;
-}
-
-juce::String HostedPluginManager::getLoadedPluginPath() const
-{
-    return loadedPluginPath;
-}

Source/HostedPluginManager.h

@@ -1,59 +0,0 @@
-#pragma once
-
-#include <juce_audio_processors/juce_audio_processors.h>
-#include <vector>
-#include <map>
-
-class HostedPluginManager
-{
-public:
-    HostedPluginManager();
-    ~HostedPluginManager();
-
-    // Plugin lifecycle
-    void loadPlugin(const juce::File& pluginFile, double sampleRate, int blockSize);
-    void unloadPlugin();
-    bool isLoaded() const;
-    juce::String getPluginName() const;
-    juce::String getLastError() const { return lastError; }
-
-    // Audio processing — called from audio thread
-    void prepareToPlay(double sampleRate, int blockSize);
-    void processBlock(juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midi);
-    void releaseResources();
-
-    // Parameter surface — called from HTTP thread (thread-safe)
-    struct ParamInfo {
-        int index;
-        juce::String id;
-        juce::String name;
-        float value;
-        juce::String displayText;
-        bool automatable;
-    };
-
-    std::vector<ParamInfo> searchParams(const juce::String& keyword) const;
-    std::vector<std::pair<int, float>> getParams(const std::vector<int>& indices) const;
-    bool setParams(const std::map<int, float>& values);
-    int getParameterCount() const;
-
-    // Thread safety
-    juce::CriticalSection& getPluginLock() { return pluginLock; }
-
-    // File path of currently loaded plugin
-    juce::String getLoadedPluginPath() const;
-
-private:
-    bool validatePluginFile(const juce::File& pluginFile);
-
-    juce::AudioPluginFormatManager formatManager;
-    std::unique_ptr<juce::AudioPluginInstance> hostedPlugin;
-    juce::CriticalSection pluginLock;
-
-    double currentSampleRate = 44100.0;
-    int currentBlockSize = 512;
-    juce::String loadedPluginPath;
-    juce::String lastError;
-
-    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(HostedPluginManager)
-};

Source/McpServer.cpp

@@ -1,319 +0,0 @@
-#include "McpServer.h"
-#include "HostedPluginManager.h"
-
-// 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, HostedPluginManager& pluginManager)
-    : server(std::make_unique<httplib::Server>()),
-      port(port),
-      pluginManager(pluginManager)
-{
-    setupRoutes();
-}
-
-McpServer::~McpServer()
-{
-    stop();
-}
-
-void McpServer::setupRoutes()
-{
-    // Single MCP endpoint
-    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") {
-                initialized = true;
-                res.status = 204;
-                return;
-            }
-            else if (method == "tools/list") {
-                responseStr = handleToolsList(req.body);
-            }
-            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&) {
-            json errResponse = {
-                {"jsonrpc", "2.0"},
-                {"id", nullptr},
-                {"error", {{"code", -32700}, {"message", "Parse error"}}}
-            };
-            res.set_content(errResponse.dump(), "application/json");
-        }
-    });
-
-    // Health check
-    server->Get("/health", [this](const httplib::Request&, httplib::Response& res) {
-        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");
-    });
-
-    // 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);
-    });
-
-    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();
-}
-
-// --- MCP Protocol Handlers ---
-
-std::string McpServer::handleInitialize(const std::string& requestBody)
-{
-    auto body = json::parse(requestBody);
-    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.2.0"}}}
-        }}
-    };
-    return response.dump();
-}
-
-std::string McpServer::handleToolsList(const std::string& requestBody)
-{
-    auto body = json::parse(requestBody);
-
-    json response = {
-        {"jsonrpc", "2.0"},
-        {"id", body.value("id", json(nullptr))},
-        {"result", {
-            {"tools", json::array({
-                {
-                    {"name", "list_plugins"},
-                    {"description", "List loaded plugin instances"},
-                    {"inputSchema", {{"type", "object"}, {"properties", json::object()}}}
-                },
-                {
-                    {"name", "search_param"},
-                    {"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 (e.g. 'band 1', 'gain', 'cutoff')"}}}
-                        }},
-                        {"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). Values are 0.0-1.0 normalized."},
-                    {"inputSchema", {
-                        {"type", "object"},
-                        {"properties", {
-                            {"plugin", {{"type", "string"}}},
-                            {"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, 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);
-    auto params = body["params"];
-    std::string toolName = params["name"];
-    auto args = params.value("arguments", json::object());
-
-    std::string resultText;
-    bool isError = false;
-
-    if (toolName == "list_plugins") {
-        resultText = toolListPlugins();
-    }
-    else if (toolName == "search_param") {
-        resultText = toolSearchParam(
-            args.value("plugin", ""),
-            args.value("keyword", ""));
-    }
-    else if (toolName == "get_params") {
-        resultText = toolGetParams(
-            args.value("plugin", ""),
-            args.value("ids", json::array()).dump());
-    }
-    else if (toolName == "set_params") {
-        resultText = toolSetParams(
-            args.value("plugin", ""),
-            args.value("values", json::object()).dump());
-    }
-    else if (toolName == "get_analysis") {
-        resultText = toolGetAnalysis();
-    }
-    else {
-        resultText = "unknown tool: " + toolName;
-        isError = true;
-    }
-
-    json response = {
-        {"jsonrpc", "2.0"},
-        {"id", body.value("id", json(nullptr))},
-        {"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";
-}

Source/McpServer.h

@@ -1,46 +0,0 @@
-#pragma once
-
-#include <thread>
-#include <atomic>
-#include <string>
-#include <memory>
-
-// Forward declarations
-namespace httplib { class Server; }
-class HostedPluginManager;
-
-class McpServer
-{
-public:
-    McpServer(int port, HostedPluginManager& pluginManager);
-    ~McpServer();
-
-    void start();
-    void stop();
-    bool isRunning() const;
-    int getPort() const { return port; }
-
-private:
-    void setupRoutes();
-
-    // MCP protocol handlers
-    std::string handleInitialize(const std::string& requestBody);
-    std::string handleToolsList(const std::string& requestBody);
-    std::string handleToolsCall(const std::string& requestBody);
-
-    // Tool implementations
-    std::string toolListPlugins();
-    std::string toolSearchParam(const std::string& plugin, const std::string& keyword);
-    std::string toolGetParams(const std::string& plugin, const std::string& idsJson);
-    std::string toolSetParams(const std::string& plugin, const std::string& valuesJson);
-    std::string toolGetAnalysis();
-
-    std::unique_ptr<httplib::Server> server;
-    std::thread serverThread;
-    std::atomic<bool> running{false};
-    int port;
-    std::string sessionId;
-    bool initialized = false;
-
-    HostedPluginManager& pluginManager;
-};

Source/PluginBridgeEditor.cpp

@@ -1,140 +0,0 @@
-#include "PluginBridgeEditor.h"
-
-PluginBridgeEditor::PluginBridgeEditor(PluginBridgeProcessor& p)
-    : AudioProcessorEditor(&p), processorRef(p)
-{
-    setSize(360, 220);
-
-    titleLabel.setText("PluginBridge", juce::dontSendNotification);
-    titleLabel.setFont(juce::FontOptions(22.0f));
-    titleLabel.setJustificationType(juce::Justification::centred);
-    titleLabel.setColour(juce::Label::textColourId, juce::Colours::white);
-    addAndMakeVisible(titleLabel);
-
-    statusLabel.setText("MCP: starting...", juce::dontSendNotification);
-    statusLabel.setFont(juce::FontOptions(12.0f));
-    statusLabel.setJustificationType(juce::Justification::centred);
-    addAndMakeVisible(statusLabel);
-
-    portLabel.setText("", juce::dontSendNotification);
-    portLabel.setFont(juce::FontOptions(10.0f));
-    portLabel.setJustificationType(juce::Justification::centred);
-    portLabel.setColour(juce::Label::textColourId, juce::Colour(0xff888888));
-    addAndMakeVisible(portLabel);
-
-    pluginLabel.setText("No plugin loaded", juce::dontSendNotification);
-    pluginLabel.setFont(juce::FontOptions(13.0f));
-    pluginLabel.setJustificationType(juce::Justification::centred);
-    pluginLabel.setColour(juce::Label::textColourId, juce::Colour(0xffaaaaaa));
-    addAndMakeVisible(pluginLabel);
-
-    pluginButton.onClick = [this]() { showPluginMenu(); };
-    pluginButton.setColour(juce::TextButton::buttonColourId, juce::Colour(0xff2d2d44));
-    pluginButton.setColour(juce::TextButton::textColourOffId, juce::Colours::white);
-    addAndMakeVisible(pluginButton);
-
-    startTimerHz(4);
-}
-
-PluginBridgeEditor::~PluginBridgeEditor()
-{
-    stopTimer();
-}
-
-void PluginBridgeEditor::paint(juce::Graphics& g)
-{
-    g.fillAll(juce::Colour(0xff12121f));
-    g.setColour(juce::Colour(0xff1e1e35));
-    g.fillRoundedRectangle(getLocalBounds().toFloat().reduced(4), 6.0f);
-}
-
-void PluginBridgeEditor::resized()
-{
-    auto area = getLocalBounds().reduced(14);
-    titleLabel.setBounds(area.removeFromTop(30));
-    area.removeFromTop(4);
-    statusLabel.setBounds(area.removeFromTop(18));
-    portLabel.setBounds(area.removeFromTop(16));
-    area.removeFromTop(10);
-    pluginButton.setBounds(area.removeFromTop(30).reduced(20, 0));
-    area.removeFromTop(8);
-    pluginLabel.setBounds(area.removeFromTop(20));
-}
-
-void PluginBridgeEditor::timerCallback()
-{
-    if (processorRef.isMcpServerRunning())
-    {
-        statusLabel.setText("MCP: running", juce::dontSendNotification);
-        statusLabel.setColour(juce::Label::textColourId, juce::Colour(0xff4cef50));
-        portLabel.setText("127.0.0.1:" + juce::String(processorRef.getMcpServerPort()),
-                          juce::dontSendNotification);
-    }
-    else
-    {
-        statusLabel.setText("MCP: offline", juce::dontSendNotification);
-        statusLabel.setColour(juce::Label::textColourId, juce::Colour(0xffef5350));
-        portLabel.setText("", juce::dontSendNotification);
-    }
-
-    auto& mgr = processorRef.getHostedPluginManager();
-    if (mgr.isLoaded())
-    {
-        pluginLabel.setText(mgr.getPluginName() + "  |  " + juce::String(mgr.getParameterCount()) + " params",
-                            juce::dontSendNotification);
-        pluginLabel.setColour(juce::Label::textColourId, juce::Colour(0xffffeb3b));
-        pluginButton.setButtonText(mgr.getPluginName());
-    }
-    else
-    {
-        pluginLabel.setText("No plugin loaded", juce::dontSendNotification);
-        pluginLabel.setColour(juce::Label::textColourId, juce::Colour(0xff888888));
-        pluginButton.setButtonText("Select Plugin...");
-    }
-}
-
-void PluginBridgeEditor::showPluginMenu()
-{
-    auto files = processorRef.getInstalledPluginFiles();
-
-    juce::PopupMenu menu;
-
-    if (files.isEmpty())
-    {
-        menu.addItem(-1, "(No plugins found)", false);
-        menu.showMenuAsync(juce::PopupMenu::Options().withTargetComponent(&pluginButton),
-            [](int) {});
-        return;
-    }
-
-    juce::PopupMenu vst3Menu;
-    juce::PopupMenu auMenu;
-    int itemId = 1;
-
-    for (int i = 0; i < files.size(); ++i)
-    {
-        const auto& file = files[i];
-        auto name = file.getFileNameWithoutExtension();
-
-        if (file.getFileExtension() == ".vst3")
-            vst3Menu.addItem(itemId, name);
-        else
-            auMenu.addItem(itemId, name);
-
-        itemId++;
-    }
-
-    if (vst3Menu.getNumItems() > 0)
-        menu.addSubMenu("VST3", vst3Menu);
-    if (auMenu.getNumItems() > 0)
-        menu.addSubMenu("Audio Units", auMenu);
-
-    menu.showMenuAsync(juce::PopupMenu::Options().withTargetComponent(&pluginButton),
-        [this, files](int result)
-        {
-            if (result > 0 && result <= files.size())
-            {
-                processorRef.loadPluginFromFile(files[result - 1]);
-            }
-        });
-}

Source/PluginBridgeEditor.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <juce_gui_basics/juce_gui_basics.h>
-#include "PluginBridgeProcessor.h"
-
-class PluginBridgeEditor : public juce::AudioProcessorEditor,
-                            private juce::Timer
-{
-public:
-    explicit PluginBridgeEditor(PluginBridgeProcessor&);
-    ~PluginBridgeEditor() override;
-
-    void paint(juce::Graphics&) override;
-    void resized() override;
-
-private:
-    void timerCallback() override;
-    void showPluginMenu();
-
-    PluginBridgeProcessor& processorRef;
-
-    juce::Label titleLabel;
-    juce::Label statusLabel;
-    juce::Label portLabel;
-    juce::Label pluginLabel;
-    juce::TextButton pluginButton{"Select Plugin..."};
-
-    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginBridgeEditor)
-};

Source/PluginBridgeProcessor.cpp

@@ -1,130 +0,0 @@
-#include "PluginBridgeProcessor.h"
-#include "PluginBridgeEditor.h"
-
-PluginBridgeProcessor::PluginBridgeProcessor()
-    : AudioProcessor(BusesProperties()
-                         .withInput("Input", juce::AudioChannelSet::stereo(), true)
-                         .withOutput("Output", juce::AudioChannelSet::stereo(), true)),
-      mcpServer(kDefaultMcpPort, hostManager)
-{
-    mcpServer.start();
-}
-
-PluginBridgeProcessor::~PluginBridgeProcessor()
-{
-    mcpServer.stop();
-}
-
-void PluginBridgeProcessor::prepareToPlay(double sampleRate, int samplesPerBlock)
-{
-    hostManager.prepareToPlay(sampleRate, samplesPerBlock);
-}
-
-void PluginBridgeProcessor::releaseResources()
-{
-    hostManager.releaseResources();
-}
-
-void PluginBridgeProcessor::processBlock(juce::AudioBuffer<float>& buffer,
-                                          juce::MidiBuffer& midiMessages)
-{
-    juce::ScopedNoDenormals noDenormals;
-
-    auto totalNumInputChannels = getTotalNumInputChannels();
-    auto totalNumOutputChannels = getTotalNumOutputChannels();
-    for (auto i = totalNumInputChannels; i < totalNumOutputChannels; ++i)
-        buffer.clear(i, 0, buffer.getNumSamples());
-
-    hostManager.processBlock(buffer, midiMessages);
-}
-
-juce::AudioProcessorEditor* PluginBridgeProcessor::createEditor()
-{
-    return new PluginBridgeEditor(*this);
-}
-
-void PluginBridgeProcessor::getStateInformation(juce::MemoryBlock& destData)
-{
-    juce::ValueTree state("PluginBridgeState");
-    state.setProperty("hostedPluginPath", hostManager.getLoadedPluginPath(), nullptr);
-
-    juce::MemoryOutputStream stream(destData, false);
-    state.writeToStream(stream);
-}
-
-void PluginBridgeProcessor::setStateInformation(const void* data, int sizeInBytes)
-{
-    auto state = juce::ValueTree::readFromData(data, (size_t)sizeInBytes);
-    if (state.isValid())
-    {
-        auto path = state.getProperty("hostedPluginPath").toString();
-        if (path.isNotEmpty())
-        {
-            juce::File pluginFile(path);
-            if (pluginFile.exists())
-                loadPluginFromFile(pluginFile);
-        }
-    }
-}
-
-bool PluginBridgeProcessor::isMcpServerRunning() const
-{
-    return mcpServer.isRunning();
-}
-
-int PluginBridgeProcessor::getMcpServerPort() const
-{
-    return mcpServer.getPort();
-}
-
-void PluginBridgeProcessor::loadPluginFromFile(const juce::File& file)
-{
-    hostManager.loadPlugin(file, getSampleRate(), getBlockSize());
-}
-
-juce::Array<juce::File> PluginBridgeProcessor::getInstalledPluginFiles() const
-{
-    juce::Array<juce::File> results;
-
-    // VST3 directories
-    juce::Array<juce::File> vst3Dirs = {
-        juce::File("/Library/Audio/Plug-Ins/VST3"),
-        juce::File::getSpecialLocation(juce::File::userHomeDirectory)
-            .getChildFile("Library/Audio/Plug-Ins/VST3")
-    };
-
-    for (auto& dir : vst3Dirs)
-    {
-        if (dir.isDirectory())
-        {
-            auto files = dir.findChildFiles(juce::File::findDirectories, false, "*.vst3");
-            results.addArray(files);
-        }
-    }
-
-    // AU directories
-    juce::Array<juce::File> auDirs = {
-        juce::File("/Library/Audio/Plug-Ins/Components"),
-        juce::File::getSpecialLocation(juce::File::userHomeDirectory)
-            .getChildFile("Library/Audio/Plug-Ins/Components")
-    };
-
-    for (auto& dir : auDirs)
-    {
-        if (dir.isDirectory())
-        {
-            auto files = dir.findChildFiles(juce::File::findDirectories, false, "*.component");
-            results.addArray(files);
-        }
-    }
-
-    // Sort alphabetically
-    results.sort();
-    return results;
-}
-
-// JUCE plugin entry point
-juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter()
-{
-    return new PluginBridgeProcessor();
-}

Source/PluginBridgeProcessor.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <juce_audio_processors/juce_audio_processors.h>
-#include <juce_dsp/juce_dsp.h>
-#include "McpServer.h"
-#include "HostedPluginManager.h"
-
-class PluginBridgeProcessor : public juce::AudioProcessor
-{
-public:
-    PluginBridgeProcessor();
-    ~PluginBridgeProcessor() override;
-
-    // AudioProcessor interface
-    void prepareToPlay(double sampleRate, int samplesPerBlock) override;
-    void releaseResources() override;
-    void processBlock(juce::AudioBuffer<float>&, juce::MidiBuffer&) override;
-
-    // Editor
-    juce::AudioProcessorEditor* createEditor() override;
-    bool hasEditor() const override { return true; }
-
-    // Plugin identity
-    const juce::String getName() const override { return "PluginBridge"; }
-    bool acceptsMidi() const override { return true; }
-    bool producesMidi() const override { return true; }
-    double getTailLengthSeconds() const override { return 0.0; }
-
-    // Programs (unused)
-    int getNumPrograms() override { return 1; }
-    int getCurrentProgram() override { return 0; }
-    void setCurrentProgram(int) override {}
-    const juce::String getProgramName(int) override { return {}; }
-    void changeProgramName(int, const juce::String&) override {}
-
-    // State
-    void getStateInformation(juce::MemoryBlock& destData) override;
-    void setStateInformation(const void* data, int sizeInBytes) override;
-
-    // Public access
-    bool isMcpServerRunning() const;
-    int getMcpServerPort() const;
-    HostedPluginManager& getHostedPluginManager() { return hostManager; }
-
-    // Load plugin (called on message thread)
-    void loadPluginFromFile(const juce::File& file);
-
-    // Plugin listing — just reads filenames, never loads binaries
-    juce::Array<juce::File> getInstalledPluginFiles() const;
-
-private:
-    HostedPluginManager hostManager;
-    McpServer mcpServer;
-    static constexpr int kDefaultMcpPort = 16620;
-
-    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginBridgeProcessor)
-};