ruflet_server 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2681e7067d0b0bd1d3d998e352b89a926cc6c8d1c129a632bb325fb5d2dde8c6
-  data.tar.gz: d4562b20a7f17a82c29cca1020b1956cc18c22ff8aa8531a7c5ebd5230db6704
+  metadata.gz: b2720e5cd2f2bbe7ea1f8c6470c420fcb2b84bb8c6c3bab83ca12b5ea64633d5
+  data.tar.gz: 410a06961fed394deb2b0bdc194cccede9c407de205b5a8e977da1c165290e68
 SHA512:
-  metadata.gz: a249874ec8efe3f1ac1c683ee69043077e73051c97eb7cfaa45b491e68df57b7cd22636f665918e33cfeac87913bca791a45ccacb36d16a815f8044ccb219717
-  data.tar.gz: 8b5aca6dde6daf9e51d8700de9609879873110b7793db145153140c813095bd294b9683a2b0a29ffdfd111f7ad43373ce830e9c0103cd3ec86b7d098e5474ff0
+  metadata.gz: e9d1f379990a194e710220e0cc872501c3ce9da07e7e9149b5eaf4377ab669f5d74cc814bb6c8cf37dec3f647ea767074c1aa5c49daab87a584da3f9909d9846
+  data.tar.gz: c59c37531ebbd43796a7117d843208680562f18e09d939aeb63ab05b5560faa79fe7fbc5014de7fd4dc413f2be80d949f4cb1a4d802aa421ed4e41aa1ca325fb

data/README.md

@@ -1,3 +1,17 @@
 # ruflet_server
 
-Part of Ruflet monorepo.
+`ruflet_server` runs server-driven Ruflet applications and connects their Ruby
+UI code to Ruflet clients.
+
+It is installed automatically in projects created with `ruflet new`. Start an
+application through the Ruflet CLI:
+
+```bash
+bundle exec ruflet run
+bundle exec ruflet run --web
+bundle exec ruflet run --desktop
+```
+
+Application code uses the public `Ruflet.run` API supplied by `ruflet_core`.
+Rails applications should use `ruflet_rails` instead of starting this server
+directly.

data/lib/ruflet/server.rb

@@ -63,7 +63,7 @@ module Ruflet
           @server_socket = TCPServer.new(@host, candidate)
           @port = candidate
           if @port != requested && ENV["RUFLET_SUPPRESS_SERVER_BANNER"] != "1"
-            warn "Requested port #{requested} is busy; bound to #{@port}"
+            warn "Port #{requested} is busy; using #{@port}."
           end
           publish_bound_port!
           return
@@ -233,10 +233,24 @@ module Ruflet
         warn e.backtrace.join("\n") if e.backtrace
         send_message(ws, Protocol::ACTIONS[:session_crashed], { "message" => e.message.to_s.dup.force_encoding("UTF-8") }) if ws
       ensure
-        close_connection(ws)
+        if ws
+          close_connection(ws)
+        else
+          # Plain HTTP request: we answer with `Connection: close`, so we must
+          # actually close the socket. Leaving it open exhausts the browser's
+          # per-host connection pool and the later /ws upgrade never opens —
+          # the app then hangs on its "connecting" screen.
+          close_http_socket(socket)
+        end
       end
     end
 
+    def close_http_socket(socket)
+      socket.close if socket && !socket.closed?
+    rescue StandardError
+      nil
+    end
+
     def read_http_upgrade_request(socket)
       request_line = socket.gets("\r\n")
       return [nil, {}] if request_line.nil?
@@ -261,7 +275,7 @@ module Ruflet
     end
 
     def websocket_upgrade_request?(path, headers)
-      return false unless path == "/ws"
+      return false unless path.to_s.split("?", 2).first == "/ws"
       return false unless headers["upgrade"]&.downcase == "websocket"
       return false unless headers["connection"]&.downcase&.include?("upgrade")
       return false if headers["sec-websocket-key"].to_s.empty?
@@ -270,21 +284,95 @@ module Ruflet
     end
 
     def handle_http_request(socket, path)
-      case path
-      when "/health"
-        write_http_response(socket, 200, "text/plain", "ok")
+      clean = path.to_s.split("?", 2).first.split("#", 2).first
+      return write_http_response(socket, 200, "text/plain", "ok") if clean == "/health"
+
+      # In web mode the standalone backend also serves the Flutter web client,
+      # so the browser loads the app and opens its websocket on this same
+      # origin/port — no separate static server or proxy is needed.
+      return serve_web_client(socket, clean) if web_client_root
+
+      case clean
       when "/"
         write_http_response(socket, 200, "text/plain", "ruflet server")
       else
-        if path.start_with?("/assets/")
-          serve_asset(socket, path)
+        if clean.start_with?("/assets/")
+          serve_asset(socket, clean)
         else
           write_http_response(socket, 404, "text/plain", "not found")
         end
       end
     rescue StandardError => e
+      # The browser routinely cancels in-flight asset requests (preloads,
+      # duplicate connections); writing to a reset socket raises EPIPE/ECONNRESET
+      # and is expected, not an error.
+      return if disconnect_error?(e)
+
       warn "http error: #{e.class}: #{e.message}"
-      write_http_response(socket, 500, "text/plain", "server error")
+      begin
+        write_http_response(socket, 500, "text/plain", "server error")
+      rescue StandardError
+        nil
+      end
+    end
+
+    def web_client_root
+      dir = ENV["RUFLET_WEB_CLIENT_DIR"].to_s
+      return nil if dir.empty?
+
+      full = File.expand_path(dir)
+      File.directory?(full) ? full : nil
+    end
+
+    def serve_web_client(socket, path)
+      root = web_client_root
+
+      # Neutralize the Flutter service worker: when this dev server hops between
+      # localhost ports a cached worker would otherwise keep a stale client
+      # alive that reconnects to the wrong backend. This unregisters it and
+      # clears caches so the browser always loads the current client.
+      if path == "/flutter_service_worker.js"
+        return write_http_response(socket, 200, "text/javascript", service_worker_reset_js, cache: false)
+      end
+
+      relative = path == "/" ? "index.html" : path.sub(%r{\A/}, "")
+      full = File.expand_path(File.join(root, relative))
+      if (full == root || full.start_with?(root + File::SEPARATOR)) && File.file?(full)
+        return write_http_response(socket, 200, content_type_for(full), File.binread(full), binary: true, cache: false)
+      end
+
+      # App runtime assets (images referenced by the app) fall back to the
+      # configured assets directory when not part of the client bundle.
+      if path.start_with?("/assets/") && (asset = resolve_asset_path(path))
+        return write_http_response(socket, 200, content_type_for(asset), File.binread(asset), binary: true, cache: false)
+      end
+
+      # SPA fallback: serve index.html for extension-less route paths.
+      index = File.join(root, "index.html")
+      if File.extname(path).empty? && File.file?(index)
+        return write_http_response(socket, 200, "text/html", File.binread(index), binary: true, cache: false)
+      end
+
+      write_http_response(socket, 404, "text/plain", "not found")
+    end
+
+    # A no-op service worker: it registers cleanly (so Flutter's loader, which
+    # awaits navigator.serviceWorker.ready, never hangs), wipes any caches a
+    # previous run left behind, claims the page, and installs NO fetch handler —
+    # so every request (including the app shell) goes straight to the network and
+    # the client always loads fresh and connects to the current origin/port.
+    # (Self-unregistering here can leave serviceWorker.ready unresolved.)
+    def service_worker_reset_js
+      <<~JS
+        self.addEventListener('install', function (e) { self.skipWaiting(); });
+        self.addEventListener('activate', function (e) {
+          e.waitUntil((async function () {
+            var keys = await caches.keys();
+            await Promise.all(keys.map(function (k) { return caches.delete(k); }));
+            await self.clients.claim();
+          })());
+        });
+      JS
     end
 
     def serve_asset(socket, path)
@@ -315,28 +403,39 @@ module Ruflet
       root = ENV["RUFLET_ASSETS_DIR"].to_s
       return root unless root.empty?
 
+      embedded_root = defined?($__ruflet_app_root) ? $__ruflet_app_root.to_s : ""
+      unless embedded_root.empty?
+        embedded_assets = File.join(embedded_root, "assets")
+        return embedded_assets if File.directory?(embedded_assets)
+      end
+
       default_root = File.join(Dir.pwd, "assets")
       File.directory?(default_root) ? default_root : nil
     end
 
     def content_type_for(path)
       case File.extname(path).downcase
-      when ".png"
-        "image/png"
-      when ".jpg", ".jpeg"
-        "image/jpeg"
-      when ".gif"
-        "image/gif"
-      when ".webp"
-        "image/webp"
-      when ".svg"
-        "image/svg+xml"
-      else
-        "application/octet-stream"
+      when ".html", ".htm" then "text/html; charset=utf-8"
+      when ".js", ".mjs" then "text/javascript; charset=utf-8"
+      when ".json", ".map" then "application/json; charset=utf-8"
+      when ".css" then "text/css; charset=utf-8"
+      when ".wasm" then "application/wasm"
+      when ".png" then "image/png"
+      when ".jpg", ".jpeg" then "image/jpeg"
+      when ".gif" then "image/gif"
+      when ".webp" then "image/webp"
+      when ".svg" then "image/svg+xml"
+      when ".ico" then "image/x-icon"
+      when ".ttf" then "font/ttf"
+      when ".otf" then "font/otf"
+      when ".woff" then "font/woff"
+      when ".woff2" then "font/woff2"
+      when ".txt" then "text/plain; charset=utf-8"
+      else "application/octet-stream"
       end
     end
 
-    def write_http_response(socket, status, content_type, body, binary: false)
+    def write_http_response(socket, status, content_type, body, binary: false, cache: true)
       reason = {
         200 => "OK",
         404 => "Not Found",
@@ -349,6 +448,10 @@ module Ruflet
       socket.write("HTTP/1.1 #{status} #{reason}\r\n")
       socket.write("Content-Type: #{content_type}\r\n")
       socket.write("Content-Length: #{length}\r\n")
+      unless cache
+        socket.write("Cache-Control: no-store, no-cache, must-revalidate, max-age=0\r\n")
+        socket.write("Pragma: no-cache\r\n")
+      end
       socket.write("Connection: close\r\n")
       socket.write("\r\n")
       socket.write(body_str)

data/lib/ruflet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruflet
-  VERSION = "0.0.15" unless const_defined?(:VERSION)
+  VERSION = "0.0.16" unless const_defined?(:VERSION)
 end

data/lib/ruflet_server.rb

@@ -6,7 +6,8 @@ require_relative "ruflet/server"
 module Ruflet
   module_function
 
-  def run(entrypoint = nil, host: "0.0.0.0", port: 8550, &block)
+  def run(entrypoint = nil, host: "0.0.0.0", port: nil, &block)
+    port = normalize_run_port(port || ENV["RUFLET_PORT"] || 8550)
     callback = entrypoint || block
     raise ArgumentError, "Ruflet.run requires a callable entrypoint or block" unless callback.respond_to?(:call)
 
@@ -27,7 +28,13 @@ module Ruflet
 
     @run_interceptors_mutex.synchronize { @run_interceptors.last }
   end
+
+  def normalize_run_port(value)
+    Integer(value)
+  rescue ArgumentError, TypeError
+    8550
+  end
   class << self
-    private :run_interceptor
+    private :run_interceptor, :normalize_run_port
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet_server
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - AdamMusa
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 0.0.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 0.0.16
 description: Ruflet WebSocket server runtime compatible with Flet protocol.
 email:
 - adammusa2222@gmail.com
@@ -38,7 +38,8 @@ files:
 - lib/ruflet/version.rb
 - lib/ruflet_server.rb
 homepage: https://github.com/AdamMusa/Ruflet
-licenses: []
+licenses:
+- MIT
 metadata: {}
 rdoc_options: []
 require_paths: