ruflet_cli 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 504fcfaa08d919daea87df9c873cb5b6e890ad477456ffd9268730f1649bae68
-  data.tar.gz: e59b5b1067f1604230353731a5297906c33d1333ae876a9644215161428f1a5e
+  metadata.gz: 36d08da2d1377a858cd6703bd694b66d937604a21544af1de95d592aec4cb4df
+  data.tar.gz: 3feccf443f7ecae27bf835a90f6fbb81c04bdbc86bf1a71350bda6c97a0d555d
 SHA512:
-  metadata.gz: 5c448739e52ec85fd83d5cb219e9f249ebe2046ba67f9038d9a7c95dac50f4f6d6f6f48d6331f7dec8be21b107dffa5116fecc50c6800f3ad81c2656ad684f3a
-  data.tar.gz: 388a23d1752044cedc4dc4b0586a240c04a03b59279aa5a0195d4aa41b3ae4e5c0b0c11a076961da78a011c92b1254397f84248121318f350b6bd986d40d1e73
+  metadata.gz: e8677cc79bdb4e546f88ea3140b95e0177a0f24f884fa679f1a5636098017186caa14859a189c755b42455bdd7bbf612a8ac78f608766cd19f36b1f756c5ad69
+  data.tar.gz: b07035a35c315f1b42cc5dda629d080a4956b1854dd96297420d6ad24986c3095101f86ff9889c13d0bc133e18967c2666fbadad3228f00b39eabd9442af88ac

data/lib/ruflet/cli/build_command.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "fileutils"
+require "yaml"
+
 module Ruflet
   module CLI
     module BuildCommand
@@ -23,7 +26,10 @@ module Ruflet
           return 1
         end
 
-        ok = system(*flutter_cmd, chdir: client_dir)
+        ok = prepare_flutter_client(client_dir)
+        return 1 unless ok
+
+        ok = system(*flutter_cmd, *args, chdir: client_dir)
         ok ? 0 : 1
       end
 
@@ -36,9 +42,174 @@ 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)
+        apply_build_config(client_dir)
+        unless system("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)
+          warn "flutter_native_splash failed"
+          return false
+        end
+
+        unless system("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"

data/lib/ruflet/cli/extra_command.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Ruflet
+  module CLI
+    module ExtraCommand
+      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}"
+        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
+      end
+
+      def command_devices(args)
+        ensure_flutter!("devices")
+        system("flutter", "devices", *args)
+        $?.exitstatus || 1
+      end
+
+      def command_emulators(args)
+        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 = ["flutter", "emulators", "--launch", emulator_id]
+          cmd << "-v" if verbose
+          system(*cmd)
+          $?.exitstatus || 1
+        when "create", "delete"
+          warn "ruflet emulators --#{action} is not implemented yet. Use your platform tools."
+          1
+        else
+          cmd = ["flutter", "emulators"]
+          cmd << "-v" if verbose
+          system(*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,
+          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
+        cmd = ["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
+
+        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)
+        $?.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
+
+      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/new_command.rb

@@ -24,18 +24,53 @@ module Ruflet
         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
@@ -30,8 +36,10 @@ module Ruflet
           "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"
 
         cmd =
@@ -47,6 +55,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 +80,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 +106,361 @@ module Ruflet
         nil
       end
 
+      def print_run_banner(target:, port:)
+        if 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 << "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
+        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", [])
+        Dir.mktmpdir("ruflet-prebuilt-") do |tmpdir|
+          wanted_assets.each do |asset_name|
+            asset = assets.find { |a| a["name"] == asset_name }
+            unless asset
+              warn "Missing release asset: #{asset_name}"
+              return nil
+            end
+            archive_path = File.join(tmpdir, asset_name)
+            download_file(asset.fetch("browser_download_url"), archive_path)
+            subdir = asset_name.include?("-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}"
+              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_latest
+      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 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}"

data/lib/ruflet/cli/templates.rb

@@ -13,8 +13,6 @@ module Ruflet
 
         def view(page)
           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)
 
           page.add(
@@ -47,13 +45,13 @@ 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
 
@@ -77,7 +75,17 @@ module Ruflet
       ## Run
 
       ```bash
-      bundle exec ruflet run main
+      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
       ```
 
       ## Build

data/lib/ruflet/cli.rb

@@ -6,6 +6,7 @@ require_relative "cli/templates"
 require_relative "cli/new_command"
 require_relative "cli/run_command"
 require_relative "cli/build_command"
+require_relative "cli/extra_command"
 
 module Ruflet
   module CLI
@@ -13,17 +14,34 @@ 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 "pack"
+        command_pack(argv)
+      when "publish"
+        command_publish(argv)
+      when "serve"
+        command_serve(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 +57,17 @@ 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 pack
+          ruflet publish
+          ruflet serve [--port N] [--root PATH]
+          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.4" 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.4
 platform: ruby
 authors:
 - AdamMusa
@@ -35,6 +35,7 @@ files:
 - bin/ruflet
 - lib/ruflet/cli.rb
 - lib/ruflet/cli/build_command.rb
+- lib/ruflet/cli/extra_command.rb
 - lib/ruflet/cli/new_command.rb
 - lib/ruflet/cli/run_command.rb
 - lib/ruflet/cli/templates.rb