ruflet 0.0.20 → 0.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78de8fe06ee145d7d509f553ec4905750a27610051ce6da3d1de48dc7b79fb64
-  data.tar.gz: 2a6527b6605fb968b7b219503e1049bf8cb0c1cbe3b35ed8c0af5f5ae4237d0a
+  metadata.gz: 4f32ccf43fe430d641b8f1b72f05a048d6c654a8ec6c4e2ac4c02b6752d67e47
+  data.tar.gz: ef7244a5cc788bf2dbfbcf74731e86d4dd1bd61d0a0fc104dffecdfeab444850
 SHA512:
-  metadata.gz: 1573aa2e047b0f7e6497e4f9a94f4a4fd81ee842d6c9e17221b814e4b289c84882302e06049274d64882ae2b8c833507d7cd86b8cfbc95da06028371544dec3d
-  data.tar.gz: 45bc272c824b3a09783e4be9202ce87272ce8f2715bd23e06a6a8db5e3839c3604b70aa629da21a1d98b91daf73beb5e2038b3c68d13cdda3e829b316ad9db23
+  metadata.gz: a6618e3cbab937475c14990529be3e96786f21c62de32ddbc0b5d6ca0fcfb2809c1c70084904948881f575d2ad3b73641f2bca30dac64d0f3402e4f57f1e0846
+  data.tar.gz: 751bf5286756eab0da77e4be3f2abcafcec4b335ea379fb02628f8ca5af7016530d4052c8e595ab385bef5001ea594d31eadfb9f3fd71cada7aa362c8194b97e

data/lib/ruflet/cli/build_command.rb

@@ -73,7 +73,7 @@ module Ruflet
         verbose = args.delete("--verbose") || args.delete("-v")
         platform = (args.shift || "").downcase
         if platform.empty?
-          warn "Usage: ruflet build <apk|android|ios|aab|web|macos|windows|linux> [--self] [--verbose]"
+          warn "Usage: ruflet build <apk|android|aab|ios|ipa|web|macos|windows|linux> [--self] [--verbose]"
           return 1
         end
 
@@ -83,6 +83,11 @@ module Ruflet
           return 1
         end
 
+        # `ipa` produces the uploadable archive; every other step — pods,
+        # signing, icons, package name — is the same as a plain iOS build.
+        requested_platform = platform
+        platform = "ios" if platform == "ipa"
+
         # The embedded Ruby VM is a native plugin with no browser
         # implementation, so a self-contained web build produces an app that
         # cannot start. Say so rather than shipping one that hangs.
@@ -115,7 +120,7 @@ module Ruflet
         return 1 unless ok
 
         build_args = [*flutter_cmd, *args]
-        build_args << "--codesign" if ios_device_build_needs_codesign_flag?(platform, build_args)
+        build_args << "--codesign" if ios_device_build_needs_codesign_flag?(requested_platform, build_args)
         target_entrypoint = flutter_target_entrypoint(client_dir, self_contained: !!self_contained)
         build_args += ["--target", target_entrypoint] if target_entrypoint
         backend_url = configured_backend_url(config)
@@ -437,6 +442,8 @@ module Ruflet
         return false unless validate_mobile_app_identity(metadata, platform: platform)
 
         apply_native_service_permissions(client_dir, config)
+        apply_android_signing_config(client_dir, platform, verbose: !!verbose)
+        apply_ios_signing_team(client_dir, config) if %w[ios ipa macos].include?(platform.to_s)
         configured = configure_client_runtime_mode(client_dir, self_contained: self_contained, verbose: verbose)
         return false if configured == false
         @ruflet_self_contained_build = self_contained
@@ -740,8 +747,11 @@ module Ruflet
         if File.file?(services_path)
           service_config = YAML.safe_load(read_text_file(services_path), aliases: true) || {}
           if service_config["app"].is_a?(Hash)
-            config["app"] = (config["app"].is_a?(Hash) ? config["app"] : {}).merge(service_config["app"])
-            config["_app_identity_source"] = "services.yaml"
+            # ruflet.yaml declares the app; services.yaml may still carry an
+            # identity from older projects, so it fills gaps rather than
+            # overriding what the project states.
+            declared = config["app"].is_a?(Hash) ? config["app"] : {}
+            config["app"] = service_config["app"].merge(declared)
           end
           config["services"] = service_config["services"] if service_config.key?("services")
         end
@@ -1200,10 +1210,10 @@ module Ruflet
           first_present(app["bundle_identifier"], config["bundle_identifier"], "#{organization}.#{package_name}")
         )
         identity_errors = []
-        identity_errors << "app.app_name" if app["app_name"].to_s.strip.empty?
+        named = first_present(app["name"], app["app_name"], app["display_name"])
+        identity_errors << "app.name" if named.nil?
         identity_errors << "app.package_name" if app["package_name"].to_s.strip.empty?
-        identity_errors << "app.organization" if app["organization"].to_s.strip.empty?
-        identity_errors << "services.yaml app section" unless config["_app_identity_source"] == "services.yaml"
+        identity_errors << "app.organization" if first_present(app["organization"], app["org"]).nil?
 
         {
           package_name: package_name,
@@ -1237,8 +1247,8 @@ module Ruflet
         errors = Array(metadata[:mobile_identity_errors])
         return true if errors.empty?
 
-        warn "build config error: services.yaml must define #{errors.join(', ')}"
-        warn "Set app.app_name, app.package_name, and app.organization before building a mobile app."
+        warn "build config error: ruflet.yaml must define #{errors.join(', ')}"
+        warn "A mobile build needs app.name, app.package_name and app.organization."
         false
       end
 
@@ -1271,6 +1281,33 @@ module Ruflet
         )
       end
 
+      # The signing team belongs to whoever ships the app, so it comes from the
+      # project rather than being baked into the client.
+      def apply_ios_signing_team(client_dir, config)
+        team = ios_signing_team(config)
+        pbxproj_path = File.join(client_dir, "ios", "Runner.xcodeproj", "project.pbxproj")
+        return unless File.file?(pbxproj_path)
+
+        if team.to_s.strip.empty?
+          build_note("No ios.team_id configured; Xcode will pick the signing team")
+          replace_in_file(pbxproj_path, /DEVELOPMENT_TEAM = [^;]*;/, "DEVELOPMENT_TEAM = \"\";")
+          return
+        end
+
+        replace_in_file(pbxproj_path, /DEVELOPMENT_TEAM = [^;]*;/, "DEVELOPMENT_TEAM = #{team};")
+        build_note("iOS signing team set to #{team}")
+      end
+
+      def ios_signing_team(config)
+        app = config["app"].is_a?(Hash) ? config["app"] : {}
+        first_present(
+          platform_build_config(config, "ios")["team_id"],
+          app["ios_team_id"],
+          app["team_id"],
+          ENV["RUFLET_IOS_TEAM_ID"]
+        )
+      end
+
       def apply_ios_metadata(client_dir, metadata)
         info_plist_path = File.join(client_dir, "ios", "Runner", "Info.plist")
         replace_plist_value(info_plist_path, "CFBundleDisplayName", metadata[:display_name])
@@ -1508,17 +1545,109 @@ module Ruflet
         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
 
+        external = external_extension_entries(config)
+
         pubspec_path = File.join(client_dir, "pubspec.yaml")
         if File.file?(pubspec_path)
           sync_client_extension_dependencies(pubspec_path, extension_packages)
           prune_client_pubspec(pubspec_path, extension_packages)
+          sync_external_extension_dependencies(pubspec_path, external)
         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)
+          next unless File.file?(entrypoint)
+
+          sync_client_main_extensions(entrypoint, extension_aliases)
+          prune_client_main(entrypoint, extension_aliases)
+          sync_external_extension_registrations(entrypoint, external)
+        end
+      end
+
+      # An extension may name a package the template does not bundle, declared
+      # with the source to fetch it from:
+      #
+      #   extensions:
+      #     - charts
+      #     - my_package:
+      #         git:
+      #           url: https://github.com/owner/my_package
+      #           ref: main
+      #
+      # `branch` is accepted for `ref`, and `path` for a local checkout.
+      def external_extension_entries(config)
+        Array(config["extensions"]).filter_map do |entry|
+          next unless entry.is_a?(Hash)
+          next unless entry.size == 1
+
+          name, source = entry.first
+          package = name.to_s.strip
+          next if package.empty?
+
+          dependency = external_extension_dependency(source)
+          next unless dependency
+
+          { name: package, dependency: dependency }
         end
       end
 
+      def external_extension_dependency(source)
+        return nil unless source.is_a?(Hash)
+
+        normalized = source.each_with_object({}) { |(key, value), out| out[key.to_s] = value }
+        git = normalized["git"] || normalized["github"] || normalized["repository"]
+        git = normalized if git.nil? && normalized.key?("url")
+
+        if git.is_a?(String)
+          return { "git" => git }
+        elsif git.is_a?(Hash)
+          git = git.each_with_object({}) { |(key, value), out| out[key.to_s] = value }
+          url = git["url"].to_s.strip
+          return nil if url.empty?
+
+          spec = { "url" => url }
+          ref = (git["ref"] || git["branch"] || git["tag"]).to_s.strip
+          spec["ref"] = ref unless ref.empty?
+          path = git["path"].to_s.strip
+          spec["path"] = path unless path.empty?
+          return { "git" => spec }
+        end
+
+        local = normalized["path"]
+        return { "path" => local.to_s } if local.is_a?(String) && !local.to_s.strip.empty?
+
+        nil
+      end
+
+      def sync_external_extension_dependencies(pubspec_path, entries)
+        return if entries.empty?
+
+        data = YAML.safe_load(read_text_file(pubspec_path), aliases: true) || {}
+        dependencies = (data["dependencies"] || {}).dup
+        entries.each { |entry| dependencies[entry[:name]] = entry[:dependency] }
+        data["dependencies"] = dependencies
+        write_pubspec_yaml(pubspec_path, data)
+        build_note("Added #{entries.map { |e| e[:name] }.join(', ')} from the extension configuration")
+      end
+
+      # Flet extension packages expose an Extension class from a library named
+      # after the package, so the import and registration can be derived.
+      def sync_external_extension_registrations(path, entries)
+        return if entries.empty?
+
+        content = read_text_file(path)
+        original = content.dup
+
+        entries.each do |entry|
+          name = entry[:name]
+          import_line = %(import 'package:#{name}/#{name}.dart' as #{name};\n)
+          extension_line = "    #{name}.Extension(),\n"
+
+          content = insert_missing_import(content, import_line) unless content.include?("package:#{name}/#{name}.dart")
+          content = insert_missing_extension(content, extension_line) unless content.match?(/^\s*#{Regexp.escape(name)}\.Extension\(\),/)
+        end
+
+        write_text_file(path, content) unless content == original
+      end
+
       def configured_service_entries(config)
         Array(config["services"]).filter_map do |entry|
           case entry
@@ -1536,6 +1665,79 @@ module Ruflet
         end
       end
 
+      ANDROID_SIGNING_KEYS = {
+        "storeFile" => "RUFLET_ANDROID_KEYSTORE",
+        "storePassword" => "RUFLET_ANDROID_KEYSTORE_PASSWORD",
+        "keyAlias" => "RUFLET_ANDROID_KEY_ALIAS",
+        "keyPassword" => "RUFLET_ANDROID_KEY_PASSWORD"
+      }.freeze
+
+      # Release signing is read from the project, never from the managed client,
+      # so nobody has to edit build/client by hand. Either keep an
+      # android/key.properties beside the app, or set the RUFLET_ANDROID_*
+      # variables. Without one of those, Gradle falls back to the debug key.
+      def apply_android_signing_config(client_dir, platform, verbose: false)
+        return unless %w[apk android aab appbundle].include?(platform.to_s)
+
+        android_dir = File.join(client_dir, "android")
+        return unless Dir.exist?(android_dir)
+
+        destination = File.join(android_dir, "key.properties")
+        properties = android_signing_properties
+        if properties.empty?
+          File.delete(destination) if File.file?(destination)
+          build_note("No Android signing configured; the release build will use the debug key")
+          return
+        end
+
+        missing = ANDROID_SIGNING_KEYS.keys - properties.keys
+        unless missing.empty?
+          warn "build config error: Android signing is missing #{missing.join(', ')}"
+          warn "Set them in android/key.properties or the matching RUFLET_ANDROID_* variables."
+          return
+        end
+
+        body = ANDROID_SIGNING_KEYS.keys.map { |key| "#{key}=#{properties.fetch(key)}" }.join("\n")
+        write_text_file(destination, "#{body}\n")
+        build_log(verbose, "wrote #{destination}")
+        build_note("Android release signing configured from #{properties.fetch("_source")}")
+      end
+
+      def android_signing_properties
+        from_env = ANDROID_SIGNING_KEYS.each_with_object({}) do |(key, variable), out|
+          value = ENV[variable].to_s.strip
+          out[key] = value unless value.empty?
+        end
+        unless from_env.empty?
+          from_env["storeFile"] = File.expand_path(from_env["storeFile"]) if from_env["storeFile"]
+          return from_env.merge("_source" => "the RUFLET_ANDROID_* environment")
+        end
+
+        source = project_android_key_properties_path
+        return {} unless source
+
+        parsed = read_text_file(source).each_line.with_object({}) do |line, out|
+          next if line.strip.empty? || line.strip.start_with?("#")
+
+          key, value = line.split("=", 2)
+          out[key.to_s.strip] = value.to_s.strip unless value.nil?
+        end
+        return {} if parsed.empty?
+
+        # storeFile is written relative to the project; the client sits deeper.
+        if parsed["storeFile"] && !Pathname.new(parsed["storeFile"]).absolute?
+          parsed["storeFile"] = File.expand_path(parsed["storeFile"], File.dirname(source))
+        end
+        parsed.merge("_source" => source)
+      end
+
+      def project_android_key_properties_path
+        [
+          File.join(Dir.pwd, "android", "key.properties"),
+          File.join(Dir.pwd, "key.properties")
+        ].find { |path| File.file?(path) }
+      end
+
       def apply_native_service_permissions(client_dir, config)
         entries = configured_service_entries(config)
         configured_extensions = Array(config["extensions"]).filter_map { |entry| normalize_extension_key(entry) }
@@ -1708,7 +1910,10 @@ module Ruflet
           "lib/connection_probe_io.dart",
           "lib/connection_probe_stub.dart",
           "ios/Podfile",
-          "windows/CMakeLists.txt"
+          "windows/CMakeLists.txt",
+          # Release signing lives here; an existing client would otherwise keep
+          # signing release builds with the debug key.
+          "android/app/build.gradle.kts"
         ]
 
         managed_files.each do |relative_path|
@@ -1848,7 +2053,7 @@ module Ruflet
       # app, so signing keys and local environment files must never be copied
       # in even when a project keeps them beside its source.
       SECRET_ASSET_EXTENSIONS = %w[.p8 .p12 .pem .key .jks .keystore .mobileprovision].freeze
-      SECRET_ASSET_BASENAMES = %w[.env .netrc].freeze
+      SECRET_ASSET_BASENAMES = %w[.env .netrc key.properties].freeze
 
       def secret_project_asset?(relative)
         basename = File.basename(relative)
@@ -2145,6 +2350,8 @@ module Ruflet
           ["build", "appbundle"]
         when "ios"
           ["build", "ios"]
+        when "ipa"
+          ["build", "ipa"]
         when "web"
           ["build", "web"]
         when "macos"

data/lib/ruflet/cli/new_command.rb

@@ -205,10 +205,16 @@ module Ruflet
         git_revision(File.expand_path("../..", template_root))
       end
 
+      # Always record where the client came from. A template resolved from a
+      # local checkout may have no readable revision, and skipping the marker
+      # entirely left the copied client indistinguishable from one that was
+      # never stamped. "local" never matches an expected revision, so the client
+      # is refreshed rather than treated as current.
       def write_client_template_revision(target, revision)
-        return unless revision
+        value = revision.to_s.strip
+        value = "local" if value.empty?
 
-        File.write(File.join(target, ".ruflet-template-revision"), "#{revision}\n")
+        File.write(File.join(target, ".ruflet-template-revision"), "#{value}\n")
       end
 
       def client_template_current?(target, template_root)

data/lib/ruflet/cli/run_command.rb

@@ -300,13 +300,12 @@ module Ruflet
         end
       end
 
-      # The backend serves the web client on its own port, so the client loads
-      # and opens its websocket on the same origin. The explicit url parameter
-      # is kept because prebuilt production clients have no default URL and use
-      # it to select the websocket transport.
+      # The backend serves the web client on its own port, so the client reads
+      # the origin it was loaded from and opens its websocket there. No URL is
+      # passed in the query string: nothing in the client parses one.
       def launch_web_client(port)
         backend_url = "http://localhost:#{port}"
-        web_url = "#{backend_url}/?#{URI.encode_www_form(url: backend_url)}"
+        web_url = "#{backend_url}/"
         browser_pid = open_in_browser_app_mode(web_url)
         open_in_browser(web_url) if browser_pid.nil?
         puts "Ruflet web client: #{web_url}"
@@ -603,23 +602,35 @@ module Ruflet
         nil
       end
 
+      # This decides both "the download installed correctly" and "the cache is
+      # still usable, skip the network". It has to agree with what `ruflet run`
+      # will actually accept later, or a half-extracted cache reports success
+      # here and then fails to launch -- and, because a present cache short
+      # circuits the download, never repairs itself without --force.
       def prebuilt_assets_present?(root, web:, desktop:, platform: nil)
-        ok_web = !web || File.file?(File.join(root, "web", "index.html"))
+        ok_web = !web || built_web_client_dir?(File.join(root, "web"))
         ok_desktop = !desktop || prebuilt_desktop_present?(root, platform: platform)
         ok_web && ok_desktop
       end
 
+      # The prebuilt client is whatever `ruflet build` produced from Ruflet
+      # Explorer, so its bundle and binary carry that project's app name --
+      # "Ruflet Explorer.app", not the old "ruflet_client.app". Match on shape
+      # the way detect_desktop_client_command does rather than on a fixed name.
       def prebuilt_desktop_present?(root, platform: nil)
         platform ||= host_platform_name
         return false if platform.nil?
 
+        desktop = File.join(root, "desktop")
+        return false unless Dir.exist?(desktop)
+
         case platform
         when "macos"
-          File.file?(File.join(root, "desktop", "ruflet_client.app", "Contents", "MacOS", "ruflet_client"))
+          Dir.glob(File.join(desktop, "*.app")).any? { |app_bundle| macos_app_executable(app_bundle) }
         when "linux"
-          File.file?(File.join(root, "desktop", "ruflet_client"))
+          Dir.children(desktop).any? { |entry| executable_file?(File.join(desktop, entry)) }
         when "windows"
-          File.file?(File.join(root, "desktop", "ruflet_client.exe"))
+          Dir.glob(File.join(desktop, "*.exe")).any? { |path| File.file?(path) }
         else
           false
         end
@@ -823,7 +834,7 @@ module Ruflet
         return if read_client_manifest(root)
 
         assets = []
-        assets << { "kind" => "web", "platform" => platform, "asset_name" => nil } if File.file?(File.join(root, "web", "index.html"))
+        assets << { "kind" => "web", "platform" => platform, "asset_name" => nil } if built_web_client_dir?(File.join(root, "web"))
         if prebuilt_desktop_present?(root, platform: platform)
           assets << { "kind" => "desktop", "platform" => platform, "asset_name" => nil }
         end

data/lib/ruflet/cli/update_command.rb

@@ -108,12 +108,12 @@ module Ruflet
 
         installed = true
         targets.each do |target|
-          present =
-            if target == :web
-              File.file?(File.join(root, "web", "index.html"))
-            else
-              prebuilt_desktop_present?(root, platform: platform)
-            end
+          present = prebuilt_assets_present?(
+            root,
+            web: target == :web,
+            desktop: target == :desktop,
+            platform: platform
+          )
           installed &&= present
           puts "#{target}: #{present ? 'installed' : 'missing'}"
         end

data/lib/ruflet/version.rb

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

metadata

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