ruflet_cli 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36d08da2d1377a858cd6703bd694b66d937604a21544af1de95d592aec4cb4df
-  data.tar.gz: 3feccf443f7ecae27bf835a90f6fbb81c04bdbc86bf1a71350bda6c97a0d555d
+  metadata.gz: 83772c8986411d4680455374f1f350c015183318e3c090426ea53edfb4ed2a89
+  data.tar.gz: 45f42f969bc487714f24c0833ca8fdbf2236e789622deb604a231d1a254ea483
 SHA512:
-  metadata.gz: e8677cc79bdb4e546f88ea3140b95e0177a0f24f884fa679f1a5636098017186caa14859a189c755b42455bdd7bbf612a8ac78f608766cd19f36b1f756c5ad69
-  data.tar.gz: b07035a35c315f1b42cc5dda629d080a4956b1854dd96297420d6ad24986c3095101f86ff9889c13d0bc133e18967c2666fbadad3228f00b39eabd9442af88ac
+  metadata.gz: 412a6524bff1cdf335256193390aca08c71b299f517da00af1da6efada84c7fc0ebd0d399be9e92235d6713ebcfbd8c8f9695695b68e3465242ed998deecf1bb
+  data.tar.gz: 0f77d2ee780f5d443e58d356ac02382ae0e5a53144ac64d9df5bf8d4e9bec2fcf51646f8d92fdc69e527259a7100e772fafcd26861c2d63ba829606531b03824

data/lib/ruflet/cli/build_command.rb

@@ -6,6 +6,8 @@ require "yaml"
 module Ruflet
   module CLI
     module BuildCommand
+      include FlutterSdk
+
       def command_build(args)
         platform = (args.shift || "").downcase
         if platform.empty?
@@ -26,10 +28,11 @@ module Ruflet
           return 1
         end
 
-        ok = prepare_flutter_client(client_dir)
+        tools = ensure_flutter!("build", client_dir: client_dir)
+        ok = prepare_flutter_client(client_dir, tools: tools)
         return 1 unless ok
 
-        ok = system(*flutter_cmd, *args, chdir: client_dir)
+        ok = system(tools[:env], tools[:flutter], *flutter_cmd, *args, chdir: client_dir)
         ok ? 0 : 1
       end
 
@@ -48,19 +51,19 @@ module Ruflet
         nil
       end
 
-      def prepare_flutter_client(client_dir)
+      def prepare_flutter_client(client_dir, tools:)
         apply_build_config(client_dir)
-        unless system("flutter", "pub", "get", chdir: client_dir)
+        unless system(tools[:env], tools[:flutter], "pub", "get", chdir: client_dir)
           warn "flutter pub get failed"
           return false
         end
 
-        unless system("dart", "run", "flutter_native_splash:create", chdir: client_dir)
+        unless system(tools[:env], tools[:dart], "run", "flutter_native_splash:create", chdir: client_dir)
           warn "flutter_native_splash failed"
           return false
         end
 
-        unless system("dart", "run", "flutter_launcher_icons", chdir: client_dir)
+        unless system(tools[:env], tools[:dart], "run", "flutter_launcher_icons", chdir: client_dir)
           warn "flutter_launcher_icons failed"
           return false
         end
@@ -213,19 +216,19 @@ module Ruflet
       def flutter_build_command(platform)
         case platform
         when "apk", "android"
-          ["flutter", "build", "apk"]
+          ["build", "apk"]
         when "aab", "appbundle"
-          ["flutter", "build", "appbundle"]
+          ["build", "appbundle"]
         when "ios"
-          ["flutter", "build", "ios", "--no-codesign"]
+          ["build", "ios", "--no-codesign"]
         when "web"
-          ["flutter", "build", "web"]
+          ["build", "web"]
         when "macos"
-          ["flutter", "build", "macos"]
+          ["build", "macos"]
         when "windows"
-          ["flutter", "build", "windows"]
+          ["build", "windows"]
         when "linux"
-          ["flutter", "build", "linux"]
+          ["build", "linux"]
         else
           nil
         end

data/lib/ruflet/cli/extra_command.rb

@@ -5,6 +5,8 @@ require "optparse"
 module Ruflet
   module CLI
     module ExtraCommand
+      include FlutterSdk
+
       def command_create(args)
         command_new(args)
       end
@@ -13,23 +15,20 @@ module Ruflet
         verbose = args.delete("--verbose") || args.delete("-v")
         puts "Ruflet doctor"
         puts "  Ruby: #{RUBY_VERSION}"
-        flutter = system("which flutter > /dev/null 2>&1")
-        puts "  Flutter: #{flutter ? 'found' : 'missing'}"
-        if flutter
-          system("flutter", "doctor", *(verbose ? ["-v"] : []))
-          return $?.exitstatus || 0
-        end
-        1
+        tools = ensure_flutter!("doctor")
+        puts "  Flutter: #{tools[:flutter]}"
+        system(tools[:env], tools[:flutter], "doctor", *(verbose ? ["-v"] : []))
+        $?.exitstatus || 1
       end
 
       def command_devices(args)
-        ensure_flutter!("devices")
-        system("flutter", "devices", *args)
+        tools = ensure_flutter!("devices")
+        system(tools[:env], tools[:flutter], "devices", *args)
         $?.exitstatus || 1
       end
 
       def command_emulators(args)
-        ensure_flutter!("emulators")
+        tools = ensure_flutter!("emulators")
         action = nil
         emulator_id = nil
         verbose = false
@@ -48,58 +47,22 @@ module Ruflet
             warn "Missing --emulator for start"
             return 1
           end
-          cmd = ["flutter", "emulators", "--launch", emulator_id]
+          cmd = [tools[:flutter], "emulators", "--launch", emulator_id]
           cmd << "-v" if verbose
-          system(*cmd)
+          system(tools[:env], *cmd)
           $?.exitstatus || 1
         when "create", "delete"
           warn "ruflet emulators --#{action} is not implemented yet. Use your platform tools."
           1
         else
-          cmd = ["flutter", "emulators"]
+          cmd = [tools[:flutter], "emulators"]
           cmd << "-v" if verbose
-          system(*cmd)
+          system(tools[:env], *cmd)
           $?.exitstatus || 1
         end
       end
 
-      def command_serve(args)
-        options = { port: 8550, root: Dir.pwd }
-        parser = OptionParser.new do |o|
-          o.on("-p", "--port PORT", Integer, "Port (default: 8550)") { |v| options[:port] = v }
-          o.on("-r", "--root PATH", "Root directory (default: current dir)") { |v| options[:root] = v }
-        end
-        parser.parse!(args)
-
-        require "webrick"
-        root = File.expand_path(options[:root])
-        server = WEBrick::HTTPServer.new(
-          Port: options[:port],
-          DocumentRoot: root,
-          AccessLog: [],
-          Logger: WEBrick::Log.new($stderr, WEBrick::Log::WARN)
-        )
-        trap("INT") { server.shutdown }
-        puts "Serving #{root} on http://127.0.0.1:#{options[:port]}"
-        server.start
-        0
-      end
-
-      def command_pack(args)
-        platform = default_desktop_platform
-        unless platform
-          warn "pack is only supported on desktop hosts (macOS, Windows, Linux)"
-          return 1
-        end
-        command_build([platform] + args)
-      end
-
-      def command_publish(args)
-        command_build(["web"] + args)
-      end
-
       def command_debug(args)
-        ensure_flutter!("debug")
         options = {
           platform: nil,
           device_id: nil,
@@ -117,7 +80,17 @@ module Ruflet
         parser.parse!(args)
 
         options[:platform] ||= args.shift
-        cmd = ["flutter", "run"]
+        client_dir = detect_client_dir
+        unless client_dir
+          warn "Could not find Flutter client directory."
+          warn "Set RUFLET_CLIENT_DIR or place client at ./ruflet_client"
+          warn "`ruflet debug` requires Flutter client source code."
+          warn "For prebuilt clients, use: `ruflet run --web` or `ruflet run --desktop`."
+          return 1
+        end
+
+        tools = ensure_flutter!("debug", client_dir: client_dir)
+        cmd = [tools[:flutter], "run"]
         cmd << "--release" if options[:release]
         cmd << "-v" if options[:verbose]
         cmd += ["--web-renderer", options[:web_renderer]] if options[:web_renderer]
@@ -135,14 +108,7 @@ module Ruflet
           end
         end
 
-        client_dir = detect_client_dir
-        unless client_dir
-          warn "Could not find Flutter client directory."
-          warn "Set RUFLET_CLIENT_DIR or place client at ./ruflet_client"
-          return 1
-        end
-
-        system(*cmd, chdir: client_dir)
+        system(tools[:env], *cmd, chdir: client_dir)
         $?.exitstatus || 1
       end
 
@@ -161,20 +127,6 @@ module Ruflet
         nil
       end
 
-      def default_desktop_platform
-        host = RbConfig::CONFIG["host_os"]
-        return "macos" if host =~ /darwin/i
-        return "windows" if host =~ /mswin|mingw|cygwin/i
-        return "linux" if host =~ /linux/i
-        nil
-      end
-
-      def ensure_flutter!(command_name)
-        return if system("which flutter > /dev/null 2>&1")
-
-        warn "Flutter is required for `ruflet #{command_name}`. Install Flutter and ensure it is on PATH."
-        exit 1
-      end
     end
   end
 end

data/lib/ruflet/cli/flutter_sdk.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "net/http"
+require "rbconfig"
+require "tmpdir"
+require "uri"
+
+module Ruflet
+  module CLI
+    module FlutterSdk
+      RELEASES_BASE = "https://storage.googleapis.com/flutter_infra_release/releases".freeze
+      DEFAULT_FLUTTER_CHANNEL = "stable".freeze
+
+      def ensure_flutter!(command_name, client_dir: nil)
+        tools = flutter_tools(client_dir: client_dir)
+        return tools if tools
+
+        warn "Flutter is required for `ruflet #{command_name}` and FVM bootstrap failed."
+        warn "Set RUFLET_FLUTTER_VERSION or add .fvmrc to the project."
+        exit 1
+      end
+
+      private
+
+      def flutter_tools(client_dir: nil)
+        # Always use FVM so Flutter/Dart match pinned SDK.
+        fvm_tools = flutter_tools_via_fvm(client_dir: client_dir)
+        return fvm_tools if fvm_tools
+
+        nil
+      end
+
+      def flutter_tools_via_fvm(client_dir: nil)
+        version = desired_flutter_version(client_dir: client_dir)
+        return nil if version.to_s.strip.empty?
+
+        project_dir = fvm_project_dir(client_dir: client_dir)
+        fvm = ensure_fvm_available(client_dir: client_dir)
+        return nil unless fvm
+
+        FileUtils.mkdir_p(project_dir)
+        fvmrc_path = File.join(project_dir, ".fvmrc")
+        unless File.file?(fvmrc_path)
+          File.write(fvmrc_path, "{\"flutter\":\"#{version}\"}\n")
+        end
+
+        system(fvm_env, fvm, "install", version.to_s, chdir: project_dir, out: File::NULL, err: File::NULL)
+        system(fvm_env, fvm, "use", "--force", version.to_s, chdir: project_dir, out: File::NULL, err: File::NULL)
+
+        flutter = File.join(project_dir, ".fvm", "flutter_sdk", "bin", windows_host? ? "flutter.bat" : "flutter")
+        return nil unless File.executable?(flutter)
+
+        tools_from_flutter_bin(flutter)
+      rescue StandardError => e
+        warn "FVM bootstrap failed: #{e.class}: #{e.message}"
+        nil
+      end
+
+      def ensure_fvm_available(client_dir: nil)
+        fvm = which_command("fvm")
+        return fvm if fvm
+
+        dart = which_command("dart")
+        unless dart
+          sdk_root = ensure_flutter_sdk_downloaded(client_dir: client_dir)
+          dart = sdk_root ? File.join(sdk_root, "bin", windows_host? ? "dart.bat" : "dart") : nil
+        end
+        return nil unless dart && File.executable?(dart)
+
+        system(dart, "pub", "global", "activate", "fvm", out: File::NULL, err: File::NULL)
+        which_command("fvm")
+      end
+
+      def fvm_env
+        pub_bin = File.join(Dir.home, ".pub-cache", "bin")
+        { "PATH" => "#{pub_bin}#{File::PATH_SEPARATOR}#{ENV.fetch('PATH', '')}" }
+      end
+
+      def tools_from_flutter_bin(flutter_bin)
+        return nil unless File.executable?(flutter_bin)
+
+        bin_dir = File.dirname(flutter_bin)
+        dart = File.join(bin_dir, windows_host? ? "dart.bat" : "dart")
+        {
+          flutter: flutter_bin,
+          dart: (File.executable?(dart) ? dart : "dart"),
+          env: { "PATH" => "#{bin_dir}#{File::PATH_SEPARATOR}#{ENV.fetch('PATH', '')}" }
+        }
+      end
+
+      def ensure_flutter_sdk_downloaded(client_dir: nil)
+        release_info = resolve_flutter_release(client_dir: client_dir)
+        return nil unless release_info
+
+        release = release_info[:release]
+        host = release_info[:host]
+        archive = release.fetch("archive")
+        install_root = File.join(Dir.home, ".ruflet", "flutter", release.fetch("version"), host)
+        sdk_root = File.join(install_root, "flutter")
+        flutter_bin = File.join(sdk_root, "bin", windows_host? ? "flutter.bat" : "flutter")
+        return sdk_root if File.executable?(flutter_bin)
+
+        FileUtils.mkdir_p(install_root)
+        Dir.mktmpdir("ruflet-flutter-sdk-") do |tmpdir|
+          archive_path = File.join(tmpdir, File.basename(archive))
+          download_file("#{RELEASES_BASE}/#{archive}", archive_path)
+          extract_archive(archive_path, install_root)
+        end
+
+        return sdk_root if File.executable?(flutter_bin)
+
+        # Some archives may unpack into a different folder name.
+        guessed = Dir.glob(File.join(install_root, "**", windows_host? ? "flutter.bat" : "flutter"))
+          .map { |p| File.expand_path("../..", p) }
+          .find { |root| File.executable?(File.join(root, "bin", windows_host? ? "flutter.bat" : "flutter")) }
+        return guessed if guessed
+
+        nil
+      rescue StandardError => e
+        warn "Flutter auto-install failed: #{e.class}: #{e.message}"
+        nil
+      end
+
+      def resolve_flutter_release(client_dir: nil)
+        host = flutter_host
+        return nil unless host
+
+        manifest = fetch_releases_manifest(host)
+        return nil unless manifest
+
+        version = desired_flutter_version(client_dir: client_dir)
+        release = pick_release(manifest, version: version)
+        return nil unless release
+
+        { release: release, host: host }
+      end
+
+      def desired_flutter_version(client_dir: nil)
+        env = ENV["RUFLET_FLUTTER_VERSION"].to_s.strip
+        return env unless env.empty?
+
+        fvm = parse_fvmrc(find_fvmrc(client_dir))
+        return fvm if fvm
+
+        DEFAULT_FLUTTER_CHANNEL
+      end
+
+      def fvm_project_dir(client_dir: nil)
+        return client_dir if client_dir
+
+        File.join(Dir.home, ".ruflet", "fvm_project")
+      end
+
+      def find_fvmrc(client_dir)
+        candidates = []
+        candidates << File.join(client_dir, ".fvmrc") if client_dir
+        candidates << File.join(Dir.pwd, ".fvmrc")
+        candidates.find { |p| File.file?(p) }
+      end
+
+      def parse_fvmrc(path)
+        return nil unless path && File.file?(path)
+
+        raw = File.read(path).strip
+        return nil if raw.empty?
+
+        if raw.start_with?("{")
+          json = JSON.parse(raw) rescue {}
+          val = json["flutter"] || json["flutterSdkVersion"] || json["flutter_version"]
+          return val.to_s.strip unless val.to_s.strip.empty?
+        end
+
+        raw
+      end
+
+      def fetch_releases_manifest(host)
+        url = "#{RELEASES_BASE}/releases_#{host}.json"
+        uri = URI(url)
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          req = Net::HTTP::Get.new(uri)
+          req["User-Agent"] = "ruflet-cli"
+          http.request(req)
+        end
+        return JSON.parse(response.body) if response.is_a?(Net::HTTPSuccess)
+
+        nil
+      end
+
+      def pick_release(manifest, version: nil)
+        releases = manifest.fetch("releases", [])
+        if version
+          pinned = releases.find { |r| r["channel"] == "stable" && r["version"] == version }
+          return pinned if pinned
+          warn "Requested Flutter #{version} not found in stable releases; falling back to latest stable."
+        end
+
+        current = manifest.fetch("current_release", {})["stable"]
+        if current
+          by_hash = releases.find { |r| r["hash"] == current }
+          return by_hash if by_hash
+        end
+
+        releases.reverse.find { |r| r["channel"] == "stable" }
+      end
+
+      def flutter_host
+        os = RbConfig::CONFIG["host_os"]
+        if os.match?(/darwin/i)
+          return machine_arch.include?("arm") ? "macos_arm64" : "macos"
+        end
+        return "linux" if os.match?(/linux/i)
+        return "windows" if os.match?(/mswin|mingw|cygwin/i)
+
+        nil
+      end
+
+      def machine_arch
+        RbConfig::CONFIG["host_cpu"].to_s.downcase
+      end
+
+      def windows_host?
+        RbConfig::CONFIG["host_os"].match?(/mswin|mingw|cygwin/i)
+      end
+
+      def which_command(name)
+        exts = windows_host? ? ENV.fetch("PATHEXT", ".EXE;.BAT;.CMD").split(";") : [""]
+        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |dir|
+          exts.each do |ext|
+            candidate = File.join(dir, "#{name}#{ext}")
+            return candidate if File.file?(candidate) && File.executable?(candidate)
+          end
+        end
+        nil
+      end
+
+      def download_file(url, destination, limit: 5)
+        raise "Too many redirects while downloading #{url}" if limit <= 0
+
+        uri = URI(url)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          req = Net::HTTP::Get.new(uri)
+          req["User-Agent"] = "ruflet-cli"
+          http.request(req) do |res|
+            case res
+            when Net::HTTPSuccess
+              File.open(destination, "wb") { |f| res.read_body { |chunk| f.write(chunk) } }
+              return destination
+            when Net::HTTPRedirection
+              return download_file(res["location"], destination, limit: limit - 1)
+            else
+              raise "Download failed (#{res.code})"
+            end
+          end
+        end
+      end
+
+      def extract_archive(archive, destination)
+        if archive.end_with?(".zip")
+          if windows_host?
+            return system("powershell", "-NoProfile", "-Command", "Expand-Archive -Path '#{archive}' -DestinationPath '#{destination}' -Force")
+          end
+          return system("unzip", "-oq", archive, "-d", destination)
+        end
+
+        if archive.end_with?(".tar.xz") || archive.end_with?(".tar.gz") || archive.end_with?(".tgz")
+          return system("tar", "-xf", archive, "-C", destination)
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/ruflet/cli/new_command.rb

@@ -19,10 +19,8 @@ module Ruflet
         end
 
         FileUtils.mkdir_p(root)
-        FileUtils.mkdir_p(File.join(root, ".bundle"))
         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, ".bundle", "config"), Ruflet::CLI::BUNDLE_CONFIG_TEMPLATE)
         File.write(File.join(root, "README.md"), format(Ruflet::CLI::README_TEMPLATE, app_name: File.basename(root)))
         copy_ruflet_client_template(root)
 

data/lib/ruflet/cli/run_command.rb

@@ -30,7 +30,8 @@ module Ruflet
           return 1
         end
 
-        selected_port = find_available_port(8550)
+        selected_port = resolve_backend_port(options[:target])
+        return 1 unless selected_port
         env = {
           "RUFLET_TARGET" => options[:target],
           "RUFLET_SUPPRESS_SERVER_BANNER" => "1",
@@ -42,10 +43,10 @@ module Ruflet
         print_run_banner(target: options[:target], port: selected_port)
         print_mobile_qr_hint(port: selected_port) if options[:target] == "mobile"
 
+        gemfile_path = find_nearest_gemfile(Dir.pwd)
         cmd =
-          if File.file?(File.expand_path("Gemfile", Dir.pwd))
-            env["BUNDLE_PATH"] = "vendor/bundle"
-            env["BUNDLE_DISABLE_SHARED_GEMS"] = "true"
+          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")
 
@@ -106,8 +107,21 @@ module Ruflet
         nil
       end
 
+      def find_nearest_gemfile(start_dir)
+        current = File.expand_path(start_dir)
+        loop do
+          candidate = File.join(current, "Gemfile")
+          return candidate if File.file?(candidate)
+
+          parent = File.expand_path("..", current)
+          return nil if parent == current
+
+          current = parent
+        end
+      end
+
       def print_run_banner(target:, port:)
-        if port != 8550
+        if target == "mobile" && port != 8550
           puts "Requested port 8550 is busy; bound to #{port}"
         end
         if target == "desktop"
@@ -316,15 +330,15 @@ module Ruflet
         platform = host_platform_name
         return nil if platform.nil?
 
-        cache_root = File.join(Dir.home, ".ruflet", "client", Ruflet::VERSION, platform)
+        cache_root = File.join(Dir.home, ".ruflet", "client", ruflet_version, platform)
         FileUtils.mkdir_p(cache_root)
 
         wanted_assets = []
-        wanted_assets << "ruflet_client-web.tar.gz" if web
+        wanted_assets << { kind: :web, name: "ruflet_client-web.tar.gz" } if web
         if desktop
           desktop_asset = desktop_asset_name_for(platform)
           return nil if desktop_asset.nil?
-          wanted_assets << desktop_asset
+          wanted_assets << { kind: :desktop, name: desktop_asset, platform: platform }
         end
         return cache_root if wanted_assets.empty? || prebuilt_assets_present?(cache_root, web: web, desktop: desktop)
 
@@ -332,20 +346,26 @@ module Ruflet
         return nil unless release
 
         assets = release.fetch("assets", [])
+        asset_names = assets.map { |a| a["name"].to_s }
         Dir.mktmpdir("ruflet-prebuilt-") do |tmpdir|
-          wanted_assets.each do |asset_name|
+          wanted_assets.each do |wanted|
+            asset_name = wanted.fetch(:name)
             asset = assets.find { |a| a["name"] == asset_name }
+            asset ||= fallback_release_asset(assets, wanted)
             unless asset
               warn "Missing release asset: #{asset_name}"
+              warn "Available assets: #{asset_names.join(', ')}" unless asset_names.empty?
               return nil
             end
-            archive_path = File.join(tmpdir, asset_name)
+            resolved_name = asset.fetch("name")
+            puts "Downloading prebuilt client asset: #{resolved_name}"
+            archive_path = File.join(tmpdir, resolved_name)
             download_file(asset.fetch("browser_download_url"), archive_path)
-            subdir = asset_name.include?("-web.") ? "web" : "desktop"
+            subdir = wanted[:kind] == :web ? "web" : "desktop"
             target = File.join(cache_root, subdir)
             FileUtils.mkdir_p(target)
             unless extract_archive(archive_path, target)
-              warn "Failed to extract asset: #{asset_name}"
+              warn "Failed to extract asset: #{resolved_name}"
               return nil
             end
           end
@@ -399,7 +419,18 @@ module Ruflet
       end
 
       def fetch_release_for_version
-        release_by_tag("v#{Ruflet::VERSION}") || release_latest
+        release_by_tag("v#{ruflet_version}") ||
+          release_by_tag(ruflet_version) ||
+          release_by_tag("prebuild") ||
+          release_by_tag("prebuild-main") ||
+          release_latest
+      end
+
+      def ruflet_version
+        return Ruflet::VERSION if Ruflet.const_defined?(:VERSION)
+
+        require_relative "../version"
+        Ruflet::VERSION
       end
 
       def release_latest
@@ -412,6 +443,33 @@ module Ruflet
         nil
       end
 
+      def fallback_release_asset(assets, wanted)
+        kind = wanted[:kind]
+        platform = wanted[:platform]
+        candidates = assets.select { |asset| release_asset_matches?(asset.fetch("name", ""), kind, platform) }
+        candidates.first
+      end
+
+      def release_asset_matches?(name, kind, platform)
+        n = name.to_s.downcase
+        return false unless n.include?("ruflet_client")
+
+        if kind == :web
+          return n.include?("web") && (n.end_with?(".tar.gz") || n.end_with?(".zip"))
+        end
+
+        case platform
+        when "macos"
+          n.include?("macos") && n.end_with?(".zip")
+        when "linux"
+          n.include?("linux") && (n.end_with?(".tar.gz") || n.end_with?(".tgz"))
+        when "windows"
+          n.include?("windows") && n.end_with?(".zip")
+        else
+          false
+        end
+      end
+
       def github_get_json(url)
         uri = URI(url)
         response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
@@ -497,6 +555,32 @@ 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
+      end
+
+      def port_available?(port)
+        probe = nil
+        begin
+          begin
+            probe = TCPServer.new("0.0.0.0", port)
+          rescue Errno::EACCES, Errno::EPERM
+            probe = TCPServer.new("127.0.0.1", port)
+          end
+          true
+        rescue Errno::EADDRINUSE
+          false
+        ensure
+          probe&.close
+        end
+      end
+
       def best_lan_host
         ips = Socket.ip_address_list
         addr = ips.find { |ip| ip.ipv4_private? && !ip.ipv4_loopback? }

data/lib/ruflet/cli/templates.rb

@@ -13,28 +13,30 @@ module Ruflet
 
         def view(page)
           page.title = "Counter Demo"
-          count_text = page.text(value: @count.to_s, size: 40)
+          page.vertical_alignment = Ruflet::MainAxisAlignment::CENTER
+          page.horizontal_alignment = Ruflet::CrossAxisAlignment::CENTER
+          count_text = text(value: @count.to_s, size: 40)
 
           page.add(
-            page.container(
+            container(
               expand: true,
               padding: 24,
-              content: page.column(
+              content: column(
                 expand: true,
                 alignment: Ruflet::MainAxisAlignment::CENTER,
                 horizontal_alignment: Ruflet::CrossAxisAlignment::CENTER,
                 spacing: 12,
                 controls: [
-                  page.text(value: "You have pushed the button this many times:"),
+                  text(value: "You have pushed the button this many times:"),
                   count_text
                 ]
               )
             ),
-            appbar: page.app_bar(
-              title: page.text(value: "Counter Demo")
+            appbar: app_bar(
+              title: text(value: "Counter Demo")
             ),
-            floating_action_button: page.fab(
-              page.icon(icon: Ruflet::MaterialIcons::ADD),
+            floating_action_button: fab(
+              icon(icon: Ruflet::MaterialIcons::ADD),
               on_click: ->(_e) {
                 @count += 1
                 page.update(count_text, value: @count.to_s)
@@ -45,22 +47,16 @@ module Ruflet
       end
 
       MainApp.new.run
+
     RUBY
 
     GEMFILE_TEMPLATE = <<~GEMFILE
       source "https://rubygems.org"
 
       gem "ruflet", ">= 0.0.3"
-      gem "ruflet_protocol", ">= 0.0.3"
       gem "ruflet_server", ">= 0.0.3"
     GEMFILE
 
-    BUNDLE_CONFIG_TEMPLATE = <<~YAML
-      ---
-      BUNDLE_PATH: "vendor/bundle"
-      BUNDLE_DISABLE_SHARED_GEMS: "true"
-    YAML
-
     README_TEMPLATE = <<~MD
       # %<app_name>s
 
@@ -75,17 +71,7 @@ module Ruflet
       ## Run
 
       ```bash
-      bundle exec ruflet run main.rb
-      ```
-
-      ## Client Template
-
-      `ruflet_client` template is generated inside this app.
-
-      ```bash
-      cd ruflet_client
-      flutter pub get
-      flutter run
+      bundle exec ruflet run main
       ```
 
       ## Build

data/lib/ruflet/cli.rb

@@ -5,6 +5,7 @@ require "optparse"
 require_relative "cli/templates"
 require_relative "cli/new_command"
 require_relative "cli/run_command"
+require_relative "cli/flutter_sdk"
 require_relative "cli/build_command"
 require_relative "cli/extra_command"
 
@@ -30,12 +31,6 @@ module Ruflet
         command_debug(argv)
       when "build"
         command_build(argv)
-      when "pack"
-        command_pack(argv)
-      when "publish"
-        command_publish(argv)
-      when "serve"
-        command_serve(argv)
       when "devices"
         command_devices(argv)
       when "emulators"
@@ -62,9 +57,6 @@ module Ruflet
           ruflet run [scriptname|path] [--web|--mobile|--desktop]
           ruflet debug [scriptname|path]
           ruflet build <apk|ios|aab|web|macos|windows|linux>
-          ruflet pack
-          ruflet publish
-          ruflet serve [--port N] [--root PATH]
           ruflet devices
           ruflet emulators
           ruflet doctor

data/lib/ruflet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruflet
-  VERSION = "0.0.4" unless const_defined?(:VERSION)
+  VERSION = "0.0.5" 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.4
+  version: 0.0.5
 platform: ruby
 authors:
 - AdamMusa
@@ -36,6 +36,7 @@ files:
 - lib/ruflet/cli.rb
 - lib/ruflet/cli/build_command.rb
 - lib/ruflet/cli/extra_command.rb
+- lib/ruflet/cli/flutter_sdk.rb
 - lib/ruflet/cli/new_command.rb
 - lib/ruflet/cli/run_command.rb
 - lib/ruflet/cli/templates.rb