ruflet_cli 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd07971461f7a7a4f8f61df41b51b4a6537de8b0dfe152fd71c52148a344c15e
-  data.tar.gz: 65b0952b26820338f5a4f4115440aac955c0ab09bac94fb3fcc94d19e302eff1
+  metadata.gz: bda605a60090590b4fd902f1b14a3b81c44fbe28cdd08ece037611feae2d775c
+  data.tar.gz: f52031603e160ccaeefe976e4b3edd24ea383f03d61dca9f15141411d7ee030e
 SHA512:
-  metadata.gz: 28b45040c5f0f3b0901d48bedfdd995e644983e3d4e3748696442f21288175722d3b13688f646f4b1cbea662405213b0e6dedf970aa4614b57d9f2000a5e65a8
-  data.tar.gz: 891b2e7de50d432d0922f7f8aa0e2d28e764d4c8c02def6a7de5c58fbc26c86b9421687516427c84efd0a431e79d546c698962d8d421a54ddf97cb2f246b99ed
+  metadata.gz: 87e2ffbe8ff812a0a56c4b7d3a55f8c981d4b614efecd451709bf026687b4c60fd42778e11d5e978c4a34f8bccafb7f93b522ea241a6d6eb51aff3f20e1e9a79
+  data.tar.gz: fba28f53a351ba5edb0e1f9bc16b178132ce8f487029d263777f11092cb19df312ea3113301b201e03b39c595ef9ca7a6d87f1e539a9fc619a1822d62969890c

data/lib/ruflet/cli/build_command.rb

@@ -1,17 +1,36 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "uri"
 require "yaml"
 
 module Ruflet
   module CLI
     module BuildCommand
       include FlutterSdk
+      CLIENT_EXTENSION_MAP = {
+        "ads" => { package: "flet_ads", alias: "ruflet_ads" },
+        "audio" => { package: "flet_audio", alias: "ruflet_audio" },
+        "audio_recorder" => { package: "flet_audio_recorder", alias: "ruflet_audio_recorder" },
+        "camera" => { package: "flet_camera", alias: "ruflet_camera" },
+        "charts" => { package: "flet_charts", alias: "ruflet_charts" },
+        "code_editor" => { package: "flet_code_editor", alias: "ruflet_code_editor" },
+        "color_pickers" => { package: "flet_color_pickers", alias: "ruflet_color_picker" },
+        "datatable2" => { package: "flet_datatable2", alias: "ruflet_datatable2" },
+        "flashlight" => { package: "flet_flashlight", alias: "ruflet_flashlight" },
+        "geolocator" => { package: "flet_geolocator", alias: "ruflet_geolocator" },
+        "lottie" => { package: "flet_lottie", alias: "ruflet_lottie" },
+        "map" => { package: "flet_map", alias: "ruflet_map" },
+        "permission_handler" => { package: "flet_permission_handler", alias: "ruflet_permission_handler" },
+        "secure_storage" => { package: "flet_secure_storage", alias: "ruflet_secure_storage" },
+        "video" => { package: "flet_video", alias: "ruflet_video" },
+        "webview" => { package: "flet_webview", alias: "ruflet_webview" }
+      }.freeze
 
       def command_build(args)
         platform = (args.shift || "").downcase
         if platform.empty?
-          warn "Usage: ruflet build <apk|ios|aab|web|macos|windows|linux>"
+          warn "Usage: ruflet build <apk|android|ios|aab|web|macos|windows|linux>"
           return 1
         end
 
@@ -28,11 +47,18 @@ module Ruflet
           return 1
         end
 
+        config = load_ruflet_config
         tools = ensure_flutter!("build", client_dir: client_dir)
-        ok = prepare_flutter_client(client_dir, tools: tools)
+        ok = prepare_flutter_client(client_dir, tools: tools, config: config)
         return 1 unless ok
 
-        ok = system(tools[:env], tools[:flutter], *flutter_cmd, *args, chdir: client_dir)
+        build_args = [*flutter_cmd, *args]
+        client_url = configured_client_url(config)
+        if client_url
+          build_args += ["--dart-define", "RUFLET_CLIENT_URL=#{client_url}"]
+        end
+
+        ok = system(tools[:env], tools[:flutter], *build_args, chdir: client_dir)
         ok ? 0 : 1
       end
 
@@ -51,35 +77,72 @@ module Ruflet
         nil
       end
 
-      def prepare_flutter_client(client_dir, tools:)
-        apply_build_config(client_dir)
+      def prepare_flutter_client(client_dir, tools:, config:)
+        apply_service_extension_config(client_dir, config)
+        asset_flags = apply_build_config(client_dir, config)
+        if asset_flags[:error]
+          warn asset_flags[:error]
+          return false
+        end
         unless system(tools[:env], tools[:flutter], "pub", "get", chdir: client_dir)
           warn "flutter pub get failed"
           return false
         end
 
-        unless system(tools[:env], tools[:dart], "run", "flutter_native_splash:create", chdir: client_dir)
-          warn "flutter_native_splash failed"
-          return false
+        if asset_flags[:has_splash]
+          unless system(tools[:env], tools[:dart], "run", "flutter_native_splash:create", chdir: client_dir)
+            warn "flutter_native_splash failed"
+            return false
+          end
         end
 
-        unless system(tools[:env], tools[:dart], "run", "flutter_launcher_icons", chdir: client_dir)
-          warn "flutter_launcher_icons failed"
-          return false
+        if asset_flags[:has_icon]
+          unless system(tools[:env], tools[:dart], "run", "flutter_launcher_icons", chdir: client_dir)
+            warn "flutter_launcher_icons failed"
+            return false
+          end
         end
 
         true
       end
 
-      def apply_build_config(client_dir)
+      def configured_client_url(config)
+        candidates = [
+          config["ruflet_client_url"],
+          (config["app"].is_a?(Hash) ? config["app"]["ruflet_client_url"] : nil)
+        ]
+        raw = candidates.find { |v| !v.to_s.strip.empty? }
+        return nil if raw.nil?
+
+        value = raw.to_s.strip
+        uri = URI.parse(value)
+        return nil unless %w[http https ws wss].include?(uri.scheme)
+        return nil if uri.host.to_s.strip.empty?
+
+        value
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def load_ruflet_config
         config_path = ENV["RUFLET_CONFIG"] || "ruflet.yaml"
         unless File.file?(config_path)
           alt = "ruflet.yml"
           config_path = alt if File.file?(alt)
         end
+        return {} unless File.file?(config_path)
 
+        YAML.safe_load(File.read(config_path), aliases: true) || {}
+      rescue StandardError => e
+        warn "Failed to load ruflet config: #{e.class}: #{e.message}"
+        {}
+      end
+
+      def apply_build_config(client_dir, config = {})
+        build = config["build"] || {}
+        assets = config["assets"] || {}
+        config_path = ENV["RUFLET_CONFIG"] || (File.file?("ruflet.yaml") ? "ruflet.yaml" : "ruflet.yml")
         config_present = File.file?(config_path)
-        config = config_present ? (YAML.load_file(config_path) || {}) : {}
         build = config["build"] || {}
         assets = config["assets"] || {}
         config_dir = config_present ? File.dirname(File.expand_path(config_path)) : Dir.pwd
@@ -87,44 +150,24 @@ module Ruflet
         assets_root = build["assets_dir"] || assets["dir"] || config["assets_dir"] || "assets"
         assets_root = File.expand_path(assets_root, config_dir)
 
-        unless config_present || Dir.exist?(assets_root) || ENV["RUFLET_SPLASH"] || ENV["RUFLET_ICON"]
-          return
-        end
-
         resolve_asset = lambda do |path|
           return nil if path.nil? || path.to_s.strip.empty?
           full = File.expand_path(path.to_s, config_dir)
           File.file?(full) ? full : nil
         end
 
-        find_first = lambda do |dir, names|
-          names.each do |name|
-            candidate = File.join(dir, name)
-            return candidate if File.file?(candidate)
-          end
-          nil
-        end
+        splash_defined = key_defined?(build, "splash_screen") || key_defined?(assets, "splash_screen") || key_defined?(config, "splash_screen")
+        icon_defined = key_defined?(build, "icon_launcher") || key_defined?(assets, "icon_launcher") || key_defined?(config, "icon_launcher")
 
-        splash = resolve_asset.call(build["splash"] || assets["splash"] || ENV["RUFLET_SPLASH"])
+        splash = resolve_asset.call(build["splash_screen"] || assets["splash_screen"] || config["splash_screen"])
         splash_dark = resolve_asset.call(build["splash_dark"] || build["splash_dark_image"] || assets["splash_dark"])
-        icon = resolve_asset.call(build["icon"] || assets["icon"] || ENV["RUFLET_ICON"])
+        icon = resolve_asset.call(build["icon_launcher"] || assets["icon_launcher"] || config["icon_launcher"])
         icon_android = resolve_asset.call(build["icon_android"] || assets["icon_android"])
         icon_ios = resolve_asset.call(build["icon_ios"] || assets["icon_ios"])
         icon_web = resolve_asset.call(build["icon_web"] || assets["icon_web"])
         icon_windows = resolve_asset.call(build["icon_windows"] || assets["icon_windows"])
         icon_macos = resolve_asset.call(build["icon_macos"] || assets["icon_macos"])
 
-        if Dir.exist?(assets_root)
-          splash ||= find_first.call(assets_root, ["splash.png", "splash.jpg", "splash.webp", "splash.bmp"])
-          splash_dark ||= find_first.call(assets_root, ["splash_dark.png", "splash_dark.jpg", "splash_dark.webp", "splash_dark.bmp"])
-          icon ||= find_first.call(assets_root, ["icon.png", "icon.jpg", "icon.webp", "icon.bmp"])
-          icon_android ||= find_first.call(assets_root, ["icon_android.png", "icon_android.jpg", "icon_android.webp"])
-          icon_ios ||= find_first.call(assets_root, ["icon_ios.png", "icon_ios.jpg", "icon_ios.webp"])
-          icon_web ||= find_first.call(assets_root, ["icon_web.png", "icon_web.jpg", "icon_web.webp"])
-          icon_windows ||= find_first.call(assets_root, ["icon_windows.ico", "icon_windows.png"])
-          icon_macos ||= find_first.call(assets_root, ["icon_macos.png", "icon_macos.jpg", "icon_macos.webp"])
-        end
-
         splash_color = build["splash_color"]
         splash_dark_color = build["splash_dark_color"] || build["splash_color_dark"]
         icon_background = build["icon_background"]
@@ -150,10 +193,19 @@ module Ruflet
         end
         copy_asset.call(icon_macos, "icon_macos.png")
 
+        if splash_defined && splash.nil?
+          return { has_icon: false, has_splash: false, error: "build config error: splash_screen is set but file was not found" }
+        end
+        if icon_defined && icon.nil?
+          return { has_icon: false, has_splash: false, error: "build config error: icon_launcher is set but file was not found" }
+        end
+
         pubspec_path = File.join(client_dir, "pubspec.yaml")
-        return unless File.file?(pubspec_path)
+        unless File.file?(pubspec_path)
+          return { has_icon: icon_defined && !icon.nil?, has_splash: splash_defined && !splash.nil?, error: nil }
+        end
 
-        if icon
+        if icon_defined && icon
           update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path", "\"assets/icon.png\"", multiple: true)
         end
         update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path_android", "\"assets/icon_android.png\"", multiple: true) if icon_android
@@ -168,10 +220,89 @@ module Ruflet
         update_pubspec_value(pubspec_path, "flutter_launcher_icons", "background_color", "\"#{icon_background}\"") if icon_background
         update_pubspec_value(pubspec_path, "flutter_launcher_icons", "theme_color", "\"#{theme_color}\"") if theme_color
 
-        update_pubspec_value(pubspec_path, "flutter_native_splash", "image", "\"assets/splash.png\"") if splash
+        update_pubspec_value(pubspec_path, "flutter_native_splash", "image", "\"assets/splash.png\"") if splash_defined && splash
         update_pubspec_value(pubspec_path, "flutter_native_splash", "image_dark", "\"assets/splash_dark.png\"") if splash_dark
         update_pubspec_value(pubspec_path, "flutter_native_splash", "color", "\"#{splash_color}\"") if splash_color
         update_pubspec_value(pubspec_path, "flutter_native_splash", "color_dark", "\"#{splash_dark_color}\"") if splash_dark_color
+
+        { has_icon: icon_defined && !icon.nil?, has_splash: splash_defined && !splash.nil?, error: nil }
+      end
+
+      def key_defined?(hash, key)
+        hash.is_a?(Hash) && (hash.key?(key) || hash.key?(key.to_sym))
+      end
+
+      def apply_service_extension_config(client_dir, config = {})
+        services = Array(config["services"])
+        extension_keys = services.map { |v| normalize_extension_key(v) }.compact.uniq
+        extension_packages = extension_keys.filter_map { |key| CLIENT_EXTENSION_MAP[key]&.fetch(:package) }.uniq
+        extension_aliases = extension_keys.filter_map { |key| CLIENT_EXTENSION_MAP[key]&.fetch(:alias) }.uniq
+
+        pubspec_path = File.join(client_dir, "pubspec.yaml")
+        main_path = File.join(client_dir, "lib", "main.dart")
+        prune_client_pubspec(pubspec_path, extension_packages) if File.file?(pubspec_path)
+        prune_client_main(main_path, extension_aliases) if File.file?(main_path)
+      end
+
+      def normalize_extension_key(value)
+        key = value.to_s.strip.downcase
+        return nil if key.empty?
+
+        key.tr!("-", "_")
+        key.gsub!(/\A(flet_)+/, "")
+        key.gsub!(/\Aservice_/, "")
+        key
+      end
+
+      def prune_client_pubspec(path, selected_packages)
+        data = YAML.safe_load(File.read(path), aliases: true) || {}
+        deps = (data["dependencies"] || {}).dup
+
+        deps.keys.each do |name|
+          next unless name.start_with?("flet_")
+          next if name == "flet"
+          next if selected_packages.include?(name)
+
+          deps.delete(name)
+        end
+
+        data["dependencies"] = deps
+        File.write(path, YAML.dump(data))
+      end
+
+      def prune_client_main(path, selected_aliases)
+        lines = File.readlines(path)
+        alias_to_package = {}
+
+        lines.each do |line|
+          match = line.match(%r{\Aimport 'package:(flet_[^/]+)/\1\.dart' as ([a-zA-Z0-9_]+);})
+          next unless match
+
+          alias_to_package[match[2]] = match[1]
+        end
+
+        kept = lines.select do |line|
+          import_match = line.match(%r{\Aimport 'package:(flet_[^/]+)/\1\.dart' as ([a-zA-Z0-9_]+);})
+          if import_match
+            package_name = import_match[1]
+            next true if package_name == "flet"
+            next true if selected_aliases.include?(import_match[2])
+            next false
+          end
+
+          extension_match = line.match(/\A\s*([a-zA-Z0-9_]+)\.Extension\(\),\s*\z/)
+          if extension_match
+            extension_alias = extension_match[1]
+            package_name = alias_to_package[extension_alias]
+            next true if package_name.nil?
+            next true if selected_aliases.include?(extension_alias)
+            next false
+          end
+
+          true
+        end
+
+        File.write(path, kept.join)
       end
 
       def update_pubspec_value(path, block, key, value, multiple: false)

data/lib/ruflet/cli/new_command.rb

@@ -1,10 +1,30 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "yaml"
 
 module Ruflet
   module CLI
     module NewCommand
+      CLIENT_EXTENSION_MAP = {
+        "ads" => { package: "flet_ads", alias: "ruflet_ads" },
+        "audio" => { package: "flet_audio", alias: "ruflet_audio" },
+        "audio_recorder" => { package: "flet_audio_recorder", alias: "ruflet_audio_recorder" },
+        "camera" => { package: "flet_camera", alias: "ruflet_camera" },
+        "charts" => { package: "flet_charts", alias: "ruflet_charts" },
+        "code_editor" => { package: "flet_code_editor", alias: "ruflet_code_editor" },
+        "color_pickers" => { package: "flet_color_pickers", alias: "ruflet_color_picker" },
+        "datatable2" => { package: "flet_datatable2", alias: "ruflet_datatable2" },
+        "flashlight" => { package: "flet_flashlight", alias: "ruflet_flashlight" },
+        "geolocator" => { package: "flet_geolocator", alias: "ruflet_geolocator" },
+        "lottie" => { package: "flet_lottie", alias: "ruflet_lottie" },
+        "map" => { package: "flet_map", alias: "ruflet_map" },
+        "permission_handler" => { package: "flet_permission_handler", alias: "ruflet_permission_handler" },
+        "secure_storage" => { package: "flet_secure_storage", alias: "ruflet_secure_storage" },
+        "video" => { package: "flet_video", alias: "ruflet_video" },
+        "webview" => { package: "flet_webview", alias: "ruflet_webview" }
+      }.freeze
+
       def command_new(args)
         app_name = args.shift
         if app_name.nil? || app_name.strip.empty?
@@ -22,10 +42,11 @@ module Ruflet
         File.write(File.join(root, "main.rb"), format(Ruflet::CLI::MAIN_TEMPLATE, app_title: humanize_name(File.basename(root))))
         File.write(File.join(root, "Gemfile"), Ruflet::CLI::GEMFILE_TEMPLATE)
         File.write(File.join(root, "README.md"), format(Ruflet::CLI::README_TEMPLATE, app_name: File.basename(root)))
+        write_default_ruflet_config(root, File.basename(root))
         copy_ruflet_client_template(root)
+        configure_ruflet_client(root)
 
         project_name = File.basename(root)
-        puts "Ruflet app created: #{project_name}"
         puts "Run:"
         puts "  cd #{project_name}"
         puts "  bundle install"
@@ -69,6 +90,129 @@ module Ruflet
         end
       end
 
+      def write_default_ruflet_config(root, app_name)
+        File.write(File.join(root, "ruflet.yaml"), <<~YAML)
+          app:
+            name: #{app_name}
+            # Optional production client endpoint used by `ruflet build`.
+            # Example: https://api.example.com
+            ruflet_client_url: ""
+
+          # Source of truth for Flutter client extensions/plugins.
+          # Examples: camera, video, audio, flashlight, webview, map
+          services: []
+
+          # Build assets configuration consumed by `ruflet build`.
+          # Paths are relative to this file unless absolute.
+          assets:
+            dir: assets
+            splash_screen: assets/splash.png
+            icon_launcher: assets/icon.png
+
+          build:
+            splash_color: "#FFFFFF"
+            splash_dark_color: "#0B0B0B"
+            icon_background: "#FFFFFF"
+            theme_color: "#FFFFFF"
+        YAML
+      end
+
+      def configure_ruflet_client(root)
+        config_path = File.join(root, "ruflet.yaml")
+        return unless File.file?(config_path)
+
+        config = YAML.safe_load(File.read(config_path), aliases: true) || {}
+        extension_keys = extract_extension_keys(config)
+        extension_packages = extension_keys.filter_map { |key| CLIENT_EXTENSION_MAP[key]&.fetch(:package) }.uniq
+        extension_aliases = extension_keys.filter_map { |key| CLIENT_EXTENSION_MAP[key]&.fetch(:alias) }.uniq
+
+        client_dir = File.join(root, "ruflet_client")
+        apply_client_manifest!(client_dir, extension_packages, extension_aliases)
+      rescue StandardError => e
+        warn "Failed to configure ruflet_client from ruflet.yaml: #{e.class}: #{e.message}"
+      end
+
+      def extract_extension_keys(config)
+        from_services = Array(config["services"])
+
+        from_services
+          .map { |v| normalize_extension_key(v) }
+          .compact
+          .uniq
+      end
+
+      def normalize_extension_key(value)
+        key = value.to_s.strip.downcase
+        return nil if key.empty?
+
+        key.tr!("-", "_")
+        key.gsub!(/\A(flet_)+/, "")
+        key.gsub!(/\Aservice_/, "")
+        key.gsub!(/\Acontrol_/, "")
+        key = "file_picker" if key == "filepicker"
+        key
+      end
+
+      def apply_client_manifest!(client_dir, extension_packages, extension_aliases)
+        return unless Dir.exist?(client_dir)
+
+        pubspec_path = File.join(client_dir, "pubspec.yaml")
+        main_path = File.join(client_dir, "lib", "main.dart")
+        prune_client_pubspec(pubspec_path, extension_packages) if File.file?(pubspec_path)
+        prune_client_main(main_path, extension_aliases) if File.file?(main_path)
+      end
+
+      def prune_client_pubspec(path, selected_packages)
+        data = YAML.safe_load(File.read(path), aliases: true) || {}
+        deps = (data["dependencies"] || {}).dup
+
+        deps.keys.each do |name|
+          next unless name.start_with?("flet_")
+          next if name == "flet"
+          next if selected_packages.include?(name)
+
+          deps.delete(name)
+        end
+
+        data["dependencies"] = deps
+        File.write(path, YAML.dump(data))
+      end
+
+      def prune_client_main(path, selected_aliases)
+        lines = File.readlines(path)
+        alias_to_package = {}
+
+        lines.each do |line|
+          match = line.match(%r{\Aimport 'package:(flet_[^/]+)/\1\.dart' as ([a-zA-Z0-9_]+);})
+          next unless match
+
+          alias_to_package[match[2]] = match[1]
+        end
+
+        kept = lines.select do |line|
+          import_match = line.match(%r{\Aimport 'package:(flet_[^/]+)/\1\.dart' as ([a-zA-Z0-9_]+);})
+          if import_match
+            package_name = import_match[1]
+            next true if package_name == "flet"
+            next true if selected_aliases.include?(import_match[2])
+            next false
+          end
+
+          extension_match = line.match(/\A\s*([a-zA-Z0-9_]+)\.Extension\(\),\s*\z/)
+          if extension_match
+            extension_alias = extension_match[1]
+            package_name = alias_to_package[extension_alias]
+            next true if package_name.nil? # non-Flet extension lines
+            next true if selected_aliases.include?(extension_alias)
+            next false
+          end
+
+          true
+        end
+
+        File.write(path, kept.join)
+      end
+
       def humanize_name(name)
         name.to_s.gsub(/[_-]+/, " ").split.map(&:capitalize).join(" ")
       end

data/lib/ruflet/cli/run_command.rb

@@ -16,12 +16,11 @@ module Ruflet
   module CLI
     module RunCommand
       def command_run(args)
-        options = { target: "mobile", hot_reload: true }
+        options = { target: "mobile", requested_port: 8550 }
         parser = OptionParser.new do |o|
           o.on("--web") { options[:target] = "web" }
           o.on("--desktop") { options[:target] = "desktop" }
-          o.on("--hot-reload", "--hot") { options[:hot_reload] = true }
-          o.on("--no-hot-reload") { options[:hot_reload] = false }
+          o.on("--port PORT", Integer) { |v| options[:requested_port] = v }
         end
         parser.parse!(args)
 
@@ -33,7 +32,7 @@ module Ruflet
           return 1
         end
 
-        selected_port = resolve_backend_port(options[:target])
+        selected_port = resolve_backend_port(options[:target], requested_port: options[:requested_port])
         return 1 unless selected_port
         env = {
           "RUFLET_TARGET" => options[:target],
@@ -43,11 +42,11 @@ module Ruflet
         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], port: selected_port)
+        print_run_banner(target: options[:target], requested_port: options[:requested_port], port: selected_port)
         print_mobile_qr_hint(port: selected_port) if options[:target] == "mobile"
 
         gemfile_path = find_nearest_gemfile(Dir.pwd)
-        cmd = build_runtime_command(script_path, gemfile_path: gemfile_path, env: env, hot_reload: options[:hot_reload])
+        cmd = build_runtime_command(script_path, gemfile_path: gemfile_path, env: env)
         return 1 unless cmd
 
         child_pid = Process.spawn(env, *cmd, pgroup: true)
@@ -63,22 +62,8 @@ module Ruflet
         previous_int = Signal.trap("INT") { forward_signal.call("INT") }
         previous_term = Signal.trap("TERM") { forward_signal.call("TERM") }
 
-        if options[:hot_reload]
-          puts "Hot reload enabled. Press 'r' to reload backend or 'R' for hot restart."
-          run_hot_reload_loop(
-            child_pid: child_pid,
-            env: env,
-            cmd: cmd,
-            script_path: script_path,
-            gemfile_path: gemfile_path,
-            target: options[:target],
-            port: selected_port,
-            launched_client_pids: launched_client_pids
-          )
-        else
-          _pid, status = Process.wait2(child_pid)
-          status.success? ? 0 : (status.exitstatus || 1)
-        end
+        _pid, status = Process.wait2(child_pid)
+        status.success? ? 0 : (status.exitstatus || 1)
       ensure
         Signal.trap("INT", previous_int) if defined?(previous_int) && previous_int
         Signal.trap("TERM", previous_term) if defined?(previous_term) && previous_term
@@ -107,103 +92,7 @@ module Ruflet
 
       private
 
-      def run_hot_reload_loop(child_pid:, env:, cmd:, script_path:, gemfile_path:, target:, port:, launched_client_pids:)
-        hot_queue = Queue.new
-        hot_listener = start_hotkey_listener(hot_queue)
-        watch_roots = watch_roots_for_script(script_path, gemfile_path)
-        watch_snapshot = build_watch_snapshot(watch_roots)
-        puts "Watching #{watch_snapshot.size} Ruby files for hot reload."
-
-        loop do
-          exited = Process.waitpid(child_pid, Process::WNOHANG)
-          if exited
-            status = $?
-            return status&.success? ? 0 : (status&.exitstatus || 1)
-          end
-
-          latest_snapshot = build_watch_snapshot(watch_roots)
-          if latest_snapshot != watch_snapshot
-            changed = changed_paths(watch_snapshot, latest_snapshot)
-            sample = changed.first(3).map { |p| File.basename(p) }.join(", ")
-            suffix = changed.size > 3 ? ", ..." : ""
-            puts "Detected change in #{changed.size} file(s): #{sample}#{suffix}"
-            hot_queue << :reload
-            watch_snapshot = latest_snapshot
-          end
-
-          process_hot_reload_actions(
-            queue: hot_queue,
-            child_pid: child_pid,
-            launched_client_pids: launched_client_pids,
-            env: env,
-            cmd: cmd,
-            target: target,
-            port: port
-          ) do |new_child_pid, new_client_pids|
-            child_pid = new_child_pid
-            launched_client_pids = new_client_pids
-          end
-
-          sleep 0.25
-        end
-      ensure
-        hot_listener&.kill
-      end
-
-      def process_hot_reload_actions(queue:, child_pid:, launched_client_pids:, env:, cmd:, target:, port:)
-        until queue.empty?
-          action = queue.pop(true)
-          case action
-          when :interrupt
-            Process.kill("INT", Process.pid)
-          when :reload
-            puts "Reloading backend..."
-            child_pid = restart_backend(child_pid, env, cmd)
-          when :restart
-            puts "Hot restarting backend and client..."
-            child_pid = restart_backend(child_pid, env, cmd)
-            launched_client_pids = restart_clients(launched_client_pids, target, port)
-          end
-          yield child_pid, launched_client_pids if block_given?
-        end
-      rescue ThreadError
-        nil
-      end
-
-      def start_hotkey_listener(queue)
-        return nil unless $stdin.tty?
-
-        Thread.new do
-          $stdin.raw do |stdin|
-            loop do
-              key = stdin.getc
-              break if key.nil?
-
-              action = hot_action_for_key(key)
-              queue << action if action
-            end
-          end
-        rescue StandardError
-          nil
-        end
-      end
-
-      def hot_action_for_key(key)
-        return :interrupt if key == "\u0003" # Ctrl+C in raw mode
-        return :reload if key == "r"
-        return :restart if key == "R"
-
-        nil
-      end
-
-      def restart_backend(child_pid, env, cmd)
-        terminate_process(child_pid)
-        new_pid = Process.spawn(env, *cmd, pgroup: true)
-        puts "Hot reload applied."
-        new_pid
-      end
-
-      def build_runtime_command(script_path, gemfile_path:, env:, hot_reload:)
+      def build_runtime_command(script_path, gemfile_path:, env:)
         if gemfile_path
           env["BUNDLE_GEMFILE"] = gemfile_path
           bundle_ready = system(env, RbConfig.ruby, "-S", "bundle", "check", out: File::NULL, err: File::NULL)
@@ -215,73 +104,6 @@ module Ruflet
         [RbConfig.ruby, script_path]
       end
 
-      def restart_clients(launched_client_pids, target, port)
-        Array(launched_client_pids).compact.each { |pid| terminate_process(pid) }
-        launch_target_client(target, port)
-      end
-
-      def terminate_process(pid)
-        return unless pid
-
-        begin
-          Process.kill("TERM", -pid)
-        rescue Errno::ESRCH
-          begin
-            Process.kill("TERM", pid)
-          rescue Errno::ESRCH
-            nil
-          end
-        end
-
-        begin
-          Timeout.timeout(2) { Process.wait(pid) }
-        rescue StandardError
-          nil
-        end
-      end
-
-      def watch_roots_for_script(script_path, gemfile_path)
-        roots = [Dir.pwd, File.dirname(script_path)]
-        if gemfile_path
-          roots << File.dirname(gemfile_path)
-          roots.concat(extra_watch_roots_from_gemfile(gemfile_path))
-        end
-        roots.uniq.select { |root| File.directory?(root) }
-      end
-
-      def extra_watch_roots_from_gemfile(gemfile_path)
-        base_dir = File.dirname(gemfile_path)
-        content = File.read(gemfile_path)
-        content.scan(/path:\s*["']([^"']+)["']/).flatten.map do |path|
-          File.expand_path(path, base_dir)
-        end.select { |path| File.directory?(path) }
-      rescue StandardError
-        []
-      end
-
-      def build_watch_snapshot(roots)
-        snapshot = {}
-        roots.each do |root|
-          Dir.glob(File.join(root, "**", "*.rb")).each do |path|
-            next if path.include?("/.git/")
-            next if path.include?("/tmp/")
-            next if path.include?("/log/")
-            next unless File.file?(path)
-
-            snapshot[path] = File.mtime(path).to_f
-          rescue Errno::ENOENT
-            nil
-          end
-        end
-        snapshot
-      end
-
-      def changed_paths(old_snapshot, new_snapshot)
-        (old_snapshot.keys | new_snapshot.keys).select do |path|
-          old_snapshot[path] != new_snapshot[path]
-        end
-      end
-
       def resolve_script(token)
         path = File.expand_path(token, Dir.pwd)
         return path if File.file?(path)
@@ -305,12 +127,14 @@ module Ruflet
         end
       end
 
-      def print_run_banner(target:, port:)
-        if target == "mobile" && port != 8550
-          puts "Requested port 8550 is busy; bound to #{port}"
+      def print_run_banner(target:, requested_port:, port:)
+        if port != requested_port.to_i
+          puts "Requested port #{requested_port} is busy; bound to #{port}"
         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}"
@@ -341,9 +165,11 @@ module Ruflet
         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)
-        browser_pid = open_in_browser_app_mode("http://localhost:#{web_port}")
-        open_in_browser("http://localhost:#{web_port}") if browser_pid.nil?
-        puts "Ruflet web client: http://localhost:#{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
@@ -711,8 +537,6 @@ module Ruflet
         puts
         puts "Ruflet mobile connect URL:"
         puts "  #{payload}"
-        puts "Ruflet server ws URL:"
-        puts "  ws://0.0.0.0:#{port}/ws"
         puts "Scan this QR from ruflet_client (Connect -> Scan QR):"
         print_ascii_qr(payload)
         puts
@@ -740,8 +564,10 @@ module Ruflet
         start_port
       end
 
-      def resolve_backend_port(target)
-        find_available_port(8550)
+      def resolve_backend_port(_target, requested_port: 8550)
+        base = requested_port.to_i
+        base = 8550 if base <= 0
+        find_available_port(base)
       end
 
       def port_available?(port)

data/lib/ruflet/cli/templates.rb

@@ -8,7 +8,7 @@ module Ruflet
       page.title = "Counter Demo"
       count = 0
       count_text = nil
-      count_text ||= text(value: count.to_s, size: 40)
+      count_text ||= text(value: count.to_s, style: { size: 40 })
       page.add(
         container(
           expand: true,
@@ -37,8 +37,8 @@ module Ruflet
     GEMFILE_TEMPLATE = <<~GEMFILE
       source "https://rubygems.org"
 
-      gem "ruflet", ">= 0.0.7"
-      gem "ruflet_server", ">= 0.0.7"
+      gem "ruflet", ">= 0.0.8"
+      gem "ruflet_server", ">= 0.0.8"
     GEMFILE
 
     README_TEMPLATE = <<~MD

data/lib/ruflet/cli.rb

@@ -4,8 +4,8 @@ require "optparse"
 
 require_relative "cli/templates"
 require_relative "cli/new_command"
-require_relative "cli/run_command"
 require_relative "cli/flutter_sdk"
+require_relative "cli/run_command"
 require_relative "cli/build_command"
 require_relative "cli/extra_command"
 
@@ -54,9 +54,9 @@ module Ruflet
         Commands:
           ruflet create <appname>
           ruflet new <appname>
-          ruflet run [scriptname|path] [--web|--desktop] [--no-hot-reload]
+          ruflet run [scriptname|path] [--web|--desktop] [--port PORT]
           ruflet debug [scriptname|path]
-          ruflet build <apk|ios|aab|web|macos|windows|linux>
+          ruflet build <apk|android|ios|aab|web|macos|windows|linux>
           ruflet devices
           ruflet emulators
           ruflet doctor

data/lib/ruflet/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet_cli
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - AdamMusa