Replace SSE price stream with WebSocket, use separate Docker port

- Replace SSE endpoint (/api/price/stream) with WebSocket (/api/price/ws)
  using ring-undertow-adapter's built-in WebSocket support
- Change Docker internal port from 4100 to 4101 to avoid conflicts with
  local dev (make run still uses 4100)
- Add free-port.sh utility script

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/clj/pmagnus/btcdata/web/routes/api.clj

@@ -1,7 +1,6 @@
 (ns pmagnus.btcdata.web.routes.api
   (:require
    [clojure.data.json :as json]
-   [clojure.string :as str]
    [integrant.core :as ig]
    [pmagnus.btcdata.web.controllers.health :as health]
    [pmagnus.btcdata.web.middleware.exception :as exception]
@@ -10,67 +9,45 @@
    [reitit.ring.coercion :as coercion]
    [reitit.ring.middleware.muuntaja :as muuntaja]
    [reitit.ring.middleware.parameters :as parameters]
-   [reitit.swagger :as swagger])
+   [reitit.swagger :as swagger]
+   [ring.adapter.undertow.websocket :as ws])
   (:import
    [io.undertow.server HttpServerExchange]
-   [io.undertow.util HttpString]
-   [java.io BufferedWriter OutputStreamWriter]
+   [io.undertow.websockets.core WebSockets WebSocketChannel]
    [java.util.concurrent LinkedBlockingQueue TimeUnit]))
 
-(defn- format-sse [event data]
-  (str "event: " event "\n"
-       (str/join "\n" (map #(str "data: " %) (str/split-lines data)))
-       "\n\n"))
-
 (defn- price->json [{:keys [price prev-price recorded-at]}]
   (json/write-str
    {:price       (str price)
     :prev_price  (when prev-price (str prev-price))
     :recorded_at (str recorded-at)}))
 
-(defn- run-sse-loop! [^HttpServerExchange exchange price-atom cors-origin]
-  (let [headers (.getResponseHeaders exchange)]
-    (.setStatusCode exchange 200)
-    (.put headers (HttpString. "Content-Type") "text/event-stream")
-    (.put headers (HttpString. "Cache-Control") "no-cache")
-    (.put headers (HttpString. "X-Accel-Buffering") "no")
-    (.put headers (HttpString. "Access-Control-Allow-Origin") cors-origin)
-    (when-not (.isBlocking exchange)
-      (.startBlocking exchange))
-    (let [out    (.getOutputStream exchange)
-          writer (BufferedWriter. (OutputStreamWriter. out "UTF-8"))
-          queue  (LinkedBlockingQueue.)
-          wkey   (keyword (gensym "sse-"))]
-      (add-watch price-atom wkey
-        (fn [_ _ _ v] (.offer queue v)))
-      (when-let [v @price-atom]
-        (.offer queue v))
-      (try
-        (loop []
-          (if-let [v (.poll queue 15 TimeUnit/SECONDS)]
-            (do (.write writer (format-sse "price-update" (price->json v)))
-                (.flush writer))
-            (do (.write writer ": heartbeat\n\n")
-                (.flush writer)))
-          (recur))
-        (catch Exception _)
-        (finally
-          (remove-watch price-atom wkey)
-          (try (.close writer) (catch Exception _))
-          (when-not (.isComplete exchange)
-            (.endExchange exchange)))))))
-
-(defn- price-stream-handler [{:keys [binance]} req]
+(defn- ws-price-handler [{:keys [binance]} req]
   (let [^HttpServerExchange exchange (:server-exchange req)
-        price-atom  (:latest-price binance)
-        cors-origin (or (System/getenv "CORS_ORIGIN") "*")]
-    ;; Dispatch to a worker thread so the Ring adapter never processes
-    ;; the return value — Undertow handles the exchange lifecycle directly.
-    (.dispatch exchange
-      (reify io.undertow.server.HttpHandler
-        (handleRequest [_ ex]
-          (run-sse-loop! ex price-atom cors-origin))))
-    ;; Return nil; exchange is dispatched so adapter won't touch it.
+        price-atom (:latest-price binance)]
+    (ws/ws-request exchange nil
+      (ws/ws-callback
+        {:on-open
+         (fn [{:keys [^WebSocketChannel channel]}]
+           (let [queue (LinkedBlockingQueue.)
+                 wkey  (keyword (gensym "ws-"))]
+             (add-watch price-atom wkey
+               (fn [_ _ _ v] (.offer queue v)))
+             (when-let [v @price-atom]
+               (.offer queue v))
+             (future
+               (try
+                 (loop []
+                   (when (.isOpen channel)
+                     (if-let [v (.poll queue 15 TimeUnit/SECONDS)]
+                       (WebSockets/sendTextBlocking (price->json v) channel)
+                       (WebSockets/sendTextBlocking "{\"ping\":true}" channel))
+                     (recur)))
+                 (catch Exception _)
+                 (finally
+                   (remove-watch price-atom wkey)
+                   (when (.isOpen channel)
+                     (try (.close channel) (catch Exception _))))))))}))
     nil))
 
 (defn- latest-price-handler [{:keys [binance]} _req]
@@ -91,8 +68,8 @@
            :handler (swagger/create-swagger-handler)}}]
    ["/health"
     {:get health/healthcheck!}]
-   ["/price/stream"
-    {:get        (fn [req] (price-stream-handler opts req))
+   ["/price/ws"
+    {:get        (fn [req] (ws-price-handler opts req))
      :no-doc     true
      :middleware []}]
    ["/price/latest"