feat: scaffold project framework with engine, node skeleton, and passthrough node

- CMake build system with vcpkg dependency management
- libdmf-node: Node interface, port definitions, WebSocket control
  server, node runner with MXL lifecycle management
- libdmf-engine: Graph model (nodes/edges CRUD, serialization),
  FlowManager (UUID + V210 NMOS flow definitions), ProcessManager
  (fork/exec node processes), ApiServer (REST API for graph control)
- Passthrough node: reads V210 grains from MXL, copies, writes to MXL
- Unit tests for Graph and FlowManager (6 cases, 21 assertions)
- MXL SDK as git submodule (symlinked from extern/mxl)

libs/dmf-node/src/control_server.cpp

@@ -0,0 +1,169 @@
+#include <dmf-node/control_server.hpp>
+#include <dmf-node/node.hpp>
+
+#include <libwebsockets.h>
+
+#include <nlohmann/json.hpp>
+
+#include <spdlog/spdlog.h>
+
+#include <cstring>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace dmf_node {
+
+struct ControlServerData {
+    StatusCallback on_event;
+    std::unordered_map<std::string, CommandHandler> commands;
+    std::mutex send_mutex;
+    std::vector<std::string> send_queue;
+    struct lws* client_wsi = nullptr;
+};
+
+struct ControlServer::Impl {
+    uint16_t port;
+    std::unique_ptr<ControlServerData> data;
+    struct lws_context* context = nullptr;
+};
+
+static int callback_ws(struct lws* wsi, enum lws_callback_reasons reason,
+                       void* user, void* in, size_t len);
+
+static const struct lws_protocols protocols[] = {
+    {
+        "dmf-control",
+        callback_ws,
+        sizeof(ControlServerData*),
+        65536,
+    },
+    {nullptr, nullptr, 0, 0},
+};
+
+static int callback_ws(struct lws* wsi, enum lws_callback_reasons reason,
+                       void* user, void* in, size_t len) {
+    auto** ppdata = static_cast<ControlServerData**>(user);
+    ControlServerData* data = ppdata ? *ppdata : nullptr;
+
+    switch (reason) {
+    case LWS_CALLBACK_ESTABLISHED: {
+        auto* vhost = lws_get_vhost(wsi);
+        data = static_cast<ControlServerData*>(lws_vhost_user(vhost));
+        if (ppdata) {
+            *ppdata = data;
+        }
+        if (data) {
+            data->client_wsi = wsi;
+        }
+        spdlog::info("Control WS: client connected");
+        break;
+    }
+    case LWS_CALLBACK_RECEIVE: {
+        if (!data) {
+            auto* vhost = lws_get_vhost(wsi);
+            data = static_cast<ControlServerData*>(lws_vhost_user(vhost));
+        }
+        if (!data) {
+            break;
+        }
+
+        try {
+            auto msg = nlohmann::json::parse(static_cast<char*>(in), static_cast<char*>(in) + len);
+            if (!msg.contains("cmd")) {
+                spdlog::warn("Control WS: message missing 'cmd' field");
+                break;
+            }
+            auto cmd = msg["cmd"].get<std::string>();
+            auto it = data->commands.find(cmd);
+            if (it != data->commands.end()) {
+                it->second(msg);
+            } else {
+                spdlog::warn("Control WS: unknown command '{}'", cmd);
+            }
+        } catch (const nlohmann::json::parse_error& e) {
+            spdlog::warn("Control WS: JSON parse error: {}", e.what());
+        }
+        break;
+    }
+    case LWS_CALLBACK_SERVER_WRITEABLE: {
+        if (!data) {
+            auto* vhost = lws_get_vhost(wsi);
+            data = static_cast<ControlServerData*>(lws_vhost_user(vhost));
+        }
+        if (!data) {
+            break;
+        }
+
+        std::lock_guard<std::mutex> lock(data->send_mutex);
+        while (!data->send_queue.empty()) {
+            auto& msg = data->send_queue.back();
+            std::vector<uint8_t> buf(LWS_PRE + msg.size());
+            std::memcpy(buf.data() + LWS_PRE, msg.data(), msg.size());
+            lws_write(wsi, buf.data() + LWS_PRE, msg.size(), LWS_WRITE_TEXT);
+            data->send_queue.pop_back();
+        }
+        break;
+    }
+    case LWS_CALLBACK_CLOSED: {
+        if (data) {
+            data->client_wsi = nullptr;
+        }
+        spdlog::info("Control WS: client disconnected");
+        break;
+    }
+    default:
+        break;
+    }
+    return 0;
+}
+
+ControlServer::ControlServer(uint16_t port, StatusCallback on_event)
+    : impl_(std::make_unique<Impl>()) {
+    impl_->port = port;
+    impl_->data = std::make_unique<ControlServerData>();
+    impl_->data->on_event = std::move(on_event);
+
+    struct lws_context_creation_info info;
+    std::memset(&info, 0, sizeof(info));
+    info.port = port;
+    info.protocols = protocols;
+    info.user = impl_->data.get();
+    info.gid = -1;
+    info.uid = -1;
+
+    impl_->context = lws_create_context(&info);
+    if (!impl_->context) {
+        spdlog::error("Failed to create WS context on port {}", port);
+        throw std::runtime_error("Failed to create WS context");
+    }
+    spdlog::info("Control WS: listening on port {}", port);
+}
+
+ControlServer::~ControlServer() {
+    if (impl_->context) {
+        lws_context_destroy(impl_->context);
+    }
+}
+
+void ControlServer::register_command(const std::string& cmd, CommandHandler handler) {
+    impl_->data->commands[cmd] = std::move(handler);
+}
+
+void ControlServer::send_event(const nlohmann::json& event) {
+    auto data = event.dump();
+    {
+        std::lock_guard<std::mutex> lock(impl_->data->send_mutex);
+        impl_->data->send_queue.push_back(data);
+    }
+    if (impl_->data->client_wsi) {
+        lws_callback_on_writable(impl_->data->client_wsi);
+    }
+}
+
+void ControlServer::poll(int timeout_ms) {
+    lws_service(impl_->context, timeout_ms);
+}
+
+} // namespace dmf_node