ruflet_cli 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 504fcfaa08d919daea87df9c873cb5b6e890ad477456ffd9268730f1649bae68
-  data.tar.gz: e59b5b1067f1604230353731a5297906c33d1333ae876a9644215161428f1a5e
+  metadata.gz: 83772c8986411d4680455374f1f350c015183318e3c090426ea53edfb4ed2a89
+  data.tar.gz: 45f42f969bc487714f24c0833ca8fdbf2236e789622deb604a231d1a254ea483
 SHA512:
-  metadata.gz: 5c448739e52ec85fd83d5cb219e9f249ebe2046ba67f9038d9a7c95dac50f4f6d6f6f48d6331f7dec8be21b107dffa5116fecc50c6800f3ad81c2656ad684f3a
-  data.tar.gz: 388a23d1752044cedc4dc4b0586a240c04a03b59279aa5a0195d4aa41b3ae4e5c0b0c11a076961da78a011c92b1254397f84248121318f350b6bd986d40d1e73
+  metadata.gz: 412a6524bff1cdf335256193390aca08c71b299f517da00af1da6efada84c7fc0ebd0d399be9e92235d6713ebcfbd8c8f9695695b68e3465242ed998deecf1bb
+  data.tar.gz: 0f77d2ee780f5d443e58d356ac02382ae0e5a53144ac64d9df5bf8d4e9bec2fcf51646f8d92fdc69e527259a7100e772fafcd26861c2d63ba829606531b03824

data/lib/ruflet/cli/build_command.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+require "fileutils"
+require "yaml"
+
 module Ruflet
   module CLI
     module BuildCommand
+      include FlutterSdk
+
       def command_build(args)
         platform = (args.shift || "").downcase
         if platform.empty?
@@ -23,7 +28,11 @@ module Ruflet
           return 1
         end
 
-        ok = system(*flutter_cmd, chdir: client_dir)
+        tools = ensure_flutter!("build", client_dir: client_dir)
+        ok = prepare_flutter_client(client_dir, tools: tools)
+        return 1 unless ok
+
+        ok = system(tools[:env], tools[:flutter], *flutter_cmd, *args, chdir: client_dir)
         ok ? 0 : 1
       end
 
@@ -36,25 +45,190 @@ module Ruflet
         local = File.expand_path("ruflet_client", Dir.pwd)
         return local if Dir.exist?(local)
 
+        template = File.expand_path("templates/ruflet_flutter_template", Dir.pwd)
+        return template if Dir.exist?(template)
+
         nil
       end
 
+      def prepare_flutter_client(client_dir, tools:)
+        apply_build_config(client_dir)
+        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
+        end
+
+        unless system(tools[:env], tools[:dart], "run", "flutter_launcher_icons", chdir: client_dir)
+          warn "flutter_launcher_icons failed"
+          return false
+        end
+
+        true
+      end
+
+      def apply_build_config(client_dir)
+        config_path = ENV["RUFLET_CONFIG"] || "ruflet.yaml"
+        unless File.file?(config_path)
+          alt = "ruflet.yml"
+          config_path = alt if File.file?(alt)
+        end
+
+        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
+
+        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 = resolve_asset.call(build["splash"] || assets["splash"] || ENV["RUFLET_SPLASH"])
+        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_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"]
+        theme_color = build["theme_color"]
+
+        assets_dir = File.join(client_dir, "assets")
+        FileUtils.mkdir_p(assets_dir)
+
+        copy_asset = lambda do |src, dest|
+          return unless src
+          FileUtils.cp(src, File.join(assets_dir, dest))
+        end
+
+        copy_asset.call(splash, "splash.png")
+        copy_asset.call(splash_dark, "splash_dark.png")
+        copy_asset.call(icon, "icon.png")
+        copy_asset.call(icon_android, "icon_android.png")
+        copy_asset.call(icon_ios, "icon_ios.png")
+        copy_asset.call(icon_web, "icon_web.png")
+        if icon_windows
+          ext = File.extname(icon_windows).downcase
+          copy_asset.call(icon_windows, ext == ".ico" ? "icon_windows.ico" : "icon_windows.png")
+        end
+        copy_asset.call(icon_macos, "icon_macos.png")
+
+        pubspec_path = File.join(client_dir, "pubspec.yaml")
+        return unless File.file?(pubspec_path)
+
+        if 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
+        update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path_ios", "\"assets/icon_ios.png\"", multiple: true) if icon_ios
+        update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path_web", "\"assets/icon_web.png\"", multiple: true) if icon_web
+        if icon_windows
+          ext = File.extname(icon_windows).downcase
+          value = ext == ".ico" ? "\"assets/icon_windows.ico\"" : "\"assets/icon_windows.png\""
+          update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path_windows", value, multiple: true)
+        end
+        update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path_macos", "\"assets/icon_macos.png\"", multiple: true) if icon_macos
+        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_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
+      end
+
+      def update_pubspec_value(path, block, key, value, multiple: false)
+        lines = File.read(path).split("\n", -1)
+        out = []
+        in_block = false
+        replaced = false
+        block_indent = nil
+        lines.each do |line|
+          if line.start_with?("#{block}:")
+            in_block = true
+            block_indent = line[/^\s*/] + "  "
+            out << line
+            next
+          end
+
+          if in_block
+            if line =~ /^\S/ && !line.start_with?("#{block}:")
+              unless replaced
+                out << "#{block_indent}#{key}: #{value}"
+                replaced = true
+              end
+              in_block = false
+            else
+              if line.strip.start_with?("#{key}:")
+                indent = line[/^\s*/]
+                out << "#{indent}#{key}: #{value}"
+                replaced = true
+                next
+              end
+            end
+          end
+
+          out << line
+        end
+        if in_block && !replaced
+          out << "#{block_indent}#{key}: #{value}"
+        end
+        File.write(path, out.join("\n"))
+      end
+
       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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Ruflet
+  module CLI
+    module ExtraCommand
+      include FlutterSdk
+
+      def command_create(args)
+        command_new(args)
+      end
+
+      def command_doctor(args)
+        verbose = args.delete("--verbose") || args.delete("-v")
+        puts "Ruflet doctor"
+        puts "  Ruby: #{RUBY_VERSION}"
+        tools = ensure_flutter!("doctor")
+        puts "  Flutter: #{tools[:flutter]}"
+        system(tools[:env], tools[:flutter], "doctor", *(verbose ? ["-v"] : []))
+        $?.exitstatus || 1
+      end
+
+      def command_devices(args)
+        tools = ensure_flutter!("devices")
+        system(tools[:env], tools[:flutter], "devices", *args)
+        $?.exitstatus || 1
+      end
+
+      def command_emulators(args)
+        tools = ensure_flutter!("emulators")
+        action = nil
+        emulator_id = nil
+        verbose = false
+        parser = OptionParser.new do |o|
+          o.on("--create") { action = "create" }
+          o.on("--delete") { action = "delete" }
+          o.on("--start") { action = "start" }
+          o.on("--emulator ID") { |v| emulator_id = v }
+          o.on("-v", "--verbose") { verbose = true }
+        end
+        parser.parse!(args)
+
+        case action
+        when "start"
+          unless emulator_id
+            warn "Missing --emulator for start"
+            return 1
+          end
+          cmd = [tools[:flutter], "emulators", "--launch", emulator_id]
+          cmd << "-v" if verbose
+          system(tools[:env], *cmd)
+          $?.exitstatus || 1
+        when "create", "delete"
+          warn "ruflet emulators --#{action} is not implemented yet. Use your platform tools."
+          1
+        else
+          cmd = [tools[:flutter], "emulators"]
+          cmd << "-v" if verbose
+          system(tools[:env], *cmd)
+          $?.exitstatus || 1
+        end
+      end
+
+      def command_debug(args)
+        options = {
+          platform: nil,
+          device_id: nil,
+          release: false,
+          verbose: false,
+          web_renderer: nil
+        }
+        parser = OptionParser.new do |o|
+          o.on("--platform NAME") { |v| options[:platform] = v }
+          o.on("--device-id ID") { |v| options[:device_id] = v }
+          o.on("--release") { options[:release] = true }
+          o.on("-v", "--verbose") { options[:verbose] = true }
+          o.on("--web-renderer NAME") { |v| options[:web_renderer] = v }
+        end
+        parser.parse!(args)
+
+        options[:platform] ||= args.shift
+        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]
+
+        if options[:device_id]
+          cmd += ["-d", options[:device_id]]
+        else
+          case options[:platform]
+          when "web"
+            cmd += ["-d", "chrome"]
+          when "macos", "windows", "linux"
+            cmd += ["-d", options[:platform]]
+          when "ios", "android"
+            # let flutter pick the default device
+          end
+        end
+
+        system(tools[:env], *cmd, chdir: client_dir)
+        $?.exitstatus || 1
+      end
+
+      private
+
+      def detect_client_dir
+        env_dir = ENV["RUFLET_CLIENT_DIR"]
+        return env_dir if env_dir && Dir.exist?(env_dir)
+
+        local = File.expand_path("ruflet_client", Dir.pwd)
+        return local if Dir.exist?(local)
+
+        template = File.expand_path("templates/ruflet_flutter_template", Dir.pwd)
+        return template if Dir.exist?(template)
+
+        nil
+      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,23 +19,56 @@ 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)
 
         project_name = File.basename(root)
         puts "Ruflet app created: #{project_name}"
         puts "Run:"
         puts "  cd #{project_name}"
         puts "  bundle install"
-        puts "  bundle exec ruflet run main"
+        puts "  bundle exec ruflet run main.rb"
+        puts
+        puts "Client template:"
+        puts "  cd ruflet_client"
+        puts "  flutter pub get"
+        puts "  flutter run"
         0
       end
 
       private
 
+      def copy_ruflet_client_template(root)
+        template_root = File.expand_path("../../../../../ruflet_client", __dir__)
+        return unless Dir.exist?(template_root)
+
+        target = File.join(root, "ruflet_client")
+        FileUtils.cp_r(template_root, target)
+        prune_client_template(target)
+      end
+
+      def prune_client_template(target)
+        paths = %w[
+          .dart_tool
+          .idea
+          build
+          ios/Pods
+          ios/.symlinks
+          ios/Podfile.lock
+          macos/Pods
+          macos/Podfile.lock
+          android/.gradle
+          android/.kotlin
+          android/local.properties
+        ]
+        paths.each do |path|
+          full = File.join(target, path)
+          FileUtils.rm_rf(full) if File.exist?(full)
+        end
+      end
+
       def humanize_name(name)
         name.to_s.gsub(/[_-]+/, " ").split.map(&:capitalize).join(" ")
       end

data/lib/ruflet/cli/run_command.rb

@@ -3,6 +3,12 @@
 require "optparse"
 require "rbconfig"
 require "socket"
+require "timeout"
+require "tmpdir"
+require "fileutils"
+require "json"
+require "net/http"
+require "uri"
 
 module Ruflet
   module CLI
@@ -24,20 +30,23 @@ 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",
           "RUFLET_PORT" => selected_port.to_s
         }
+        assets_dir = File.join(File.dirname(script_path), "assets")
+        env["RUFLET_ASSETS_DIR"] = assets_dir if File.directory?(assets_dir)
 
-        puts "Requested port 8550 is busy; bound to #{selected_port}" if selected_port != 8550
+        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")
 
@@ -47,6 +56,7 @@ module Ruflet
           end
 
         child_pid = Process.spawn(env, *cmd, pgroup: true)
+        launched_client_pids = launch_target_client(options[:target], selected_port)
         forward_signal = lambda do |signal|
           begin
             Process.kill(signal, -child_pid)
@@ -71,6 +81,18 @@ module Ruflet
             nil
           end
         end
+
+        Array(defined?(launched_client_pids) ? launched_client_pids : nil).compact.each do |pid|
+          begin
+            Process.kill("TERM", -pid)
+          rescue Errno::ESRCH
+            begin
+              Process.kill("TERM", pid)
+            rescue Errno::ESRCH
+              nil
+            end
+          end
+        end
       end
 
       private
@@ -85,6 +107,418 @@ 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 target == "mobile" && port != 8550
+          puts "Requested port 8550 is busy; bound to #{port}"
+        end
+        if target == "desktop"
+          puts "Ruflet desktop URL: http://localhost:#{port}"
+        else
+          puts "Ruflet target: #{target}"
+          puts "Ruflet URL: http://localhost:#{port}"
+        end
+      end
+
+      def launch_target_client(target, port)
+        wait_for_server_boot(port)
+
+        case target
+        when "web"
+          launch_web_client(port)
+        when "desktop"
+          launch_desktop_client("http://localhost:#{port}")
+        else
+          []
+        end
+      end
+
+      def launch_web_client(port)
+        web_dir = detect_web_client_dir
+        unless web_dir
+          warn "Web client build not found and prebuilt download failed."
+          return []
+        end
+
+        web_port = find_available_port(port + 1)
+        web_pid = Process.spawn("python3", "-m", "http.server", web_port.to_s, "--bind", "127.0.0.1", chdir: web_dir, out: File::NULL, err: File::NULL)
+        Process.detach(web_pid)
+        wait_for_server_boot(web_port)
+        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}"
+        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 launch web client: #{e.class}: #{e.message}"
+        []
+      end
+
+      def wait_for_server_boot(port, timeout_seconds: 10)
+        Timeout.timeout(timeout_seconds) do
+          loop do
+            begin
+              sock = TCPSocket.new("127.0.0.1", port)
+              sock.write("GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
+              sock.close
+              break
+            rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+              sleep 0.15
+            end
+          end
+        end
+      rescue Timeout::Error
+        warn "Server did not become reachable at http://localhost:#{port} yet."
+      end
+
+      def open_in_browser(url)
+        cmd =
+          case RbConfig::CONFIG["host_os"]
+          when /darwin/i
+            ["open", url]
+          when /mswin|mingw|cygwin/i
+            ["cmd", "/c", "start", "", url]
+          else
+            ["xdg-open", url]
+          end
+        if system(*cmd, out: File::NULL, err: File::NULL)
+          puts "Opened browser at #{url}"
+        else
+          warn "Could not auto-open browser. Open manually: #{url}"
+        end
+      end
+
+      def open_in_browser_app_mode(url)
+        host_os = RbConfig::CONFIG["host_os"]
+        if host_os.match?(/darwin/i)
+          chrome = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+          chromium = "/Applications/Chromium.app/Contents/MacOS/Chromium"
+          browser = [chrome, chromium].find { |p| File.file?(p) && File.executable?(p) }
+          return nil unless browser
+
+          profile_dir = Dir.mktmpdir("ruflet-webapp-")
+          pid = Process.spawn(
+            browser,
+            "--new-window",
+            "--no-first-run",
+            "--no-default-browser-check",
+            "--user-data-dir=#{profile_dir}",
+            "--app=#{url}",
+            pgroup: true,
+            out: File::NULL,
+            err: File::NULL
+          )
+          Process.detach(pid)
+          return pid
+        end
+
+        if host_os.match?(/linux/i)
+          browser = %w[google-chrome chromium chromium-browser].find { |cmd| system("which", cmd, out: File::NULL, err: File::NULL) }
+          return nil unless browser
+
+          profile_dir = Dir.mktmpdir("ruflet-webapp-")
+          pid = Process.spawn(
+            browser,
+            "--new-window",
+            "--no-first-run",
+            "--no-default-browser-check",
+            "--user-data-dir=#{profile_dir}",
+            "--app=#{url}",
+            pgroup: true,
+            out: File::NULL,
+            err: File::NULL
+          )
+          Process.detach(pid)
+          return pid
+        end
+
+        nil
+      rescue StandardError
+        nil
+      end
+
+      def launch_desktop_client(url)
+        cmd = detect_desktop_client_command(url)
+        unless cmd
+          warn "Desktop client executable not found."
+          warn "Set RUFLET_CLIENT_DIR to your client path."
+          warn "Example: export RUFLET_CLIENT_DIR=/path/to/ruflet_client"
+          return
+        end
+
+        pid = Process.spawn(*cmd, out: File::NULL, err: File::NULL)
+        Process.detach(pid)
+        if !pid
+          warn "Failed to launch desktop client: #{cmd.first}"
+          warn "Start it manually with URL: #{url}"
+        end
+        [pid]
+      rescue StandardError => e
+        warn "Failed to launch desktop client: #{e.class}: #{e.message}"
+        warn "Start it manually with URL: #{url}"
+        []
+      end
+
+      def detect_desktop_client_command(url)
+        root = ENV["RUFLET_CLIENT_DIR"]
+        root = File.expand_path("ruflet_client", Dir.pwd) if root.to_s.strip.empty?
+        root = nil unless Dir.exist?(root)
+        root ||= ensure_prebuilt_client(desktop: true)
+        return nil unless root && Dir.exist?(root)
+
+        host_os = RbConfig::CONFIG["host_os"]
+        if host_os.match?(/darwin/i)
+          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, "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, "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 = 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)
+
+        built = File.join(root, "build", "web")
+        return built if Dir.exist?(built) && File.file?(File.join(built, "index.html"))
+        prebuilt = File.join(root, "web")
+        return prebuilt if Dir.exist?(prebuilt) && File.file?(File.join(prebuilt, "index.html"))
+
+        nil
+      end
+
+      def ensure_prebuilt_client(web: false, desktop: false)
+        platform = host_platform_name
+        return nil if platform.nil?
+
+        cache_root = File.join(Dir.home, ".ruflet", "client", ruflet_version, platform)
+        FileUtils.mkdir_p(cache_root)
+
+        wanted_assets = []
+        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 << { kind: :desktop, name: desktop_asset, platform: platform }
+        end
+        return cache_root if wanted_assets.empty? || prebuilt_assets_present?(cache_root, web: web, desktop: desktop)
+
+        release = fetch_release_for_version
+        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 |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
+            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 = 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: #{resolved_name}"
+              return nil
+            end
+          end
+        end
+
+        return cache_root if prebuilt_assets_present?(cache_root, web: web, desktop: desktop)
+
+        nil
+      rescue StandardError => e
+        warn "Prebuilt client bootstrap failed: #{e.class}: #{e.message}"
+        nil
+      end
+
+      def prebuilt_assets_present?(root, web:, desktop:)
+        ok_web = !web || File.file?(File.join(root, "web", "index.html"))
+        ok_desktop = !desktop || prebuilt_desktop_present?(root)
+        ok_web && ok_desktop
+      end
+
+      def prebuilt_desktop_present?(root)
+        platform = host_platform_name
+        return false if platform.nil?
+
+        case platform
+        when "macos"
+          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"
+          File.file?(File.join(root, "desktop", "ruflet_client.exe"))
+        else
+          false
+        end
+      end
+
+      def host_platform_name
+        host_os = RbConfig::CONFIG["host_os"]
+        return "macos" if host_os.match?(/darwin/i)
+        return "linux" if host_os.match?(/linux/i)
+        return "windows" if host_os.match?(/mswin|mingw|cygwin/i)
+
+        nil
+      end
+
+      def desktop_asset_name_for(platform)
+        case platform
+        when "macos" then "ruflet_client-macos-universal.zip"
+        when "linux" then "ruflet_client-linux-x64.tar.gz"
+        when "windows" then "ruflet_client-windows-x64.zip"
+        end
+      end
+
+      def fetch_release_for_version
+        release_by_tag("v#{ruflet_version}") ||
+          release_by_tag(ruflet_version) ||
+          release_by_tag("prebuild") ||
+          release_by_tag("prebuild-main") ||
+          release_latest
+      end
+
+      def ruflet_version
+        return Ruflet::VERSION if Ruflet.const_defined?(:VERSION)
+
+        require_relative "../version"
+        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 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|
+          req = Net::HTTP::Get.new(uri)
+          req["Accept"] = "application/vnd.github+json"
+          req["User-Agent"] = "ruflet-cli"
+          http.request(req)
+        end
+        return JSON.parse(response.body) if response.is_a?(Net::HTTPSuccess)
+
+        raise "GitHub API failed (#{response.code})"
+      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?(".tar.gz")
+          return system("tar", "-xzf", archive, "-C", destination, out: File::NULL, err: File::NULL)
+        end
+        if archive.end_with?(".zip")
+          host_os = RbConfig::CONFIG["host_os"]
+          if host_os.match?(/darwin/i)
+            return system("ditto", "-x", "-k", archive, destination, out: File::NULL, err: File::NULL)
+          end
+          return system("unzip", "-oq", archive, "-d", destination, out: File::NULL, err: File::NULL)
+        end
+
+        false
+      end
+
       def print_mobile_qr_hint(port: 8550)
         host = best_lan_host
         payload = "http://#{host}:#{port}"
@@ -121,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

@@ -15,28 +15,28 @@ module Ruflet
           page.title = "Counter Demo"
           page.vertical_alignment = Ruflet::MainAxisAlignment::CENTER
           page.horizontal_alignment = Ruflet::CrossAxisAlignment::CENTER
-          count_text = page.text(value: @count.to_s, size: 40)
+          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)
@@ -57,12 +57,6 @@ module Ruflet
       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
 

data/lib/ruflet/cli.rb

@@ -5,7 +5,9 @@ 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"
 
 module Ruflet
   module CLI
@@ -13,17 +15,28 @@ module Ruflet
     extend NewCommand
     extend RunCommand
     extend BuildCommand
+    extend ExtraCommand
 
     def run(argv = ARGV)
       command = (argv.shift || "help").downcase
 
       case command
+      when "create"
+        command_create(argv)
       when "new", "bootstrap", "init"
         command_new(argv)
       when "run"
         command_run(argv)
+      when "debug"
+        command_debug(argv)
       when "build"
         command_build(argv)
+      when "devices"
+        command_devices(argv)
+      when "emulators"
+        command_emulators(argv)
+      when "doctor"
+        command_doctor(argv)
       when "help", "-h", "--help"
         print_help
         0
@@ -39,9 +52,14 @@ module Ruflet
         Ruflet CLI
 
         Commands:
+          ruflet create <appname>
           ruflet new <appname>
           ruflet run [scriptname|path] [--web|--mobile|--desktop]
+          ruflet debug [scriptname|path]
           ruflet build <apk|ios|aab|web|macos|windows|linux>
+          ruflet devices
+          ruflet emulators
+          ruflet doctor
       HELP
     end
 

data/lib/ruflet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruflet
-  VERSION = "0.0.3" 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.3
+  version: 0.0.5
 platform: ruby
 authors:
 - AdamMusa
@@ -35,6 +35,8 @@ files:
 - bin/ruflet
 - 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