@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-rt/lib/src/services/http_server/http_listener.cpp

@@ -0,0 +1,130 @@
+#include "./http_listener.h"
+
+#include "./http_server_impl.h"
+#include "./http_session.h"
+
+namespace net = boost::asio;
+namespace beast = boost::beast;
+namespace http = beast::http;
+
+namespace hkp {
+
+inline void fail(boost::beast::error_code ec, char const* what)
+{
+  std::cerr << what << ": " << ec.message() << "\n";
+}
+
+Listener::Listener(HttpServerImpl& impl, tcp::endpoint endpoint)
+        : m_impl(impl)
+        , acceptor_(net::make_strand(impl.getIOContext()))
+        
+{
+    beast::error_code ec;
+    acceptor_.open(endpoint.protocol(), ec);
+    if(ec)
+    {
+      fail(ec, "Listener::Listener() open");
+      return;
+    }
+
+    // Allow address reuse
+    acceptor_.set_option(net::socket_base::reuse_address(true), ec);
+    if(ec)
+    {
+      fail(ec, "Listener::Listener() set_option");
+      return;
+    }
+
+    // Bind to the server address
+    acceptor_.bind(endpoint, ec);
+    if(ec)
+    {
+      fail(ec, "Listener::Listener() bind");
+      return;
+    }
+
+    // Start listening for connections
+    acceptor_.listen(net::socket_base::max_listen_connections, ec);
+    if(ec)
+    {
+      fail(ec, "Listener::Listener() listen");
+      return;
+    }
+}
+
+Listener::~Listener()
+{
+   stop();
+}
+
+unsigned short Listener::start()
+{
+    // A failed open/bind leaves the acceptor closed — the constructor has no
+    // way to report it other than that. Asking a closed acceptor for its
+    // endpoint throws, so answer "no port" and let the caller decide what a
+    // port it could not get means.
+    if (!acceptor_.is_open())
+    {
+      return 0;
+    }
+
+    do_accept();
+
+    beast::error_code ec;
+    const auto endpoint = acceptor_.local_endpoint(ec);
+    if (ec)
+    {
+      fail(ec, "Listener::start() local_endpoint");
+      return 0;
+    }
+    return endpoint.port();
+}
+
+bool Listener::stop() 
+{
+  beast::error_code ec;
+  acceptor_.close(ec);
+  if (ec) 
+  {
+      std::cerr << "Listener::stop Error closing acceptor: " << ec.message() << "\n";
+      return false;
+  }
+  return true;
+}
+
+void Listener::onSessionOpened(std::shared_ptr<Session> session)
+{
+    m_impl.onSessionOpened(session);
+}
+
+void Listener::onSessionClosed(std::shared_ptr<Session> session)
+{
+    m_impl.onSessionClosed(session);
+}
+
+void Listener::do_accept()
+{
+    // The new connection gets its own strand
+    acceptor_.async_accept(
+        net::make_strand(m_impl.getIOContext()),
+        beast::bind_front_handler(
+            &Listener::on_accept,
+            shared_from_this()));
+}
+
+void Listener::on_accept(beast::error_code ec, tcp::socket socket)
+{
+  if(ec)
+  {
+    fail(ec, "Listener::on_accept accept");
+  }
+  else
+  {
+    std::make_shared<Session>(m_impl, std::move(socket))->run();
+    
+    // Accept another connection
+    do_accept();
+  }
+}
+
+} // namespace hkp

package/bundle/hkp-rt/lib/src/services/http_server/http_listener.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <boost/beast.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/json.hpp>
+
+namespace hkp {
+
+class HttpServerImpl;
+class Session;
+class Listener : public std::enable_shared_from_this<Listener>
+{
+public:
+    using tcp = boost::asio::ip::tcp;
+
+    Listener(HttpServerImpl& impl, tcp::endpoint endpoint);
+    ~Listener();
+
+    unsigned short start();
+    bool stop();
+
+    void onSessionOpened(std::shared_ptr<Session> session);
+    void onSessionClosed(std::shared_ptr<Session> session);
+
+private:
+    void do_accept();
+    void on_accept(boost::beast::error_code ec, tcp::socket socket);
+
+    HttpServerImpl& m_impl;
+    tcp::acceptor acceptor_;
+};
+
+} // namespace hkp

package/bundle/hkp-rt/lib/src/services/http_server/http_server.cpp

@@ -0,0 +1,351 @@
+#include "./http_server.h"
+
+#include <boost/beast.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/json.hpp>
+
+#include "./http_server_impl.h"
+#include "./http_listener.h"
+#include "./http_session.h"
+#include "./request_decode.h"
+#include "mount.h"
+#include "../../process_context.h"
+
+#include <algorithm>
+#include <cctype>
+#include <optional>
+#include <string>
+#include <thread>
+
+namespace beast = boost::beast;
+namespace http = beast::http;
+namespace net = boost::asio;
+using tcp = net::ip::tcp;
+
+namespace hkp {
+
+using namespace request_decode;
+
+HttpServer::HttpServer(const std::string& instanceId)
+  : Service(instanceId, serviceId())
+  , m_impl(std::make_shared<HttpServerImpl>())
+{
+  m_bypass = true; // Start in bypass mode
+  m_mode = "process_on_session"; // alternative: "process_on_data"
+  m_impl->setOnSessionOpenedCallback(
+    [this](std::shared_ptr<Session> session, const std::string& path, const std::string& method){ onNewSession(session, path, method); }
+  );
+}
+
+HttpServer::~HttpServer()
+{
+  m_mount.release();
+  m_impl->stop();
+}
+
+MountHandle HttpServer::claimMount(const std::string& name)
+{
+  // Held weakly: the mount must not keep this service's endpoint alive.
+  std::weak_ptr<HttpServerImpl> held = m_impl;
+  return mountEndpoint(name, [held](MountedConnection connection) {
+    if (auto impl = held.lock())
+    {
+      impl->adopt(std::move(connection));
+    }
+  });
+}
+
+void HttpServer::onNewSession(std::shared_ptr<Session> session, const std::string& path, const std::string& method, bool /*awaitResponse*/)
+{
+  // OPTIONS is a protocol-level concern (CORS preflight) — handle inline, never enters pipeline.
+  if (method == "OPTIONS")
+  {
+    session->sendCorsPreflightResponse();
+    return;
+  }
+
+  // Describe the request uniformly.
+  // meta["method"]      — HTTP method so downstream services can route on it.
+  // meta["requestPath"] — the URL path, without the query string.
+  // meta["query"]       — decoded query parameters.
+  // meta["path"]        — filename; set only for file transfers, and what the
+  //                       filesystem service writes to.
+  // meta["contentType"] — Content-Type header (for body-carrying requests).
+  //
+  // What leaves this service depends on what the body turns out to be:
+  //   * bytes that cannot be interpreted (an upload) → MixedData, meta + binary
+  //   * a body whose type says what it means, or none → JSON, meta + body
+  // Emitting MixedData unconditionally is what made a Map downstream fail: it
+  // only accepts plain JSON, so a request it could have handled stopped there.
+  MixedData request;
+  std::string requestPath;
+  json query;
+  splitTarget(path, requestPath, query);
+  request.meta["method"]      = method;
+  request.meta["requestPath"] = requestPath;
+  request.meta["query"]       = query;
+
+  std::optional<json> decodedBody;
+
+  if (method == "POST" || method == "PUT" || method == "PATCH")
+  {
+    const auto& body              = session->getRequestBody();
+    const auto contentDisposition = session->getRequestHeader("content-disposition");
+    const auto contentType        = session->getRequestHeader("content-type");
+    const auto filename           = extractFilename(contentDisposition);
+
+    request.meta["contentType"] = contentType;
+
+    // Chunked upload: client sends X-Upload-Id + X-Chunk-Index + X-Total-Chunks.
+    const auto uploadId       = session->getRequestHeader("x-upload-id");
+    const auto chunkIndexStr  = session->getRequestHeader("x-chunk-index");
+    const auto totalChunksStr = session->getRequestHeader("x-total-chunks");
+
+    if (!uploadId.empty() && !chunkIndexStr.empty() && !totalChunksStr.empty())
+    {
+      int chunkIndex  = -1;
+      int totalChunks = -1;
+      try
+      {
+        chunkIndex  = std::stoi(chunkIndexStr);
+        totalChunks = std::stoi(totalChunksStr);
+      }
+      catch (const std::exception& e)
+      {
+        std::cerr << "HttpServer: failed to parse chunk headers: index='"
+                  << chunkIndexStr << "' total='" << totalChunksStr
+                  << "' error=" << e.what() << std::endl;
+        session->sendJsonResponseWithCors(json{{"error", "bad chunk headers"}});
+        return;
+      }
+      if (chunkIndex < 0 || totalChunks <= 0 || chunkIndex >= totalChunks)
+      {
+        std::cerr << "HttpServer: invalid chunk values: index=" << chunkIndex
+                  << " total=" << totalChunks << std::endl;
+        session->sendJsonResponseWithCors(json{{"error", "invalid chunk values"}});
+        return;
+      }
+
+      bool complete = false;
+      MixedData assembled;
+
+      {
+        std::lock_guard<std::mutex> lock(m_assemblyMutex);
+        auto& assembly = m_assemblies[uploadId];
+
+        if (assembly.totalChunks == 0)
+        {
+          assembly.totalChunks = totalChunks;
+          assembly.filename    = filename;
+          assembly.contentType = contentType;
+          // The split path, matching the non-chunked branch — an assembled
+          // upload should not describe itself differently from a plain one.
+          assembly.requestPath = requestPath;
+          assembly.query       = query;
+          assembly.chunks.resize(totalChunks);
+        }
+
+        assembly.chunks[chunkIndex] = body;
+        assembly.receivedCount++;
+
+        if (assembly.receivedCount == totalChunks)
+        {
+          BinaryData binary;
+          for (const auto& chunk : assembly.chunks)
+            binary.insert(binary.end(), chunk.begin(), chunk.end());
+
+          assembled.meta   = json{{"method", "POST"}, {"path", assembly.filename},
+                                  {"contentType", assembly.contentType},
+                                  {"requestPath", assembly.requestPath},
+                                  {"query", assembly.query}};
+          assembled.binary = std::move(binary);
+          m_assemblies.erase(uploadId);
+          complete = true;
+        }
+      }
+
+      if (complete)
+      {
+        auto data = Data(assembled);
+        nextInRun(data, ProcessContext::newRun("mount"), [session](Data result) {
+          session->sendResult(result);
+        });
+      }
+      else
+      {
+        // Intermediate chunk acknowledged — do not enter pipeline yet.
+        session->sendJsonResponseWithCors(json{{"status", "ok"}, {"chunkIndex", chunkIndex}});
+      }
+      return;
+    }
+
+    // Non-chunked body. A file transfer keeps its bytes and its filename; any
+    // other body is decoded when its content type says what it means.
+    if (isFileTransfer(contentDisposition, uploadId))
+    {
+      request.meta["path"] = filename;
+      request.binary       = BinaryData(body.begin(), body.end());
+    }
+    else
+    {
+      decodedBody = decodeBody(body, contentType);
+      if (!decodedBody)
+      {
+        request.binary = BinaryData(body.begin(), body.end());
+      }
+    }
+  }
+
+  // Forward into the pipeline; let downstream services (e.g. method-router) decide what to do.
+  // Bytes we could not interpret stay MixedData so the filesystem service still
+  // receives them; everything else goes as plain JSON, which every
+  // JSON-consuming service can act on.
+  Data data = Null();
+  if (request.binary.empty())
+  {
+    json envelope = json{{"meta", request.meta}};
+    if (decodedBody) envelope["body"] = *decodedBody;
+    data = Data(envelope);
+  }
+  else
+  {
+    data = Data(request);
+  }
+
+  nextInRun(data, ProcessContext::newRun("mount"), [session](Data result) {
+    session->sendResult(result);
+  });
+}
+
+std::string HttpServer::getServiceId() const
+{
+  return serviceId();
+}
+
+json HttpServer::configure(Data data)
+{
+  if (auto buf = getJSONFromData(data))
+  {
+    unsigned short port = m_impl->port();
+    if (updateIfNeeded(port, (*buf)["port"]))
+    {
+      m_impl->setPort(port);
+    }
+    if (buf->contains("mountName") && (*buf)["mountName"].is_string())
+    {
+      m_mountName = (*buf)["mountName"].get<std::string>();
+    }
+
+    if (updateIfNeeded(m_mode, (*buf)["mode"]))
+    {
+      if (m_mode == "process_on_session")
+      {
+        m_impl->setOnSessionOpenedCallback(
+          [this](std::shared_ptr<Session> session, const std::string& path, const std::string& method) { onNewSession(session, path, method); }
+        );
+      }
+      else
+      {
+        m_impl->resetOnSessionOpenedCallback();
+      }
+    }
+  }
+  auto state = Service::configure(data);
+
+  // `mountName` is the deliberate address-rotation lever. A running mounted
+  // endpoint has to move immediately, and the address it leaves must stop
+  // answering (the same behaviour as the Node and Python runtimes).
+  if (m_mount && mountName() != m_mount.name())
+  {
+    m_mount = claimMount(mountName());
+    if (m_mount)
+    {
+      sendNotification(json{{MOUNT_FIELD, m_mount.url()}});
+    }
+  }
+  return state;
+}
+
+json HttpServer::getState() const
+{
+  return Service::mergeStateWith(json{
+    {"port", m_impl->port()},
+    {MOUNT_FIELD, m_mount.url()},
+    {"mountName", m_mountName}
+  });
+}
+
+bool HttpServer::onBypassChanged(bool bypass)
+{
+  if (bypass)
+  {
+    if (!stop())
+    {
+      std::cerr << "Failed to stop HTTP server on port: " << m_impl->port() << std::endl;
+      return false;
+    }
+  }
+  else
+  {
+    if (!start())
+    {
+      std::cerr << "Failed to start HTTP server on port: " << m_impl->port() << std::endl;
+      return false;
+    }
+  }
+  return bypass;
+}
+
+Data HttpServer::process(Data data)
+{
+  if (m_mode == "process_on_data")
+  {
+    m_impl->processData(data);
+  }
+  return data;
+}
+
+bool HttpServer::start()
+{
+  if (!isBypass())
+  {
+    std::cout << "HttpServer::start() HTTP server is already running on port: " << m_impl->port() << std::endl;
+    return false;
+  }
+
+  // A path on the runtime server's own port where it serves mounts; a port of
+  // this service's own where it does not. See mounts.h.
+  m_impl->startMounted();
+  m_mount = claimMount(mountName());
+  if (m_mount)
+  {
+    std::cout << "HttpServer::start() mounted at " << m_mount.url() << std::endl;
+    sendNotification(json{{MOUNT_FIELD, m_mount.url()}});
+    return true;
+  }
+  m_impl->stop();
+
+  auto port = m_impl->start();
+  if (port == 0)
+  {
+    std::cerr << "HttpServer::start() Failed to start HTTP server, port is not set or already in use." << std::endl;
+    return false;
+  }
+
+  std::cout << "HttpServer::start() HTTP server started on port: " << m_impl->port() << std::endl;
+  sendNotification(json{{"port", m_impl->port()}});
+  return true;
+}
+
+bool HttpServer::stop()
+{
+  if (isBypass())
+  {
+    std::cout << "HttpServer::stop() HTTP server is not running" << std::endl;
+    return false;
+  }
+  m_mount.release();
+  return m_impl->stop();
+}
+
+}

package/bundle/hkp-rt/lib/src/services/http_server/http_server.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <iostream>
+#include <mutex>
+#include <map>
+#include <vector>
+
+#include <types/types.h>
+#include <service.h>
+#include <types/data.h>
+
+/**
+ * Service Documentation
+ * Service ID: http-server
+ * Service Name: HttpServer
+ * Runtime: hkp-rt
+ * Modes: unspecified
+ * Key Config: runtime-specific state/config
+ * IO: in=runtime-dependent -> out=runtime-dependent
+ * Arrays: service-dependent
+ * Binary: supported (service-dependent)
+ * MixedData: native in runtime (service-dependent usage)
+ */
+namespace hkp {
+
+class Session;
+class HttpServerImpl;
+
+class HttpServer : public Service 
+{
+public:
+  static std::string serviceId() { return "http-server"; }
+
+  HttpServer(const std::string& instanceId);
+  ~HttpServer();
+
+  json configure(Data data) override;
+  std::string getServiceId() const override;
+  json getState() const override;
+  Data process(Data data) override;
+
+protected:
+  bool onBypassChanged(bool bypass) override;
+
+  void onNewSession(std::shared_ptr<Session> session, const std::string& path, const std::string& method, bool awaitResponse = true);
+
+private:  
+  bool start();
+  bool stop();
+
+private:
+  // Accumulates chunks for a single in-flight chunked upload.
+  struct ChunkAssembly
+  {
+    std::vector<std::string> chunks; // indexed by chunkIndex
+    int receivedCount = 0;
+    int totalChunks   = 0;
+    std::string filename;
+    std::string contentType;
+    std::string requestPath;
+    json query;
+  };
+
+private:
+  std::shared_ptr<HttpServerImpl> m_impl;
+  std::string m_mode;
+  // Where it is served when the runtime server mounts it; see mounts.h. Holds
+  // the name the mount was made under, which configuration may since have
+  // changed.
+  MountHandle m_mount;
+  std::string m_mountName;
+  std::string mountName() const { return m_mountName.empty() ? getId() : m_mountName; }
+  MountHandle claimMount(const std::string& name);
+
+  std::mutex m_assemblyMutex;
+  std::map<std::string, ChunkAssembly> m_assemblies; // keyed by X-Upload-Id
+};
+
+}