ruflet 0.0.14 → 0.0.16

data/lib/ruflet/cli/run_command.rb

@@ -17,12 +17,18 @@ require "yaml"
 module Ruflet
   module CLI
     module RunCommand
+      DEFAULT_BACKEND_PORTS = {
+        "web" => 8550,
+        "desktop" => 8560,
+        "mobile" => 8570
+      }.freeze
+
       def command_run(args)
-        options = { target: "mobile", requested_port: 8550 }
+        options = { target: "mobile", requested_port: nil }
         parser = OptionParser.new do |o|
           o.on("--web") { options[:target] = "web" }
           o.on("--desktop") { options[:target] = "desktop" }
-          o.on("--port PORT", Integer) { |v| options[:requested_port] = v }
+          o.on("--port PORT", Integer, "Backend port (defaults: web 8550, desktop 8560, mobile 8570)") { |v| options[:requested_port] = v }
         end
         parser.parse!(args)
 
@@ -34,18 +40,33 @@ module Ruflet
           return 1
         end
 
-        selected_port = resolve_backend_port(options[:target], requested_port: options[:requested_port])
+        requested_port = options[:requested_port] || default_backend_port(options[:target])
+        selected_port = resolve_backend_port(options[:target], requested_port: requested_port)
         return 1 unless selected_port
         env = {
           "RUFLET_TARGET" => options[:target],
           "RUFLET_SUPPRESS_SERVER_BANNER" => "1",
-          "RUFLET_PORT" => selected_port.to_s
+          "RUFLET_PORT" => selected_port.to_s,
+          "RUFLET_STRICT_PORT" => "1"
         }
         apply_local_ruflet_dev_overrides(env)
         assets_dir = File.join(File.dirname(script_path), "assets")
         env["RUFLET_ASSETS_DIR"] = assets_dir if File.directory?(assets_dir)
 
-        print_run_banner(target: options[:target], requested_port: options[:requested_port], port: selected_port)
+        # Web: the Ruby backend serves the Flutter web client itself (same
+        # origin/port as /ws), so no separate static server or proxy is needed.
+        if options[:target] == "web"
+          web_dir = detect_web_client_dir
+          if web_dir
+            env["RUFLET_WEB_CLIENT_DIR"] = web_dir
+          else
+            warn "Ruflet web client unavailable for version #{ruflet_version}."
+            warn "Install the matching GitHub release client before running --web."
+            return 1
+          end
+        end
+
+        print_run_banner(target: options[:target], requested_port: requested_port, port: selected_port)
         print_mobile_qr_hint(port: selected_port) if options[:target] == "mobile"
 
         gemfile_path = find_nearest_gemfile(Dir.pwd)
@@ -150,16 +171,14 @@ module Ruflet
 
       def print_run_banner(target:, requested_port:, port:)
         if port != requested_port.to_i
-          puts "Requested port #{requested_port} is busy; bound to #{port}"
+          puts "Port #{requested_port} is busy; using #{port} for #{target}."
         end
         if target == "desktop"
           puts "Ruflet desktop URL: http://localhost:#{port}"
         elsif target == "mobile"
           puts "Ruflet target: #{target}"
-        else
-          puts "Ruflet target: #{target}"
-          puts "Ruflet URL: http://localhost:#{port}"
         end
+        # web: launch_web_client prints the single app URL after the server boots
       end
 
       def launch_target_client(target, port)
@@ -175,30 +194,19 @@ module Ruflet
         end
       end
 
+      # The Ruby backend (Ruflet::Server) serves the Flutter web client on its
+      # own port, so the client loads and opens its websocket on that same
+      # origin. The prebuilt web client derives its backend from Uri.base, so
+      # the public URL stays clean and dynamic port selection works naturally.
       def launch_web_client(port)
-        web_dir = detect_web_client_dir
-        unless web_dir
-          warn "Web client build not found and prebuilt download failed."
-          return []
-        end
-
-        web_port = find_available_port(port + 1)
-        web_pid = Process.spawn("python3", "-m", "http.server", web_port.to_s, "--bind", "127.0.0.1", chdir: web_dir, out: File::NULL, err: File::NULL)
-        Process.detach(web_pid)
-        wait_for_server_boot(web_port)
-        backend_url = "http://localhost:#{port}"
-        web_url = "http://localhost:#{web_port}/?#{URI.encode_www_form(url: backend_url)}"
-        browser_pid = open_in_browser_app_mode(web_url)
-        open_in_browser(web_url) if browser_pid.nil?
-        puts "Ruflet web client: #{web_url}"
-        puts "Ruflet backend ws: ws://localhost:#{port}/ws"
-        [web_pid, browser_pid].compact
-      rescue Errno::ENOENT
-        warn "python3 is required to host web client locally."
-        warn "Install Python 3 and rerun."
-        []
+        url = "http://localhost:#{port}/"
+        browser_pid = open_in_browser_app_mode(url)
+        open_in_browser(url) if browser_pid.nil?
+        puts "Ruflet web app: #{url}"
+        [browser_pid].compact
       rescue StandardError => e
-        warn "Failed to launch web client: #{e.class}: #{e.message}"
+        warn "Failed to open web client: #{e.class}: #{e.message}"
+        warn "Open it manually: http://localhost:#{port}/"
         []
       end
 
@@ -286,7 +294,7 @@ module Ruflet
       end
 
       def launch_desktop_client(url)
-        cmd = detect_project_desktop_client_command(url) || detect_desktop_client_command(url)
+        cmd = detect_desktop_client_command(url)
         unless cmd
           warn "Desktop client executable not found."
           warn "Set RUFLET_CLIENT_DIR to your client path."
@@ -307,119 +315,37 @@ module Ruflet
         []
       end
 
-      def detect_project_desktop_client_command(url)
-        return nil unless project_run_requires_managed_client?
-        return nil unless respond_to?(:ensure_flutter_client_dir, true)
-        return nil unless respond_to?(:prepare_flutter_client, true)
-        return nil unless respond_to?(:ensure_flutter!, true)
-
-        platform = host_platform_name
-        return nil unless %w[macos windows linux].include?(platform)
-
-        ensure_ruflet_build_assets(verbose: false) if respond_to?(:ensure_ruflet_build_assets, true)
-        client_dir = ensure_flutter_client_dir(verbose: false)
-        return nil unless client_dir
-
-        config = project_run_config
-        tools = ensure_flutter!("run", client_dir: client_dir)
-        env = build_tool_env(tools[:env], platform, client_dir)
-        return nil unless prepare_flutter_client(
-          client_dir,
-          platform: platform,
-          tools: tools,
-          config: config,
-          self_contained: false,
-          verbose: false
-        )
-
-        [
-          env,
-          tools[:flutter],
-          "run",
-          "-d",
-          platform,
-          "--target",
-          "lib/main.server.dart",
-          "--dart-define",
-          "RUFLET_BACKEND_URL=#{url}"
-        ]
-      rescue StandardError => e
-        warn "Project desktop client setup failed: #{e.class}: #{e.message}"
-        nil
-      end
-
-      def project_run_requires_managed_client?
-        return false unless defined?(Ruflet::CLI::BuildCommand::CLIENT_EXTENSION_MAP)
-
-        services = Array(project_run_config["services"]).map { |value| normalize_run_extension_key(value) }.compact
-        return false if services.empty?
-
-        extension_keys = Ruflet::CLI::BuildCommand::CLIENT_EXTENSION_MAP.keys
-        (services & extension_keys).any?
-      end
-
-      def project_run_config
-        config_path = ENV["RUFLET_CONFIG"] || (File.file?("ruflet.yaml") ? "ruflet.yaml" : "ruflet.yml")
-        return {} unless File.file?(config_path)
-
-        YAML.safe_load(File.read(config_path), aliases: true) || {}
-      rescue StandardError
-        {}
-      end
+      def detect_desktop_client_command(url)
+        root = configured_client_root
 
-      def normalize_run_extension_key(value)
-        key = value.to_s.strip.downcase
-        return nil if key.empty?
+        command = desktop_client_command_from_root(root, url)
+        return command if command
 
-        key.tr!("-", "_")
-        key.gsub!(/\A(flet_)+/, "")
-        key.gsub!(/\Aservice_/, "")
-        key
+        cached_root = ensure_prebuilt_client(desktop: true)
+        desktop_client_command_from_root(cached_root, url)
       end
 
-      def detect_desktop_client_command(url)
-        root = ENV["RUFLET_CLIENT_DIR"]
-        root = File.expand_path("ruflet_client", Dir.pwd) if root.to_s.strip.empty?
-        root = nil unless Dir.exist?(root)
-        root ||= ensure_prebuilt_client(desktop: true)
+      def desktop_client_command_from_root(root, url)
         return nil unless root && Dir.exist?(root)
 
         host_os = RbConfig::CONFIG["host_os"]
         if host_os.match?(/darwin/i)
-          app_path = [
-            File.join(root, "build", "macos", "Build", "Products", "Release", "ruflet_client.app"),
-            File.join(root, "build", "macos", "Build", "Products", "Debug", "ruflet_client.app"),
-            File.join(root, "desktop", "ruflet_client.app")
-          ].find do |candidate|
-            bin = File.join(candidate, "Contents", "MacOS", "ruflet_client")
-            File.file?(bin) && File.executable?(bin) && ensure_macos_file_picker_entitlement(candidate)
-          end
-          return [File.join(app_path, "Contents", "MacOS", "ruflet_client"), url] if app_path
+          app_path = File.join(root, "desktop", "ruflet_client.app")
+          bin = File.join(app_path, "Contents", "MacOS", "ruflet_client")
+          return [bin, url] if File.file?(bin) && File.executable?(bin) && ensure_macos_file_picker_entitlement(app_path)
         elsif host_os.match?(/mswin|mingw|cygwin/i)
-          exe = File.join(root, "build", "windows", "x64", "runner", "Release", "ruflet_client.exe")
-          prebuilt = File.join(root, "desktop", "ruflet_client.exe")
-          exe = prebuilt if !File.file?(exe) && File.file?(prebuilt)
+          exe = File.join(root, "desktop", "ruflet_client.exe")
           return [exe, url] if File.file?(exe)
         else
-          direct = File.join(root, "build", "linux", "x64", "release", "bundle", "ruflet_client")
-          prebuilt_direct = File.join(root, "desktop", "ruflet_client")
-          direct = prebuilt_direct if !File.file?(direct) && File.file?(prebuilt_direct)
+          direct = File.join(root, "desktop", "ruflet_client")
           return [direct, url] if File.file?(direct)
-          bundle_dir = File.join(root, "build", "linux", "x64", "release", "bundle")
-          if Dir.exist?(bundle_dir)
-            candidate = Dir.children(bundle_dir).map { |f| File.join(bundle_dir, f) }
-              .find { |path| File.file?(path) && File.executable?(path) }
-            return [candidate, url] if candidate
-          end
         end
 
         nil
       end
 
       def detect_web_client_dir
-        root = ENV["RUFLET_CLIENT_DIR"]
-        root = File.expand_path("ruflet_client", Dir.pwd) if root.to_s.strip.empty?
-        root = nil unless Dir.exist?(root)
+        root = configured_client_root
         root ||= ensure_prebuilt_client(web: true)
         return nil unless root && Dir.exist?(root)
 
@@ -431,6 +357,14 @@ module Ruflet
         nil
       end
 
+      def configured_client_root
+        root = ENV["RUFLET_CLIENT_DIR"].to_s.strip
+        return nil if root.empty?
+
+        expanded = File.expand_path(root)
+        Dir.exist?(expanded) ? expanded : nil
+      end
+
       def ensure_prebuilt_client(web: false, desktop: false, platform: nil, force: false)
         platform ||= host_platform_name
         return nil if platform.nil?
@@ -445,10 +379,12 @@ module Ruflet
           return nil if desktop_asset.nil?
           wanted_assets << { kind: :desktop, name: desktop_asset, platform: platform }
         end
-        if !force && (wanted_assets.empty? || prebuilt_assets_present?(cache_root, web: web, desktop: desktop, platform: platform))
-          ensure_client_manifest(cache_root, platform: platform)
+        cached = prebuilt_assets_present?(cache_root, web: web, desktop: desktop, platform: platform)
+        compatible_cache = cached && compatible_client_cache?(cache_root, platform: platform)
+        if !force && (wanted_assets.empty? || compatible_cache)
           return cache_root
         end
+        force = true if cached && !compatible_cache
 
         release = fetch_release_for_version
         return nil unless release
@@ -544,11 +480,33 @@ module Ruflet
       end
 
       def fetch_release_for_version
-        release_by_tag("v#{ruflet_version}") ||
-          release_by_tag(ruflet_version) ||
-          release_by_tag("prebuild") ||
-          release_by_tag("prebuild-main") ||
-          release_latest
+        client_release_tags.each do |tag|
+          release = release_by_tag(tag)
+          return release if release
+        end
+
+        nil
+      end
+
+      def client_release_tags
+        channel = ENV["RUFLET_CLIENT_CHANNEL"].to_s.strip
+        unless channel.empty?
+          raise ArgumentError, "Invalid RUFLET_CLIENT_CHANNEL" unless channel.match?(/\A[A-Za-z0-9._-]+\z/)
+
+          return [channel]
+        end
+
+        ["v#{ruflet_version}", ruflet_version]
+      end
+
+      def compatible_client_cache?(root, platform:)
+        manifest = read_client_manifest(root)
+        return false unless manifest
+
+        manifest["schema"] == 1 &&
+          manifest["ruflet_version"] == ruflet_version &&
+          manifest["platform"] == platform &&
+          client_release_tags.include?(manifest["release_tag"])
       end
 
       def ruflet_version
@@ -558,10 +516,6 @@ module Ruflet
         Ruflet::VERSION
       end
 
-      def release_latest
-        github_get_json("https://api.github.com/repos/AdamMusa/Ruflet/releases/latest")
-      end
-
       def release_by_tag(tag)
         github_get_json("https://api.github.com/repos/AdamMusa/Ruflet/releases/tags/#{tag}")
       rescue StandardError
@@ -731,19 +685,6 @@ module Ruflet
         nil
       end
 
-      def ensure_client_manifest(root, platform:)
-        return if read_client_manifest(root)
-
-        assets = []
-        assets << { "kind" => "web", "platform" => platform, "asset_name" => nil } if File.file?(File.join(root, "web", "index.html"))
-        if prebuilt_desktop_present?(root, platform: platform)
-          assets << { "kind" => "desktop", "platform" => platform, "asset_name" => nil }
-        end
-        return if assets.empty?
-
-        write_client_manifest(root, platform: platform, release: nil, assets: assets)
-      end
-
       def write_client_manifest(root, platform:, release:, assets:)
         FileUtils.mkdir_p(root)
         payload = {
@@ -776,26 +717,24 @@ module Ruflet
         port = start_port.to_i
 
         max_attempts.times do
-          begin
-            begin
-              probe = TCPServer.new("0.0.0.0", port)
-            rescue Errno::EACCES, Errno::EPERM
-              probe = TCPServer.new("127.0.0.1", port)
-            end
-            probe.close
-            return port
-          rescue Errno::EADDRINUSE, Errno::EACCES, Errno::EPERM
-            port += 1
-          end
+          return port if port_available?(port)
+
+          port += 1
         end
 
-        start_port
+        nil
+      end
+
+      def default_backend_port(target)
+        DEFAULT_BACKEND_PORTS.fetch(target.to_s, DEFAULT_BACKEND_PORTS.fetch("mobile"))
       end
 
-      def resolve_backend_port(_target, requested_port: 8550)
+      def resolve_backend_port(target, requested_port: nil)
         base = requested_port.to_i
-        base = 8550 if base <= 0
-        find_available_port(base)
+        base = default_backend_port(target) if base <= 0
+        selected = find_available_port(base)
+        warn "No available Ruflet port found starting at #{base}." unless selected
+        selected
       end
 
       def port_available?(port)
@@ -807,7 +746,7 @@ module Ruflet
             probe = TCPServer.new("127.0.0.1", port)
           end
           true
-        rescue Errno::EADDRINUSE
+        rescue Errno::EADDRINUSE, Errno::EACCES, Errno::EPERM
           false
         ensure
           probe&.close

data/lib/ruflet/cli.rb

@@ -2,10 +2,23 @@
 
 require "optparse"
 
+# Project files (pbxproj, plists, embedded runtime sources) are UTF-8; never
+# depend on the caller's locale for reading them.
+Encoding.default_external = Encoding::UTF_8 if Encoding.default_external == Encoding::US_ASCII
+
+# Provisioning (downloads, package installs, SDK extraction) can run for
+# minutes. When stdout is not a TTY (CI logs, pipes, editor consoles) Ruby
+# buffers it, so progress notes would only appear once the whole run finishes.
+# Unbuffer both streams so the pipeline reports progress as it happens.
+$stdout.sync = true
+$stderr.sync = true
+
 require_relative "version"
 require_relative "cli/templates"
 require_relative "cli/new_command"
 require_relative "cli/flutter_sdk"
+require_relative "cli/environment_setup"
+require_relative "cli/android_sdk"
 require_relative "cli/run_command"
 require_relative "cli/update_command"
 require_relative "cli/build_command"

data/lib/ruflet/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.16
 platform: ruby
 authors:
 - AdamMusa
@@ -37,7 +37,9 @@ files:
 - assets/splash.png
 - bin/ruflet
 - lib/ruflet/cli.rb
+- lib/ruflet/cli/android_sdk.rb
 - lib/ruflet/cli/build_command.rb
+- lib/ruflet/cli/environment_setup.rb
 - lib/ruflet/cli/extra_command.rb
 - lib/ruflet/cli/flutter_sdk.rb
 - lib/ruflet/cli/new_command.rb
@@ -47,7 +49,8 @@ files:
 - lib/ruflet/version.rb
 - lib/ruflet_cli.rb
 homepage: https://github.com/AdamMusa/Ruflet
-licenses: []
+licenses:
+- MIT
 metadata: {}
 rdoc_options: []
 require_paths: