ruflet 0.0.17 → 0.0.19

data/lib/ruflet/cli/run_command.rb

@@ -12,23 +12,19 @@ require "uri"
 require "thread"
 require "io/console"
 require "time"
-require "yaml"
 
 module Ruflet
   module CLI
     module RunCommand
-      DEFAULT_BACKEND_PORTS = {
-        "web" => 8550,
-        "desktop" => 8560,
-        "mobile" => 8570
-      }.freeze
+      CLIENT_CHANNEL_MANIFEST = "ruflet_client-manifest.json"
+      DEFAULT_CLIENT_UPDATE_INTERVAL = 6 * 60 * 60
 
       def command_run(args)
-        options = { target: "mobile", requested_port: nil }
+        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("--port PORT", Integer, "Backend port (defaults: web 8550, desktop 8560, mobile 8570)") { |v| options[:requested_port] = v }
+          o.on("--port PORT", Integer) { |v| options[:requested_port] = v }
         end
         parser.parse!(args)
 
@@ -40,33 +36,18 @@ module Ruflet
           return 1
         end
 
-        requested_port = options[:requested_port] || default_backend_port(options[:target])
-        selected_port = resolve_backend_port(options[:target], requested_port: requested_port)
+        selected_port = resolve_backend_port(options[:target], requested_port: options[:requested_port])
         return 1 unless selected_port
         env = {
           "RUFLET_TARGET" => options[:target],
           "RUFLET_SUPPRESS_SERVER_BANNER" => "1",
-          "RUFLET_PORT" => selected_port.to_s,
-          "RUFLET_STRICT_PORT" => "1"
+          "RUFLET_PORT" => selected_port.to_s
         }
         apply_local_ruflet_dev_overrides(env)
         assets_dir = File.join(File.dirname(script_path), "assets")
         env["RUFLET_ASSETS_DIR"] = assets_dir if File.directory?(assets_dir)
 
-        # Web: the Ruby backend serves the Flutter web client itself (same
-        # origin/port as /ws), so no separate static server or proxy is needed.
-        if options[:target] == "web"
-          web_dir = detect_web_client_dir
-          if web_dir
-            env["RUFLET_WEB_CLIENT_DIR"] = web_dir
-          else
-            warn "Ruflet web client unavailable for version #{ruflet_version}."
-            warn "Install the matching GitHub release client before running --web."
-            return 1
-          end
-        end
-
-        print_run_banner(target: options[:target], requested_port: requested_port, port: selected_port)
+        print_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)
@@ -171,14 +152,16 @@ module Ruflet
 
       def print_run_banner(target:, requested_port:, port:)
         if port != requested_port.to_i
-          puts "Port #{requested_port} is busy; using #{port} for #{target}."
+          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}"
         end
-        # web: launch_web_client prints the single app URL after the server boots
       end
 
       def launch_target_client(target, port)
@@ -194,19 +177,30 @@ module Ruflet
         end
       end
 
-      # The Ruby backend (Ruflet::Server) serves the Flutter web client on its
-      # own port, so the client loads and opens its websocket on that same
-      # origin. The prebuilt web client derives its backend from Uri.base, so
-      # the public URL stays clean and dynamic port selection works naturally.
       def launch_web_client(port)
-        url = "http://localhost:#{port}/"
-        browser_pid = open_in_browser_app_mode(url)
-        open_in_browser(url) if browser_pid.nil?
-        puts "Ruflet web app: #{url}"
-        [browser_pid].compact
+        web_dir = detect_web_client_dir
+        unless web_dir
+          warn "Web client build not found and prebuilt download failed."
+          return []
+        end
+
+        web_port = find_available_port(port + 1)
+        web_pid = Process.spawn("python3", "-m", "http.server", web_port.to_s, "--bind", "127.0.0.1", chdir: web_dir, out: File::NULL, err: File::NULL)
+        Process.detach(web_pid)
+        wait_for_server_boot(web_port)
+        backend_url = "http://localhost:#{port}"
+        web_url = "http://localhost:#{web_port}/?#{URI.encode_www_form(url: backend_url)}"
+        browser_pid = open_in_browser_app_mode(web_url)
+        open_in_browser(web_url) if browser_pid.nil?
+        puts "Ruflet web client: #{web_url}"
+        puts "Ruflet backend ws: ws://localhost:#{port}/ws"
+        [web_pid, browser_pid].compact
+      rescue Errno::ENOENT
+        warn "python3 is required to host web client locally."
+        warn "Install Python 3 and rerun."
+        []
       rescue StandardError => e
-        warn "Failed to open web client: #{e.class}: #{e.message}"
-        warn "Open it manually: http://localhost:#{port}/"
+        warn "Failed to launch web client: #{e.class}: #{e.message}"
         []
       end
 
@@ -316,36 +310,45 @@ module Ruflet
       end
 
       def detect_desktop_client_command(url)
-        root = configured_client_root
-
-        command = desktop_client_command_from_root(root, url)
-        return command if command
-
-        cached_root = ensure_prebuilt_client(desktop: true)
-        desktop_client_command_from_root(cached_root, url)
-      end
-
-      def desktop_client_command_from_root(root, url)
+        root = ENV["RUFLET_CLIENT_DIR"]
+        root = File.expand_path("ruflet_client", Dir.pwd) if root.to_s.strip.empty?
+        root = nil unless Dir.exist?(root)
+        root ||= ensure_prebuilt_client(desktop: true)
         return nil unless root && Dir.exist?(root)
 
         host_os = RbConfig::CONFIG["host_os"]
         if host_os.match?(/darwin/i)
-          app_path = File.join(root, "desktop", "ruflet_client.app")
-          bin = File.join(app_path, "Contents", "MacOS", "ruflet_client")
-          return [bin, url] if File.file?(bin) && File.executable?(bin) && ensure_macos_file_picker_entitlement(app_path)
+          release_bin = File.join(root, "build", "macos", "Build", "Products", "Release", "ruflet_client.app", "Contents", "MacOS", "ruflet_client")
+          debug_bin = File.join(root, "build", "macos", "Build", "Products", "Debug", "ruflet_client.app", "Contents", "MacOS", "ruflet_client")
+          prebuilt_bin = File.join(root, "desktop", "ruflet_client.app", "Contents", "MacOS", "ruflet_client")
+          executable = [release_bin, debug_bin].find { |p| File.file?(p) && File.executable?(p) }
+          executable ||= prebuilt_bin if File.file?(prebuilt_bin) && File.executable?(prebuilt_bin)
+          return [executable, url] if executable
         elsif host_os.match?(/mswin|mingw|cygwin/i)
-          exe = File.join(root, "desktop", "ruflet_client.exe")
+          exe = File.join(root, "build", "windows", "x64", "runner", "Release", "ruflet_client.exe")
+          prebuilt = File.join(root, "desktop", "ruflet_client.exe")
+          exe = prebuilt if !File.file?(exe) && File.file?(prebuilt)
           return [exe, url] if File.file?(exe)
         else
-          direct = File.join(root, "desktop", "ruflet_client")
+          direct = File.join(root, "build", "linux", "x64", "release", "bundle", "ruflet_client")
+          prebuilt_direct = File.join(root, "desktop", "ruflet_client")
+          direct = prebuilt_direct if !File.file?(direct) && File.file?(prebuilt_direct)
           return [direct, url] if File.file?(direct)
+          bundle_dir = File.join(root, "build", "linux", "x64", "release", "bundle")
+          if Dir.exist?(bundle_dir)
+            candidate = Dir.children(bundle_dir).map { |f| File.join(bundle_dir, f) }
+              .find { |path| File.file?(path) && File.executable?(path) }
+            return [candidate, url] if candidate
+          end
         end
 
         nil
       end
 
       def detect_web_client_dir
-        root = configured_client_root
+        root = ENV["RUFLET_CLIENT_DIR"]
+        root = File.expand_path("ruflet_client", Dir.pwd) if root.to_s.strip.empty?
+        root = nil unless Dir.exist?(root)
         root ||= ensure_prebuilt_client(web: true)
         return nil unless root && Dir.exist?(root)
 
@@ -357,14 +360,6 @@ module Ruflet
         nil
       end
 
-      def configured_client_root
-        root = ENV["RUFLET_CLIENT_DIR"].to_s.strip
-        return nil if root.empty?
-
-        expanded = File.expand_path(root)
-        Dir.exist?(expanded) ? expanded : nil
-      end
-
       def ensure_prebuilt_client(web: false, desktop: false, platform: nil, force: false)
         platform ||= host_platform_name
         return nil if platform.nil?
@@ -379,19 +374,29 @@ module Ruflet
           return nil if desktop_asset.nil?
           wanted_assets << { kind: :desktop, name: desktop_asset, platform: platform }
         end
-        cached = prebuilt_assets_present?(cache_root, web: web, desktop: desktop, platform: platform)
-        compatible_cache = cached && compatible_client_cache?(cache_root, platform: platform)
-        if !force && (wanted_assets.empty? || compatible_cache)
-          return cache_root
+        cache_ready = wanted_assets.empty? || prebuilt_assets_present?(cache_root, web: web, desktop: desktop, platform: platform)
+        release = nil
+        if !force && cache_ready
+          ensure_client_manifest(cache_root, platform: platform)
+          manifest = read_client_manifest(cache_root)
+          return cache_root unless client_update_due?(manifest)
+
+          release = fetch_release_for_version(wanted_assets: wanted_assets)
+          if release.nil? || client_release_current?(manifest, release, wanted_assets)
+            mark_client_update_checked(cache_root)
+            return cache_root
+          end
+
+          force = true
         end
-        force = true if cached && !compatible_cache
 
-        release = fetch_release_for_version
+        release ||= fetch_release_for_version(wanted_assets: wanted_assets)
         return nil unless release
 
         assets = release.fetch("assets", [])
         asset_names = assets.map { |a| a["name"].to_s }
         installed_assets = []
+        release_revision = client_release_revision(release)
         Dir.mktmpdir("ruflet-prebuilt-") do |tmpdir|
           wanted_assets.each do |wanted|
             asset_name = wanted.fetch(:name)
@@ -418,7 +423,8 @@ module Ruflet
               "kind" => wanted[:kind].to_s,
               "platform" => wanted[:platform] || platform,
               "asset_name" => resolved_name,
-              "download_url" => asset.fetch("browser_download_url")
+              "download_url" => asset.fetch("browser_download_url"),
+              "release_revision" => release_revision
             }
           end
         end
@@ -446,9 +452,7 @@ module Ruflet
 
         case platform
         when "macos"
-          app_path = File.join(root, "desktop", "ruflet_client.app")
-          bin = File.join(app_path, "Contents", "MacOS", "ruflet_client")
-          File.file?(bin) && ensure_macos_file_picker_entitlement(app_path)
+          File.file?(File.join(root, "desktop", "ruflet_client.app", "Contents", "MacOS", "ruflet_client"))
         when "linux"
           File.file?(File.join(root, "desktop", "ruflet_client"))
         when "windows"
@@ -479,34 +483,71 @@ module Ruflet
         File.join(Dir.home, ".ruflet", "client", ruflet_version, platform.to_s)
       end
 
-      def fetch_release_for_version
-        client_release_tags.each do |tag|
-          release = release_by_tag(tag)
-          return release if release
+      def fetch_release_for_version(wanted_assets: [])
+        releases = []
+        channel = client_release_channel
+        if channel != "stable"
+          rolling = release_by_tag(channel)
+          releases << rolling if rolling && rolling_release_complete?(rolling)
         end
+        releases << release_by_tag("v#{ruflet_version}")
+        releases << release_by_tag(ruflet_version)
+        releases << release_latest
+        releases.compact.find { |release| release_has_wanted_assets?(release, wanted_assets) }
+      end
 
-        nil
+      def client_release_channel
+        value = ENV.fetch("RUFLET_CLIENT_CHANNEL", "prebuild-main").to_s.strip
+        value.empty? ? "prebuild-main" : value
       end
 
-      def client_release_tags
-        channel = ENV["RUFLET_CLIENT_CHANNEL"].to_s.strip
-        unless channel.empty?
-          raise ArgumentError, "Invalid RUFLET_CLIENT_CHANNEL" unless channel.match?(/\A[A-Za-z0-9._-]+\z/)
+      def rolling_release_complete?(release)
+        release.fetch("assets", []).any? { |asset| asset["name"] == CLIENT_CHANNEL_MANIFEST }
+      end
 
-          return [channel]
+      def release_has_wanted_assets?(release, wanted_assets)
+        assets = release.fetch("assets", [])
+        wanted_assets.all? do |wanted|
+          assets.any? { |asset| asset["name"] == wanted[:name] } || fallback_release_asset(assets, wanted)
         end
+      end
 
-        ["v#{ruflet_version}", ruflet_version]
+      def client_release_revision(release)
+        marker = release.fetch("assets", []).find { |asset| asset["name"] == CLIENT_CHANNEL_MANIFEST }
+        source = marker || release
+        [source["id"], source["updated_at"] || source["published_at"], source["size"]].compact.join(":")
       end
 
-      def compatible_client_cache?(root, platform:)
-        manifest = read_client_manifest(root)
+      def client_release_current?(manifest, release, wanted_assets)
         return false unless manifest
 
-        manifest["schema"] == 1 &&
-          manifest["ruflet_version"] == ruflet_version &&
-          manifest["platform"] == platform &&
-          client_release_tags.include?(manifest["release_tag"])
+        revision = client_release_revision(release)
+        targets = Array(manifest["targets"])
+        wanted_assets.all? do |wanted|
+          targets.any? do |target|
+            target["kind"] == wanted[:kind].to_s &&
+              (wanted[:platform].nil? || target["platform"] == wanted[:platform]) &&
+              target["release_revision"] == revision
+          end
+        end
+      end
+
+      def client_update_due?(manifest)
+        return false if ENV["RUFLET_CLIENT_AUTO_UPDATE"].to_s.match?(/\A(?:0|false|no|off)\z/i)
+        return true unless manifest
+
+        checked_at = manifest["checked_at"] || manifest["installed_at"]
+        return true if checked_at.to_s.empty?
+
+        Time.now.utc - Time.iso8601(checked_at) >= client_update_interval
+      rescue ArgumentError
+        true
+      end
+
+      def client_update_interval
+        Integer(ENV.fetch("RUFLET_CLIENT_UPDATE_INTERVAL", DEFAULT_CLIENT_UPDATE_INTERVAL.to_s), 10).clamp(0, 7 * 24 * 60 * 60)
+      rescue ArgumentError
+        DEFAULT_CLIENT_UPDATE_INTERVAL
       end
 
       def ruflet_version
@@ -516,59 +557,16 @@ module Ruflet
         Ruflet::VERSION
       end
 
+      def release_latest
+        github_get_json("https://api.github.com/repos/AdamMusa/Ruflet/releases/latest")
+      end
+
       def release_by_tag(tag)
         github_get_json("https://api.github.com/repos/AdamMusa/Ruflet/releases/tags/#{tag}")
       rescue StandardError
         nil
       end
 
-      def ensure_macos_file_picker_entitlement(app_path)
-        return true if macos_app_has_file_picker_entitlement?(app_path)
-
-        Dir.mktmpdir("ruflet-entitlements-") do |dir|
-          entitlements_path = File.join(dir, "ruflet_file_picker.entitlements")
-          File.write(entitlements_path, macos_file_picker_entitlements_plist)
-          system(
-            "/usr/bin/codesign",
-            "--force",
-            "--deep",
-            "--sign",
-            "-",
-            "--entitlements",
-            entitlements_path,
-            app_path,
-            out: File::NULL,
-            err: File::NULL
-          )
-        end
-
-        macos_app_has_file_picker_entitlement?(app_path)
-      end
-
-      def macos_app_has_file_picker_entitlement?(app_path)
-        output = IO.popen(["/usr/bin/codesign", "-d", "--entitlements", ":-", app_path], err: [:child, :out], &:read)
-        $?.success? && output.include?("com.apple.security.files.user-selected.read-write")
-      rescue StandardError
-        false
-      end
-
-      def macos_file_picker_entitlements_plist
-        <<~PLIST
-          <?xml version="1.0" encoding="UTF-8"?>
-          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "https://www.apple.com/DTDs/PropertyList-1.0.dtd">
-          <plist version="1.0">
-          <dict>
-          \t<key>com.apple.security.app-sandbox</key>
-          \t<true/>
-          \t<key>com.apple.security.files.user-selected.read-write</key>
-          \t<true/>
-          \t<key>com.apple.security.network.client</key>
-          \t<true/>
-          </dict>
-          </plist>
-        PLIST
-      end
-
       def fallback_release_asset(assets, wanted)
         kind = wanted[:kind]
         platform = wanted[:platform]
@@ -607,8 +605,6 @@ module Ruflet
         return JSON.parse(response.body) if response.is_a?(Net::HTTPSuccess)
 
         raise "GitHub API failed (#{response.code})"
-      rescue OpenSSL::SSL::SSLError
-        JSON.parse(curl_get(url, headers: ["Accept: application/vnd.github+json", "User-Agent: ruflet-cli"]))
       end
 
       def download_file(url, destination, limit: 5)
@@ -630,31 +626,6 @@ module Ruflet
             end
           end
         end
-      rescue OpenSSL::SSL::SSLError
-        curl_download(url, destination)
-      end
-
-      def curl_get(url, headers: [])
-        args = ["curl", "-fsSL"]
-        headers.each do |header|
-          args += ["-H", header]
-        end
-        args << url
-        output = IO.popen(args, err: File::NULL, &:read)
-        return output if $?.success?
-
-        raise "curl failed while requesting #{url}"
-      rescue Errno::ENOENT
-        raise "Ruby SSL verification failed and curl is not available"
-      end
-
-      def curl_download(url, destination)
-        ok = system("curl", "-fL", "--retry", "2", "--connect-timeout", "20", "-o", destination, url, out: File::NULL, err: File::NULL)
-        return destination if ok
-
-        raise "curl failed while downloading #{url}"
-      rescue Errno::ENOENT
-        raise "Ruby SSL verification failed and curl is not available"
       end
 
       def extract_archive(archive, destination)
@@ -685,20 +656,51 @@ module Ruflet
         nil
       end
 
+      def ensure_client_manifest(root, platform:)
+        return if read_client_manifest(root)
+
+        assets = []
+        assets << { "kind" => "web", "platform" => platform, "asset_name" => nil } if File.file?(File.join(root, "web", "index.html"))
+        if prebuilt_desktop_present?(root, platform: platform)
+          assets << { "kind" => "desktop", "platform" => platform, "asset_name" => nil }
+        end
+        return if assets.empty?
+
+        write_client_manifest(root, platform: platform, release: nil, assets: assets)
+      end
+
       def write_client_manifest(root, platform:, release:, assets:)
         FileUtils.mkdir_p(root)
+        existing = read_client_manifest(root) || {}
+        installed_targets = Array(existing["targets"])
+        assets.each do |asset|
+          installed_targets.reject! do |target|
+            target["kind"] == asset["kind"] && target["platform"] == asset["platform"]
+          end
+          installed_targets << asset
+        end
         payload = {
-          "schema" => 1,
+          "schema" => 2,
           "ruflet_version" => ruflet_version,
           "platform" => platform,
-          "release_tag" => release && release["tag_name"],
-          "released_at" => release && release["published_at"],
+          "release_tag" => release && release["tag_name"] || existing["release_tag"],
+          "release_revision" => release && client_release_revision(release) || existing["release_revision"],
+          "released_at" => release && release["published_at"] || existing["released_at"],
+          "checked_at" => Time.now.utc.iso8601,
           "installed_at" => Time.now.utc.iso8601,
-          "targets" => assets
+          "targets" => installed_targets
         }
         File.write(client_manifest_path(root), JSON.pretty_generate(payload))
       end
 
+      def mark_client_update_checked(root)
+        manifest = read_client_manifest(root)
+        return unless manifest
+
+        manifest["checked_at"] = Time.now.utc.iso8601
+        File.write(client_manifest_path(root), JSON.pretty_generate(manifest))
+      end
+
       def print_mobile_qr_hint(port: 8550)
         host = best_lan_host
         payload = "http://#{host}:#{port}"
@@ -717,24 +719,26 @@ module Ruflet
         port = start_port.to_i
 
         max_attempts.times do
-          return port if port_available?(port)
-
-          port += 1
+          begin
+            begin
+              probe = TCPServer.new("0.0.0.0", port)
+            rescue Errno::EACCES, Errno::EPERM
+              probe = TCPServer.new("127.0.0.1", port)
+            end
+            probe.close
+            return port
+          rescue Errno::EADDRINUSE, Errno::EACCES, Errno::EPERM
+            port += 1
+          end
         end
 
-        nil
-      end
-
-      def default_backend_port(target)
-        DEFAULT_BACKEND_PORTS.fetch(target.to_s, DEFAULT_BACKEND_PORTS.fetch("mobile"))
+        start_port
       end
 
-      def resolve_backend_port(target, requested_port: nil)
+      def resolve_backend_port(_target, requested_port: 8550)
         base = requested_port.to_i
-        base = default_backend_port(target) if base <= 0
-        selected = find_available_port(base)
-        warn "No available Ruflet port found starting at #{base}." unless selected
-        selected
+        base = 8550 if base <= 0
+        find_available_port(base)
       end
 
       def port_available?(port)
@@ -746,7 +750,7 @@ module Ruflet
             probe = TCPServer.new("127.0.0.1", port)
           end
           true
-        rescue Errno::EADDRINUSE, Errno::EACCES, Errno::EPERM
+        rescue Errno::EADDRINUSE
           false
         ensure
           probe&.close

data/lib/ruflet/cli/templates.rb

@@ -5,9 +5,16 @@ module Ruflet
     MAIN_TEMPLATE = <<~RUBY
     require "ruflet"
     Ruflet.run do |page|
-      page.title = "%<app_title>s"
+      page.title = "Counter Demo"
       count = 0
       count_text = text(count.to_s, style: {size: 40})
+      page.floating_action_button = fab(
+        icon: "add",
+        on_click: ->(_e) do
+          count += 1
+          page.update(count_text, value: count.to_s)
+        end
+      )
       page.add(
         container(
           expand: true,
@@ -20,13 +27,6 @@ module Ruflet
               count_text
             ]
           )
-        ),
-        floating_action_button: fab(
-          icon: "add",
-          on_click: ->(_e) do
-            count += 1
-            page.update(count_text, value: count.to_s)
-          end
         )
       )
     end
@@ -36,7 +36,6 @@ module Ruflet
     GEMFILE_TEMPLATE = <<~GEMFILE
       source "https://rubygems.org"
 
-      gem "ruflet", ">= #{Ruflet::VERSION}"
       gem "ruflet_core", ">= #{Ruflet::VERSION}"
       gem "ruflet_server", ">= #{Ruflet::VERSION}"
     GEMFILE

data/lib/ruflet/cli.rb

@@ -2,23 +2,10 @@
 
 require "optparse"
 
-# Project files (pbxproj, plists, embedded runtime sources) are UTF-8; never
-# depend on the caller's locale for reading them.
-Encoding.default_external = Encoding::UTF_8 if Encoding.default_external == Encoding::US_ASCII
-
-# Provisioning (downloads, package installs, SDK extraction) can run for
-# minutes. When stdout is not a TTY (CI logs, pipes, editor consoles) Ruby
-# buffers it, so progress notes would only appear once the whole run finishes.
-# Unbuffer both streams so the pipeline reports progress as it happens.
-$stdout.sync = true
-$stderr.sync = true
-
 require_relative "version"
 require_relative "cli/templates"
 require_relative "cli/new_command"
 require_relative "cli/flutter_sdk"
-require_relative "cli/environment_setup"
-require_relative "cli/android_sdk"
 require_relative "cli/run_command"
 require_relative "cli/update_command"
 require_relative "cli/build_command"
@@ -86,7 +73,7 @@ module Ruflet
           ruflet install [--device DEVICE_ID] [--verbose]
           ruflet devices
           ruflet emulators
-          ruflet doctor
+          ruflet doctor [--fix] [--verbose]
       HELP
     end
 
@@ -102,7 +89,7 @@ module Ruflet
     private
 
     def ensure_first_run_assets(command)
-      return if %w[version -v --version help -h --help].include?(command)
+      return unless %w[create new bootstrap init update debug build install doctor].include?(command)
       return unless respond_to?(:download_ruflet_assets, true)
 
       send(:download_ruflet_assets)

data/lib/ruflet/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet
 version: !ruby/object:Gem::Version
-  version: 0.0.17
+  version: 0.0.19
 platform: ruby
 authors:
 - AdamMusa
@@ -37,9 +37,7 @@ files:
 - assets/splash.png
 - bin/ruflet
 - lib/ruflet/cli.rb
-- lib/ruflet/cli/android_sdk.rb
 - lib/ruflet/cli/build_command.rb
-- lib/ruflet/cli/environment_setup.rb
 - lib/ruflet/cli/extra_command.rb
 - lib/ruflet/cli/flutter_sdk.rb
 - lib/ruflet/cli/new_command.rb