ruflet 0.0.14 → 0.0.16

data/lib/ruflet/cli/build_command.rb

@@ -3,6 +3,7 @@
 require "fileutils"
 require "find"
 require "json"
+require "open3"
 require "pathname"
 require "rbconfig"
 require "uri"
@@ -12,6 +13,8 @@ module Ruflet
   module CLI
     module BuildCommand
       include FlutterSdk
+      include EnvironmentSetup
+      include AndroidSdk
       CLIENT_EXTENSION_MAP = {
         "ads" => { package: "flet_ads", alias: "ruflet_ads" },
         "audio" => { package: "flet_audio", alias: "ruflet_audio" },
@@ -26,13 +29,37 @@ module Ruflet
         "lottie" => { package: "flet_lottie", alias: "ruflet_lottie" },
         "map" => { package: "flet_map", alias: "ruflet_map" },
         "permission_handler" => { package: "flet_permission_handler", alias: "ruflet_permission_handler" },
+        "rive" => { package: "flet_rive", alias: "ruflet_rive" },
         "secure_storage" => { package: "flet_secure_storage", alias: "ruflet_secure_storage" },
+        "spinkit" => { package: "flet_spinkit", alias: "ruflet_spinkit" },
         "video" => { package: "flet_video", alias: "ruflet_video" },
         "webview" => { package: "flet_webview", alias: "ruflet_webview" }
       }.freeze
 
-      SERVICE_NATIVE_REQUIREMENTS = {
-        "audio_recorder" => {
+      SERVICE_EXTENSION_MAP = {
+        "camera" => %w[camera permission_handler],
+        "microphone" => %w[audio_recorder permission_handler],
+        "location" => %w[geolocator permission_handler],
+        "motion" => %w[permission_handler]
+      }.freeze
+
+      DEFAULT_SERVICE_NATIVE_REQUIREMENTS = {
+        "camera" => {
+          android_permissions: ["android.permission.CAMERA"],
+          ios_info: {
+            "NSCameraUsageDescription" => "Camera access is required for camera experiences."
+          },
+          macos_info: {
+            "NSCameraUsageDescription" => "Camera access is required for camera experiences."
+          },
+          macos_entitlements: {
+            "com.apple.security.device.camera" => true
+          },
+          ios_permission_definitions: %w[
+            PERMISSION_CAMERA=1
+          ]
+        },
+        "microphone" => {
           android_permissions: ["android.permission.RECORD_AUDIO"],
           ios_info: {
             "NSMicrophoneUsageDescription" => "Microphone access is required for audio recording."
@@ -42,14 +69,20 @@ module Ruflet
           },
           macos_entitlements: {
             "com.apple.security.device.audio-input" => true
-          }
+          },
+          ios_permission_definitions: %w[
+            PERMISSION_MICROPHONE=1
+          ]
         },
-        "barometer" => {
+        "motion" => {
           ios_info: {
-            "NSMotionUsageDescription" => "Motion access is required for barometer readings."
-          }
+            "NSMotionUsageDescription" => "Motion access is required for motion and sensor readings."
+          },
+          ios_permission_definitions: %w[
+            PERMISSION_SENSORS=1
+          ]
         },
-        "geolocator" => {
+        "location" => {
           android_permissions: [
             "android.permission.ACCESS_FINE_LOCATION",
             "android.permission.ACCESS_COARSE_LOCATION"
@@ -62,11 +95,40 @@ module Ruflet
           },
           macos_entitlements: {
             "com.apple.security.personal-information.location" => true
-          }
+          },
+          ios_permission_definitions: %w[
+            PERMISSION_LOCATION=1
+          ]
         }
       }.freeze
 
       def command_build(args)
+        with_project_build_lock { run_build_command(args) }
+      end
+
+      # Concurrent builds share build/client and corrupt each other's state
+      # (missing app.dill, Xcode build.db I/O errors). flock is released
+      # automatically when the process exits, so the lock cannot go stale.
+      def with_project_build_lock
+        lock_dir = File.join(Dir.pwd, "build")
+        FileUtils.mkdir_p(lock_dir)
+        lock_path = File.join(lock_dir, ".ruflet_build.lock")
+        File.open(lock_path, File::RDWR | File::CREAT, 0o644) do |file|
+          unless file.flock(File::LOCK_EX | File::LOCK_NB)
+            owner = file.read.to_s.strip
+            warn "Another ruflet build is already running for this project#{owner.empty? ? '' : " (#{owner})"}."
+            warn "Concurrent builds share the same build directory and corrupt each other."
+            warn "Wait for it to finish, then retry."
+            return 1
+          end
+          file.truncate(0)
+          file.write("pid=#{Process.pid} started=#{Time.now}")
+          file.flush
+          yield
+        end
+      end
+
+      def run_build_command(args)
         self_contained = args.delete("--self")
         verbose = args.delete("--verbose") || args.delete("-v")
         platform = (args.shift || "").downcase
@@ -110,6 +172,10 @@ module Ruflet
         backend_url = configured_backend_url(config)
         if self_contained
           build_args += ["--dart-define", "RUFLET_BACKEND_URL=#{backend_url}"] if backend_url
+          # Pin the embedded entry project so the runtime doesn't have to guess.
+          # Apps that bundle nested projects (e.g. ruflet_studio's standalone_apps,
+          # each with their own main.rb) otherwise trip auto-discovery.
+          build_args += ["--dart-define", "RUFLET_EMBEDDED_PROJECT=#{self_contained_project_name}"]
         else
           unless backend_url
             warn "build config error: backend_url is required for server-driven builds"
@@ -145,8 +211,16 @@ module Ruflet
         end
 
         tools = ensure_flutter!("install", client_dir: client_dir)
-        command_env = install_tool_env(tools[:env], client_dir)
+        discovery_env = unbundled_command_env(tools[:env])
+        device_id ||= select_install_device(
+          flutter: tools[:flutter],
+          env: discovery_env,
+          client_dir: client_dir
+        )
+        return 1 unless device_id
+
         install_platform = install_platform_for_device(device_id)
+        command_env = install_tool_env(tools[:env], client_dir, platform: install_platform)
         unless sync_built_outputs_for_install(client_dir, platform: install_platform, verbose: !!verbose)
           warn "Could not find built app outputs under ./build"
           warn "Run `ruflet build ...` first, then `ruflet install`."
@@ -184,6 +258,59 @@ module Ruflet
         nil
       end
 
+      def select_install_device(flutter:, env:, client_dir:, input: $stdin, output: $stdout)
+        devices = discover_install_devices(flutter: flutter, env: env, client_dir: client_dir)
+        if devices.empty?
+          warn "No supported devices are connected."
+          warn "Run `ruflet devices` to check device availability."
+          return nil
+        end
+
+        output.puts "Available devices:"
+        devices.each_with_index do |device, index|
+          details = [device["targetPlatform"], device["emulator"] ? "emulator" : "physical"].compact
+          output.puts "  #{index + 1}) #{device.fetch("name", device["id"])} (#{details.join(", ")}) [#{device["id"]}]"
+        end
+
+        loop do
+          output.print "Choose a device [1-#{devices.length}]: "
+          output.flush
+          choice = input.gets
+          unless choice
+            warn "Device selection cancelled. Use `--device DEVICE_ID` for noninteractive installs."
+            return nil
+          end
+
+          index = Integer(choice.strip, exception: false)
+          return devices[index - 1]["id"] if index && index.between?(1, devices.length)
+
+          output.puts "Enter a number from 1 to #{devices.length}."
+        end
+      end
+
+      def discover_install_devices(flutter:, env:, client_dir:)
+        stdout, stderr, status = Open3.capture3(
+          env,
+          flutter,
+          "devices",
+          "--machine",
+          chdir: client_dir
+        )
+        unless status.success?
+          warn "Could not list Flutter devices."
+          warn stderr.strip unless stderr.to_s.strip.empty?
+          return []
+        end
+
+        devices = JSON.parse(stdout)
+        Array(devices).select do |device|
+          device.is_a?(Hash) && !device["id"].to_s.empty? && device["isSupported"] != false
+        end
+      rescue JSON::ParserError => e
+        warn "Could not parse Flutter device list: #{e.message}"
+        []
+      end
+
       def ensure_flutter_client_dir(verbose: false)
         client_dir = detect_flutter_client_dir
         return client_dir if client_dir
@@ -194,6 +321,9 @@ module Ruflet
       end
 
       def build_tool_env(env, platform, client_dir = nil)
+        if %w[android apk aab appbundle].include?(platform)
+          return android_build_env(unbundled_command_env(env))
+        end
         return env unless %w[ios macos].include?(platform)
 
         apple_env = unbundled_command_env(env)
@@ -202,8 +332,9 @@ module Ruflet
         apple_env
       end
 
-      def install_tool_env(env, client_dir)
-        return build_tool_env(env, inferred_install_platform, client_dir) if inferred_install_platform
+      def install_tool_env(env, client_dir, platform: nil)
+        platform ||= inferred_install_platform
+        return build_tool_env(env, platform, client_dir) if platform
 
         command_env = unbundled_command_env(env)
         command_env["PATH"] = apple_build_path(command_env["PATH"])
@@ -511,7 +642,20 @@ module Ruflet
       end
 
       def unbundled_command_env(env)
-        env.reject { |key, _value| key.start_with?("BUNDLE_") || key == "RUBYOPT" || key == "RUBYLIB" || key.start_with?("GEM_") }
+        command_env = env.reject { |key, _value| key.start_with?("BUNDLE_") || key == "RUBYOPT" || key == "RUBYLIB" || key.start_with?("GEM_") }
+        ensure_utf8_locale(command_env)
+      end
+
+      # CocoaPods refuses to run in a non-UTF-8 terminal and Xcode project
+      # files contain UTF-8; guarantee a UTF-8 locale for child tools.
+      def ensure_utf8_locale(env)
+        locale = env["LC_ALL"].to_s
+        locale = env["LANG"].to_s if locale.empty?
+        return env if locale.downcase.include?("utf-8") || locale.downcase.include?("utf8")
+
+        env["LANG"] = "en_US.UTF-8"
+        env["LC_ALL"] = "en_US.UTF-8"
+        env
       end
 
       def run_external_command(env, *cmd, chdir:, unbundled: false)
@@ -923,6 +1067,23 @@ module Ruflet
         cmake_path = File.join(client_dir, "linux", "CMakeLists.txt")
         replace_in_file(cmake_path, /^set\(BINARY_NAME ".*"\)$/, %(set(BINARY_NAME "#{metadata[:package_name]}")))
         replace_in_file(cmake_path, /^set\(APPLICATION_ID ".*"\)$/, %(set(APPLICATION_ID "#{metadata[:linux_application_id]}")))
+
+        # The GTK runner hardcodes the window title (header-bar and fallback
+        # paths). Without this it shows the package name (e.g. "ruflet_client")
+        # instead of the configured app name. Match the call, not the literal,
+        # so re-runs stay idempotent.
+        my_application_path = File.join(client_dir, "linux", "runner", "my_application.cc")
+        title = c_string_escape(metadata[:display_name])
+        replace_in_file(
+          my_application_path,
+          /gtk_header_bar_set_title\(header_bar, "[^"]*"\)/,
+          %(gtk_header_bar_set_title(header_bar, "#{title}"))
+        )
+        replace_in_file(
+          my_application_path,
+          /gtk_window_set_title\(window, "[^"]*"\)/,
+          %(gtk_window_set_title(window, "#{title}"))
+        )
       end
 
       def apply_dart_metadata(client_dir, metadata)
@@ -1015,6 +1176,13 @@ module Ruflet
         value.to_s.gsub('"', '""')
       end
 
+      # Escape a value for embedding inside a C string literal (used for the
+      # GTK runner window title in my_application.cc). Block form avoids
+      # backslash interpretation in the gsub replacement string.
+      def c_string_escape(value)
+        value.to_s.gsub(/[\\"]/) { |ch| "\\#{ch}" }
+      end
+
       def dart_single_quote_escape(value)
         value.to_s.gsub("\\", "\\\\\\").gsub("'", "\\\\'")
       end
@@ -1024,11 +1192,15 @@ module Ruflet
       end
 
       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
+        service_definitions = load_service_definitions(client_dir)
+        service_extension_keys = service_definitions.keys.flat_map { |key| Array(SERVICE_EXTENSION_MAP[key]) }.uniq
+        protected_extension_keys = SERVICE_EXTENSION_MAP.values.flatten.uniq
+        configured_extension_keys = Array(config["extensions"]).map { |value| normalize_extension_key(value) }.compact
+        extension_keys = ((configured_extension_keys - protected_extension_keys) | service_extension_keys).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
 
+        sync_client_flet_packages(client_dir, extension_packages)
         pubspec_path = File.join(client_dir, "pubspec.yaml")
         if File.file?(pubspec_path)
           sync_client_extension_dependencies(pubspec_path, extension_packages)
@@ -1038,14 +1210,19 @@ module Ruflet
           sync_client_main_extensions(entrypoint, extension_aliases) if File.file?(entrypoint)
           prune_client_main(entrypoint, extension_aliases) if File.file?(entrypoint)
         end
-        apply_service_native_requirements(client_dir, extension_keys)
+        apply_service_native_requirements(client_dir, service_definitions.keys, service_definitions)
       end
 
-      def apply_service_native_requirements(client_dir, extension_keys)
-        stale_keys = SERVICE_NATIVE_REQUIREMENTS.keys - extension_keys
-        remove_service_native_requirements(client_dir, stale_keys)
+      def apply_service_native_requirements(client_dir, extension_keys, service_definitions = load_service_definitions(client_dir))
+        service_requirements = service_native_requirements(service_definitions)
+        stale_keys = service_requirements.keys - extension_keys
+        remove_service_native_requirements(client_dir, stale_keys, service_requirements)
 
-        requirements = merge_service_native_requirements(extension_keys)
+        requirements = merge_service_native_requirements(extension_keys, service_requirements)
+        sync_ios_permission_definitions(
+          File.join(client_dir, "ios", "Podfile"),
+          Array(requirements[:ios_permission_definitions])
+        )
         return if requirements.empty?
 
         android_manifest = File.join(client_dir, "android", "app", "src", "main", "AndroidManifest.xml")
@@ -1071,8 +1248,8 @@ module Ruflet
         end
       end
 
-      def remove_service_native_requirements(client_dir, extension_keys)
-        requirements = merge_service_native_requirements(extension_keys)
+      def remove_service_native_requirements(client_dir, extension_keys, service_requirements = service_native_requirements(load_service_definitions(client_dir)))
+        requirements = merge_service_native_requirements(extension_keys, service_requirements)
         return if requirements.empty?
 
         android_manifest = File.join(client_dir, "android", "app", "src", "main", "AndroidManifest.xml")
@@ -1094,13 +1271,15 @@ module Ruflet
         end
       end
 
-      def merge_service_native_requirements(extension_keys)
+      def merge_service_native_requirements(extension_keys, service_requirements = DEFAULT_SERVICE_NATIVE_REQUIREMENTS)
         extension_keys.each_with_object({}) do |key, memo|
-          requirements = SERVICE_NATIVE_REQUIREMENTS[key]
+          requirements = service_requirements[key]
           next unless requirements
 
           memo[:android_permissions] ||= []
           memo[:android_permissions] |= Array(requirements[:android_permissions])
+          memo[:ios_permission_definitions] ||= []
+          memo[:ios_permission_definitions] |= Array(requirements[:ios_permission_definitions])
           %i[ios_info macos_info macos_entitlements].each do |section|
             memo[section] ||= {}
             memo[section].merge!(requirements[section] || {})
@@ -1108,6 +1287,72 @@ module Ruflet
         end
       end
 
+      def load_service_definitions(client_dir = nil)
+        path = services_config_path(client_dir)
+        return {} unless path
+
+        data = YAML.safe_load(File.read(path), aliases: true) || {}
+        Array(data["services"]).each_with_object({}) do |entry, memo|
+          name, metadata =
+            if entry.is_a?(Hash)
+              entry.first
+            else
+              [entry, {}]
+            end
+          key = normalize_extension_key(name)
+          memo[key] = metadata.is_a?(Hash) ? metadata : {} if key
+        end
+      rescue Psych::Exception => e
+        warn "Could not parse #{path}: #{e.message}"
+        {}
+      end
+
+      def services_config_path(client_dir = nil)
+        candidates = [ENV["RUFLET_SERVICES"], File.expand_path("services.yaml", Dir.pwd)]
+        candidates << File.join(client_dir, "services.yaml") if client_dir
+        candidates.compact.find { |path| File.file?(path) }
+      end
+
+      def service_native_requirements(service_definitions)
+        all_keys = (DEFAULT_SERVICE_NATIVE_REQUIREMENTS.keys | service_definitions.keys)
+        all_keys.each_with_object({}) do |key, memo|
+          defaults = DEFAULT_SERVICE_NATIVE_REQUIREMENTS[key] || {}
+          metadata = service_definitions[key] || {}
+          native = metadata["native"].is_a?(Hash) ? metadata["native"] : metadata
+          memo[key] = {
+            android_permissions: Array(native["android_permissions"] || defaults[:android_permissions]),
+            ios_permission_definitions: Array(native["ios_permission_definitions"] || defaults[:ios_permission_definitions]),
+            ios_info: native["ios_info"].is_a?(Hash) ? native["ios_info"] : (defaults[:ios_info] || {}),
+            macos_info: native["macos_info"].is_a?(Hash) ? native["macos_info"] : (defaults[:macos_info] || {}),
+            macos_entitlements: native["macos_entitlements"].is_a?(Hash) ? native["macos_entitlements"] : (defaults[:macos_entitlements] || {})
+          }
+        end
+      end
+
+      def sync_ios_permission_definitions(path, definitions)
+        return unless File.file?(path)
+
+        content = File.read(path)
+        marker_pattern = %r{\n?\s*# BEGIN RUFLET PERMISSION DEFINITIONS.*?# END RUFLET PERMISSION DEFINITIONS\n?}m
+        updated = content.gsub(marker_pattern, "\n")
+        definitions = Array(definitions).map(&:to_s).reject(&:empty?).uniq.sort
+        if definitions.any?
+          block = <<~RUBY.chomp
+                # BEGIN RUFLET PERMISSION DEFINITIONS
+                target.build_configurations.each do |config|
+                  config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= ['$(inherited)']
+                  config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] += #{definitions.inspect}
+                end
+                # END RUFLET PERMISSION DEFINITIONS
+          RUBY
+          updated = updated.sub(
+            /^(\s*)flutter_additional_ios_build_settings\(target\)\s*$/,
+            "\\0\n\n#{block}"
+          )
+        end
+        File.write(path, updated) unless updated == content
+      end
+
       def ensure_android_permission(path, permission)
         return unless File.file?(path)
 
@@ -1142,8 +1387,23 @@ module Ruflet
         return if content.include?("<key>#{key}</key>")
 
         entry = "\t<key>#{key}</key>\n\t#{value_xml}\n"
-        updated = content.sub(%r{</dict>}, "#{entry}</dict>")
-        File.write(path, updated == content ? "#{content}\n#{entry}" : updated)
+
+        # Insert into the ROOT <dict> (opened right after <plist ...>), never the
+        # first nested </dict>. Modern Flutter Info.plists nest a dict inside
+        # UIApplicationSceneManifest, so subbing the first </dict> would bury
+        # top-level keys (e.g. NS*UsageDescription) where iOS can't read them —
+        # which crashes the app the moment a permission is requested.
+        root_open = content.match(%r{<plist\b[^>]*>\s*<dict>}m)
+        updated =
+          if root_open
+            insert_at = root_open.end(0)
+            content[0...insert_at] + "\n#{entry}" + content[insert_at..]
+          elsif (last = content.rindex("</dict>"))
+            content[0...last] + entry + content[last..]
+          else
+            "#{content}\n#{entry}"
+          end
+        File.write(path, updated)
       end
 
       def remove_plist_entry(path, key)
@@ -1207,18 +1467,20 @@ module Ruflet
         flutter = data["flutter"]
         flutter = data["flutter"] = {} unless flutter.is_a?(Hash)
         assets = Array(flutter["assets"]).map(&:to_s)
+        project_asset_prefix = "assets/#{self_contained_project_name}/"
+        assets.reject! { |asset| asset.start_with?(project_asset_prefix) }
 
         if self_contained
           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}/"
-          assets << project_asset_path unless assets.include?(project_asset_path)
+          project_asset_relative_paths.each do |relative_path|
+            assets << "#{project_asset_prefix}#{relative_path}"
+          end
         else
           dependencies.delete("ruby_runtime")
           assets.delete("assets/main.rb")
           assets.delete("assets/ruby_project/")
-          assets.delete("assets/#{self_contained_project_name}/")
         end
 
         flutter["assets"] = assets unless assets.empty?
@@ -1226,11 +1488,46 @@ module Ruflet
         write_pubspec_yaml(pubspec_path, data)
       end
 
+      RUBY_RUNTIME_FALLBACK_REQUIREMENT = "^0.0.6"
+
       def ruby_runtime_dependency(current_dependency = nil)
-        local_path = explicit_local_ruby_runtime_path
+        local_path = explicit_local_ruby_runtime_path || repo_checkout_ruby_runtime_path
         return { "path" => local_path } if local_path
 
-        current_dependency || "^0.0.3"
+        template_dependency = template_client_pubspec_dependencies["ruby_runtime"]
+        return template_dependency if usable_ruby_runtime_dependency?(template_dependency)
+
+        return current_dependency if usable_ruby_runtime_dependency?(current_dependency)
+
+        RUBY_RUNTIME_FALLBACK_REQUIREMENT
+      end
+
+      # In a ruflet repo checkout the plugin lives next to templates/; build
+      # against it so framework changes are exercised without publishing.
+      def repo_checkout_ruby_runtime_path
+        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
+
+        candidate = File.expand_path(File.join(template_root, "..", "..", "ruby_runtime"))
+        File.file?(File.join(candidate, "pubspec.yaml")) ? candidate : nil
+      end
+
+      # Relative path dependencies only resolve from the directory the
+      # template was authored in — never copy them into a user's client.
+      def usable_ruby_runtime_dependency?(dependency)
+        case dependency
+        when nil then false
+        when Hash
+          path = dependency["path"] || dependency[:path]
+          return true if path.nil? # hosted/git table form
+
+          Pathname.new(path.to_s).absolute? && File.file?(File.join(path, "pubspec.yaml"))
+        else
+          !dependency.to_s.strip.empty?
+        end
       end
 
       def explicit_local_ruby_runtime_path
@@ -1271,6 +1568,27 @@ module Ruflet
           FileUtils.cp(source, destination)
           build_log(verbose, "refreshed template file #{relative_path}")
         end
+
+        repair_legacy_self_contained_bootstrap(client_dir, verbose: verbose)
+      end
+
+      def repair_legacy_self_contained_bootstrap(client_dir, verbose: false)
+        path = File.join(client_dir, "lib", "main.self.dart")
+        return unless File.file?(path)
+
+        content = File.read(path)
+        updated = content.gsub(
+          /^\s*await RubyRuntime\.eval\("ENV\['RUFLET_DEBUG'\].*?\n/,
+          ""
+        )
+        updated = updated.gsub(
+          /^\s*final digestLength = await RubyRuntime\.eval\(\n.*?^\s*\);\n\s*debugPrint\('Embedded Digest::SHA1 bytesize: \$digestLength'\);\n/m,
+          ""
+        )
+        return if updated == content
+
+        File.write(path, updated)
+        build_log(verbose, "removed legacy pre-server RubyRuntime.eval diagnostics")
       end
 
       def write_pubspec_yaml(path, data)
@@ -1540,6 +1858,50 @@ module Ruflet
         write_pubspec_yaml(path, data)
       end
 
+      def sync_client_flet_packages(client_dir, selected_packages)
+        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
+
+        source_root = File.join(template_root, "flet_packages")
+        target_root = File.join(client_dir, "flet_packages")
+        return unless Dir.exist?(source_root)
+        return if File.expand_path(source_root) == File.expand_path(target_root)
+
+        # The repository's standalone client intentionally carries the full
+        # local package catalog. Only generated/template-derived clients are
+        # conditioned for a particular Ruflet application.
+        return if standalone_ruflet_client_source?(client_dir, template_root)
+
+        known_packages = CLIENT_EXTENSION_MAP.values.map { |meta| meta.fetch(:package) }.uniq
+        required_packages = (["flet"] + selected_packages).uniq
+
+        FileUtils.mkdir_p(target_root)
+        required_packages.each do |package_name|
+          source = File.join(source_root, package_name)
+          target = File.join(target_root, package_name)
+          next unless Dir.exist?(source)
+          next if Dir.exist?(target)
+
+          FileUtils.cp_r(source, target)
+        end
+
+        (known_packages - selected_packages).each do |package_name|
+          FileUtils.rm_rf(File.join(target_root, package_name))
+        end
+      end
+
+      def standalone_ruflet_client_source?(client_dir, template_root)
+        client_root = File.expand_path(client_dir)
+        candidates = [
+          File.expand_path("../../ruflet_client", template_root),
+          File.expand_path("../../../../../ruflet_client", __dir__)
+        ]
+        candidates.any? { |candidate| File.expand_path(candidate) == client_root }
+      end
+
       def sync_client_extension_dependencies(path, selected_packages)
         return if selected_packages.empty?
 
@@ -1548,14 +1910,30 @@ module Ruflet
 
         data = YAML.safe_load(File.read(path), aliases: true) || {}
         deps = (data["dependencies"] || {}).dup
+        if selected_packages.include?("flet_rive")
+          deps.delete("rive")
+          deps.delete("rive_native")
+        end
         selected_packages.each do |package_name|
           deps[package_name] = template_deps[package_name] if template_deps.key?(package_name)
         end
 
         data["dependencies"] = deps
+        sync_local_flet_dependency_override(data, deps["flet"])
         write_pubspec_yaml(path, data)
       end
 
+      # Git-backed Flet extensions declare their own Flet source. When Ruflet
+      # vendors the core engine locally, force every extension to resolve that
+      # same copy instead of letting Pub reject the mixed sources.
+      def sync_local_flet_dependency_override(data, flet_dependency)
+        return unless flet_dependency.is_a?(Hash) && key_defined?(flet_dependency, "path")
+
+        overrides = data["dependency_overrides"]
+        overrides = data["dependency_overrides"] = {} unless overrides.is_a?(Hash)
+        overrides["flet"] = flet_dependency
+      end
+
       def template_client_pubspec_dependencies
         template_root =
           if Ruflet::CLI.respond_to?(:resolve_ruflet_client_template_root, true)