ruby_everywhere 0.1.14 → 0.2.0

data/lib/everywhere/commands/dev.rb

@@ -2,48 +2,211 @@
 
 require "dry/cli"
 require "socket"
+require "shellwords"
 require_relative "../shellout"
 require_relative "../paths"
+require_relative "../builders/ios"
+require_relative "../simulator"
+require_relative "logs"
 
 module Everywhere
   module Commands
-    # Run the app's normal dev server and open the desktop shell pointed at it.
-    # No packaging: the shell skips the sidecar when NATIVE_DEV_URL is set,
-    # so the edit-refresh loop is untouched Rails/Hanami.
+    # Run the app's normal dev server and open native shells pointed at it.
+    # No packaging: the desktop shell skips the sidecar when NATIVE_DEV_URL is
+    # set, and the iOS shell reads EVERYWHERE_DEV_URL at launch — so the
+    # edit-refresh loop is untouched Rails/Hanami either way.
+    #
+    # Target flags are additive (--desktop --ios --browser opens all three);
+    # with no flags the server boots and a key menu launches shells on demand.
     class Dev < Dry::CLI::Command
-      desc "Run the dev server inside the desktop shell (live reload, no packaging)"
+      desc "Run the dev server with native shells on demand (live reload, no packaging)"
 
       option :port,      default: "3000", desc: "Dev server port"
       option :shell_dir, default: nil,    desc: "Path to the shell's src-tauri directory"
+      option :target,    default: nil,    desc: "Single shell to open: macos (desktop) or ios (Simulator)"
+      option :desktop,   type: :boolean, default: false, desc: "Open the desktop shell"
+      option :ios,       type: :boolean, default: false, desc: "Open the iOS Simulator shell"
+      option :browser,   type: :boolean, default: false, desc: "Open the app in the default browser"
 
-      def call(port: "3000", shell_dir: nil, **)
-        framework = Framework.detect
-        config = Everywhere::Config.load(framework.root)
-        shell_dir ||= Everywhere::Paths.shell_dir!
+      def call(port: "3000", shell_dir: nil, target: nil, desktop: false, ios: false, browser: false, **)
+        @shell_dir = shell_dir
+        targets = requested_targets(target, desktop: desktop, ios: ios, browser: browser)
+        framework, @config = detect_app
+
+        start_server(framework, port)
+        @dev_url = if framework
+                     "http://127.0.0.1:#{port}#{@config.entry_path}"
+                   else
+                     "#{@config.remote_url}#{@config.entry_path}"
+                   end
+
+        # Headless (non-tty) runs can't take keystrokes, so keep the old
+        # default of the desktop shell.
+        targets << "desktop" if targets.empty? && !$stdin.tty?
+        targets.each { |t| launch(t) }
+
+        $stdin.tty? ? interact : wait_for_children
+      rescue Interrupt
+        nil
+      ensure
+        teardown
+      end
+
+      private
+
+      def requested_targets(target, desktop:, ios:, browser:)
+        targets = []
+        targets << "desktop" if desktop || (target && Everywhere::Config.os_of(target) != "ios")
+        targets << "ios"     if ios     || (target && Everywhere::Config.os_of(target) == "ios")
+        targets << "browser" if browser
+        targets
+      end
+
+      # The framework (nil for remote-only roots) and config. A root with
+      # neither a framework nor remote.url is a genuine error.
+      def detect_app
+        framework = begin
+          Framework.detect
+        rescue Everywhere::Error
+          nil
+        end
+        config = Everywhere::Config.load(framework ? framework.root : Dir.pwd)
+        unless framework || config.remote?
+          UI.die!("no supported framework here (Rails, Hanami, Sinatra) and no remote.url in " \
+                  "config/everywhere.yml — nothing to run")
+        end
+        [framework, config]
+      end
+
+      def start_server(framework, port)
+        unless framework
+          # Remote-mode app with no local code (just everywhere.yml): nothing
+          # to serve, point the shells straight at the deployed app.
+          UI.step("#{UI.bold("remote")} mode → #{UI.cyan(@config.remote_url)} #{UI.dim("(no local server)")}")
+          return
+        end
 
-        server_pid = nil
         if port_open?(port)
           UI.warn "something is ALREADY RUNNING on port #{port} — attaching to it instead of starting"
           UI.warn "#{UI.dim("your Procfile.dev/watchers are NOT running; stop that server or use --port if this isn't yours")}"
         else
           UI.step("starting #{UI.bold(framework.name)} dev server #{UI.dim("(" + framework.dev_command + ")")}")
-          server_pid = Shellout.spawn({ "PORT" => port.to_s }, framework.dev_command, chdir: framework.root)
+          @server_pid = Shellout.spawn({ "PORT" => port.to_s }, framework.dev_command, chdir: framework.root)
+          @server_thread = Process.detach(@server_pid)
           wait_for_port(port)
         end
+      end
+
+      def launch(target)
+        case target
+        when "ios"     then launch_ios
+        when "browser" then launch_browser
+        else                launch_desktop
+        end
+      end
+
+      def launch_desktop
+        if @desktop_pid && alive?(@desktop_pid)
+          UI.warn "desktop shell already running"
+          return
+        end
+        dir = @shell_dir || Everywhere::Paths.shell_dir!
+        UI.step("opening desktop shell → #{UI.cyan(@dev_url)}")
+        @desktop_pid = Shellout.spawn({ "NATIVE_DEV_URL" => @dev_url, "NATIVE_CONFIG" => @config.to_shell_json,
+                                        "CARGO_TARGET_DIR" => Everywhere::Paths.cargo_target_dir },
+                                      "cargo run", chdir: dir)
+        @desktop_thread = Process.detach(@desktop_pid)
+      end
+
+      # Build the shell (Debug, warm after the first run), put it on a booted
+      # Simulator and hand it the dev URL. The Simulator shares the Mac's
+      # loopback, so 127.0.0.1 works as-is; the template's ATS exception
+      # covers plain http for local networking. Pressing i again rebuilds and
+      # relaunches, so it doubles as a native-shell reload.
+      def launch_ios
+        app = Builders::Ios.new(config: @config, root: @config.root, target: "ios-arm64")
+                           .build!(dist_dir: File.expand_path("dist", @config.root), dev: true)
 
-        dev_url = "http://127.0.0.1:#{port}#{config.entry_path}"
-        UI.step("opening desktop shell → #{UI.cyan(dev_url)}")
-        Shellout.run!({ "NATIVE_DEV_URL" => dev_url, "NATIVE_CONFIG" => config.to_shell_json,
-                        "CARGO_TARGET_DIR" => Everywhere::Paths.cargo_target_dir },
-                      "cargo", "run", chdir: shell_dir)
+        udid = Simulator.boot_default!
+        UI.step("installing #{UI.bold(File.basename(app))}")
+        Simulator.install(udid, app)
+        UI.step("launching → #{UI.cyan(@dev_url)}")
+        Simulator.launch(udid, @config.bundle_id(target: "ios-arm64"), env: { "EVERYWHERE_DEV_URL" => @dev_url })
+      end
+
+      def launch_browser
+        UI.step("opening browser → #{UI.cyan(@dev_url)}")
+        opener = RUBY_PLATFORM.include?("darwin") ? "open" : "xdg-open"
+        Shellout.run?(opener, @dev_url, quiet: true)
+      end
+
+      # Toggle the `every logs --ios` stream, interleaved with the server
+      # output on this same terminal.
+      def toggle_logs
+        if @logs_pid && alive?(@logs_pid)
+          stop(@logs_pid)
+          @logs_pid = nil
+          UI.step("stopped iOS Simulator logs")
+          return
+        end
+
+        udid = Simulator.booted_udid
+        unless udid
+          UI.warn "no booted iOS Simulator — press #{UI.bold("i")} first"
+          return
+        end
+        UI.step("watching iOS Simulator logs #{UI.dim("(press l again to stop)")}")
+        @logs_pid = Shellout.spawn({}, Logs.new.argv(udid).shelljoin, chdir: Dir.pwd)
+      end
+
+      # Key menu. io/console's getch holds full raw mode while blocked, which
+      # clears OPOST and stair-steps every log line the server prints; stty
+      # -icanon -echo disables only line buffering and echo, leaving output
+      # processing (and Ctrl-C as SIGINT) intact.
+      def interact
+        UI.note("press #{UI.bold("d")} desktop · #{UI.bold("i")} iOS Simulator · #{UI.bold("b")} browser · " \
+                "#{UI.bold("l")} iOS logs · #{UI.bold("q")} quit", marker: "⌨", color: :cyan)
+        saved_tty = `stty -g`.chomp
+        system("stty", "-icanon", "-echo")
+        loop do
+          case $stdin.getc
+          when "d"               then launch("desktop")
+          when "i"               then launch("ios")
+          when "b"               then launch("browser")
+          when "l"               then toggle_logs
+          when "q", "\u0004", nil then break # q, Ctrl-D, EOF (Ctrl-C stays a real SIGINT)
+          end
+        end
       ensure
-        if server_pid
-          Process.kill("TERM", -Process.getpgid(server_pid)) rescue Process.kill("TERM", server_pid) rescue nil
-          Process.wait(server_pid) rescue nil
+        system("stty", saved_tty) unless saved_tty.to_s.empty?
+      end
+
+      def wait_for_children
+        (@server_thread || @desktop_thread)&.join
+      end
+
+      def teardown
+        [@server_pid, @desktop_pid, @logs_pid].compact.each { |pid| stop(pid) }
+      end
+
+      def stop(pid)
+        return unless alive?(pid)
+
+        begin
+          Process.kill("TERM", -Process.getpgid(pid))
+        rescue StandardError
+          Process.kill("TERM", pid) rescue nil
         end
       end
 
-      private
+      def alive?(pid)
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH
+        false
+      rescue Errno::EPERM
+        true
+      end
 
       def port_open?(port)
         TCPSocket.new("127.0.0.1", Integer(port)).close

data/lib/everywhere/commands/doctor.rb

@@ -2,19 +2,27 @@
 
 require "dry/cli"
 require_relative "../shellout"
+require_relative "../paths"
 
 module Everywhere
   module Commands
-    # Check that this machine can build desktop apps.
+    # Check that this machine can build native apps. Desktop checks always
+    # run; the iOS section joins in when the app's build.targets include an
+    # ios target, or explicitly via --target ios-*.
     class Doctor < Dry::CLI::Command
-      desc "Check the toolchain (rbe-tebako, rust, brew deps)"
+      desc "Check the toolchain (rbe-tebako, rust, brew deps; Xcode for iOS targets)"
 
-      def call(**)
+      option :root,   default: ".", desc: "App root (its build.targets pick the sections)"
+      option :target, default: nil, desc: "Also check a specific target's toolchain (e.g. ios-arm64)"
+
+      def call(root: ".", target: nil, **)
         ok = true
         ok &= check("rbe-tebako installed") { Shellout.run?("rbe-tebako help > /dev/null 2>&1") }
         ok &= check("cargo installed")    { Shellout.run?("cargo --version > /dev/null 2>&1") }
         ok &= check("homebrew bison")     { !`brew --prefix bison 2>/dev/null`.strip.empty? }
 
+        ok &= ios_checks if ios_wanted?(root, target)
+
         puts
         ok ? UI.success("ready to build") : UI.bad("fix the items above (see https://rubyeverywhere.com/docs/diy/requirements)")
         exit(1) unless ok
@@ -22,6 +30,40 @@ module Everywhere
 
       private
 
+      def ios_wanted?(root, target)
+        return true if target && Everywhere::Config.os_of(target) == "ios"
+
+        Everywhere::Config.load(File.expand_path(root)).targets
+                          .any? { |t| Everywhere::Config.os_of(t) == "ios" }
+      rescue StandardError
+        false
+      end
+
+      def ios_checks
+        puts
+        UI.step("iOS target")
+        ok = check("full Xcode selected") { Shellout.run?("xcodebuild -version > /dev/null 2>&1") }
+        ok &= check("iOS Simulator SDK") do
+          Shellout.run?("xcrun", "--sdk", "iphonesimulator", "--show-sdk-path", quiet: true)
+        end
+        # A runtime matching the SDK's iOS version specifically: a half-installed
+        # platform (download interrupted mid-registration) leaves older runtimes
+        # in place and fails builds with "No simulator runtime version … available"
+        # / "Platform Not Installed". `xcodebuild -downloadPlatform iOS` fixes it.
+        ok &= check("Simulator runtime matches the iOS SDK (xcodebuild -downloadPlatform iOS)") do
+          sdk, = Shellout.capture("xcrun", "--sdk", "iphonesimulator", "--show-sdk-version")
+          version = sdk.strip[/\A\d+\.\d+/]
+          # `runtime list` shows the disk images; `list runtimes` can lag on
+          # lazily-mounted ones, so accept a Ready image OR a registered runtime.
+          images, = Shellout.capture("xcrun", "simctl", "runtime", "list")
+          runtimes, = Shellout.capture("xcrun", "simctl", "list", "runtimes")
+          !version.nil? && (images.match?(/iOS #{Regexp.escape(version)}.*\(Ready\)/) ||
+                            runtimes.include?("iOS #{version}"))
+        end
+        ok &= check("bundled iOS shell template") { !Everywhere::Paths.ios_dir.nil? }
+        ok
+      end
+
       def check(label)
         passed = yield
         passed ? UI.ok(label) : UI.bad(label)

data/lib/everywhere/commands/icon.rb

@@ -36,6 +36,11 @@ module Everywhere
         Everywhere::Icon.write_icns(master, File.join(out, "AppIcon.icns"))
         UI.ok("macOS icon    AppIcon.icns")
 
+        background = ios_background(root_path)
+        Everywhere::Icon.write_ios_appiconset(source, File.join(out, "ios", "AppIcon.appiconset"),
+                                              background: background)
+        UI.ok("iOS icon      ios/AppIcon.appiconset #{UI.dim("(full-bleed 1024px, alpha flattened)")}")
+
         Everywhere::Icon.write_ico(source, File.join(out, "icon.ico"))
         UI.ok("Windows icon  icon.ico")
 
@@ -57,6 +62,15 @@ module Everywhere
         default = File.join(root_path, "icon.png")
         File.exist?(default) ? default : nil
       end
+
+      # The iOS icon's flatten backdrop: the app's light background color when
+      # set, else Icon's white default.
+      def ios_background(root_path)
+        color = Everywhere::Config.load(root_path).background_color
+        Everywhere::Icon.hex_rgb(color && color["light"])
+      rescue StandardError
+        nil
+      end
     end
   end
 end

data/lib/everywhere/commands/install.rb

@@ -66,13 +66,15 @@ module Everywhere
       # Rack frameworks vary too much to auto-edit their boot files safely, so we
       # vendor the bridge and print the remaining wiring rather than guess.
       def vendor_bridge_to_public
-        source = File.expand_path("../../../bridge/everywhere/bridge.js", __dir__)
         target_dir = app_file("public")
         FileUtils.mkdir_p(target_dir)
-        target = File.join(target_dir, "bridge.js")
-        fresh = !File.exist?(target) || File.read(target) != File.read(source)
-        FileUtils.cp(source, target) if fresh
-        change("vendor @rubyeverywhere/bridge to public/bridge.js", fresh)
+        %w[bridge.js native.css].each do |name|
+          source = File.expand_path("../../../bridge/everywhere/#{name}", __dir__)
+          target = File.join(target_dir, name)
+          fresh = !File.exist?(target) || File.read(target) != File.read(source)
+          FileUtils.cp(source, target) if fresh
+          change("vendor @rubyeverywhere/bridge to public/#{name}", fresh)
+        end
       end
 
       def guide_rack_manual_steps(db:, boot:, script:)
@@ -130,6 +132,13 @@ module Everywhere
               light: "#FFFFFF"
               dark: "#1C1B1A"
 
+          # Native permissions the app may request — only declared ones can prompt.
+          # camera/location values are the sentence iOS shows when asking (mandatory).
+          # permissions:
+          #   notifications: true
+          #   camera: "Scan QR codes to pair devices."
+          #   location: "Find things near you."
+
           # Native menu-bar items — each one visits a route in your app (no native code).
           # menu:
           #   - label: Settings…
@@ -149,12 +158,34 @@ module Everywhere
           #   - label: Quit
           #     action: quit
 
+          # Mobile tab bar (iOS today, Android soon). Served live from
+          # /everywhere/ios_v1.json too, so tab changes deploy with the app —
+          # no app-store release. Icons: ios = SF Symbol name.
+          # tabs:
+          #   - name: Home
+          #     path: /
+          #     icons:
+          #       ios: house
+          #   - name: Settings
+          #     path: /settings
+          #     icons:
+          #       ios: gear
+
+          # iOS-specific knobs (and native Swift you compile into the shell —
+          # see /docs/diy/native-extensions).
+          # native:
+          #   ios:
+          #     lazy_load_tabs: true   # defer each tab's first load until it's tapped
+          #                            # (false = load every tab up front; omit = default)
+
           # 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
+          #     # - ios-arm64         # Hotwire Native shell; remote mode only. Local builds
+          #     #                     # (`every build` / `every dev --ios`) work today;
+          #     #                     # hosted platform builds for iOS aren't live yet.
           #     # - android-arm64     # future — mobile is remote mode only
           #   permissions: [notifications, filesystem:read, clipboard]
 

data/lib/everywhere/commands/logs.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require_relative "../simulator"
+require_relative "../ui"
+
+module Everywhere
+  module Commands
+    # Tail the native shell's logs. iOS only so far: the Simulator's unified
+    # log, scoped to the shell process. Watches (log stream) by default;
+    # --last replays recent history (log show) and exits.
+    class Logs < Dry::CLI::Command
+      desc "Stream native shell logs (iOS Simulator; watches by default)"
+
+      option :ios,     type: :boolean, default: false, desc: "iOS Simulator logs (the only target so far)"
+      option :last,    default: nil, desc: 'Show recent history instead of watching (e.g. "5m", "1h")'
+      option :udid,    default: nil, desc: "Simulator UDID (default: the booted one)"
+      option :verbose, type: :boolean, default: false, desc: "Everything the shell process logs, debug level included"
+
+      # The template contract fixes the product name (App.app), so the shell's
+      # process on the Simulator is always "App" — one predicate covers every
+      # Everywhere app without knowing which one is installed. Scoping to the
+      # process alone still yields ~100k lines/half hour of Apple-framework
+      # chatter (WebKit resource loads, activities); the default predicate
+      # keeps what a shell developer logs — NSLog (Foundation sender, no
+      # subsystem), Hotwire Native's subsystem, UIKit warnings — and drops the
+      # rest. --verbose falls back to the whole process.
+      PREDICATE = 'process == "App" AND eventType == logEvent AND NOT subsystem BEGINSWITH "com.apple"'
+      VERBOSE_PREDICATE = 'process == "App"'
+
+      def call(ios: false, last: nil, udid: nil, verbose: false, **)
+        UI.die!("only the iOS Simulator is supported so far — run: every logs --ios") unless ios
+
+        udid ||= Everywhere::Simulator.booted_udid
+        UI.die!("no booted iOS Simulator — start one with `every dev --ios`") unless udid
+
+        UI.step(last ? "iOS Simulator logs from the last #{UI.bold(last)}"
+                     : "watching iOS Simulator logs #{UI.dim("(Ctrl-C to stop)")}")
+        exec(*argv(udid, last: last, verbose: verbose))
+      end
+
+      # simctl spawn runs the `log` tool inside the Simulator runtime — the
+      # supported way to read a Simulator's unified log from the host. `log show`
+      # spells verbosity --info/--debug where `log stream` takes --level.
+      def argv(udid, last: nil, verbose: false)
+        argv = ["xcrun", "simctl", "spawn", udid, "log"]
+        argv += if last
+                  ["show", "--last", last, *(verbose ? ["--info", "--debug"] : [])]
+                else
+                  ["stream", *(verbose ? ["--level", "debug"] : [])]
+                end
+        argv + ["--style", "compact", "--predicate", verbose ? VERBOSE_PREDICATE : PREDICATE]
+      end
+    end
+  end
+end

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

@@ -49,13 +49,17 @@ module Everywhere
           ).manifest
 
           build = submit(client, targets, channel, signed_id, manifest)
-          UI.success("submitted #{UI.bold(build["id"])} for #{targets.join(", ")}")
+          UI.success("submitted #{UI.bold(build["id"])} for #{targets.map { |t| UI.target_label(t) }.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
 
+          # Set expectations before the quiet part: a hosted macOS runner is not
+          # instant, and knowing that up front is the difference between "slow"
+          # and "broken".
+          UI.substep(UI.dim("hosted macOS runners usually start within a few minutes"))
           final = poll_and_tail(client, build["id"])
           report(client, final, output || File.join(root_path, "dist"), download)
         end
@@ -94,7 +98,7 @@ module Everywhere
           UI.bad("can't build yet — missing signing credentials:")
           Array(res.body["targets"]).each do |t|
             tgt = t["target"] || {}
-            UI.step("#{tgt["os"]}-#{tgt["arch"]}/#{tgt["distribution_channel"]}: add #{Array(t["missing"]).join(", ")}")
+            UI.step("#{UI.os_label(tgt["os"])}-#{tgt["arch"]}/#{tgt["distribution_channel"]}: add #{Array(t["missing"]).join(", ")}")
           end
           UI.step("set them up → #{UI.cyan(res.body["manage_url"])}")
           exit 1
@@ -102,24 +106,74 @@ module Everywhere
         UI.die!("build submission failed (HTTP #{res.status}) #{res.body["error"]}")
       end
 
+      # How often we ask the Platform for new logs. A build spends most of its
+      # wall clock before the first log byte (GitHub queue + toolchain), so poll
+      # lazily until something is actually building, then tighten up so the log
+      # tails smoothly.
+      IDLE_POLL    = 5
+      ACTIVE_POLL  = 2
+      SPINNER_TICK = 0.2
+
       def poll_and_tail(client, build_id)
         printed = Hash.new("")
         last = {}
+        started = now
+        status = UI::Status.new
+
         loop do
           res = client.get("/cli/builds/#{build_id}/logs")
-          if res.ok?
-            artifacts = res.body["artifacts"] || []
-            artifacts.each do |artifact|
-              tail_log(artifact, printed)
-              announce_status(artifact, last)
-            end
-            break if artifacts.any? && artifacts.all? { |a| terminal?(a["status"]) }
+          artifacts = res.ok? ? (res.body["artifacts"] || []) : []
+
+          status.clear
+          artifacts.each do |artifact|
+            tail_log(artifact, printed)
+            announce_phase(artifact, last)
           end
-          sleep(2)
+          break if artifacts.any? && artifacts.all? { |a| terminal?(a["status"]) }
+
+          interval = artifacts.any? { |a| a["status"] == "running" } ? ACTIVE_POLL : IDLE_POLL
+          spin(status, artifacts, started, interval)
         end
+
         client.get("/cli/builds/#{build_id}").body
+      ensure
+        status&.clear
+      end
+
+      # Hold the status line alive for `interval` seconds. The spinner ticks far
+      # faster than we poll so the line reads as "alive" during the multi-minute
+      # pre-runner wait rather than freezing between requests.
+      def spin(status, artifacts, started, interval)
+        deadline = now + interval
+        loop do
+          status.update("#{waiting_summary(artifacts)} · #{UI.elapsed(now - started)} elapsed")
+          remaining = deadline - now
+          break if remaining <= 0
+
+          sleep([remaining, SPINNER_TICK].min)
+        end
+      end
+
+      # What to show on the status line. One target names its phase; several
+      # collapse to a count, since per-target detail already lands as permanent
+      # `announce_phase` lines.
+      def waiting_summary(artifacts)
+        pending = artifacts.reject { |a| terminal?(a["status"]) }
+        return "waiting for the build" if pending.empty?
+        return phase_text(pending.first) if pending.size == 1
+
+        "#{pending.size} of #{artifacts.size} targets in progress"
+      end
+
+      # `phase_label` is a newer field; fall back to the status so this still
+      # says something useful against an older Platform.
+      def phase_text(artifact)
+        label = artifact["phase_label"].to_s
+        label.empty? ? artifact["status"].to_s : label
       end
 
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
       def tail_log(artifact, printed)
         full = artifact["log"].to_s
         prev = printed[artifact["id"]]
@@ -129,11 +183,16 @@ module Everywhere
         printed[artifact["id"]] = full
       end
 
-      def announce_status(artifact, last)
-        return if last[artifact["id"]] == artifact["status"]
+      # A permanent line per boundary crossed. Keyed on phase, not status: the
+      # whole point is that `status` sits on `queued` through the dispatch, the
+      # GitHub queue wait, and toolchain setup — three stages the developer used
+      # to experience as one unexplained silence.
+      def announce_phase(artifact, last)
+        key = artifact["phase"] || artifact["status"]
+        return if last[artifact["id"]] == key
 
-        UI.step("#{label(artifact["target"])} → #{artifact["status"]}")
-        last[artifact["id"]] = artifact["status"]
+        UI.step("#{label(artifact["target"])} → #{phase_text(artifact)}")
+        last[artifact["id"]] = key
       end
 
       def report(client, build, out_dir, download)
@@ -173,7 +232,7 @@ module Everywhere
       end
 
       def label(target)
-        target ? "#{target["os"]}-#{target["arch"]}" : "target"
+        target ? "#{UI.os_label(target["os"])}-#{target["arch"]}" : "target"
       end
 
       def terminal?(status) = %w[succeeded failed].include?(status)

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

@@ -43,7 +43,7 @@ module Everywhere
 
         job = get!("/runner/artifacts/#{artifact}")
         patch!("/runner/artifacts/#{artifact}", status: "running")
-        remote_log("picked up #{UI.cyan("#{job.dig("target", "os")}-#{job.dig("target", "arch")}")} for #{UI.bold(job.dig("app", "name"))}")
+        remote_log("picked up #{UI.cyan("#{UI.os_label(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)
@@ -149,6 +149,7 @@ module Everywhere
       end
 
       def complete_success(zip, release_json)
+        report_phase("uploading")
         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",
@@ -200,6 +201,14 @@ module Everywhere
         nil # never let a log hiccup kill the build
       end
 
+      # Progress ping for the phases that produce no log output — same contract
+      # as the workflow's curl steps, and just as non-fatal.
+      def report_phase(name)
+        @client.post("/runner/artifacts/#{@artifact}/phase", phase: name)
+      rescue Everywhere::Error
+        nil
+      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.

data/lib/everywhere/commands/release.rb

@@ -49,7 +49,7 @@ 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.phase("Building #{app_name} for #{target}")
+          UI.phase("Building #{app_name} for #{UI.target_label(target)}")
           Build.new.call(root: root, ruby: ruby, entry: entry, app_name: app_name, target: target, shell_dir: shell_dir, **)
         end