ruby_everywhere 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bbeb5f84c4ec19197b0943357aab3392040876afe678f504f717acb22201d18
-  data.tar.gz: c48f81139c0aac8763b0c4fd9d04ace837e9131676a151d8d05fe964219ef79e
+  metadata.gz: 19d066bb2584933621929b270c69e6205804d07441a6e4a8bfcc052cc6483e55
+  data.tar.gz: c337dfa569b91412f4cb03027006d3199c9f224ebe63e5c5a066396986729194
 SHA512:
-  metadata.gz: 4d144af27b9eaaa9ea2c11c847b41956021ea92d94929d12764f80d1b06dbfa2b43d9fbc43b18e0697c782866a1f46b9a5c5229ed8287ce086aab4c86832d83a
-  data.tar.gz: ff6f45ab57847acd8897cf0548e3d6b076289f67524863067f1f581a48af5131b34c6da0a4ac82bcdde269c60aa9d809e93f15710395eeae49b61bc46d6fea67
+  metadata.gz: b0865c4cc65cfdc86706332f2d00c704fcd361ffe72ed6bbc51100297640634d246a3537b2f4ed38318fbacacbbd490ff422e4b6449905d06918ce7663dbc2f5
+  data.tar.gz: 119672c4cf55ea3ea05e768c3eba161ee2aa6b81b6f5f68046c6327bc99f2dcd9897658d7320e0a0d7a58cbc64d8ac457a2522d6cd71434f1df8ef974367a783

data/lib/everywhere/cli.rb

@@ -5,6 +5,7 @@ require_relative "../everywhere"
 require_relative "framework"
 require_relative "commands/build"
 require_relative "commands/dev"
+require_relative "commands/icon"
 require_relative "commands/doctor"
 require_relative "commands/install"
 require_relative "commands/release"
@@ -33,6 +34,7 @@ module Everywhere
     register "install", Commands::Install
     register "dev",     Commands::Dev
     register "build",   Commands::Build
+    register "icon",    Commands::Icon
     register "release", Commands::Release
 
     register "platform login",       Commands::PlatformLogin

data/lib/everywhere/commands/build.rb

@@ -6,6 +6,7 @@ require "tmpdir"
 require "shellwords"
 require_relative "../shellout"
 require_relative "../png"
+require_relative "../icon"
 require_relative "../paths"
 
 module Everywhere
@@ -28,20 +29,23 @@ module Everywhere
       option :ruby,       default: "4.0.6",          desc: "Ruby version to package"
       option :entry,      default: "native_boot.rb", desc: "Entry point script relative to root"
       option :app_name,   default: nil,              desc: "Bundle name (default: capitalized app dir)"
+      option :target,     default: "macos-arm64",    desc: "Build target (os-arch) — selects any platforms: overrides"
       option :shell_dir,  default: nil,              desc: "Path to the shell's src-tauri directory"
       option :skip_press, type: :boolean, default: false, desc: "Reuse the existing pressed binary, only rebuild the .app"
 
       def call(root: ".", output: nil, ruby: "4.0.6", entry: "native_boot.rb",
-               app_name: nil, shell_dir: nil, skip_press: false, **)
+               app_name: nil, target: "macos-arm64", shell_dir: nil, skip_press: false, **)
         root_path = File.expand_path(root)
         config = Everywhere::Config.load(root_path)
-        app_name ||= config.name
+        # The os of `target` selects any per-platform overrides (bundle id,
+        # version, name) — local builds always target the host, macOS today.
+        app_name ||= config.name(target: target)
 
         # Remote mode: thin shell around an already-deployed app. No Rails app
         # required locally, nothing to press — just shell + config in a bundle.
         if config.remote?
           UI.step("#{UI.bold("remote")} mode → #{UI.cyan(config.remote_url)} #{UI.dim("(no local server packaged)")}")
-          app_dir = bundle_app(nil, app_name, shell_dir, config, dist_dir: File.expand_path("dist", root_path))
+          app_dir = bundle_app(nil, app_name, shell_dir, config, target: target, dist_dir: File.expand_path("dist", root_path))
           return
         end
 
@@ -63,7 +67,7 @@ module Everywhere
           press!(framework, entry, ruby, output_path)
         end
 
-        bundle_app(output_path, app_name, shell_dir, config) if RUBY_PLATFORM.include?("darwin")
+        bundle_app(output_path, app_name, shell_dir, config, target: target) if RUBY_PLATFORM.include?("darwin")
 
         UI.success("built #{output} (#{(File.size(output_path) / 1024.0 / 1024.0).round}MB)")
       end
@@ -111,7 +115,7 @@ module Everywhere
       # Assemble dist/<App Name>.app: the release shell binary + the pressed
       # Rails binary (as "app-server") + Info.plist + icon. An .app bundle is
       # just a directory layout, so we build it by hand — no tauri-cli needed.
-      def bundle_app(server_binary, app_name, shell_dir, config, dist_dir: nil)
+      def bundle_app(server_binary, app_name, shell_dir, config, target: "macos-arm64", dist_dir: nil)
         shell_dir ||= Everywhere::Paths.shell_dir!
         dist_dir ||= File.dirname(server_binary)
 
@@ -122,15 +126,40 @@ module Everywhere
         end
         UI.step("app icon: #{icon_source ? icon_source.sub("#{config.root}/", "") : "placeholder"}")
 
+        # macOS renders icons literally — no OS-applied rounding or margins — so
+        # a full-bleed square looks wrong next to native apps. Bake the Big Sur
+        # look (inset + squircle) into a shaped 1024px master and use it for
+        # both the compiled Dock icon and the bundle .icns. work/ is torn down
+        # when the .app is assembled.
+        work = Dir.mktmpdir("everywhere-icon")
+        macos_icon = icon_source
+        if icon_source
+          shaped = File.join(work, "AppIcon-macos.png")
+          if Everywhere::Icon.macos_master(icon_source, shaped)
+            macos_icon = shaped
+          else
+            UI.warn "couldn't read #{File.basename(icon_source)} (unusual PNG flavor) — using it unshaped"
+          end
+        end
+
         # Tauri bakes icons/icon.png into the shell binary and sets it as the
         # Dock icon at runtime (stomping the bundle's icns after launch), so the
-        # shell must be COMPILED with the app's icon. Swap it in for the build,
-        # restore the placeholder after; touch build.rs so tauri-build re-embeds.
+        # shell must be COMPILED with the app's icon. Swap in the shaped master
+        # for the build, restore the placeholder after; touch build.rs so
+        # tauri-build re-embeds.
         shell_icon = File.join(shell_dir, "icons", "icon.png")
         placeholder_backup = "#{shell_icon}.placeholder"
         if icon_source
           FileUtils.cp(shell_icon, placeholder_backup) unless File.exist?(placeholder_backup)
-          unless Everywhere::PNG.ensure_rgba(icon_source, shell_icon)
+          # The shaped master is already RGBA; fall back to raw RGBA conversion
+          # if shaping failed, and to the placeholder if even that fails.
+          dock_ok = if macos_icon == icon_source
+                      Everywhere::PNG.ensure_rgba(icon_source, shell_icon)
+                    else
+                      FileUtils.cp(macos_icon, shell_icon)
+                      true
+                    end
+          unless dock_ok
             UI.warn "couldn't convert #{File.basename(icon_source)} to RGBA (unusual PNG flavor) — Dock icon will use the placeholder after launch"
             FileUtils.cp(placeholder_backup, shell_icon)
           end
@@ -162,7 +191,7 @@ module Everywhere
         FileUtils.cp(shell_bin, File.join(macos, exe_name))
         FileUtils.cp(server_binary, File.join(macos, "app-server")) if server_binary
 
-        File.write(File.join(resources, "everywhere.json"), config.to_shell_json)
+        File.write(File.join(resources, "everywhere.json"), config.to_shell_json(target: target))
         if (splash = config.splash)
           if File.exist?(splash)
             FileUtils.cp(splash, File.join(resources, "splash.html"))
@@ -171,9 +200,9 @@ module Everywhere
             UI.warn "splash #{splash} not found — using the default splash"
           end
         end
-        icns = make_icns(icon_source || File.join(shell_dir, "icons", "icon.png"), resources)
+        icns = make_icns(macos_icon || File.join(shell_dir, "icons", "icon.png"), resources)
         File.write(File.join(app_dir, "Contents", "Info.plist"),
-                   info_plist(app_name, exe_name, icns, config.bundle_id, config.version))
+                   info_plist(app_name, exe_name, icns, config.bundle_id(target: target), config.version(target: target)))
 
         UI.step("signing #{File.basename(app_dir)}")
         Shellout.run!({}, "codesign", "-s", "-", "-f", File.join(macos, "app-server")) if server_binary
@@ -185,24 +214,19 @@ module Everywhere
         Shellout.run?("/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -f #{app_dir.shellescape} 2>/dev/null")
 
         UI.success("app bundle: #{app_dir.sub("#{Dir.pwd}/", "")} #{UI.dim("(open it!)")}")
+      ensure
+        FileUtils.remove_entry(work) if work && File.directory?(work)
       end
 
-      # macOS ships everything needed to make an .icns from a png.
+      # Write Resources/AppIcon.icns from a (shaped) PNG. Pure Ruby — no sips or
+      # iconutil — so it produces the same icns on any build host.
       def make_icns(png, resources_dir)
         return nil unless File.exist?(png)
 
-        require "shellwords"
-        Dir.mktmpdir do |tmp|
-          iconset = File.join(tmp, "App.iconset")
-          FileUtils.mkdir_p(iconset)
-          [16, 32, 128, 256, 512].each do |size|
-            [[size, "icon_#{size}x#{size}.png"], [size * 2, "icon_#{size}x#{size}@2x.png"]].each do |px, name|
-              Shellout.run?("sips -z #{px} #{px} #{png.shellescape} --out #{File.join(iconset, name).shellescape} >/dev/null 2>&1")
-            end
-          end
-          out = File.join(resources_dir, "AppIcon.icns")
-          return "AppIcon" if Shellout.run?("iconutil -c icns #{iconset.shellescape} -o #{out.shellescape} >/dev/null 2>&1")
-        end
+        out = File.join(resources_dir, "AppIcon.icns")
+        Everywhere::Icon.write_icns(png, out) ? "AppIcon" : nil
+      rescue StandardError => e
+        UI.warn "icon generation failed (#{e.message}) — bundling without a custom icon"
         nil
       end
 

data/lib/everywhere/commands/icon.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "fileutils"
+require_relative "../icon"
+require_relative "../config"
+require_relative "../ui"
+
+module Everywhere
+  module Commands
+    # Generate platform-native app icons from a single source PNG — the same
+    # pipeline `every build` uses, exposed on its own for previewing and CI.
+    class Icon < Dry::CLI::Command
+      desc "Generate macOS (.icns), Windows (.ico) and Linux icons from a source PNG"
+
+      argument :source, required: false, desc: "Source PNG (default: app.icon / icon.png from everywhere.yml)"
+      option :root,   default: ".",     desc: "App root directory (to resolve the default icon)"
+      option :output, default: nil,     desc: "Output directory (default: dist/icons)"
+
+      def call(source: nil, root: ".", output: nil, **)
+        root_path = File.expand_path(root)
+        source ||= default_source(root_path)
+        UI.die!("no source PNG — pass one or set app.icon in everywhere.yml") unless source
+        UI.die!("source PNG not found: #{source}") unless File.exist?(source)
+
+        out = File.expand_path(output || File.join(root_path, "dist", "icons"))
+        FileUtils.mkdir_p(out)
+        UI.step("generating icons from #{File.basename(source)} → #{out.sub("#{Dir.pwd}/", "")}")
+
+        master = File.join(out, "AppIcon-macos.png")
+        unless Everywhere::Icon.macos_master(source, master)
+          UI.die!("couldn't read #{File.basename(source)} — expected an 8-bit RGB/RGBA PNG")
+        end
+        UI.ok("macOS master  #{rel(master, out)} #{UI.dim("(inset + squircle, 1024px)")}")
+
+        Everywhere::Icon.write_icns(master, File.join(out, "AppIcon.icns"))
+        UI.ok("macOS icon    AppIcon.icns")
+
+        Everywhere::Icon.write_ico(source, File.join(out, "icon.ico"))
+        UI.ok("Windows icon  icon.ico")
+
+        pngs = Everywhere::Icon.write_png_set(source, File.join(out, "linux"))
+        UI.ok("Linux icons   linux/ #{UI.dim("(#{pngs.size} sizes)")}")
+
+        UI.success("icons written to #{out.sub("#{Dir.pwd}/", "")}")
+      end
+
+      private
+
+      def rel(path, base)
+        path.sub("#{base}/", "")
+      end
+
+      def default_source(root_path)
+        Everywhere::Config.load(root_path).icon
+      rescue StandardError
+        default = File.join(root_path, "icon.png")
+        File.exist?(default) ? default : nil
+      end
+    end
+  end
+end

data/lib/everywhere/commands/install.rb

@@ -102,17 +102,26 @@ module Everywhere
         return change("create config/everywhere.yml", false) if File.exist?(config)
 
         app_name = File.basename(@root).split(/[-_]/).map(&:capitalize).join(" ")
+        slug = app_name.downcase.gsub(/[^a-z0-9]+/, "-")
         File.write(config, <<~YAML)
-          # RubyEverywhere app configuration — https://rubyeverywhere.com
+          # RubyEverywhere app configuration.
+          # Full reference: https://rubyeverywhere.com/docs/shared/everywhere-yml
           app:
             name: #{app_name}
             # Reverse-DNS app identifier: names the app-data directory on every
             # platform (and the macOS bundle id). Set once, never change it.
-            bundle_id: com.example.#{app_name.downcase.gsub(/[^a-z0-9]+/, "-")}
+            bundle_id: com.example.#{slug}
+            version: "0.1.0"       # marketing version (CFBundleShortVersionString)
+            mode: local            # "local" (compile & ship the app) or "remote" (native shell around a deployed site)
             entry_path: /          # initial url on app launch
             # icon: icon.png       # PNG used to generate app icons (defaults to icon.png at the app root if present)
             # splash: splash.html  # custom boot splash (HTML); window.__EVERYWHERE_CONFIG__ carries name/colors
 
+          # Remote mode only — the deployed URL the native shell opens.
+          # Set mode: remote above, then uncomment:
+          # remote:
+          #   url: https://example.com
+
           appearance:
             # Colors take a hex string, or split by system theme:
             #   tint_color:
@@ -122,6 +131,42 @@ module Everywhere
             background_color:
               light: "#FFFFFF"
               dark: "#1C1B1A"
+
+          # Native menu-bar items — each one visits a route in your app (no native code).
+          # menu:
+          #   - label: Settings…
+          #     path: /settings
+          #     accelerator: CmdOrCtrl+,
+          #   - separator
+          #   - label: Documentation
+          #     path: /help
+
+          # System tray / menu-bar-extra items — same shape as menu, plus action: show | quit.
+          # tray:
+          #   - label: Open #{app_name}
+          #     action: show
+          #   - label: New…
+          #     path: /new
+          #   - separator
+          #   - label: Quit
+          #     action: quit
+
+          # Durable build knobs (CLI flags still override per-run).
+          # build:
+          #   ruby: "4.0.6"
+          #   targets:               # the platforms you ship — the CI matrix, expressed once
+          #     - macos-arm64
+          #     # - ios-arm64         # future — mobile is remote mode only
+          #     # - android-arm64     # future — mobile is remote mode only
+          #   permissions: [notifications, filesystem:read, clipboard]
+
+          # Per-platform overrides. Keys are platform names (macos / ios / android /
+          # windows / linux); anything here overrides the app: defaults above for that
+          # platform — handy when a store needs a distinct bundle id or version.
+          # platforms:
+          #   ios:
+          #     bundle_id: com.example.#{slug}.ios
+          #     version: "0.1.1"
         YAML
         change("create config/everywhere.yml", true)
       end

data/lib/everywhere/commands/release.rb

@@ -37,7 +37,7 @@ module Everywhere
                app_name: nil, shell_dir: nil, env_file: nil, skip_build: false, **)
         root_path = File.expand_path(root)
         config = Everywhere::Config.load(root_path)
-        app_name ||= config.name
+        app_name ||= config.name(target: target)
         ruby ||= config.build_ruby || "4.0.6"
 
         preflight!(target)
@@ -49,7 +49,7 @@ module Everywhere
         #    notarize step below re-signs it inside-out with the Developer ID.
         unless skip_build
           UI.step("building #{UI.bold(app_name)} for #{UI.cyan(target)}")
-          Build.new.call(root: root, ruby: ruby, entry: entry, app_name: app_name, shell_dir: shell_dir, **)
+          Build.new.call(root: root, ruby: ruby, entry: entry, app_name: app_name, target: target, shell_dir: shell_dir, **)
         end
 
         app_dir = Dir[File.join(dist_dir, "*.app")].max_by { |d| File.mtime(d) }

data/lib/everywhere/config.rb

@@ -31,15 +31,23 @@ module Everywhere
       @root = root
     end
 
-    def name
-      app["name"] || File.basename(File.expand_path(root)).split(/[-_]/).map(&:capitalize).join(" ")
+    # Every target (os-arch string) resolves to a single platform (its os), and
+    # a platform may override the app-level identity/version keys — see
+    # `platforms:` below. Pass `target:` to any of these accessors to apply the
+    # matching override; omit it for the shared app-level value.
+    def self.os_of(target) = target.to_s.split("-", 2).first
+
+    def name(target: nil)
+      resolved(target)["name"] || File.basename(File.expand_path(root)).split(/[-_]/).map(&:capitalize).join(" ")
     end
 
     # Reverse-DNS identifier: macOS bundle id, and the name of the per-user
     # app-data directory on every platform. Set it explicitly and never change
-    # it — renaming moves users' data.
-    def bundle_id
-      app["bundle_id"] || "com.rubyeverywhere.#{name.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-|-\z/, "")}"
+    # it — renaming moves users' data. A platform may override it (e.g. the App
+    # Store often wants `com.example.app.ios`).
+    def bundle_id(target: nil)
+      resolved(target)["bundle_id"] ||
+        "com.rubyeverywhere.#{name(target: target).downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-|-\z/, "")}"
     end
 
     # App icon source: a PNG (ideally square, 1024px+). Explicit `app.icon`
@@ -67,9 +75,11 @@ module Everywhere
     end
 
     # Marketing/display version of the app (CFBundleShortVersionString, and the
-    # `version` recorded in the build receipt). Defaults conservatively.
-    def version
-      app["version"] || "0.1.0"
+    # `version` recorded in the build receipt). One shared `app.version` is the
+    # default for every target; a platform may override it when a store forces a
+    # different number. Defaults conservatively.
+    def version(target: nil)
+      resolved(target)["version"] || "0.1.0"
     end
 
     # The `build:` section — durable build knobs that were once `every build`
@@ -149,11 +159,13 @@ module Everywhere
     end
 
     # The subset the shell needs, shipped as JSON (env var in dev,
-    # Resources/everywhere.json inside a bundled .app).
-    def to_shell_hash
+    # Resources/everywhere.json inside a bundled .app). Pass `target:` so the
+    # packaged config reflects the platform being built (its bundle id / name).
+    def to_shell_hash(target: nil)
       {
-        "name" => name,
-        "bundle_id" => bundle_id,
+        "name" => name(target: target),
+        "bundle_id" => bundle_id(target: target),
+        "version" => version(target: target),
         "mode" => mode,
         "remote_url" => remote_url,
         "entry_path" => entry_path,
@@ -164,9 +176,9 @@ module Everywhere
       }.compact
     end
 
-    def to_shell_json
+    def to_shell_json(target: nil)
       require "json"
-      JSON.generate(to_shell_hash)
+      JSON.generate(to_shell_hash(target: target))
     end
 
     private
@@ -174,6 +186,19 @@ module Everywhere
     def app = @data.fetch("app", nil) || {}
     def appearance = @data.fetch("appearance", nil) || {}
 
+    # Per-platform overrides, keyed by os (macos / ios / android / windows /
+    # linux). Each value overrides the matching `app:` keys for that platform.
+    def platforms = @data.fetch("platforms", nil) || {}
+
+    # The app-level keys with the target's platform override merged on top.
+    # Blank override values are dropped (`.compact`) so they don't erase a
+    # default. Without a target — or without an override for that os — this is
+    # just the plain `app:` hash.
+    def resolved(target)
+      override = target && platforms[self.class.os_of(target)]
+      override.is_a?(Hash) ? app.merge(override.compact) : app
+    end
+
     def normalize_color(value)
       case value
       when String

data/lib/everywhere/icon.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "raster"
+
+module Everywhere
+  # Turns one source PNG into platform-native app icons — no Tauri, no sips, no
+  # iconutil, no ImageMagick. Pure Ruby, so it runs the same locally and on the
+  # cloud build runners.
+  #
+  # The important part is macОS shaping. macOS renders an .icns *literally*: it
+  # does not round the corners or add margins the way iOS does. A full-bleed
+  # square PNG therefore shows up as a hard square, out of place next to every
+  # native app. So we bake the platform's look into the artwork ourselves —
+  # inset the icon to the Big Sur grid (~824px inside a 1024px canvas) and clip
+  # it to a superellipse ("squircle") with transparent corners.
+  #
+  # Windows (.ico) and Linux (hicolor PNGs) don't get the squircle — those
+  # desktops present square icons — so they're generated straight from the
+  # full-bleed source.
+  module Icon
+    # Big Sur icon-grid geometry, all as fractions of the 1024px canvas so it
+    # scales to any master size.
+    CANVAS       = 1024
+    INSET        = 0.8047 # icon body is 824/1024 of the canvas
+    CORNER_RATIO = 0.2237 # corner radius as a fraction of the body's side
+    EXPONENT     = 5.0    # superellipse power — the iOS/macOS "squircle" corner
+
+    # .icns type codes -> pixel size. Mirrors what `iconutil` emits from a
+    # standard .iconset (retina variants included), so the result is
+    # indistinguishable from an Apple-toolchain icns.
+    ICNS_TYPES = [
+      ["icp4", 16], ["icp5", 32], ["ic07", 128], ["ic08", 256], ["ic09", 512],
+      ["ic11", 32], ["ic12", 64], ["ic13", 256], ["ic14", 512], ["ic10", 1024]
+    ].freeze
+
+    ICO_SIZES   = [16, 32, 48, 64, 128, 256].freeze
+    LINUX_SIZES = [16, 32, 48, 64, 128, 256, 512].freeze
+
+    module_function
+
+    # Write a macOS-shaped 1024px RGBA master PNG (padding + squircle) from a
+    # source PNG. Returns true, or false if the source PNG can't be read.
+    def macos_master(source, dest, canvas: CANVAS)
+      raster = Raster.decode_png(source) or return false
+
+      body = (canvas * INSET).round
+      offset = (canvas - body) / 2
+
+      # Fit the artwork inside the body square preserving aspect ratio (square
+      # sources fill it exactly; non-square ones are centred, not stretched).
+      fit = [body.to_f / raster.width, body.to_f / raster.height].min
+      sw = (raster.width * fit).round.clamp(1, body)
+      sh = (raster.height * fit).round.clamp(1, body)
+      scaled = raster.resample(sw, sh)
+
+      out = Raster.transparent(canvas, canvas)
+      out.paste!(scaled, offset + (body - sw) / 2, offset + (body - sh) / 2)
+
+      centre = canvas / 2.0
+      half = body / 2.0
+      radius = [body * CORNER_RATIO, half].min
+      straight = half - radius # half-extent of the straight edges
+      out.mask_region!(offset, offset, offset + body, offset + body) do |x, y|
+        squircle_coverage(x, y, centre, half, straight, radius, EXPONENT)
+      end
+
+      out.write_png(dest)
+      true
+    end
+
+    # Build a macOS .icns from an already-shaped master PNG (ideally 1024px).
+    # Returns true on success.
+    def write_icns(master_png, dest)
+      master = Raster.decode_png(master_png) or return false
+
+      body = ICNS_TYPES.map do |type, size|
+        png = sized_png(master, size)
+        type.b + [png.bytesize + 8].pack("N") + png
+      end.join
+
+      File.binwrite(dest, "icns".b + [body.bytesize + 8].pack("N") + body)
+      true
+    end
+
+    # Build a Windows .ico (PNG-compressed entries, Vista+) from a full-bleed
+    # source PNG. Returns true on success.
+    def write_ico(source, dest, sizes: ICO_SIZES)
+      master = Raster.decode_png(source) or return false
+
+      images = sizes.map { |s| [s, sized_png(master, s)] }
+      offset = 6 + images.size * 16
+      entries = +"".b
+      blob = +"".b
+      images.each do |size, png|
+        dim = size >= 256 ? 0 : size # 0 means 256 in the ICONDIRENTRY
+        entries << [dim, dim, 0, 0, 1, 32, png.bytesize, offset].pack("CCCCvvVV")
+        blob << png
+        offset += png.bytesize
+      end
+
+      header = [0, 1, images.size].pack("vvv") # reserved, type=icon, count
+      File.binwrite(dest, header + entries + blob)
+      true
+    end
+
+    # Write a set of square PNGs (Linux/desktop use) named "<size>x<size>.png"
+    # into dest_dir from a full-bleed source. Returns the written paths.
+    def write_png_set(source, dest_dir, sizes: LINUX_SIZES)
+      master = Raster.decode_png(source) or return []
+
+      FileUtils.mkdir_p(dest_dir)
+      sizes.map do |size|
+        path = File.join(dest_dir, "#{size}x#{size}.png")
+        File.binwrite(path, sized_png(master, size))
+        path
+      end
+    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
+    end
+
+    # Coverage (0.0..1.0) of pixel (x, y) by the squircle: a rounded rectangle
+    # with continuous (superelliptical) corners. Interior pixels return 1.0,
+    # exterior 0.0, and boundary pixels are antialiased by 4x4 supersampling.
+    def squircle_coverage(x, y, centre, half, straight, radius, exponent)
+      c0 = squircle_inside?(x,     y,     centre, half, straight, radius, exponent)
+      c1 = squircle_inside?(x + 1, y,     centre, half, straight, radius, exponent)
+      c2 = squircle_inside?(x,     y + 1, centre, half, straight, radius, exponent)
+      c3 = squircle_inside?(x + 1, y + 1, centre, half, straight, radius, exponent)
+      return 1.0 if c0 && c1 && c2 && c3
+      return 0.0 unless c0 || c1 || c2 || c3
+
+      hit = 0
+      4.times do |i|
+        4.times do |j|
+          hit += 1 if squircle_inside?(x + (i + 0.5) / 4.0, y + (j + 0.5) / 4.0,
+                                       centre, half, straight, radius, exponent)
+        end
+      end
+      hit / 16.0
+    end
+
+    # Is the continuous point (sx, sy) inside the squircle? Straight edges up to
+    # `straight` from centre, superelliptical corners of `radius` beyond that.
+    def squircle_inside?(sx, sy, centre, half, straight, radius, exponent)
+      u = (sx - centre).abs
+      v = (sy - centre).abs
+      return false if u > half || v > half
+      return true if u <= straight || v <= straight
+
+      du = (u - straight) / radius
+      dv = (v - straight) / radius
+      (du**exponent) + (dv**exponent) <= 1.0
+    end
+  end
+end

data/lib/everywhere/png.rb

@@ -39,6 +39,60 @@ module Everywhere
       true
     end
 
+    # Decode an 8-bit RGB/RGBA PNG to a flat RGBA pixel buffer. Returns
+    # [width, height, bytes] (bytes = width*height*4, no per-scanline filter
+    # byte) or nil for flavors we don't handle (palette, 16-bit, interlaced,
+    # grayscale). This is the pixel gateway the Raster/Icon generators build on.
+    def decode_rgba(path)
+      data = File.binread(path)
+      return nil unless data.start_with?(SIGNATURE)
+
+      chunks = read_chunks(data)
+      ihdr = chunks.find { |type, _| type == "IHDR" }&.last or return nil
+      width, height, depth, color, _comp, _filter, interlace = ihdr.unpack("NNC5")
+      return nil unless depth == 8 && interlace.zero?
+      return nil unless color == 2 || color == 6 # RGB or RGBA
+
+      bpp = color == 6 ? 4 : 3
+      raw = Zlib::Inflate.inflate(chunks.select { |t, _| t == "IDAT" }.map(&:last).join)
+      stride = width * bpp
+      prev = "\0".b * stride
+      out = String.new(capacity: width * height * 4)
+
+      height.times do |y|
+        filter = raw.getbyte(y * (stride + 1))
+        line = raw.byteslice(y * (stride + 1) + 1, stride).dup
+        unfilter!(line, prev, filter, bpp)
+        if bpp == 4
+          out << line
+        else
+          x = 0
+          while x < width
+            out << line.byteslice(x * 3, 3) << "\xFF".b
+            x += 1
+          end
+        end
+        prev = line
+      end
+      [width, height, out]
+    end
+
+    # Encode a flat RGBA pixel buffer to PNG bytes (filter 0, single IDAT).
+    def encode_rgba(width, height, rgba)
+      stride = width * 4
+      raw = String.new(capacity: (stride + 1) * height)
+      height.times do |y|
+        raw << "\0".b # filter: None
+        raw << rgba.byteslice(y * stride, stride)
+      end
+
+      out = SIGNATURE.dup
+      out << chunk("IHDR", [width, height, 8, 6, 0, 0, 0].pack("NNC5"))
+      out << chunk("IDAT", Zlib::Deflate.deflate(raw, Zlib::BEST_COMPRESSION))
+      out << chunk("IEND", "")
+      out
+    end
+
     def read_chunks(data)
       chunks = []
       pos = 8

data/lib/everywhere/raster.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require_relative "png"
+
+module Everywhere
+  # A mutable RGBA raster and the handful of pixel operations the icon
+  # generator needs — decode/encode PNG, high-quality resampling, pasting, and
+  # a superellipse ("squircle") alpha mask. Pure Ruby (zlib only): no
+  # ImageMagick, no sips, no Tauri. Works the same on any OS the CLI runs on.
+  #
+  # Pixels are stored as a flat 8-bit RGBA byte string (row-major, 4 bytes per
+  # pixel). Resampling is a separable area/box filter done in *premultiplied*
+  # alpha so transparent regions never bleed their colour into opaque edges.
+  class Raster
+    attr_reader :width, :height, :pixels
+
+    def initialize(width, height, pixels = nil)
+      @width = width
+      @height = height
+      @pixels = pixels || ("\x00".b * (width * height * 4))
+    end
+
+    # A fully transparent canvas.
+    def self.transparent(width, height)
+      new(width, height)
+    end
+
+    # Decode a PNG file into a Raster, or nil if it's a flavor PNG.decode_rgba
+    # can't read (palette, 16-bit, interlaced, grayscale).
+    def self.decode_png(path)
+      width, height, bytes = PNG.decode_rgba(path)
+      return nil unless width
+
+      new(width, height, bytes)
+    end
+
+    def encode_png
+      PNG.encode_rgba(width, height, pixels)
+    end
+
+    def write_png(path)
+      File.binwrite(path, encode_png)
+    end
+
+    # Resample to a new size with a separable area filter. Great for the
+    # downscales an icon set is made of; degrades gracefully on upscale.
+    def resample(new_width, new_height)
+      return self if new_width == width && new_height == height
+
+      # Premultiplied float channels: pr = r * (a/255), etc.
+      pr = Array.new(width * height)
+      pg = Array.new(width * height)
+      pb = Array.new(width * height)
+      pa = Array.new(width * height)
+      i = 0
+      (width * height).times do |p|
+        a = pixels.getbyte(i + 3)
+        af = a / 255.0
+        pr[p] = pixels.getbyte(i) * af
+        pg[p] = pixels.getbyte(i + 1) * af
+        pb[p] = pixels.getbyte(i + 2) * af
+        pa[p] = a.to_f
+        i += 4
+      end
+
+      # Horizontal pass (width -> new_width), then vertical (height -> new_height).
+      wx = self.class.axis_weights(width, new_width)
+      hr = resample_axis(pr, width, height, new_width, wx, rows: true)
+      hg = resample_axis(pg, width, height, new_width, wx, rows: true)
+      hb = resample_axis(pb, width, height, new_width, wx, rows: true)
+      ha = resample_axis(pa, width, height, new_width, wx, rows: true)
+
+      wy = self.class.axis_weights(height, new_height)
+      vr = resample_axis(hr, new_width, height, new_height, wy, rows: false)
+      vg = resample_axis(hg, new_width, height, new_height, wy, rows: false)
+      vb = resample_axis(hb, new_width, height, new_height, wy, rows: false)
+      va = resample_axis(ha, new_width, height, new_height, wy, rows: false)
+
+      out = String.new(capacity: new_width * new_height * 4)
+      (new_width * new_height).times do |p|
+        a = va[p]
+        if a <= 0.001
+          out << "\x00\x00\x00\x00".b
+        else
+          out << [
+            (vr[p] * 255.0 / a).round.clamp(0, 255),
+            (vg[p] * 255.0 / a).round.clamp(0, 255),
+            (vb[p] * 255.0 / a).round.clamp(0, 255),
+            a.round.clamp(0, 255)
+          ].pack("C4")
+        end
+      end
+      self.class.new(new_width, new_height, out)
+    end
+
+    # Copy src into this raster with its top-left at (ox, oy), replacing pixels
+    # (the canvas is transparent underneath, so a plain copy is the composite).
+    def paste!(src, ox, oy)
+      row = src.width * 4
+      src.height.times do |y|
+        dst_index = ((oy + y) * width + ox) * 4
+        pixels[dst_index, row] = src.pixels.byteslice(y * row, row)
+      end
+      self
+    end
+
+    # Multiply the alpha channel of every pixel in [x0, x1) x [y0, y1) by the
+    # coverage the block returns for pixel (x, y) — a value in 0.0..1.0.
+    # Pixels outside the range keep their (already transparent) alpha.
+    def mask_region!(x0, y0, x1, y1)
+      y0.upto(y1 - 1) do |y|
+        base = y * width
+        x0.upto(x1 - 1) do |x|
+          cov = yield(x, y)
+          next if cov >= 1.0
+
+          idx = (base + x) * 4 + 3
+          a = pixels.getbyte(idx)
+          next if a.zero?
+
+          pixels.setbyte(idx, cov <= 0.0 ? 0 : (a * cov).round)
+        end
+      end
+      self
+    end
+
+    # For each output index along an axis of `n_out` pixels, the list of
+    # [input_index, weight] contributions, where weights sum to 1 (area filter:
+    # each output pixel is the average of the input pixels it overlaps).
+    def self.axis_weights(n_in, n_out)
+      scale = n_in.to_f / n_out
+      Array.new(n_out) do |i|
+        start = i * scale
+        finish = [start + scale, n_in.to_f].min # float slop can push this past n_in
+        weights = []
+        k = [start.floor, 0].max
+        while k < finish && k < n_in
+          lo = [k.to_f, start].max
+          hi = [k + 1.0, finish].min
+          overlap = hi - lo
+          weights << [k, overlap / scale] if overlap > 0
+          k += 1
+        end
+        weights
+      end
+    end
+
+    private
+
+    # Resample one float channel along a single axis. `rows: true` resizes each
+    # row from `n_in` to `n_out` columns; `rows: false` resizes each column.
+    def resample_axis(src, in_w, in_h, n_out, weights, rows:)
+      if rows
+        out = Array.new(n_out * in_h, 0.0)
+        in_h.times do |y|
+          src_base = y * in_w
+          out_base = y * n_out
+          n_out.times do |o|
+            acc = 0.0
+            weights[o].each { |k, wt| acc += src[src_base + k] * wt }
+            out[out_base + o] = acc
+          end
+        end
+        out
+      else
+        out = Array.new(in_w * n_out, 0.0)
+        in_w.times do |x|
+          n_out.times do |o|
+            acc = 0.0
+            weights[o].each { |k, wt| acc += src[k * in_w + x] * wt }
+            out[o * in_w + x] = acc
+          end
+        end
+        out
+      end
+    end
+  end
+end

data/lib/everywhere/receipt.rb

@@ -27,6 +27,7 @@ module Everywhere
       @config = config
       @framework = framework
       @ruby = ruby
+      @target_str = target                     # raw "os-arch" — selects platforms: overrides
       @target = parse_target(target, channel)
       @shell_dir = shell_dir
     end
@@ -35,9 +36,9 @@ module Everywhere
     def manifest
       {
         "app" => {
-          "name" => @config.name,
-          "bundle_id" => @config.bundle_id,
-          "version" => @config.version
+          "name" => @config.name(target: @target_str),
+          "bundle_id" => @config.bundle_id(target: @target_str),
+          "version" => @config.version(target: @target_str)
         },
         "framework" => framework_info,
         "ruby" => @ruby,

data/lib/everywhere/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 
   # Version of the vendored @rubyeverywhere/bridge JS this gem ships. Tracks
   # bridge/package.json — bump it whenever lib/everywhere/javascript/bridge.js is

data/support/shell/src-tauri/Cargo.lock

@@ -993,6 +993,9 @@ dependencies = [
 name = "example-shell"
 version = "0.1.0"
 dependencies = [
+ "objc2",
+ "objc2-foundation",
+ "objc2-web-kit",
  "serde_json",
  "tauri",
  "tauri-build",
@@ -2366,6 +2369,16 @@ dependencies = [
  "objc2-core-foundation",
 ]
 
+[[package]]
+name = "objc2-javascript-core"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a1e6550c4caed348956ce3370c9ffeca70bb1dbed4fa96112e7c6170e074586"
+dependencies = [
+ "objc2",
+ "objc2-core-foundation",
+]
+
 [[package]]
 name = "objc2-quartz-core"
 version = "0.3.2"
@@ -2378,6 +2391,17 @@ dependencies = [
  "objc2-foundation",
 ]
 
+[[package]]
+name = "objc2-security"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "709fe137109bd1e8b5a99390f77a7d8b2961dafc1a1c5db8f2e60329ad6d895a"
+dependencies = [
+ "bitflags 2.13.0",
+ "objc2",
+ "objc2-core-foundation",
+]
+
 [[package]]
 name = "objc2-ui-kit"
 version = "0.3.2"
@@ -2421,6 +2445,8 @@ dependencies = [
  "objc2-app-kit",
  "objc2-core-foundation",
  "objc2-foundation",
+ "objc2-javascript-core",
+ "objc2-security",
 ]
 
 [[package]]

data/support/shell/src-tauri/Cargo.toml

@@ -14,6 +14,15 @@ tauri-plugin-notification = "2"
 tauri-plugin-dialog = "2"
 tauri-plugin-clipboard-manager = "2"
 
+# macOS: set the WebView's `applicationNameForUserAgent`, which WKWebView
+# natively APPENDS to its real default UA — so we get the true system UA plus
+# our marker without ever reading or hardcoding the base string. Versions are
+# pinned to match what wry 0.55 already resolves, so no duplicate objc2 trees.
+[target.'cfg(target_os = "macos")'.dependencies]
+objc2 = "0.6"
+objc2-foundation = { version = "0.3", features = ["NSString", "NSUUID", "NSProcessInfo"] }
+objc2-web-kit = { version = "0.3", features = ["WKWebViewConfiguration", "WKWebsiteDataStore"] }
+
 [profile.release]
 strip = true
 lto = true

data/support/shell/src-tauri/src/main.rs

@@ -32,6 +32,7 @@ struct AppConfig {
     raw_json: String,
     name: String,
     bundle_id: Option<String>,
+    version: Option<String>,
     entry_path: String,
     remote_url: Option<String>,
     background_light: Option<(u8, u8, u8)>,
@@ -71,6 +72,7 @@ fn load_config() -> AppConfig {
         raw_json: if value.is_null() { "{}".to_string() } else { value.to_string() },
         name: value["name"].as_str().unwrap_or("RubyEverywhere App").to_string(),
         bundle_id: value["bundle_id"].as_str().map(str::to_string),
+        version: value["version"].as_str().map(str::to_string),
         entry_path: value["entry_path"].as_str().unwrap_or("/").to_string(),
         remote_url: (value["mode"].as_str() == Some("remote"))
             .then(|| value["remote_url"].as_str().map(str::to_string))
@@ -549,12 +551,72 @@ const INIT_SCRIPT: &str = r#"
 })();
 "#;
 
+// The marker we append to the WebView's own user agent. We never build or
+// hardcode the browser part of the UA — the WebView keeps producing its real
+// default and this is added on the end, so anything the Ruby side sniffs (the
+// `browser` gem, `request.variant`) still sees a genuine desktop browser. The
+// contract with the app: `request.user_agent =~ %r{RubyEverywhere/([\d.]+)}`
+// tells it the request came from the native shell and which app version (from
+// everywhere.yml → the submitted build) made it. Version is absent only in bare
+// `cargo run` dev where no config was passed.
+fn ua_marker(config: &AppConfig) -> String {
+    let os = std::env::consts::OS;
+    match &config.version {
+        Some(v) => format!("RubyEverywhere/{v} ({os})"),
+        None => format!("RubyEverywhere ({os})"),
+    }
+}
+
+// macOS: build the WKWebViewConfiguration ourselves so we can set
+// `applicationNameForUserAgent` — WebKit appends it to the real default UA (the
+// one clean, no-read way to *append* rather than replace). Because wry uses the
+// config's own `websiteDataStore` when we supply a configuration (and ignores
+// Tauri's `data_store_identifier`), we must reproduce the per-app persistent
+// store here too, or logins would leak into the shared default store. Mirrors
+// wry's own logic: identified store on macOS 14+, default otherwise / in dev.
+#[cfg(target_os = "macos")]
+fn macos_webview_configuration(
+    config: &AppConfig,
+    dev_mode: bool,
+) -> objc2::rc::Retained<objc2_web_kit::WKWebViewConfiguration> {
+    use objc2::MainThreadMarker;
+    use objc2_foundation::{NSProcessInfo, NSString, NSUUID, NSOperatingSystemVersion};
+    use objc2_web_kit::{WKWebViewConfiguration, WKWebsiteDataStore};
+
+    let mtm = MainThreadMarker::new().expect("webview configuration must be built on the main thread");
+    let cfg = unsafe { WKWebViewConfiguration::new(mtm) };
+
+    unsafe {
+        cfg.setApplicationNameForUserAgent(Some(&NSString::from_str(&ua_marker(config))));
+    }
+
+    // Cookie / session persistence, keyed by bundle_id so each app is isolated.
+    // Dev mode keeps the default store (matches the previous ephemeral-ish dev
+    // behaviour). dataStoreForIdentifier needs macOS 14+.
+    if !dev_mode {
+        let os14 = NSProcessInfo::processInfo().isOperatingSystemAtLeastVersion(
+            NSOperatingSystemVersion { majorVersion: 14, minorVersion: 0, patchVersion: 0 },
+        );
+        if os14 {
+            let id = config.bundle_id.as_deref().unwrap_or("com.rubyeverywhere.app");
+            let store = unsafe {
+                WKWebsiteDataStore::dataStoreForIdentifier(&NSUUID::from_bytes(data_store_id(id)), mtm)
+            };
+            unsafe { cfg.setWebsiteDataStore(&store) };
+        }
+    }
+
+    cfg
+}
+
 fn build_window(
     app: &tauri::App,
     config: &AppConfig,
     title: &str,
     url: WebviewUrl,
 ) -> tauri::Result<tauri::WebviewWindow> {
+    let dev_mode = std::env::var("NATIVE_DEV_URL").is_ok();
+
     let mut builder = WebviewWindowBuilder::new(app, "main", url)
         .title(title)
         .inner_size(1100.0, 750.0)
@@ -566,23 +628,19 @@ fn build_window(
     }
 
     // Cookie / session persistence: give the webview a stable data store so
-    // logins survive relaunches. macOS wants a 16-byte identifier (derived from
-    // bundle_id); Windows/Linux want an explicit directory. Dev mode stays
-    // ephemeral — a persistent cache would keep serving stale dev assets.
-    let dev_mode = std::env::var("NATIVE_DEV_URL").is_ok();
+    // logins survive relaunches. macOS carries it (and the UA marker) on a
+    // custom WKWebViewConfiguration; Windows/Linux want an explicit directory.
+    // Dev mode stays ephemeral — a persistent cache would keep serving stale
+    // dev assets.
+    #[cfg(target_os = "macos")]
+    {
+        builder = builder.with_webview_configuration(macos_webview_configuration(config, dev_mode));
+    }
+    #[cfg(any(windows, target_os = "linux"))]
     if !dev_mode {
-        #[cfg(target_os = "macos")]
-        {
-            builder = builder.data_store_identifier(data_store_id(
-                config.bundle_id.as_deref().unwrap_or("com.rubyeverywhere.app"),
-            ));
-        }
-        #[cfg(any(windows, target_os = "linux"))]
-        {
-            if let Ok(dir) = app.path().data_dir() {
-                let id = config.bundle_id.clone().unwrap_or("com.rubyeverywhere.app".into());
-                builder = builder.data_directory(dir.join(id).join("webview"));
-            }
+        if let Ok(dir) = app.path().data_dir() {
+            let id = config.bundle_id.clone().unwrap_or("com.rubyeverywhere.app".into());
+            builder = builder.data_directory(dir.join(id).join("webview"));
         }
     }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_everywhere
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Andrea Fomera
@@ -55,6 +55,7 @@ files:
 - lib/everywhere/commands/build.rb
 - lib/everywhere/commands/dev.rb
 - lib/everywhere/commands/doctor.rb
+- lib/everywhere/commands/icon.rb
 - lib/everywhere/commands/install.rb
 - lib/everywhere/commands/platform/auth_status.rb
 - lib/everywhere/commands/platform/build.rb
@@ -65,6 +66,7 @@ files:
 - lib/everywhere/config.rb
 - lib/everywhere/database.rb
 - lib/everywhere/framework.rb
+- lib/everywhere/icon.rb
 - lib/everywhere/ignore.rb
 - lib/everywhere/javascript/bridge.js
 - lib/everywhere/paths.rb
@@ -72,6 +74,7 @@ files:
 - lib/everywhere/platform/credentials.rb
 - lib/everywhere/platform/snapshot.rb
 - lib/everywhere/png.rb
+- lib/everywhere/raster.rb
 - lib/everywhere/receipt.rb
 - lib/everywhere/shellout.rb
 - lib/everywhere/ui.rb