ruflet 0.0.11 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd06c38b3f93c8ae4197f120eeda91d388b2a25114ca4d8a5df37f40a499ee95
-  data.tar.gz: ba86fc65fd65202ed745c019f64a19a8ebfd6c759348ea7a6d2c165e98897bdb
+  metadata.gz: 877c730a76717b1a9623d285666db0cb3b5a47fb08eafe0e9d3bb49c681c0b88
+  data.tar.gz: a649878ca4f0a7fc8d752e6ba2e0f3eaa1963213fa96dfee3f4a52d2905e4b9a
 SHA512:
-  metadata.gz: 1898d117b21f34c326a38da7a2b57db1902874839a3bf954d37090f620d0650589edf2ab47a493cbb71a9d8e5643f54a5e59c17b57b86624517b4bcec9e038e9
-  data.tar.gz: aee1a5ae587c543fa957fd2a10254b3cd7e06069bc3525862750d2445aa17c9340fa0fbcc26c9b1fe9e86d6ad8ab91274a13991696f15794a5a69b4c20b5092d
+  metadata.gz: a1a15a38fa5973a84e921d3b57fd54a135d5d4090fdd996294991f0fede09a89e1553037388f7a07a9dace52b9b4e753273d4da2b0940ca6f326344b708b0de2
+  data.tar.gz: d10353a23bb436679d2a82226f490ad7c2ef1d470b33808ff3d523a94432f871982a1ed998a2c9fc80a9321ed07fbf2ad8ba23633dbe492e2ebc20c1b03fea96

data/lib/ruflet/cli/build_command.rb

@@ -46,6 +46,7 @@ module Ruflet
           return 1
         end
 
+        ensure_ruflet_build_assets(verbose: !!verbose)
         client_dir = ensure_flutter_client_dir(verbose: !!verbose)
         unless client_dir
           warn "Could not find Flutter client directory."
@@ -340,6 +341,15 @@ module Ruflet
         Dir.exist?(target) ? target : nil
       end
 
+      def ensure_ruflet_build_assets(force: false, verbose: false)
+        return true unless respond_to?(:download_ruflet_assets, true)
+
+        !!send(:download_ruflet_assets, force: force, verbose: verbose)
+      rescue StandardError => e
+        build_log(verbose, "ruflet asset bootstrap skipped: #{e.class}: #{e.message}")
+        false
+      end
+
       def hidden_flutter_client_dir(root = Dir.pwd)
         File.join(root, "build", "client")
       end
@@ -352,6 +362,7 @@ module Ruflet
         refresh_managed_client_template_files(client_dir, verbose: verbose)
         sync_client_metadata(client_dir, config, verbose: verbose)
         configure_client_runtime_mode(client_dir, self_contained: self_contained, verbose: verbose)
+        @ruflet_self_contained_build = self_contained
         apply_service_extension_config(client_dir, config)
         asset_flags = apply_build_config(client_dir, config)
         if asset_flags[:error]
@@ -361,6 +372,9 @@ module Ruflet
         announce_asset_configuration(asset_flags)
         clear_flutter_build_state(client_dir, verbose: verbose)
         clear_stale_platform_outputs(client_dir, platform, verbose: verbose)
+        unless ensure_flutter_platform_artifacts(client_dir, platform, tools[:env], tools[:flutter], verbose: verbose)
+          return false
+        end
         build_note("Resolving Flutter packages")
         build_log(verbose, "running flutter pub get")
         unless run_external_command(tools[:env], tools[:flutter], "pub", "get", chdir: client_dir, unbundled: true)
@@ -393,6 +407,38 @@ module Ruflet
         true
       end
 
+      def ensure_flutter_platform_artifacts(client_dir, platform, env, flutter, verbose: false)
+        precache_flags = flutter_precache_flags(platform)
+        return true if precache_flags.empty?
+
+        build_note("Preparing Flutter #{platform} platform artifacts")
+        build_log(verbose, "running flutter precache #{precache_flags.join(' ')}")
+        ok = run_external_command(env, flutter, "precache", *precache_flags, chdir: client_dir, unbundled: true)
+        return true if ok
+
+        warn "Flutter platform artifact setup failed for #{platform}"
+        false
+      end
+
+      def flutter_precache_flags(platform)
+        case platform
+        when "apk", "android", "aab", "appbundle"
+          ["--android"]
+        when "ios"
+          ["--ios"]
+        when "macos"
+          ["--macos"]
+        when "windows"
+          ["--windows"]
+        when "linux"
+          ["--linux"]
+        when "web"
+          ["--web"]
+        else
+          []
+        end
+      end
+
       def ensure_native_build_dependencies(client_dir, platform, env, verbose: false)
         case platform
         when "ios"
@@ -430,15 +476,7 @@ module Ruflet
       end
 
       def unbundled_command_env(env)
-        sanitized_env = env.reject { |key, _value| key.start_with?("BUNDLE_") || key == "RUBYOPT" || key == "RUBYLIB" }
-        cleared_env = {}
-        ENV.each_key do |key|
-          next unless key.start_with?("BUNDLE_") || key == "RUBYOPT" || key == "RUBYLIB" || key.start_with?("GEM_")
-
-          cleared_env[key] = nil
-        end
-
-        cleared_env.merge(sanitized_env)
+        env.reject { |key, _value| key.start_with?("BUNDLE_") || key == "RUBYOPT" || key == "RUBYLIB" || key.start_with?("GEM_") }
       end
 
       def run_external_command(env, *cmd, chdir:, unbundled: false)
@@ -654,6 +692,7 @@ module Ruflet
         apply_web_metadata(client_dir, metadata)
         apply_windows_metadata(client_dir, metadata)
         apply_linux_metadata(client_dir, metadata)
+        apply_dart_metadata(client_dir, metadata)
         build_log(
           verbose,
           "app=#{metadata[:display_name]} package=#{metadata[:package_name]} org=#{metadata[:organization]} bundle=#{metadata[:bundle_identifier]}"
@@ -851,6 +890,14 @@ module Ruflet
         replace_in_file(cmake_path, /^set\(APPLICATION_ID ".*"\)$/, %(set(APPLICATION_ID "#{metadata[:linux_application_id]}")))
       end
 
+      def apply_dart_metadata(client_dir, metadata)
+        title = dart_single_quote_escape(metadata[:display_name])
+        client_entrypoint_paths(client_dir).each do |entrypoint|
+          replace_in_file(entrypoint, /title: 'Ruflet'/, "title: '#{title}'")
+          replace_in_file(entrypoint, /AppBar\(title: const Text\('Ruflet'\)\)/, "AppBar(title: const Text('#{title}'))")
+        end
+      end
+
       def replace_plist_value(path, key, value)
         return unless File.file?(path)
 
@@ -866,7 +913,7 @@ module Ruflet
         return unless File.file?(path)
 
         content = File.read(path)
-        updated = content.gsub(pattern, replacement)
+        updated = content.gsub(pattern) { replacement }
         File.write(path, updated) unless updated == content
       end
 
@@ -933,19 +980,27 @@ module Ruflet
         value.to_s.gsub('"', '""')
       end
 
+      def dart_single_quote_escape(value)
+        value.to_s.gsub("\\", "\\\\\\").gsub("'", "\\\\'")
+      end
+
       def key_defined?(hash, key)
         hash.is_a?(Hash) && (hash.key?(key) || hash.key?(key.to_sym))
       end
 
-      def apply_service_extension_config(client_dir, config = {})
+      def apply_service_extension_config(client_dir, config = {}, self_contained: @ruflet_self_contained_build)
         services = Array(config["services"])
         extension_keys = services.map { |v| normalize_extension_key(v) }.compact.uniq
         extension_packages = extension_keys.filter_map { |key| CLIENT_EXTENSION_MAP[key]&.fetch(:package) }.uniq
         extension_aliases = extension_keys.filter_map { |key| CLIENT_EXTENSION_MAP[key]&.fetch(:alias) }.uniq
 
         pubspec_path = File.join(client_dir, "pubspec.yaml")
-        prune_client_pubspec(pubspec_path, extension_packages) if File.file?(pubspec_path)
+        if File.file?(pubspec_path)
+          sync_client_extension_dependencies(pubspec_path, extension_packages)
+          prune_client_pubspec(pubspec_path, extension_packages)
+        end
         client_entrypoint_paths(client_dir).each do |entrypoint|
+          sync_client_main_extensions(entrypoint, extension_aliases) if File.file?(entrypoint)
           prune_client_main(entrypoint, extension_aliases) if File.file?(entrypoint)
         end
       end
@@ -1005,7 +1060,7 @@ module Ruflet
         assets = Array(flutter["assets"]).map(&:to_s)
 
         if self_contained
-          dependencies["ruby_runtime"] = "^0.0.3"
+          dependencies["ruby_runtime"] = ruby_runtime_dependency(dependencies["ruby_runtime"])
           assets.delete("assets/main.rb")
           assets.delete("assets/ruby_project/")
           project_asset_path = "assets/#{self_contained_project_name}/"
@@ -1022,6 +1077,23 @@ module Ruflet
         write_pubspec_yaml(pubspec_path, data)
       end
 
+      def ruby_runtime_dependency(current_dependency = nil)
+        local_path = explicit_local_ruby_runtime_path
+        return { "path" => local_path } if local_path
+
+        current_dependency || "^0.0.3"
+      end
+
+      def explicit_local_ruby_runtime_path
+        env_path = ENV["RUFLET_RUBY_RUNTIME_PATH"].to_s.strip
+        return nil if env_path.empty?
+
+        candidate = Pathname.new(env_path).expand_path
+        return candidate.to_s if candidate.join("pubspec.yaml").file?
+
+        nil
+      end
+
       def refresh_managed_client_template_files(client_dir, verbose: false)
         template_root =
           if Ruflet::CLI.respond_to?(:resolve_ruflet_client_template_root, true)
@@ -1035,7 +1107,10 @@ module Ruflet
           "lib/main.server.dart",
           "lib/connection_probe.dart",
           "lib/connection_probe_io.dart",
-          "lib/connection_probe_stub.dart"
+          "lib/connection_probe_stub.dart",
+          "lib/ruflet_file_picker_service.dart",
+          "macos/Runner/DebugProfile.entitlements",
+          "macos/Runner/Release.entitlements"
         ]
 
         managed_files.each do |relative_path|
@@ -1089,13 +1164,100 @@ module Ruflet
 
           destination = File.join(destination_root, relative_path)
           FileUtils.mkdir_p(File.dirname(destination))
-          FileUtils.cp(source.to_s, destination)
+          copy_project_asset_file(source.to_s, destination, project_root: project_root.to_s)
           copied += 1
         end
 
         build_log(verbose, "copied #{copied} project file#{copied == 1 ? '' : 's'} to assets/#{self_contained_project_name}")
       end
 
+      def copy_project_asset_file(source, destination, project_root: nil)
+        if File.extname(source).downcase == ".rb"
+          ruby_source =
+            if File.basename(source) == "main.rb" && project_root
+              bundled_embedded_ruby_source(source, project_root)
+            else
+              File.read(source)
+            end
+          File.write(destination, normalize_embedded_ruby_source(ruby_source))
+        else
+          FileUtils.cp(source, destination)
+        end
+      end
+
+      def bundled_embedded_ruby_source(source, project_root, visited = {})
+        absolute = File.expand_path(source)
+        return "" if visited[absolute]
+
+        visited[absolute] = true
+        base = File.dirname(absolute)
+        File.read(absolute).lines.map do |line|
+          match = line.match(/^\s*require_relative\s+["']([^"']+)["']\s*$/)
+          next line unless match
+
+          required = File.expand_path(match[1], base)
+          required = "#{required}.rb" unless File.file?(required)
+          next line unless File.file?(required) && required.start_with?(File.expand_path(project_root))
+
+          bundled_embedded_ruby_source(required, project_root, visited)
+        end.join
+      end
+
+      def normalize_embedded_ruby_source(source)
+        source.lines.map do |line|
+          expand_endless_method_line(line)
+        end.join
+      end
+
+      def expand_endless_method_line(line)
+        match = line.match(/^(\s*)def\s+(.+)$/)
+        return line unless match
+
+        indent = match[1]
+        body = match[2].chomp
+        newline = line.end_with?("\n") ? "\n" : ""
+        split = endless_method_split(body)
+        return line unless split
+
+        signature, expression = split
+        "#{indent}def #{signature.rstrip}\n#{indent}  #{expression.lstrip}\n#{indent}end#{newline}"
+      end
+
+      def endless_method_split(body)
+        depth = 0
+        quote = nil
+        escape = false
+
+        body.each_char.with_index do |char, index|
+          if quote
+            escape = char == "\\" && !escape
+            if char == quote && !escape
+              quote = nil
+            elsif char != "\\"
+              escape = false
+            end
+            next
+          end
+
+          case char
+          when "'", '"'
+            quote = char
+          when "(", "[", "{"
+            depth += 1
+          when ")", "]", "}"
+            depth -= 1 if depth.positive?
+          when "="
+            next unless depth.zero? && body[index + 1] == " "
+
+            signature = body[0...index]
+            expression = body[(index + 1)..]
+            return [signature, expression] unless signature.strip.empty? || expression.to_s.strip.empty?
+          end
+        end
+
+        nil
+      end
+
       def remove_self_contained_project_assets(client_dir, verbose: false)
         assets_root = File.join(client_dir, "assets")
         legacy_entrypoint = File.join(client_dir, "assets", "main.rb")
@@ -1226,7 +1388,94 @@ module Ruflet
         end
 
         data["dependencies"] = deps
-        File.write(path, YAML.dump(data))
+        write_pubspec_yaml(path, data)
+      end
+
+      def sync_client_extension_dependencies(path, selected_packages)
+        return if selected_packages.empty?
+
+        template_deps = template_client_pubspec_dependencies
+        return if template_deps.empty?
+
+        data = YAML.safe_load(File.read(path), aliases: true) || {}
+        deps = (data["dependencies"] || {}).dup
+        selected_packages.each do |package_name|
+          deps[package_name] = template_deps[package_name] if template_deps.key?(package_name)
+        end
+
+        data["dependencies"] = deps
+        write_pubspec_yaml(path, data)
+      end
+
+      def template_client_pubspec_dependencies
+        template_root =
+          if Ruflet::CLI.respond_to?(:resolve_ruflet_client_template_root, true)
+            Ruflet::CLI.send(:resolve_ruflet_client_template_root)
+          end
+        return {} unless template_root
+
+        pubspec_path = File.join(template_root, "pubspec.yaml")
+        return {} unless File.file?(pubspec_path)
+
+        data = YAML.safe_load(File.read(pubspec_path), aliases: true) || {}
+        deps = data["dependencies"]
+        deps.is_a?(Hash) ? deps : {}
+      rescue StandardError
+        {}
+      end
+
+      def sync_client_main_extensions(path, selected_aliases)
+        return if selected_aliases.empty?
+
+        template_path = template_client_entrypoint_path(File.basename(path))
+        return unless template_path
+
+        content = File.read(path)
+        template = File.read(template_path)
+
+        selected_aliases.each do |extension_alias|
+          import_line = template.lines.find { |line| line.match?(/\sas #{Regexp.escape(extension_alias)};\s*\z/) }
+          extension_line = template.lines.find { |line| line.match?(/^\s*#{Regexp.escape(extension_alias)}\.Extension\(\),\s*$/) }
+
+          content = insert_missing_import(content, import_line) if import_line && !content.include?(import_line)
+          content = insert_missing_extension(content, extension_line) if extension_line && !content.include?(extension_line)
+        end
+
+        File.write(path, content)
+      end
+
+      def template_client_entrypoint_path(name)
+        template_root =
+          if Ruflet::CLI.respond_to?(:resolve_ruflet_client_template_root, true)
+            Ruflet::CLI.send(:resolve_ruflet_client_template_root)
+          end
+        return nil unless template_root
+
+        path = File.join(template_root, "lib", name)
+        File.file?(path) ? path : nil
+      end
+
+      def insert_missing_import(content, import_line)
+        lines = content.lines
+        last_import_index = lines.rindex { |line| line.start_with?("import ") }
+        if last_import_index
+          lines.insert(last_import_index + 1, import_line)
+        else
+          lines.unshift(import_line)
+        end
+        lines.join
+      end
+
+      def insert_missing_extension(content, extension_line)
+        lines = content.lines
+        marker_index = lines.index { |line| line.include?("// --FAT_CLIENT_START--") }
+        if marker_index
+          lines.insert(marker_index, extension_line)
+        else
+          list_index = lines.index { |line| line.include?("final extensions = <FletExtension>[") }
+          lines.insert(list_index ? list_index + 1 : lines.length, extension_line)
+        end
+        lines.join
       end
 
       def prune_client_main(path, selected_aliases)
@@ -1296,7 +1545,7 @@ module Ruflet
         if in_block && !replaced
           out << "#{block_indent}#{key}: #{value}"
         end
-        File.write(path, out.join("\n"))
+        File.write(path, indent_pubspec_sequences(out.join("\n")))
       end
 
       def flutter_build_command(platform)

data/lib/ruflet/cli/extra_command.rb

@@ -23,7 +23,7 @@ module Ruflet
         if template_root
           puts "  Template: #{template_root}"
         elsif fix
-          template_root = ensure_cached_ruflet_client_template!(verbose: !!verbose)
+          template_root = ensure_cached_ruflet_client_template!(force: true, verbose: !!verbose)
           unless template_root
             warn "  Template: missing"
             warn "Failed to fetch the Ruflet Flutter template from GitHub."
@@ -34,6 +34,7 @@ module Ruflet
           warn "  Template: missing"
           warn "Run `ruflet doctor --fix` to fetch the Flutter template from GitHub."
         end
+        puts "  Ruby runtime: pub.dev package"
         if fix
           tools = ensure_flutter!("doctor", client_dir: client_dir, auto_install: true)
         else
@@ -144,6 +145,15 @@ module Ruflet
 
       private
 
+      def resolve_ruby_runtime_root
+        env_path = ENV["RUFLET_RUBY_RUNTIME_PATH"].to_s.strip
+        candidates = []
+        candidates << File.expand_path(env_path) unless env_path.empty?
+        candidates << File.expand_path("../../../../../ruby_runtime", __dir__)
+        candidates << cached_ruby_runtime_root
+        candidates.find { |path| File.file?(File.join(path, "pubspec.yaml")) }
+      end
+
       def detect_client_dir
         env_dir = ENV["RUFLET_CLIENT_DIR"]
         return env_dir if env_dir && Dir.exist?(env_dir)

data/lib/ruflet/cli/flutter_sdk.rb

@@ -47,13 +47,25 @@ module Ruflet
       private
 
       def flutter_tools(client_dir: nil, auto_install: true)
-        # Always use FVM so Flutter/Dart match pinned SDK.
+        # Prefer FVM when available so Flutter/Dart match a pinned SDK.
         fvm_tools = flutter_tools_via_fvm(client_dir: client_dir, auto_install: auto_install)
         return fvm_tools if fvm_tools
 
+        managed_tools = flutter_tools_via_managed_sdk(client_dir: client_dir, auto_install: auto_install)
+        return managed_tools if managed_tools
+
         nil
       end
 
+      def flutter_tools_via_managed_sdk(client_dir: nil, auto_install: true)
+        return nil unless auto_install
+
+        sdk_root = ensure_flutter_sdk_downloaded(client_dir: client_dir)
+        return nil unless sdk_root
+
+        tools_from_flutter_bin(File.join(sdk_root, "bin", flutter_executable_name))
+      end
+
       def flutter_tools_via_fvm(client_dir: nil, auto_install: true)
         version = desired_flutter_version(client_dir: client_dir)
         return nil if version.to_s.strip.empty?
@@ -226,6 +238,9 @@ module Ruflet
         template_client = File.expand_path("../../../../../templates/ruflet_flutter_template/.metadata", __dir__)
         candidates << repo_client
         candidates << template_client
+        if Ruflet::CLI.respond_to?(:cached_ruflet_client_template_root, true)
+          candidates << File.join(Ruflet::CLI.send(:cached_ruflet_client_template_root), ".metadata")
+        end
         candidates.find { |path| File.file?(path) }
       end
 

data/lib/ruflet/cli/new_command.rb

@@ -7,6 +7,9 @@ require "yaml"
 module Ruflet
   module CLI
     module NewCommand
+      TEMPLATE_REPO_URL = ENV.fetch("RUFLET_TEMPLATE_REPO_URL", "https://github.com/AdamMusa/ruflet-template.git")
+      RUNTIME_REPO_URL = ENV.fetch("RUFLET_RUNTIME_REPO_URL", "https://github.com/AdamMusa/ruflet.git")
+
       CLIENT_EXTENSION_MAP = {
         "ads" => { package: "flet_ads", alias: "ruflet_ads" },
         "audio" => { package: "flet_audio", alias: "ruflet_audio" },
@@ -74,40 +77,69 @@ module Ruflet
       end
 
       def resolve_ruflet_client_template_root
-        repo_template = File.expand_path("../../../../../templates/ruflet_flutter_template", __dir__)
-        return repo_template if Dir.exist?(repo_template)
+        [
+          File.expand_path("../../../../../templates/ruflet_flutter_template", __dir__)
+        ].each do |template|
+          return template if Dir.exist?(template)
+        end
 
         cached_template = cached_ruflet_client_template_root
         return cached_template if Dir.exist?(cached_template)
 
-        fallback = File.expand_path("../../../../../ruflet_client", __dir__)
-        return fallback if Dir.exist?(fallback)
+        [
+          File.expand_path("../../../ruflet_client", __dir__),
+          File.expand_path("../../../../../ruflet_client", __dir__)
+        ].each do |fallback|
+          return fallback if Dir.exist?(fallback)
+        end
 
         nil
       end
 
-      def ensure_cached_ruflet_client_template!(verbose: false)
+      def ensure_cached_ruflet_client_template!(force: false, verbose: false)
         cached_template = cached_ruflet_client_template_root
-        return cached_template if Dir.exist?(cached_template)
+        return cached_template if !force && Dir.exist?(cached_template)
+
+        download_ruflet_template(force: force, verbose: verbose)
+        Dir.exist?(cached_template) ? cached_template : nil
+      end
 
-        download_ruflet_client_template(verbose: verbose)
+      def ensure_cached_ruby_runtime!(force: false, verbose: false)
+        nil
       end
 
       def cached_ruflet_client_template_root
         File.join(template_cache_root, "ruflet_flutter_template")
       end
 
+      def cached_ruby_runtime_root
+        File.join(cache_root, "ruby_runtime")
+      end
+
       def template_cache_root
-        File.join(Dir.home, ".ruflet", "templates")
+        File.join(cache_root, "templates")
+      end
+
+      def cache_root
+        ENV.fetch("RUFLET_CACHE_DIR", File.join(Dir.home, ".ruflet"))
       end
 
-      def download_ruflet_client_template(verbose: false)
+      def download_ruflet_assets(force: false, verbose: false)
+        template_target = cached_ruflet_client_template_root
+        return true if !force && Dir.exist?(template_target)
+
+        Dir.exist?(template_target) || download_ruflet_template(force: force, verbose: verbose)
+      end
+
+      def download_ruflet_template(force: false, verbose: false)
         target = cached_ruflet_client_template_root
+        return target if !force && Dir.exist?(target)
+
         FileUtils.mkdir_p(template_cache_root)
 
-        Dir.mktmpdir("ruflet-template") do |tmp|
+        Dir.mktmpdir("ruflet-assets") do |tmp|
           repo_dir = File.join(tmp, "Ruflet")
-          clone_cmd = ["git", "clone", "--depth", "1", "--filter=blob:none", "--sparse", "https://github.com/AdamMusa/Ruflet.git", repo_dir]
+          clone_cmd = ["git", "clone", "--depth", "1", "--filter=blob:none", "--sparse", TEMPLATE_REPO_URL, repo_dir]
           return nil unless run_template_command(clone_cmd, verbose: verbose)
           return nil unless run_template_command(["git", "-C", repo_dir, "sparse-checkout", "set", "templates/ruflet_flutter_template"], verbose: verbose)
 
@@ -164,7 +196,10 @@ module Ruflet
             backend_url: ""
 
           # Source of truth for Flutter client extensions/plugins.
-          # Examples: camera, video, audio, flashlight, webview, map
+          # To test every extension, list all services:
+          # ads, audio, audio_recorder, camera, charts, code_editor, color_pickers,
+          # datatable2, flashlight, geolocator, lottie, map, permission_handler,
+          # secure_storage, video, webview
           services: []
 
           # Build assets configuration consumed by `ruflet build`.

data/lib/ruflet/cli/run_command.rb

@@ -12,6 +12,7 @@ require "uri"
 require "thread"
 require "io/console"
 require "time"
+require "yaml"
 
 module Ruflet
   module CLI
@@ -285,7 +286,7 @@ module Ruflet
       end
 
       def launch_desktop_client(url)
-        cmd = detect_desktop_client_command(url)
+        cmd = detect_project_desktop_client_command(url) || detect_desktop_client_command(url)
         unless cmd
           warn "Desktop client executable not found."
           warn "Set RUFLET_CLIENT_DIR to your client path."
@@ -306,6 +307,76 @@ module Ruflet
         []
       end
 
+      def detect_project_desktop_client_command(url)
+        return nil unless project_run_requires_managed_client?
+        return nil unless respond_to?(:ensure_flutter_client_dir, true)
+        return nil unless respond_to?(:prepare_flutter_client, true)
+        return nil unless respond_to?(:ensure_flutter!, true)
+
+        platform = host_platform_name
+        return nil unless %w[macos windows linux].include?(platform)
+
+        ensure_ruflet_build_assets(verbose: false) if respond_to?(:ensure_ruflet_build_assets, true)
+        client_dir = ensure_flutter_client_dir(verbose: false)
+        return nil unless client_dir
+
+        config = project_run_config
+        tools = ensure_flutter!("run", client_dir: client_dir)
+        env = build_tool_env(tools[:env], platform, client_dir)
+        return nil unless prepare_flutter_client(
+          client_dir,
+          platform: platform,
+          tools: tools,
+          config: config,
+          self_contained: false,
+          verbose: false
+        )
+
+        [
+          env,
+          tools[:flutter],
+          "run",
+          "-d",
+          platform,
+          "--target",
+          "lib/main.server.dart",
+          "--dart-define",
+          "RUFLET_BACKEND_URL=#{url}"
+        ]
+      rescue StandardError => e
+        warn "Project desktop client setup failed: #{e.class}: #{e.message}"
+        nil
+      end
+
+      def project_run_requires_managed_client?
+        return false unless defined?(Ruflet::CLI::BuildCommand::CLIENT_EXTENSION_MAP)
+
+        services = Array(project_run_config["services"]).map { |value| normalize_run_extension_key(value) }.compact
+        return false if services.empty?
+
+        extension_keys = Ruflet::CLI::BuildCommand::CLIENT_EXTENSION_MAP.keys
+        (services & extension_keys).any?
+      end
+
+      def project_run_config
+        config_path = ENV["RUFLET_CONFIG"] || (File.file?("ruflet.yaml") ? "ruflet.yaml" : "ruflet.yml")
+        return {} unless File.file?(config_path)
+
+        YAML.safe_load(File.read(config_path), aliases: true) || {}
+      rescue StandardError
+        {}
+      end
+
+      def normalize_run_extension_key(value)
+        key = value.to_s.strip.downcase
+        return nil if key.empty?
+
+        key.tr!("-", "_")
+        key.gsub!(/\A(flet_)+/, "")
+        key.gsub!(/\Aservice_/, "")
+        key
+      end
+
       def detect_desktop_client_command(url)
         root = ENV["RUFLET_CLIENT_DIR"]
         root = File.expand_path("ruflet_client", Dir.pwd) if root.to_s.strip.empty?
@@ -315,12 +386,15 @@ module Ruflet
 
         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
+          app_path = [
+            File.join(root, "build", "macos", "Build", "Products", "Release", "ruflet_client.app"),
+            File.join(root, "build", "macos", "Build", "Products", "Debug", "ruflet_client.app"),
+            File.join(root, "desktop", "ruflet_client.app")
+          ].find do |candidate|
+            bin = File.join(candidate, "Contents", "MacOS", "ruflet_client")
+            File.file?(bin) && File.executable?(bin) && ensure_macos_file_picker_entitlement(candidate)
+          end
+          return [File.join(app_path, "Contents", "MacOS", "ruflet_client"), url] if app_path
         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")
@@ -436,7 +510,9 @@ module Ruflet
 
         case platform
         when "macos"
-          File.file?(File.join(root, "desktop", "ruflet_client.app", "Contents", "MacOS", "ruflet_client"))
+          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)
         when "linux"
           File.file?(File.join(root, "desktop", "ruflet_client"))
         when "windows"
@@ -492,6 +568,53 @@ module Ruflet
         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]

data/lib/ruflet/cli/templates.rb

@@ -5,7 +5,7 @@ module Ruflet
     MAIN_TEMPLATE = <<~RUBY
     require "ruflet"
     Ruflet.run do |page|
-      page.title = "Counter Demo"
+      page.title = "%<app_title>s"
       count = 0
       count_text = text(count.to_s, style: {size: 40})
       page.add(
@@ -36,8 +36,9 @@ module Ruflet
     GEMFILE_TEMPLATE = <<~GEMFILE
       source "https://rubygems.org"
 
-      gem "ruflet_core", ">= 0.0.10"
-      gem "ruflet_server", ">= 0.0.10"
+      gem "ruflet", ">= #{Ruflet::VERSION}"
+      gem "ruflet_core", ">= #{Ruflet::VERSION}"
+      gem "ruflet_server", ">= #{Ruflet::VERSION}"
     GEMFILE
 
     README_TEMPLATE = <<~MD

data/lib/ruflet/cli/update_command.rb

@@ -61,6 +61,9 @@ module Ruflet
 
         return check_client_updates(targets, platform: platform) if options[:check]
 
+        ensure_cached_ruflet_assets_for_update(force: options[:force])
+        ensure_flutter!("update", client_dir: nil, auto_install: true) if respond_to?(:ensure_flutter!, true)
+
         targets.each do |target|
           root =
             if target == :web
@@ -83,6 +86,17 @@ module Ruflet
 
       private
 
+      def ensure_cached_ruflet_assets_for_update(force: false)
+        if Ruflet::CLI.respond_to?(:download_ruflet_assets, true)
+          Ruflet::CLI.send(:download_ruflet_assets, force: force)
+          return
+        end
+
+        if Ruflet::CLI.respond_to?(:ensure_cached_ruflet_client_template!, true)
+          Ruflet::CLI.send(:ensure_cached_ruflet_client_template!, force: force)
+        end
+      end
+
       def check_client_updates(targets, platform:)
         root = client_cache_root_for(platform)
         manifest = read_client_manifest(root)

data/lib/ruflet/cli.rb

@@ -2,6 +2,7 @@
 
 require "optparse"
 
+require_relative "version"
 require_relative "cli/templates"
 require_relative "cli/new_command"
 require_relative "cli/flutter_sdk"
@@ -9,7 +10,6 @@ require_relative "cli/run_command"
 require_relative "cli/update_command"
 require_relative "cli/build_command"
 require_relative "cli/extra_command"
-require_relative "version"
 
 module Ruflet
   module CLI
@@ -22,6 +22,7 @@ module Ruflet
 
     def run(argv = ARGV)
       command = (argv.shift || "help").downcase
+      ensure_first_run_assets(command)
 
       case command
       when "version", "-v", "--version"
@@ -84,5 +85,16 @@ module Ruflet
     def version_string
       "ruflet #{Ruflet::VERSION}"
     end
+
+    private
+
+    def ensure_first_run_assets(command)
+      return if %w[version -v --version help -h --help].include?(command)
+      return unless respond_to?(:download_ruflet_assets, true)
+
+      send(:download_ruflet_assets)
+    rescue StandardError
+      nil
+    end
   end
 end

data/lib/ruflet/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.13
 platform: ruby
 authors:
 - AdamMusa