feat: add Java HTTP ring adapter

Author: hugoduncan

components/http-server/deps.edn

@@ -0,0 +1,2 @@
+{:deps {ring/ring-core                          {:mvn/version "1.13.0"}
+        ring-sse-middleware/ring-sse-middleware {:mvn/version "0.1.3"}}}

components/http-server/src/mcp_clj/http_server/ring_adapter.clj

@@ -0,0 +1,89 @@
+(ns mcp-clj.http-server.ring-adapter
+  "Ring adapter for Java's com.sun.net.httpserver.HttpServer with SSE support"
+  (:require
+   [clojure.string :as str]
+   [ring.util.response :as response])
+  (:import
+   [com.sun.net.httpserver HttpServer HttpHandler HttpExchange]
+   [java.net InetSocketAddress]
+   [java.io InputStream]))
+
+(defn- exchange->ring-request
+  "Convert HttpExchange to Ring request map"
+  [^HttpExchange exchange]
+  {:server-port    (.getPort (.getLocalAddress exchange))
+   :server-name    (.getHostName (.getLocalAddress exchange))
+   :remote-addr    (-> exchange .getRemoteAddress .getAddress .getHostAddress)
+   :uri            (.getPath (.getRequestURI exchange))
+   :query-string   (.getRawQuery (.getRequestURI exchange))
+   :scheme         :http
+   :request-method (-> exchange .getRequestMethod .toLowerCase keyword)
+   :headers        (into {}
+                         (for [k (.keySet (.getRequestHeaders exchange))
+                               :let [vs (.get (.getRequestHeaders exchange) k)]]
+                           [(str/lower-case k) (str (first vs))]))
+   :body           (.getRequestBody exchange)})
+
+(defn- send-streaming-response
+  "Handle streaming response for SSE"
+  [^HttpExchange exchange response]
+  (let [{:keys [status headers body]} response]
+    (doseq [[k v] headers]
+      (.add (.getResponseHeaders exchange)
+            (name k)
+            (str v)))
+    (.sendResponseHeaders exchange status 0)
+    (with-open [os (.getResponseBody exchange)]
+      (try
+        (body os)
+        (.flush os)
+        (catch Exception e
+          (.printStackTrace e))))))
+
+(defn- send-ring-response
+  "Send Ring response, detecting streaming vs normal response"
+  [^HttpExchange exchange response]
+  (if (fn? (:body response))
+    (send-streaming-response exchange response)
+    (let [{:keys [status headers body]}
+          response
+          body-bytes (cond
+                       (string? body)               (.getBytes body)
+                       (instance? InputStream body) (with-open [is body]
+                                                      (.readAllBytes is))
+                       :else                        body)]
+      (doseq [[k v] headers]
+        (.add (.getResponseHeaders exchange)
+              (name k)
+              (str v)))
+      (.sendResponseHeaders exchange status (count body-bytes))
+      (with-open [os (.getResponseBody exchange)]
+        (.write os body-bytes)
+        (.flush os)))))
+
+
+(defn run-server
+  "Start an HttpServer instance with the given Ring handler"
+  [handler {:keys [port join?]
+            :or   {port  8080
+                   join? false}}]
+  (let [server     (HttpServer/create (InetSocketAddress. port) 0)
+        handler-fn (reify HttpHandler
+                     (handle [_ exchange]
+                       (try
+                         (let [request  (exchange->ring-request exchange)
+                               response (handler request)]
+                           (if (fn? (:body response))
+                             (send-streaming-response exchange response)
+                             (send-ring-response exchange response)))
+                         (catch Exception e
+                           (.printStackTrace e)
+                           (.sendResponseHeaders exchange 500 0))
+                         ;; Removed exchange close from finally block
+                         )))]
+    (.createContext server "/" handler-fn)
+    (.setExecutor server nil)
+    (.start server)
+    (when join?
+      (.awaitTermination (.getExecutor server) Long/MAX_VALUE java.util.concurrent.TimeUnit/SECONDS))
+    server))

components/http-server/test/mcp_clj/http_server/ring_adapter_test.clj

@@ -0,0 +1,72 @@
+(ns mcp-clj.http-server.ring-adapter-test
+  "Tests for Ring adapter for Java's HttpServer"
+  (:require
+   [clojure.test :refer [deftest testing is use-fixtures]]
+   [mcp-clj.http-server.ring-adapter :as adapter]
+   [ring.util.response :as response])
+  (:import
+   [java.net URL HttpURLConnection]))
+
+(defn test-handler [request]
+  (case (:uri request)
+    "/" (-> (response/response "Hello World")
+            (response/content-type "text/plain"))
+
+    "/stream" (-> (response/response
+                   #(doseq [n (range 3)]
+                      (.write % (.getBytes (str "data: " n "\n\n")))
+                      (.flush %)))
+                  (response/content-type "text/event-stream"))
+
+    "/echo-headers" (-> (response/response
+                         (pr-str {:headers (:headers request)}))
+                        (response/content-type "application/edn"))
+
+    "/error" {:status  500
+              :headers {"Content-Type" "text/plain"}
+              :body    "Error"}))
+
+(def ^:dynamic *server* nil)
+(def test-port 8899)
+
+(defn server-fixture [f]
+  (let [server (adapter/run-server test-handler {:port test-port})]
+    (try
+      (binding [*server* server]
+        (f))
+      (finally
+        (.stop server 0)))))
+
+(use-fixtures :each server-fixture)
+
+(defn http-get [path]
+  (let [url  (URL. (str "http://localhost:" test-port path))
+        conn ^HttpURLConnection (.openConnection url)]
+    (.setRequestMethod conn "GET")
+    conn))
+
+(deftest basic-request-test
+  (testing "basic GET request"
+    (let [conn     (http-get "/")
+          response (slurp (.getInputStream conn))]
+      (is (= 200 (.getResponseCode conn)))
+      (is (= "text/plain" (.getHeaderField conn "Content-Type")))
+
+      (is (= "Hello World" response))))
+
+  (testing "streaming SSE response"
+    (let [conn     (http-get "/stream")
+          response (slurp (.getInputStream conn))]
+      (is (= 200 (.getResponseCode conn)))
+      (is (= "text/event-stream" (.getHeaderField conn "Content-Type")))
+      (is (= "data: 0\n\ndata: 1\n\ndata: 2\n\n" response))))
+
+  (testing "error response"
+    (let [conn (http-get "/error")]
+      (is (= 500 (.getResponseCode conn)))))
+
+  (testing "header passing"
+    (let [conn (http-get "/echo-headers")]
+      (.setRequestProperty conn "X-Test" "test-value")
+      (let [response (read-string (slurp (.getInputStream conn)))]
+        (is (= "test-value" (get-in response [:headers "x-test"])))))))

components/json-rpc/deps.edn

@@ -1,7 +1,6 @@
 {:paths ["src"]
- :deps {org.clojure/clojure {:mvn/version "1.12.0"}
-        org.clojure/data.json {:mvn/version "2.5.0"}
-        aleph/aleph {:mvn/version "0.7.0"}}  ; HTTP/TCP server
+ :deps  {org.clojure/clojure   {:mvn/version "1.12.0"}
+         org.clojure/data.json {:mvn/version "2.5.0"}}
  :aliases
  {:test {:extra-paths ["test"]
-         :extra-deps {}}}}
+         :extra-deps  {}}}}

deps.edn

@@ -3,11 +3,15 @@
  {:dev
   {:extra-paths ["development/src" "components/json-rpc/test"]
    :extra-deps
-   {poly/json-rpc                 {:local/root "components/json-rpc"}
+   {poly/http-server              {:local/root "components/http-server"}
+    poly/json-rpc                 {:local/root "components/json-rpc"}
+    poly/mcp-server               {:local/root "components/mcp-server"}
     lambdaisland/kaocha           {:mvn/version "1.87.1366"}
     lambdaisland/kaocha-cloverage {:mvn/version "1.1.89"}
     org.clojure/clojure           {:mvn/version "1.12.0"}}}
-  :test   {:extra-paths ["components/json-rpc/test"]
+  :test   {:extra-paths ["components/http-server/test"
+                         "components/json-rpc/test"
+                         "components/mcp-server/test"]
            :extra-deps
            {org.clojure/test.check {:mvn/version "1.1.1"}}
            :exec-fn     kaocha.runner/exec-fn