RubyGems - ruby_everywhere - Versions diffs - 0.1.15 → 0.2.0 - Mend

ruby_everywhere 0.1.15 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (59) hide show

checksums.yaml +4 -4
data/bridge/README.md +57 -2
data/bridge/everywhere/bridge.js +803 -9
data/bridge/package.json +1 -1
data/lib/everywhere/builders/ios.rb +364 -0
data/lib/everywhere/cli.rb +2 -0
data/lib/everywhere/commands/build.rb +17 -1
data/lib/everywhere/commands/clean.rb +19 -10
data/lib/everywhere/commands/dev.rb +182 -19
data/lib/everywhere/commands/doctor.rb +45 -3
data/lib/everywhere/commands/icon.rb +14 -0
data/lib/everywhere/commands/install.rb +37 -6
data/lib/everywhere/commands/logs.rb +56 -0
data/lib/everywhere/commands/platform/build.rb +3 -3
data/lib/everywhere/commands/platform/runner.rb +1 -1
data/lib/everywhere/commands/release.rb +1 -1
data/lib/everywhere/commands/shell_dir.rb +11 -4
data/lib/everywhere/config.rb +366 -1
data/lib/everywhere/engine.rb +33 -1
data/lib/everywhere/icon.rb +50 -0
data/lib/everywhere/log_filter.rb +28 -2
data/lib/everywhere/mobile_config_endpoint.rb +75 -0
data/lib/everywhere/mobile_configs_controller.rb +46 -0
data/lib/everywhere/native_helper.rb +156 -0
data/lib/everywhere/paths.rb +41 -0
data/lib/everywhere/raster.rb +17 -0
data/lib/everywhere/shellout.rb +3 -1
data/lib/everywhere/simulator.rb +74 -0
data/lib/everywhere/ui.rb +18 -0
data/lib/everywhere/version.rb +1 -1
data/support/mobile/ios/App/App.xcconfig +6 -0
data/support/mobile/ios/App/AppDelegate.swift +163 -0
data/support/mobile/ios/App/Assets.xcassets/AccentColor.colorset/Contents.json +20 -0
data/support/mobile/ios/App/Assets.xcassets/AppIcon.appiconset/AppIcon.png +0 -0
data/support/mobile/ios/App/Assets.xcassets/AppIcon.appiconset/Contents.json +14 -0
data/support/mobile/ios/App/Assets.xcassets/Contents.json +6 -0
data/support/mobile/ios/App/Assets.xcassets/LaunchBackground.colorset/Contents.json +38 -0
data/support/mobile/ios/App/Base.lproj/LaunchScreen.storyboard +32 -0
data/support/mobile/ios/App/Bridge/BiometricsComponent.swift +276 -0
data/support/mobile/ios/App/Bridge/HapticsComponent.swift +47 -0
data/support/mobile/ios/App/Bridge/NotificationComponent.swift +56 -0
data/support/mobile/ios/App/Bridge/PermissionsComponent.swift +142 -0
data/support/mobile/ios/App/Bridge/StorageComponent.swift +63 -0
data/support/mobile/ios/App/ErrorViewController.swift +64 -0
data/support/mobile/ios/App/EverywhereConfig.swift +268 -0
data/support/mobile/ios/App/EverywhereHost.swift +34 -0
data/support/mobile/ios/App/Extensions/EverywhereExtensions.swift +32 -0
data/support/mobile/ios/App/Info.plist +28 -0
data/support/mobile/ios/App/Resources/everywhere.json +8 -0
data/support/mobile/ios/App/Resources/path-configuration.json +19 -0
data/support/mobile/ios/App/SceneDelegate.swift +443 -0
data/support/mobile/ios/App.xcodeproj/project.pbxproj +454 -0
data/support/mobile/ios/App.xcodeproj/project.xcworkspace/contents.xcworkspacedata +7 -0
data/support/mobile/ios/App.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved +14 -0
data/support/mobile/ios/App.xcodeproj/xcshareddata/xcschemes/App.xcscheme +77 -0
data/support/mobile/ios/NativeExtensions/Package.swift +26 -0
data/support/mobile/ios/NativeExtensions/Sources/NativeExtensions/Exports.swift +5 -0
data/support/mobile/ios/README.md +66 -0
metadata +35 -1

data/lib/everywhere/config.rb CHANGED Viewed

@@ -3,6 +3,62 @@
 require "yaml"
 module Everywhere
+  class << self
+    # Register a per-request filter for the mobile tab bar. The block receives
+    # the resolved tab list (`[{ "title" =>, "path" =>, "icon" => }, …]`) and
+    # the current request, and returns the subset to show — return `[]` to hide
+    # the tab bar entirely (the shell falls back to single-screen navigation).
+    #
+    # It runs inside the mobile config endpoint, which shares the app's session
+    # and cookies, so it can branch on auth or any request state:
+    #
+    #   # config/initializers/everywhere.rb
+    #   Everywhere.filter_tabs do |tabs, request|
+    #     request.session[:user_id] ? tabs : []
+    #   end
+    #
+    # Live like the rest of the config: the shell re-reads it on launch and on
+    # every foreground, so a sign-in shows the tabs on next foreground — no
+    # rebuild, no app-store release.
+    def filter_tabs(&block)
+      @tabs_filter = block
+    end
+    # Apply the registered filter (identity when none is set). Always returns
+    # an Array so a stray nil/scalar from a block can't break serialization.
+    def resolve_tabs(tabs, request)
+      return tabs unless @tabs_filter
+      Array(@tabs_filter.call(tabs, request))
+    end
+    # The tiny page served at /everywhere/reset. Auth flows redirect the native
+    # app here so it resets cleanly (fresh web views, re-fetched tabs) before
+    # continuing — the standard Hotwire Native "reset the app" pattern. It talks
+    # to the shell's control channel directly (no bridge/importmap dependency);
+    # in a plain browser it just forwards to the target. `to` is constrained to
+    # a same-origin path.
+    def mobile_reset_html(to)
+      require "json"
+      target = to.to_s
+      target = "/" unless target.start_with?("/") && !target.start_with?("//")
+      encoded = target.to_json
+      <<~HTML
+        <!DOCTYPE html><html><head><meta charset="utf-8"><title>One moment…</title>
+        <meta name="viewport" content="width=device-width,initial-scale=1"></head>
+        <body><script>
+        (function(){var to=#{encoded};
+        var ch=window.webkit&&window.webkit.messageHandlers&&window.webkit.messageHandlers.everywhereControl;
+        if(ch){ch.postMessage({action:"reset",to:to});}else{window.location.replace(to);}})();
+        </script></body></html>
+      HTML
+    end
+    # Test/reset hook.
+    attr_writer :tabs_filter
+  end
   # Loads config/everywhere.yml:
   #
   #   app:
@@ -109,6 +165,16 @@ module Everywhere
       @data.dig("remote", "url")&.chomp("/")
     end
+    # Multi-instance apps (`remote.instances: true`): the mobile shell boots
+    # into remote.url — a hosted instance-picker page — and lets that page
+    # re-root the app onto a chosen instance via Everywhere.instance.set,
+    # persisted across launches until Everywhere.instance.clear. Opt-in
+    # because it lets page JS repoint the whole app: apps that aren't
+    # multi-instance shouldn't carry that surface.
+    def remote_instances?
+      @data.dig("remote", "instances") == true
+    end
     # The `updates:` section — self-hosted auto-updates. Two halves:
     # a client half (url/channel/public_key/auto/interval) that ships to the
     # shell, and a publish-side `s3:` half that NEVER leaves the dev machine.
@@ -153,6 +219,301 @@ module Everywhere
       normalize_color(appearance["background_color"])
     end
+    # Mobile tab bar, platform-neutral. Icons are per-platform (ios = SF
+    # Symbol, android = Material icon later), with a shared `icon:` fallback:
+    #
+    #   tabs:
+    #     - name: Builds
+    #       path: /builds
+    #       icons:
+    #         ios: hammer
+    #         android: build
+    #
+    # Tabs ship two ways from the same source: baked into the app's bundled
+    # path-configuration.json at build time (offline/first-launch), and served
+    # live from /everywhere/<platform>_v1.json (MobileConfigEndpoint) so tab
+    # changes deploy with the web app — no app-store release.
+    def tabs
+      entries = @data["tabs"]
+      return [] unless entries.is_a?(Array)
+      entries.filter_map do |tab|
+        next unless tab.is_a?(Hash) && tab["name"] && tab["path"]
+        path = tab["path"].start_with?("/") ? tab["path"] : "/#{tab["path"]}"
+        { "name" => tab["name"], "path" => path,
+          "icon" => tab["icon"], "icons" => (tab["icons"] if tab["icons"].is_a?(Hash)) }.compact
+      end
+    end
+    # Tabs with the icon resolved for one platform: icons.<os>, then the
+    # shared icon, then a safe default.
+    def tabs_for(os)
+      tabs.map do |tab|
+        { "title" => tab["name"], "path" => tab["path"],
+          "icon" => tab.dig("icons", os.to_s) || tab["icon"] || DEFAULT_TAB_ICONS[os.to_s] }.compact
+      end
+    end
+    DEFAULT_TAB_ICONS = { "ios" => "circle", "android" => "circle" }.freeze
+    # The Hotwire Native path-configuration rules every RubyEverywhere mobile
+    # shell starts from. Single source of truth: the builder bakes this into
+    # the app bundle and MobileConfigEndpoint serves it live.
+    MOBILE_PATH_RULES = [
+      { "patterns" => [".*"],
+        "properties" => { "context" => "default", "pull_to_refresh_enabled" => true } },
+      { "patterns" => ["/new$", "/edit$"],
+        "properties" => { "context" => "modal", "pull_to_refresh_enabled" => false } }
+    ].freeze
+    # Native permissions the app declares (top-level `permissions:`). Only
+    # declared permissions can be requested at runtime — the shell answers
+    # `undeclared` for everything else, so an app that doesn't need a
+    # permission can never prompt for it. For camera and location the value is
+    # the user-facing usage string iOS shows in the permission prompt (the
+    # "why"); it's mandatory there because requesting without one crashes the
+    # app. Notifications need no string — declare with `true`.
+    #
+    #   permissions:
+    #     notifications: true
+    #     camera: "Scan QR codes to pair devices."
+    #     location:
+    #       ios: "Find build agents near you."
+    #     biometrics: "Unlock your account with Face ID."
+    #
+    # Returns { name => { "ios" => usage-or-nil, ... } }.
+    MOBILE_PERMISSIONS = %w[notifications camera location biometrics].freeze
+    # Info.plist usage-description keys per permission. Presence here makes
+    # the usage string mandatory on iOS.
+    IOS_USAGE_KEYS = {
+      "camera" => "NSCameraUsageDescription",
+      "location" => "NSLocationWhenInUseUsageDescription",
+      "biometrics" => "NSFaceIDUsageDescription"
+    }.freeze
+    def permissions
+      entries = @data["permissions"]
+      return {} unless entries.is_a?(Hash)
+      entries.each_with_object({}) do |(name, value), acc|
+        next if value.nil? || value == false
+        acc[name.to_s] =
+          case value
+          when String then { "ios" => value }
+          when Hash then value.transform_keys(&:to_s).transform_values(&:to_s)
+          else {}
+          end
+      end
+    end
+    # Problems with the permissions declaration for one platform, as
+    # human-readable strings — unknown names, and camera/location missing the
+    # mandatory usage string. Empty means buildable.
+    def permission_errors(os)
+      permissions.flat_map do |name, usage|
+        unless MOBILE_PERMISSIONS.include?(name)
+          next ["unknown permission #{name.inspect} — supported: #{MOBILE_PERMISSIONS.join(", ")}"]
+        end
+        if os == "ios" && IOS_USAGE_KEYS.key?(name) && usage["ios"].to_s.strip.empty?
+          next ["#{name} needs a usage string — the sentence iOS shows when asking. " \
+                "In config/everywhere.yml:\n  permissions:\n    #{name}: \"Why the app needs #{name}.\""]
+        end
+        []
+      end
+    end
+    # App-declared Hotwire Native path-configuration rules (everywhere.yml
+    # top-level `rules:`), appended after MOBILE_PATH_RULES — later rules win
+    # per property, so apps can make routes modal, disable pull-to-refresh,
+    # or set any other Hotwire path property without touching native code:
+    #
+    #   rules:
+    #     - patterns: ["/preferences$"]
+    #       properties:
+    #         context: default        # not a modal, unlike other /edit routes
+    #     - patterns: ["/live/"]
+    #       properties:
+    #         pull_to_refresh_enabled: false
+    def mobile_rules
+      entries = @data["rules"]
+      return [] unless entries.is_a?(Array)
+      entries.filter_map do |rule|
+        next unless rule.is_a?(Hash) && rule["patterns"].is_a?(Array) && rule["properties"].is_a?(Hash)
+        { "patterns" => rule["patterns"].map(&:to_s), "properties" => rule["properties"] }
+      end
+    end
+    # The full path-configuration document for one mobile platform — rules plus
+    # our settings (tabs live in settings, per Hotwire Native convention).
+    # Pass `tabs:` to override the resolved list (the mobile config endpoint
+    # passes a per-request-filtered list; build-time stamping omits it and
+    # bakes them all).
+    def path_configuration_hash(os, tabs: nil)
+      settings = {}
+      platform_tabs = tabs || tabs_for(os)
+      settings["tabs"] = platform_tabs unless platform_tabs.empty?
+      { "settings" => settings, "rules" => MOBILE_PATH_RULES + mobile_rules }
+    end
+    def path_configuration_json(os, tabs: nil)
+      require "json"
+      JSON.generate(path_configuration_hash(os, tabs: tabs))
+    end
+    # Native code extensions ("supernative"): Swift the app repo carries in
+    # native/ios/ that `every build` compiles into the shell, plus this
+    # declaration of what to hook up. Build-time only — stores forbid
+    # downloading native code, so extensions ship with the app binary.
+    #
+    #   native:
+    #     ios:
+    #       components: [ChartComponent]   # BridgeComponent subclasses to register
+    #       screens:                       # path rules with view_controller: <id>
+    #         map: MapScreen               #   SwiftUI View or UIViewController, init(url:)
+    #       splash: LaunchSplash           # SwiftUI View or UIViewController, init()
+    #       splash_min_seconds: 1.0        # how long the custom splash stays up at minimum
+    #       lazy_load_tabs: true           # defer each tab's first visit until it's selected
+    def native_ios
+      section = @data.dig("native", "ios")
+      section.is_a?(Hash) ? section : {}
+    end
+    def native_ios_components = Array(native_ios["components"]).map(&:to_s)
+    def native_ios_screens
+      entries = native_ios["screens"]
+      return {} unless entries.is_a?(Hash)
+      entries.to_h { |id, type| [id.to_s, type.to_s] }
+    end
+    def native_ios_splash = native_ios["splash"]&.to_s
+    # Minimum seconds a custom splash stays on screen (default 1.0 shell-side;
+    # a fast server would otherwise dismiss a branded splash in a ~50ms flash).
+    # Clamped to the shell's 8s give-up timeout.
+    def native_ios_splash_min_seconds
+      value = native_ios["splash_min_seconds"]
+      value.to_f.clamp(0.0, 8.0) if value.is_a?(Numeric)
+    end
+    # Whether the native tab bar defers each non-selected tab's initial visit
+    # until the tab is first selected (Hotwire Native `lazyLoadTabs`). Tri-state
+    # so apps can opt in or opt out explicitly: `true` lazy-loads, `false` loads
+    # every tab up front, and an absent key leaves the shell on its default
+    # (eager).
+    def native_ios_lazy_load_tabs
+      value = native_ios["lazy_load_tabs"]
+      value if value == true || value == false
+    end
+    # Third-party Swift packages this app pins for its native/ios code. Each
+    # entry is one SPM dependency; `every build` writes them into the shell's
+    # local NativeExtensions package and re-exports every product, so native/ios
+    # code reaches them with a single `import NativeExtensions`.
+    #
+    #   packages:
+    #     - url: https://github.com/simibac/ConfettiSwiftUI
+    #       from: "1.1.0"                 # or exact: / branch: / revision:
+    #       products: [ConfettiSwiftUI]   # optional; defaults to the repo name
+    #
+    # Returns normalized entries: { "url", "requirement" => { "kind", "value" },
+    # "products" => [...] }. Assumes the config validated clean (see
+    # native_ios_package_errors) — the requirement is always present here.
+    PACKAGE_REQUIREMENT_KEYS = %w[from exact branch revision].freeze
+    def native_ios_packages
+      Array(native_ios["packages"]).filter_map do |entry|
+        next unless entry.is_a?(Hash)
+        url = entry["url"].to_s.strip
+        kind = PACKAGE_REQUIREMENT_KEYS.find { |k| entry.key?(k) && !entry[k].to_s.strip.empty? }
+        products = Array(entry["products"]).map { |p| p.to_s.strip }.reject(&:empty?)
+        products = [package_identity(url)] if products.empty?
+        { "url" => url,
+          "requirement" => (kind && { "kind" => kind, "value" => entry[kind].to_s.strip }),
+          "products" => products }
+      end
+    end
+    def native_ios_packages? = !native_ios_packages.empty?
+    # SPM's package identity: the URL's last path segment without a .git suffix
+    # (github.com/simibac/ConfettiSwiftUI → "ConfettiSwiftUI"). Used as the
+    # default product name and as the `package:` key in .product(name:package:).
+    def package_identity(url) = File.basename(url.to_s.sub(%r{/+\z}, "")).sub(/\.git\z/, "")
+    def native_ios? = !(native_ios_components.empty? && native_ios_screens.empty? && native_ios_splash.nil?)
+    # Everything declared here is interpolated into generated Swift, so names
+    # are validated hard: type names must be plain Swift identifiers, screen
+    # identifiers must be safe inside a Swift string literal.
+    SWIFT_TYPE_NAME = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+    SCREEN_IDENTIFIER = /\A[A-Za-z0-9_-]+\z/
+    def native_ios_errors
+      types = native_ios_components + native_ios_screens.values + [native_ios_splash].compact
+      errors = types.reject { |t| t.match?(SWIFT_TYPE_NAME) }.map do |t|
+        "native.ios: #{t.inspect} is not a Swift type name (letters, digits, _)"
+      end
+      errors += native_ios_screens.keys.reject { |id| id.match?(SCREEN_IDENTIFIER) }.map do |id|
+        "native.ios.screens: identifier #{id.inspect} must match #{SCREEN_IDENTIFIER.inspect}"
+      end
+      raw = native_ios["splash_min_seconds"]
+      errors << "native.ios.splash_min_seconds must be a number (seconds)" if raw && !raw.is_a?(Numeric)
+      errors + native_ios_package_errors
+    end
+    # A URL SPM accepts (https for the common case, git@ for SSH remotes) and a
+    # loose semver for from:/exact: — enough to catch typos without reimplementing
+    # SPM's resolver, which reports anything subtler at build time.
+    PACKAGE_URL = %r{\A(https?://|git@).+}
+    PACKAGE_VERSION = /\A\d+(\.\d+){0,2}(-[0-9A-Za-z.-]+)?\z/
+    def native_ios_package_errors
+      raw = native_ios["packages"]
+      return [] if raw.nil?
+      return ["native.ios.packages must be a list"] unless raw.is_a?(Array)
+      raw.each_with_index.flat_map do |entry, i|
+        at = "native.ios.packages[#{i}]"
+        next ["#{at} must be a mapping with a url:"] unless entry.is_a?(Hash)
+        errors = []
+        url = entry["url"].to_s.strip
+        if url.empty?
+          errors << "#{at}.url is required"
+        elsif !url.match?(PACKAGE_URL)
+          errors << "#{at}.url #{url.inspect} must be an https:// or git@ URL"
+        end
+        present = PACKAGE_REQUIREMENT_KEYS.select { |k| entry.key?(k) && !entry[k].to_s.strip.empty? }
+        if present.empty?
+          errors << "#{at} needs one version requirement (#{PACKAGE_REQUIREMENT_KEYS.join(" / ")})"
+        elsif present.length > 1
+          errors << "#{at} sets conflicting requirements (#{present.join(", ")}) — pick one"
+        elsif %w[from exact].include?(present.first) && !entry[present.first].to_s.strip.match?(PACKAGE_VERSION)
+          errors << "#{at}.#{present.first} #{entry[present.first].to_s.inspect} must be a version like \"1.2.0\""
+        end
+        Array(entry["products"]).each do |product|
+          next if product.to_s.match?(SWIFT_TYPE_NAME)
+          errors << "#{at}.products: #{product.to_s.inspect} is not a module name (letters, digits, _)"
+        end
+        errors
+      end
+    end
     # Custom native menu items (macOS app menu). Each entry: label + path
     # (+ optional accelerator), or "separator". Clicks arrive in the page as
     # "everywhere:menu" events and navigate via Turbo.
@@ -204,12 +565,16 @@ module Everywhere
         "version" => version(target: target),
         "mode" => mode,
         "remote_url" => remote_url,
+        "remote_instances" => (true if remote_instances?),
         "entry_path" => entry_path,
         "tint_color" => tint_color,
         "background_color" => background_color,
         "menu" => (menu unless menu.empty?),
         "tray" => (tray unless tray.empty?),
-        "updates" => updates_shell_hash
+        "lazy_load_tabs" => native_ios_lazy_load_tabs,
+        "splash_min_seconds" => native_ios_splash_min_seconds,
+        "updates" => updates_shell_hash,
+        "permissions" => (permissions.keys unless permissions.empty?)
       }.compact
     end

data/lib/everywhere/engine.rb CHANGED Viewed

@@ -15,7 +15,19 @@ module Everywhere
     initializer "everywhere.assets" do |app|
       if app.config.respond_to?(:assets)
         app.config.assets.paths << Engine.root.join("bridge").to_s
-        app.config.assets.precompile += %w[everywhere/bridge.js] if app.config.assets.respond_to?(:precompile)
+        if app.config.assets.respond_to?(:precompile)
+          app.config.assets.precompile += %w[everywhere/bridge.js everywhere/native.css]
+        end
+      end
+    end
+    # Make native_app? / native_platform / native_version available in every
+    # view (and controllers, via helper_method-style access through helpers).
+    initializer "everywhere.helpers" do
+      require_relative "native_helper"
+      ActiveSupport.on_load(:action_controller) do
+        include Everywhere::NativeHelper # controllers: native_app?, everywhere_auth_redirect
+        helper Everywhere::NativeHelper  # views: native_app?, native_platform, native_version
       end
     end
@@ -26,5 +38,25 @@ module Everywhere
         app.config.importmap.paths << Engine.root.join("config/importmap.rb")
       end
     end
+    # /everywhere/ios_v1.json — the mobile shells' remote path configuration
+    # (rules + settings.tabs), generated from config/everywhere.yml at request
+    # time so tab changes ship with a normal deploy. A real controller (not
+    # middleware — that's the Sinatra/Hanami strategy, MobileConfigEndpoint):
+    # it logs, instruments, and lists in `rails routes`. Appended routes have
+    # the lowest priority, so an app can draw its own to override.
+    initializer "everywhere.mobile_config" do |app|
+      app.routes.append do
+        # Required here — routes are drawn after the framework is fully
+        # booted, so the controller class loads with everything available.
+        require_relative "mobile_configs_controller"
+        get "/everywhere/reset", to: Everywhere::MobileConfigsController.action(:reset),
+                                 as: :everywhere_reset
+        get "/everywhere/:platform_v1", to: Everywhere::MobileConfigsController.action(:show),
+                                        constraints: { platform_v1: /(?:ios|android)_v1/ },
+                                        defaults: { format: "json" },
+                                        as: :everywhere_mobile_config
+      end
+    end
   end
 end

data/lib/everywhere/icon.rb CHANGED Viewed

@@ -37,6 +37,25 @@ module Everywhere
     ICO_SIZES   = [16, 32, 48, 64, 128, 256].freeze
     LINUX_SIZES = [16, 32, 48, 64, 128, 256, 512].freeze
+    # Modern (Xcode 14+) single-size asset catalog entry: one 1024px universal
+    # image, iOS derives every size itself.
+    IOS_APPICON_CONTENTS = <<~JSON
+      {
+        "images" : [
+          {
+            "filename" : "AppIcon.png",
+            "idiom" : "universal",
+            "platform" : "ios",
+            "size" : "1024x1024"
+          }
+        ],
+        "info" : {
+          "author" : "xcode",
+          "version" : 1
+        }
+      }
+    JSON
     module_function
     # Write a macOS-shaped 1024px RGBA master PNG (padding + squircle) from a
@@ -69,6 +88,30 @@ module Everywhere
       true
     end
+    # Write an iOS AppIcon.appiconset (Contents.json + one 1024px PNG) from a
+    # full-bleed source PNG. Unlike macOS, iOS masks the icon itself, so the
+    # artwork ships as a plain square — no inset, no squircle. The App Store
+    # rejects alpha channels, so the source is flattened onto `background`
+    # ([r, g, b] bytes, default white). Returns true, false if unreadable.
+    def write_ios_appiconset(source, dest_dir, background: nil)
+      raster = Raster.decode_png(source) or return false
+      # Fit the artwork inside the canvas preserving aspect ratio (square
+      # sources fill it exactly), then flatten onto the opaque backdrop.
+      fit = [CANVAS.to_f / raster.width, CANVAS.to_f / raster.height].min
+      sw = (raster.width * fit).round.clamp(1, CANVAS)
+      sh = (raster.height * fit).round.clamp(1, CANVAS)
+      canvas = Raster.transparent(CANVAS, CANVAS)
+      canvas.paste!(raster.resample(sw, sh), (CANVAS - sw) / 2, (CANVAS - sh) / 2)
+      out = canvas.flatten_onto(Array(background || [255, 255, 255])[0, 3])
+      FileUtils.mkdir_p(dest_dir)
+      out.write_png(File.join(dest_dir, "AppIcon.png"))
+      File.write(File.join(dest_dir, "Contents.json"), IOS_APPICON_CONTENTS)
+      true
+    end
     # Build a macOS .icns from an already-shaped master PNG (ideally 1024px).
     # Returns true on success.
     def write_icns(master_png, dest)
@@ -117,6 +160,13 @@ module Everywhere
       end
     end
+    # "#RRGGBB" (or "RRGGBBAA" — alpha ignored) -> [r, g, b] bytes, nil if
+    # unparseable. For resolving appearance colors into flatten backdrops.
+    def hex_rgb(hex)
+      m = hex.to_s.strip.match(/\A#?(\h{2})(\h{2})(\h{2})/) or return nil
+      m.captures.map { |c| c.to_i(16) }
+    end
     # PNG bytes of `master` at `size`x`size` (no-op resample when already sized).
     def sized_png(master, size)
       (size == master.width && size == master.height ? master : master.resample(size, size)).encode_png

data/lib/everywhere/log_filter.rb CHANGED Viewed

@@ -27,8 +27,9 @@ module Everywhere
       return :drop if line.empty?
       case @profile
-      when :notarize then notarize(line)
-      when :tebako   then tebako(line)
+      when :notarize   then notarize(line)
+      when :tebako     then tebako(line)
+      when :xcodebuild then xcodebuild(line)
       end
     end
@@ -127,6 +128,31 @@ module Everywhere
       end
     end
+    # --- xcodebuild (iOS shell) ----------------------------------------------
+    #
+    # xcodebuild echoes every compiler invocation and file path. Keep phases,
+    # errors and warnings; collapse the per-file spew into dim background.
+    def xcodebuild(line)
+      short = UI.short_path(line)
+      case line
+      when /(error|fatal error):/i, /\A\*\* BUILD FAILED \*\*/
+        "    #{UI.red(short)}"
+      when /warning:/i
+        "    #{UI.yellow(short)}"
+      when /\A\*\* BUILD SUCCEEDED \*\*/
+        UI.note_line("build succeeded", marker: "✓", color: :green)
+      when /\AResolve Package Graph/, /\AResolved source packages/
+        once(:spm) { UI.note_line("resolving Swift packages") }
+      when /\A(CompileSwift|SwiftCompile|CompileC|Ld|CodeSign|CopySwiftLibs|ProcessInfoPlistFile|CompileAssetCatalog|Touch|RegisterExecutionPolicyException|CreateBuildDirectory|SwiftDriver|SwiftEmitModule|ExtractAppIntentsMetadata|GenerateAssetSymbols|ProcessProductPackaging|Validate|MkDir|WriteAuxiliaryFile|Copy|PhaseScriptExecution|ClangStatCache|ScanDependencies|Planning|GatherProvisioningInputs|ComputePackagePrebuildTargetDependencies)\b/
+        phase = Regexp.last_match(1)
+        once("phase-#{phase}") { UI.note_line(phase.gsub(/(?<=[a-z])(?=[A-Z])/, " ").downcase) }
+      when /\Anote:/, /\A\s{4,}/, /\A(cd|export) /, /^$/
+        :drop
+      else
+        "    #{UI.gray(short)}"
+      end
+    end
     # Show a line only the first time its key is seen; :drop the repeats. Keeps a
     # long notarization from scrolling a wall of identical "waiting" lines (and
     # notarytool's thrice-echoed submission id from showing three times).

data/lib/everywhere/mobile_config_endpoint.rb ADDED Viewed

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require_relative "config"
+module Everywhere
+  # Rack middleware serving the mobile shells' remote path configuration:
+  #
+  #   GET /everywhere/ios_v1.json      (android_v1.json when that shell lands)
+  #
+  # The JSON is built from config/everywhere.yml on each request (it's a tiny
+  # file, and re-reading means tab changes deploy with the app — the whole
+  # point: no app-store release to change tabs). This middleware is the
+  # SINATRA/HANAMI strategy — add it to config.ru:
+  #
+  #   use Everywhere::MobileConfigEndpoint
+  #
+  # Rails apps don't need it: Everywhere::Engine appends a real route to
+  # MobileConfigsController instead (logging, instrumentation, overridable).
+  #
+  # The native shells load it as a Hotwire Native path-configuration source
+  # (after their bundled copy), so both rules and settings.tabs can be
+  # overridden server-side.
+  class MobileConfigEndpoint
+    PATH = %r{\A/everywhere/(ios|android)_v1\.json\z}
+    RESET = "/everywhere/reset"
+    def initialize(app, root: Dir.pwd)
+      @app = app
+      @root = root
+    end
+    def call(env)
+      return @app.call(env) unless env["REQUEST_METHOD"] == "GET"
+      if env["PATH_INFO"] == RESET
+        require "rack/utils"
+        to = Rack::Utils.parse_query(env["QUERY_STRING"])["to"]
+        return html(Everywhere.mobile_reset_html(to))
+      end
+      match = PATH.match(env["PATH_INFO"]) or return @app.call(env)
+      os = match[1]
+      config = Config.load(@root)
+      tabs = Everywhere.resolve_tabs(config.tabs_for(os), request_for(env))
+      json(config.path_configuration_json(os, tabs: tabs))
+    end
+    private
+    def json(body)
+      [200, { "content-type" => "application/json", "cache-control" => cache_control }, [body]]
+    end
+    def html(body)
+      [200, { "content-type" => "text/html; charset=utf-8", "cache-control" => "no-store" }, [body]]
+    end
+    # A Rack::Request the tab filter can read (session/cookies) when the host
+    # app has it; otherwise the raw env is enough for header-based checks.
+    def request_for(env)
+      require "rack/request"
+      Rack::Request.new(env)
+    rescue LoadError
+      env
+    end
+    # Never cache: the response depends on the session (filter_tabs), so a
+    # public cache could leak one user's tabs to another and a client cache
+    # would serve stale tabs across sign-in/out. It's a couple of ms anyway.
+    def cache_control
+      "no-store"
+    end
+  end
+end

data/lib/everywhere/mobile_configs_controller.rb ADDED Viewed

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require_relative "config"
+module Everywhere
+  # Serves the mobile shells' remote path configuration in Rails apps:
+  #
+  #   GET /everywhere/ios_v1.json      -> MobileConfigsController#show
+  #
+  # The route is appended by Everywhere::Engine, so it shows up in
+  # `rails routes` and the app can override it by drawing its own. Inherits
+  # ActionController::API on purpose:
+  #   * never the app's ApplicationController — its before_actions
+  #     (authentication!) would lock the shells out, and
+  #   * not ActionController::Base — its `helper :all` resolution reaches
+  #     into the host app's helpers, which aren't loadable when the gem is
+  #     required during boot. A JSON endpoint needs none of that.
+  #
+  # everywhere.yml is re-read on every request: tab changes go live with a
+  # deploy — or a plain file save in development, where responses are
+  # explicitly uncached so the dev shell's reload polling sees them instantly.
+  class MobileConfigsController < ActionController::API
+    def show
+      config = Config.load(::Rails.root.to_s)
+      # Never cache: the response depends on the session (filter_tabs can hide
+      # tabs when signed out), so a shared/public cache could serve one user's
+      # tabs to another, and a client cache would serve stale tabs across
+      # sign-in/out. The endpoint is a couple of milliseconds — no cache needed.
+      response.headers["cache-control"] = "no-store"
+      os = params[:platform_v1].delete_suffix("_v1")
+      tabs = Everywhere.resolve_tabs(config.tabs_for(os), request)
+      render json: config.path_configuration_hash(os, tabs: tabs)
+    end
+    # GET /everywhere/reset?to=/path — the native "reset the app" page. Auth
+    # flows redirect the shell here so it rebuilds cleanly before landing on
+    # `to`. Never cached (it must run every time).
+    def reset
+      response.headers["cache-control"] = "no-store"
+      render html: Everywhere.mobile_reset_html(params[:to]).html_safe,
+             layout: false, content_type: "text/html"
+    end
+  end
+end