ruflet_cli 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 716c849e84715c603f30e6ad789cdf3d8d0dc3ef4be40a436af77546dde1d629
-  data.tar.gz: 765cf04a191c9e915b43ef525d1a21f6d42a7226a36db9d47b490117392a2a9d
+  metadata.gz: bda605a60090590b4fd902f1b14a3b81c44fbe28cdd08ece037611feae2d775c
+  data.tar.gz: f52031603e160ccaeefe976e4b3edd24ea383f03d61dca9f15141411d7ee030e
 SHA512:
-  metadata.gz: 239d1dc8d36a8db268eaf17e0c6aed617ae786a59c09dc8c12f2b7d1c15ec3778d8bceff8f57fd51973f0da7be015013b8cb936d39ed566aed099c88739d18eb
-  data.tar.gz: 24be0703279d8cda99245929f7fdd4975e278a1d9768fd46785701c1aa5a478f8c7fd3b9f73b3ebf6be9f5b08cbadac582880213102709fb8c5d9b66ee91926d
+  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

@@ -9,16 +9,18 @@ require "fileutils"
 require "json"
 require "net/http"
 require "uri"
+require "thread"
+require "io/console"
 
 module Ruflet
   module CLI
     module RunCommand
       def command_run(args)
-        options = { target: "mobile" }
+        options = { target: "mobile", requested_port: 8550 }
         parser = OptionParser.new do |o|
           o.on("--web") { options[:target] = "web" }
-          o.on("--mobile") { options[:target] = "mobile" }
           o.on("--desktop") { options[:target] = "desktop" }
+          o.on("--port PORT", Integer) { |v| options[:requested_port] = v }
         end
         parser.parse!(args)
 
@@ -30,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],
@@ -40,20 +42,12 @@ 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 =
-          if gemfile_path
-            env["BUNDLE_GEMFILE"] = gemfile_path
-            bundle_ready = system(env, "bundle", "check", out: File::NULL, err: File::NULL)
-            return 1 unless bundle_ready || system(env, "bundle", "install")
-
-            ["bundle", "exec", RbConfig.ruby, script_path]
-          else
-            [RbConfig.ruby, script_path]
-          end
+        cmd = build_runtime_command(script_path, gemfile_path: gemfile_path, env: env)
+        return 1 unless cmd
 
         child_pid = Process.spawn(env, *cmd, pgroup: true)
         launched_client_pids = launch_target_client(options[:target], selected_port)
@@ -93,10 +87,23 @@ module Ruflet
             end
           end
         end
+
       end
 
       private
 
+      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)
+          return nil unless bundle_ready || system(env, RbConfig.ruby, "-S", "bundle", "install")
+
+          return [RbConfig.ruby, "-rbundler/setup", script_path]
+        end
+
+        [RbConfig.ruby, script_path]
+      end
+
       def resolve_script(token)
         path = File.expand_path(token, Dir.pwd)
         return path if File.file?(path)
@@ -120,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}"
@@ -156,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
@@ -526,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
@@ -547,7 +556,7 @@ module Ruflet
             end
             probe.close
             return port
-          rescue Errno::EADDRINUSE
+          rescue Errno::EADDRINUSE, Errno::EACCES, Errno::EPERM
             port += 1
           end
         end
@@ -555,14 +564,10 @@ module Ruflet
         start_port
       end
 
-      def resolve_backend_port(target)
-        return find_available_port(8550) if target == "mobile"
-
-        return 8550 if port_available?(8550)
-
-        warn "Port 8550 is required for `ruflet run --#{target}`."
-        warn "Stop the process using 8550 and run again."
-        nil
+      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.6"
-      gem "ruflet_server", ">= 0.0.6"
+      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|--mobile|--desktop]
+          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.6" 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.6
+  version: 0.0.8
 platform: ruby
 authors:
 - AdamMusa