ruby_everywhere 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6445e84081e08a1d5c545054c0a7dc6ef2e4b05338aff54ea68dc4c48d6b6c60
-  data.tar.gz: 2a057925b0ee3266c294046b0be24cb1c0d3fa4b8a82e179b88425cd6afa7e91
+  metadata.gz: e8f07eb6ae976f35ea7ccda33b87bfefd7c2d0ffd39c1b7aa1f7001bedbd482b
+  data.tar.gz: b0b9afc49cdc99e731c5bc7a742f8a90c4a5c94d496749131fa37b403567f91c
 SHA512:
-  metadata.gz: 1e8528cf2ac3b62191795709e23ee708d1c706672b8fc5d5f2beec6c3455d1a092b71498a086d67506e9c8175efcad1ad2f5c22df0b5d7dbe0f130a3aba8600e
-  data.tar.gz: ff1a73eeaabf7d7b839b092b3482c4a06511a6793133b6133f9671ad17d883092877b608fa8db04c9709a419d38c73f905e44dca32d952c992121a18c9e05aa1
+  metadata.gz: f13c6059ba2dae4dbe87c21a376265ae7cef7f84a890492897694dde101e9b94bc4990df82b6efc64f278e1ed35d3d921e8bfd7d5c131763cc79589d096d4211
+  data.tar.gz: 741d54c87c703df48024662485d03edcc15546c20f3fbe6f6d52b2b3c6056658c8aff7f2e73eb558d7f31961aa1c65c686a656bfc5e9bf9c2d900a3c633057aa

data/lib/everywhere/commands/build.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require "tmpdir"
 require "shellwords"
 require_relative "../shellout"
+require_relative "../log_filter"
 require_relative "../png"
 require_relative "../icon"
 require_relative "../paths"
@@ -29,20 +30,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
 
@@ -64,7 +68,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
@@ -86,11 +90,11 @@ module Everywhere
         staging = File.join(Dir.mktmpdir("everywhere-press"), File.basename(output_path))
         log = "#{output_path}.build.log"
 
-        UI.step("rbe-tebako press (Ruby #{ruby}) #{UI.dim("— grab a coffee on first run")}")
-        UI.step(UI.dim("full build log: #{log}"))
+        UI.step("rbe-tebako press #{UI.dim("(Ruby #{ruby} — grab a coffee on first run)")}")
+        UI.detail("full build log: #{UI.short_path(log)}")
         Shellout.run_logged!(press_env, ["rbe-tebako", "press",
              "--root=#{framework.root}", "--entry-point=#{entry}",
-             "--Ruby=#{ruby}", "--output=#{staging}"], log: log)
+             "--Ruby=#{ruby}", "--output=#{staging}"], log: log, filter: LogFilter.for(:tebako))
 
         # Tebako's final strip step only warns (and still exits 0) if it can't
         # write the output, so verify the artifact instead of trusting exit codes.
@@ -112,7 +116,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)
 
@@ -188,7 +192,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"))
@@ -199,7 +203,7 @@ module Everywhere
         end
         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

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/platform/build.rb

@@ -50,6 +50,9 @@ module Everywhere
 
           build = submit(client, targets, channel, signed_id, manifest)
           UI.success("submitted #{UI.bold(build["id"])} for #{targets.join(", ")}")
+          if (build_url = build["url"] || "#{client.base_url}/builds/#{build["id"]}")
+            UI.substep("watch it live → #{UI.cyan(build_url)}")
+          end
 
           return unless wait
 

data/lib/everywhere/commands/platform/runner.rb

@@ -31,13 +31,18 @@ module Everywhere
       option :shell_dir, default: nil,   desc: "Path to the generic Tauri shell (src-tauri)"
 
       def call(artifact:, token:, url: nil, shell_dir: nil, **)
+        # We run headless on a build runner (a pipe, not a TTY) and stream into
+        # the Platform web log, which renders ANSI. Force color on so the hosted
+        # log reads like a local run.
+        ENV["CLICOLOR_FORCE"] ||= "1" unless ENV["NO_COLOR"]
+
         base = Everywhere::Platform::Client.base_url(url)
         @client = Everywhere::Platform::Client.new(base, token: token)
         @artifact = artifact
 
         job = get!("/runner/artifacts/#{artifact}")
         patch!("/runner/artifacts/#{artifact}", status: "running")
-        remote_log("runner: picked up #{job.dig("target", "os")}-#{job.dig("target", "arch")} for #{job.dig("app", "name")}")
+        remote_log("picked up #{UI.cyan("#{job.dig("target", "os")}-#{job.dig("target", "arch")}")} for #{UI.bold(job.dig("app", "name"))}")
 
         Dir.mktmpdir("every-runner") do |work|
           src = fetch_snapshot(work, job)
@@ -63,7 +68,7 @@ module Everywhere
       # ---- pipeline steps ------------------------------------------------------
 
       def fetch_snapshot(work, job)
-        remote_log("runner: downloading source snapshot")
+        remote_log("downloading source snapshot")
         tarball = File.join(work, "snapshot.tar.gz")
         @client.download(job["snapshot_url"], tarball)
         src = File.join(work, "src")
@@ -73,7 +78,7 @@ module Everywhere
       end
 
       def pull_credentials(work)
-        remote_log("runner: pulling signing credentials")
+        remote_log("pulling signing credentials")
         creds = get!("/runner/artifacts/#{@artifact}/credentials")["credentials"] || []
         env = {}
         creds.each do |cred|
@@ -113,19 +118,23 @@ module Everywhere
         listing = `security find-identity -p codesigning #{@keychain.shellescape} 2>/dev/null`
         sha = listing[/\b([0-9A-F]{40})\b/, 1]
         UI.die!("no codesigning identity in the delivered .p12") unless sha
-        remote_log("runner: signing identity #{listing[/"(.+)"/, 1]} (#{sha[0, 10]}…)")
+        remote_log("signing identity #{listing[/"(.+)"/, 1]} #{UI.dim("(#{sha[0, 10]}…)")}")
         sha
       end
 
       def run_release(src, job, signing_env, shell_dir)
-        remote_log("runner: every release (press → sign → notarize → staple)")
+        remote_log("every release — press → sign → notarize → staple")
         cmd = [RbConfig.ruby, "-I", lib_dir, every_exe, "release",
                "--root", src,
                "--target", "#{job.dig("target", "os")}-#{job.dig("target", "arch")}",
                "--channel", job.dig("target", "distribution_channel").to_s]
         cmd += ["--shell-dir", shell_dir] if shell_dir
 
-        success = stream(signing_env, cmd)
+        # The web UI renders ANSI, but `every release` runs here as a pipe (not a
+        # TTY) so it would otherwise strip all color. Force it on — for our own
+        # output and for cargo — so the hosted log looks like the local one.
+        forced = { "CLICOLOR_FORCE" => "1", "CARGO_TERM_COLOR" => "always" }
+        success = stream(forced.merge(signing_env), cmd)
 
         dist = File.join(src, "dist")
         release_json = JSON.parse(File.read(File.join(dist, "release.json"))) rescue nil
@@ -134,7 +143,7 @@ module Everywhere
       end
 
       def complete_success(zip, release_json)
-        remote_log("runner: uploading artifact (#{(File.size(zip) / 1024.0 / 1024.0).round(1)}MB)")
+        remote_log("uploading artifact #{UI.dim("(#{(File.size(zip) / 1024.0 / 1024.0).round(1)}MB)")}")
         signed_id = upload_artifact(zip)
         post!("/runner/artifacts/#{@artifact}/complete",
               status: "succeeded", file_signed_id: signed_id, release_json: release_json)
@@ -185,9 +194,13 @@ module Everywhere
         nil # never let a log hiccup kill the build
       end
 
+      # A runner-orchestration line: distinct from the `every release` steps it
+      # brackets (tagged "runner"), rendered once and forwarded verbatim — color
+      # and all — to the web log.
       def remote_log(message)
-        UI.step(message)
-        flush_log("#{message}\n")
+        line = "#{UI.gray("runner")} #{UI.cyan("→")} #{message}"
+        puts line
+        flush_log("#{line}\n")
       end
 
       # ---- helpers -------------------------------------------------------------

data/lib/everywhere/commands/release.rb

@@ -2,6 +2,7 @@
 
 require "dry/cli"
 require_relative "../shellout"
+require_relative "../log_filter"
 require_relative "../receipt"
 require_relative "../paths"
 require_relative "build"
@@ -37,7 +38,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)
@@ -48,8 +49,8 @@ module Everywhere
         # 1. Produce (or reuse) the signed-for-dev .app via the build path. The
         #    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, **)
+          UI.phase("Building #{app_name} for #{target}")
+          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) }
@@ -58,10 +59,11 @@ module Everywhere
         # 2. Sign (Developer ID + hardened runtime) → notarize → staple → verify.
         env_file ||= discover_env_file(root_path)
         env = env_file ? { "ENV_FILE" => env_file } : {}
-        UI.step("signing + notarizing #{File.basename(app_dir)}#{env_file ? " #{UI.dim("(#{rel(env_file, root_path)})")}" : ""}")
+        UI.phase("Signing & notarizing #{File.basename(app_dir)}")
+        UI.step("preparing #{File.basename(app_dir)}#{env_file ? " #{UI.dim("(env: #{rel(env_file, root_path)})")}" : ""}")
         UI.warn("no signing env found — set APPLE_* or pass --env-file (notarize.sh will fail without it)") unless env_file || ENV["APPLE_SIGNING_IDENTITY"]
         log = "#{app_dir}.notarize.log"
-        Shellout.run_logged!(env, ["/bin/bash", NOTARIZE, app_dir], log: log)
+        Shellout.run_logged!(env, ["/bin/bash", NOTARIZE, app_dir], log: log, filter: LogFilter.for(:notarize))
 
         # 3. Gather signing facts from the bundle itself, then emit the receipt.
         artifact = "#{app_dir.sub(/\.app\z/, "")}.zip" # notarize.sh re-zips the stapled app
@@ -125,18 +127,16 @@ module Everywhere
       end
 
       def summarize(out, artifact, signing, root_path)
-        UI.success("release ready")
-        UI.step("artifact: #{rel(artifact, root_path)} (#{(File.size(artifact) / 1024.0 / 1024.0).round}MB)")
-        UI.step("signed by #{signing["signed_by"] || "?"} · " \
-                "notarized #{yn(signing.dig("platform", "notarized"))} · " \
-                "stapled #{yn(signing.dig("platform", "stapled"))} · " \
-                "gatekeeper #{yn(signing["verified"])}")
-        UI.step("receipt: #{rel(out, root_path)}")
+        UI.phase("Release ready 🎉")
+        UI.success("#{rel(artifact, root_path)} #{UI.dim("(#{(File.size(artifact) / 1024.0 / 1024.0).round}MB — send this to your friends)")}")
+        UI.substep("signed by #{UI.bold(signing["signed_by"] || "?")}")
+        UI.substep("notarized #{UI.yn(signing.dig("platform", "notarized"))} · " \
+                   "stapled #{UI.yn(signing.dig("platform", "stapled"))} · " \
+                   "gatekeeper #{UI.yn(signing["verified"])}")
+        UI.substep("receipt #{UI.dim(rel(out, root_path))}")
       end
 
-      def yn(bool) = bool ? UI.green("yes") : UI.red("no")
-
-      def rel(path, root_path) = path.sub("#{root_path}/", "").sub("#{Dir.pwd}/", "")
+      def rel(path, root_path) = UI.short_path(path.sub("#{root_path}/", "").sub("#{Dir.pwd}/", ""))
     end
   end
 end

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/log_filter.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative "ui"
+
+module Everywhere
+  # Turns the raw, chatty output of the external build tools (tebako, the
+  # notarize script and the Apple tools it drives) into clean, indented, colored
+  # lines for the console and the Platform web log.
+  #
+  # A filter is a small state machine fed one raw line at a time. It returns:
+  #   * a String  -> print this (already colored/indented) instead of the raw line
+  #   * :drop     -> swallow the line (pure noise: repeated status, temp paths…)
+  #   * nil       -> not recognized; caller shows the raw line dimmed as a detail
+  #
+  # The FULL raw stream is always still written to the on-disk log, so nothing is
+  # lost — this only governs what a human sees scroll by.
+  class LogFilter
+    def self.for(profile) = new(profile)
+
+    def initialize(profile)
+      @profile = profile
+      @seen = {}
+    end
+
+    def call(raw)
+      line = raw.to_s.rstrip
+      return :drop if line.empty?
+
+      case @profile
+      when :notarize then notarize(line)
+      when :tebako   then tebako(line)
+      end
+    end
+
+    private
+
+    # --- `every release` signing pipeline (notarize.sh + Apple tools) ---------
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    def notarize(line)
+      case line
+      # notarize.sh's own "==> phase" markers become substeps.
+      when /\A==> signing with:\s*(.+)/
+        UI.substep_line("signing bundle #{UI.dim("(#{short_identity(Regexp.last_match(1))})")}")
+      when /\A==> verifying signature/
+        UI.substep_line("verifying signature")
+      when /\A==> zipping for notarization:\s*(.+)/
+        UI.substep_line("zipping for notarization #{UI.dim("→ #{File.basename(Regexp.last_match(1))}")}")
+      when /\A==> submitting to Apple notary service/
+        UI.substep_line("submitting to Apple notary service #{UI.dim("(this can take a few minutes)")}")
+      when /\A==> stapling ticket/
+        UI.substep_line("stapling notarization ticket")
+      when /\A==> Gatekeeper assessment/
+        UI.substep_line("Gatekeeper assessment")
+      when /\A==> re-zipping/
+        UI.substep_line("re-zipping stapled app for distribution")
+
+      # Per-binary signing chatter -> one dim line each (basename only).
+      when /\A\s+sign (.+)/
+        UI.note_line("signed #{File.basename(Regexp.last_match(1))}")
+      when /: replacing existing signature/
+        :drop
+
+      # codesign --verify / stapler / spctl outcomes.
+      when /: valid on disk/
+        UI.note_line("valid on disk", marker: "✓", color: :green)
+      when /: satisfies its Designated Requirement/
+        :drop
+      when /The staple and validate action worked!/
+        UI.note_line("stapled and validated", marker: "✓", color: :green)
+      when /The validate action worked!/
+        :drop
+      when /\A(.+): accepted/
+        UI.note_line("Gatekeeper accepted", marker: "✓", color: :green)
+      when /\Asource=/, /\Aorigin=/
+        UI.note_line(line)
+
+      # notarytool --wait progress. Collapse the repeated dotted "In Progress"
+      # lines into a single heartbeat, and celebrate the terminal states.
+      when /Current status:\s*Accepted/
+        UI.note_line("notarization accepted", marker: "✓", color: :green)
+      when /Current status:\s*(Invalid|Rejected)/
+        UI.note_line("notarization #{Regexp.last_match(1).downcase}", marker: "✗", color: :red)
+      when /Current status:\s*In Progress/
+        once(:progress) { UI.note_line("waiting on Apple…", marker: "⋯") }
+      when /\A\s*id:\s*([0-9a-fA-F-]{36})/
+        once(:submission) { UI.note_line("submission #{Regexp.last_match(1)[0, 8]}…") }
+
+      # Pure noise from notarytool's own prose / the final banner (release.rb
+      # prints its own summary, so drop notarize.sh's).
+      when /\AConducting pre-submission checks/,
+           /\ASubmission ID received/,
+           /\ASuccessfully uploaded file/,
+           /\A\s*path:/,
+           /\A\s*status:/,
+           /\AWaiting for processing/,
+           /\AProcessing:/,
+           /Processing complete/,
+           /\A✅ Done\./,
+           /Send this to your friend/,
+           /Stapled, so it works even offline/,
+           /zipping preserves the signature/
+        :drop
+
+      else
+        nil # unrecognized -> caller shows it dimmed
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+    # --- tebako press ---------------------------------------------------------
+    #
+    # Thousands of lines of C++/Ruby build output. We can't restructure it, but
+    # we can keep errors/warnings legible and dim the rest into the background so
+    # the important lines (and our own steps around it) stand out.
+    def tebako(line)
+      short = UI.short_path(line)
+      case line
+      when /\b(error|fatal|undefined reference|cannot find)\b/i
+        "    #{UI.red(short)}"
+      when /\b(warning|deprecated)\b/i
+        "    #{UI.yellow(short)}"
+      when /\A-- /, /\bBuilding\b/, /\bConfiguring\b/, /\bInstalling\b/
+        UI.note_line(short.sub(/\A-- /, ""))
+      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).
+    def once(key)
+      return :drop if @seen[key]
+
+      @seen[key] = true
+      yield
+    end
+
+    # "Developer ID Application: Andrea Fomera (TU4485Z3KR)" or a bare SHA-1.
+    def short_identity(id)
+      id = id.strip
+      return "#{id[0, 10]}…" if id.match?(/\A[0-9A-F]{40}\z/i)
+
+      id[/\(([^)]+)\)\s*\z/, 1] || id
+    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/shellout.rb

@@ -31,14 +31,45 @@ module Everywhere
       ["", nil]
     end
 
-    # Run a command streaming to the console while also capturing to a log file.
-    def run_logged!(env, cmd, log:)
-      require "shellwords"
-      line = "#{cmd.shelljoin} 2>&1 | tee #{log.shellescape}"
-      success = unbundled { system(env, "/bin/bash", "-o", "pipefail", "-c", line) }
+    # Run a command, capturing its full combined output to a log file while
+    # showing a (optionally filtered) view on the console.
+    #
+    # Pass filter: a LogFilter (or any #call(line) -> String | :drop | nil) to
+    # prettify what a human sees; the on-disk log always gets the raw stream, so
+    # nothing is lost. Unrecognized lines (filter returns nil) are shown dimmed
+    # and indented so they read as background detail under the current step.
+    def run_logged!(env, cmd, log:, filter: nil)
+      require "open3"
+      success = false
+      unbundled do
+        File.open(log, "w") do |logf|
+          Open3.popen2e(env, *cmd) do |stdin, out, wait|
+            stdin.close
+            out.each_line do |raw|
+              logf.write(raw)
+              emit(raw, filter)
+            end
+            success = wait.value.success?
+          end
+        end
+      end
       UI.die!("command failed: #{cmd.join(" ")} (full log: #{log})") unless success
     end
 
+    # Route one raw line to the console: verbatim when there's no filter, else
+    # the filter's rendition (:drop swallows it, nil falls back to dim detail).
+    def emit(raw, filter)
+      return $stdout.print(raw) unless filter
+
+      shown = filter.call(raw)
+      case shown
+      when :drop, false then nil
+      when nil          then $stdout.puts("    #{UI.gray(UI.short_path(raw.rstrip))}")
+      else                   $stdout.puts(shown)
+      end
+    end
+    private_class_method :emit
+
     def spawn(env, cmd, chdir:)
       unbundled { Process.spawn(env, cmd, chdir: chdir) }
     end

data/lib/everywhere/ui.rb

@@ -3,6 +3,10 @@
 module Everywhere
   # Terminal output helpers. Colors follow the informal standard:
   # on when stdout is a TTY or CLICOLOR_FORCE=1, always off when NO_COLOR is set.
+  #
+  # The hosted runner streams `every release` through a pipe (not a TTY) into the
+  # Platform web log, so it exports CLICOLOR_FORCE=1 to keep our color — the web
+  # UI renders ANSI. That's why we force rather than sniff the TTY there.
   module UI
     module_function
 
@@ -17,21 +21,76 @@ module Everywhere
       color? ? "\e[#{codes.join(";")}m#{text}\e[0m" : text.to_s
     end
 
-    def bold(t)   = paint(t, 1)
-    def dim(t)    = paint(t, 2)
-    def red(t)    = paint(t, 31)
-    def green(t)  = paint(t, 32)
-    def yellow(t) = paint(t, 33)
-    def cyan(t)   = paint(t, 36)
+    def bold(t)    = paint(t, 1)
+    def dim(t)     = paint(t, 2)
+    def red(t)     = paint(t, 31)
+    def green(t)   = paint(t, 32)
+    def yellow(t)  = paint(t, 33)
+    def blue(t)    = paint(t, 34)
+    def magenta(t) = paint(t, 35)
+    def cyan(t)    = paint(t, 36)
+    def gray(t)    = paint(t, 90) # bright black — dimmer than dim() on most themes
 
-    def step(msg)    = puts("#{cyan("→")} #{msg}")
-    def ok(msg)      = puts("#{green("✓")} #{msg}")
-    def bad(msg)     = puts("#{red("✗")} #{msg}")
-    def warn(msg)    = puts("#{yellow("!")} #{msg}")
-    def success(msg) = puts("#{green("✓")} #{bold(msg)}")
+    # --- output levels --------------------------------------------------------
+    #
+    #   phase   ●  a major phase boundary (build / sign / notarize)
+    #   step    →  a top-level action inside a phase
+    #   substep ▸  a sub-action under a step (indented)
+    #   detail  ·  raw-ish detail under a substep (indented + dim)
+    #
+    # Every level has a *_line string builder (used by LogFilter, which returns
+    # lines for someone else to print) and a printer that puts it. ok / success /
+    # warn / bad / die! carry outcomes at any level.
+
+    def phase_line(msg)   = "\n#{bold(cyan("●"))} #{bold(msg)}"
+    def step_line(msg)    = "#{cyan("→")} #{msg}"
+    def substep_line(msg) = "  #{cyan("▸")} #{msg}"
+    def detail_line(msg)  = "    #{gray("·")} #{gray(msg)}"
+    def ok_line(msg)      = "#{green("✓")} #{msg}"
+    def bad_line(msg)     = "#{red("✗")} #{msg}"
+    def warn_line(msg)    = "#{yellow("!")} #{msg}"
+    def success_line(msg) = "#{green("✓")} #{bold(msg)}"
+
+    def phase(msg)   = puts(phase_line(msg))
+    def step(msg)    = puts(step_line(msg))
+    def substep(msg) = puts(substep_line(msg))
+    def detail(msg)  = puts(detail_line(msg))
+    def ok(msg)      = puts(ok_line(msg))
+    def bad(msg)     = puts(bad_line(msg))
+    def warn(msg)    = puts(warn_line(msg))
+    def success(msg) = puts(success_line(msg))
+
+    # An indented, dim outcome under a substep — e.g. "accepted", "valid on disk".
+    def note_line(msg, marker: "·", color: :gray)
+      tint = respond_to?(color) ? method(color) : method(:gray)
+      "    #{tint.call(marker)} #{tint.call(msg)}"
+    end
+
+    def note(msg, marker: "·", color: :gray) = puts(note_line(msg, marker: marker, color: color))
 
     def die!(msg)
       abort "#{red("✗")} #{red(msg)}"
     end
+
+    # A yes/no fact, colored by truthiness (for signing receipts).
+    def yn(bool) = bool ? green("yes") : red("no")
+
+    # --- path shortening ------------------------------------------------------
+
+    # Collapse the noisy machine paths that external tools echo (codesign,
+    # notarytool, stapler) down to something a human can scan. In particular the
+    # runner works out of a deep `/var/folders/…/every-runner…/src/` sandbox — we
+    # strip that prefix so only the meaningful `dist/App.app` tail remains. Then
+    # $HOME → ~ and the cwd → a leading (dropped) prefix.
+    def short_path(str)
+      s = str.to_s.dup
+      # Runner/local temp sandboxes: keep only the part after the extracted src/.
+      s = s.gsub(%r{/(?:private/)?(?:var|tmp)/[^\s"']*?/every-[a-z]+[0-9A-Za-z_-]+/src/}, "")
+      # Any other everywhere-* scratch dir: keep the basename tail.
+      s = s.gsub(%r{/(?:private/)?(?:var|tmp)/[^\s"']*?/everywhere-[a-z]+[0-9A-Za-z_.-]*/}, "")
+      home = ENV["HOME"]
+      s = s.gsub("#{home}/", "~/") if home && !home.empty?
+      s
+    end
   end
 end

data/lib/everywhere/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.1.3"
+  VERSION = "0.1.5"
 
   # 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.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Andrea Fomera
@@ -69,6 +69,7 @@ files:
 - lib/everywhere/icon.rb
 - lib/everywhere/ignore.rb
 - lib/everywhere/javascript/bridge.js
+- lib/everywhere/log_filter.rb
 - lib/everywhere/paths.rb
 - lib/everywhere/platform/client.rb
 - lib/everywhere/platform/credentials.rb