ruby_everywhere 0.3.0 → 0.5.0

data/lib/everywhere/paths.rb

@@ -12,24 +12,28 @@ module Everywhere
       File.expand_path("../..", __dir__)
     end
 
-    # The generic Tauri shell bundled inside the gem: support/shell/ holds the
-    # src-tauri app and the splash/ dir it serves. This is the CANONICAL copy of
-    # the shell — external consumers (e.g. the build-runner repo) resolve it via
+    # The generic Tauri shell bundled inside the gem: support/desktop/ holds the
+    # src-tauri app and the splash/ dir it serves, alongside support/mobile/ios
+    # and support/mobile/android. This is the CANONICAL copy of the shell —
+    # external consumers (e.g. the build-runner repo) resolve it via
     # `every shell-dir`. The CLI uses it unless the caller passes --shell-dir.
-    def bundled_shell_dir
-      File.join(gem_root, "support", "shell", "src-tauri")
+    #
+    # The directory is named for the platform; the reader keeps the "shell"
+    # wording because that's what the flag, the command and every caller call it.
+    def bundled_desktop_dir
+      File.join(gem_root, "support", "desktop", "src-tauri")
     end
 
     # Absolute path to the shell's src-tauri directory, or nil if the bundled
     # copy is missing (a corrupt/partial install).
     def shell_dir
-      bundled_shell_dir if File.exist?(File.join(bundled_shell_dir, "tauri.conf.json"))
+      bundled_desktop_dir if File.exist?(File.join(bundled_desktop_dir, "tauri.conf.json"))
     end
 
     # Like #shell_dir but aborts with a helpful message when the shell is
     # missing. The --shell-dir hint covers dev on a modified shell checkout.
     def shell_dir!
-      shell_dir or UI.die!("couldn't find the bundled shell at #{bundled_shell_dir}; " \
+      shell_dir or UI.die!("couldn't find the bundled shell at #{bundled_desktop_dir}; " \
                            "reinstall ruby_everywhere or pass --shell-dir")
     end
 
@@ -54,6 +58,30 @@ module Everywhere
                          "reinstall ruby_everywhere or pass --template-dir")
     end
 
+    # The Hotwire Native Android shell template bundled inside the gem:
+    # support/mobile/android/ holds a frozen Gradle project (wrapper committed)
+    # the CLI stamps per-app — everywhere.properties + assets + res, never a
+    # build script. Same freeze contract the iOS template has.
+    def bundled_android_dir
+      File.join(gem_root, "support", "mobile", "android")
+    end
+
+    # Absolute path to the Android template, or nil when it isn't there. Unlike
+    # #ios_dir, nil is the NORMAL state until the template lands — callers must
+    # read it as "Android isn't buildable in this release yet", not as a corrupt
+    # install. settings.gradle.kts is the marker because it's the one file every
+    # Gradle project must have at its root.
+    def android_dir
+      bundled_android_dir if File.exist?(File.join(bundled_android_dir, "settings.gradle.kts"))
+    end
+
+    # Like #android_dir but aborts with a helpful message when the template is
+    # missing. The --template-dir hint covers dev on a modified template.
+    def android_dir!
+      android_dir or UI.die!("couldn't find the bundled Android template at #{bundled_android_dir}; " \
+                             "reinstall ruby_everywhere or pass --template-dir")
+    end
+
     # Per-user cache dir. Keeps heavy build state out of the gem and the app.
     def cache_dir
       File.expand_path(ENV["RUBYEVERYWHERE_HOME"] || "~/.rubyeverywhere")
@@ -79,10 +107,80 @@ module Everywhere
       File.join(cache_dir, "ios-packages")
     end
 
-    # Where cargo writes the shell's build output (CARGO_TARGET_DIR). Redirected
-    # here so cargo never dumps a multi-GB target/ into the installed gem, and so
-    # the shell compiles warm across projects — the shell source is identical for
-    # everyone, so one shared target dir is safe to reuse.
+    # The stamped copy of the Android template for one app, keyed by
+    # applicationId. Persistent for the same reasons ios_work_dir is: Gradle's
+    # incremental state is path-sensitive, and the stamped project opens in
+    # Android Studio unmodified.
+    def android_work_dir(application_id)
+      File.join(cache_dir, "android", application_id)
+    end
+
+    # GRADLE_USER_HOME for shell builds. Redirected here so the multi-GB Gradle
+    # distribution, the Android Gradle Plugin and the Hotwire artifacts are
+    # downloaded once and stay warm across every app — and never land inside the
+    # installed gem. Same trick as cargo_target_dir.
+    def android_gradle_home
+      File.join(cache_dir, "android-gradle")
+    end
+
+    # Where the Material Symbols icon font is cached after its one-time fetch.
+    # The font is ~10 MB, so it's fetched on first Android build instead of
+    # riding along in a 229 KB gem that most users never build Android with.
+    def android_fonts_dir
+      File.join(cache_dir, "android-fonts")
+    end
+
+    # The stamped copy of the Tauri shell for one app, keyed by bundle id.
+    # Only apps that declare `native.desktop` get one — everyone else compiles
+    # the gem's own copy, which is identical for them and stays warm across
+    # projects (see cargo_target_dir). Persistent for the same reason the mobile
+    # work dirs are: cargo's incremental state lives inside it, and a cold Tauri
+    # build is minutes where a warm one is seconds.
+    def desktop_work_dir(bundle_id)
+      File.join(cache_dir, "desktop", bundle_id)
+    end
+
+    # CARGO_TARGET_DIR for a stamped shell. Per-app rather than shared, because
+    # the whole point of stamping is that this app's crate graph differs from
+    # every other app's — pointing them at one target dir would make cargo
+    # rebuild the world on every alternating build.
+    def desktop_target_dir(bundle_id)
+      File.join(cache_dir, "desktop-target", bundle_id)
+    end
+
+    # Where `every dev` keeps the throwaway .app wrapper it runs the shell
+    # inside. macOS reads the application name from CFBundleName, so a bare
+    # `cargo run` binary shows up as the crate name — "example-shell" — in the
+    # menu bar, the About/Hide/Quit items and the Dock. The wrapper exists only
+    # to carry an Info.plist; the binary inside it is a hard link to cargo's.
+    def desktop_dev_app_dir(bundle_id)
+      File.join(cache_dir, "desktop-app", bundle_id)
+    end
+
+    # Where `every dev` stages the app's Dock icon for the running shell. The
+    # shaped master is derived from app.icon, so it's a build product, not the
+    # app's own file — it belongs in the cache next to the rest of them.
+    def desktop_icon_dir(bundle_id)
+      File.join(cache_dir, "desktop-icon", bundle_id)
+    end
+
+    # Where `every dev` stages native/desktop/assets for the running shell.
+    # A staged copy rather than the source tree on purpose: the packaged app
+    # reads ONE flat Resources/assets folder, and pointing dev at the nested
+    # source would quietly resolve assets/branding/logo.png in a build and not
+    # in dev. Staging runs the same DesktopAssets compiler both ways, so the two
+    # can't drift. Keyed by bundle id like the mobile work dirs.
+    def desktop_assets_dir(bundle_id)
+      File.join(cache_dir, "desktop-assets", bundle_id)
+    end
+
+    # Where cargo writes the shell's build output (CARGO_TARGET_DIR) for apps on
+    # the fast path — the ones that declare no `native.desktop`. Redirected here
+    # so cargo never dumps a multi-GB target/ into the installed gem, and so the
+    # shell compiles warm across projects: with no app Rust in it the shell
+    # source really is identical for everyone, so one shared target dir is safe
+    # to reuse. An app that declares extensions gets desktop_target_dir instead,
+    # because that premise stops holding the moment its crate graph differs.
     def cargo_target_dir
       File.join(cache_dir, "shell-target")
     end

data/lib/everywhere/relay.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "console"
+require_relative "line_pump"
+require_relative "ui"
+
+module Everywhere
+  # Reads one child's output off a pty and republishes it, one whole line at a
+  # time, tagged with its source.
+  #
+  # `every dev` used to hand the dev server and desktop shell its own stdout and
+  # let them write straight to the terminal. That made two things impossible:
+  # telling which of four concurrent things printed a line, and keeping anything
+  # pinned to the bottom of the screen. Relaying costs a thread per child and
+  # buys both.
+  #
+  # The full raw stream is also tee'd to a log file, matching what the builders
+  # already do with dist/ios-build.log — so nothing a filter hides is lost.
+  class Relay
+    CHUNK = 4096
+    POLL = 0.1
+
+    # on_line: an optional callback given every settled line before filtering.
+    # `every dev` uses it to notice the moment cargo actually starts the desktop
+    # shell — there is no other signal that the build turned into a running app.
+    def initialize(io, source:, log: nil, filter: nil, on_line: nil)
+      @io = io
+      @source = source
+      @filter = filter
+      @on_line = on_line
+      @log = log && File.open(log, "w")
+    end
+
+    # Blocking; run it in a thread. Returns when the child closes the pty.
+    def run
+      Console.tag = @source
+      pump = LinePump.new
+      loop do
+        if @io.wait_readable(POLL)
+          chunk = @io.read_nonblock(CHUNK, exception: false)
+          break if chunk.nil? # EOF
+
+          publish(pump << chunk) unless chunk == :wait_readable
+        else
+          publish(pump.flush_idle)
+        end
+      end
+      publish(pump.drain)
+    rescue Errno::EIO, IOError, Errno::EBADF
+      # A pty master raises EIO (not EOF) once the last slave closes, which is
+      # simply how a child exiting looks from this side.
+      publish(pump.drain) if pump
+    ensure
+      @log&.close
+      begin
+        @io.close
+      rescue StandardError
+        nil
+      end
+    end
+
+    private
+
+    def publish(lines)
+      lines.each do |line|
+        @log&.puts(line)
+        @on_line&.call(line)
+        shown = @filter ? @filter.call(line) : line
+        case shown
+        when :drop, false then nil
+        when nil          then Console.puts("    #{UI.gray(UI.short_path(line))}")
+        else                   Console.puts(shown)
+        end
+      end
+    end
+  end
+end

data/lib/everywhere/shellout.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "ui"
+require_relative "console"
+require_relative "child_processes"
 
 module Everywhere
   # All external commands (tebako, cargo, the app's own bin/dev) run outside
@@ -8,27 +10,57 @@ module Everywhere
   module Shellout
     module_function
 
-    def unbundled(&block)
-      defined?(Bundler) ? Bundler.with_unbundled_env(&block) : yield
+    # The environment a child should get: this gem's bundle stripped back out,
+    # plus the caller's overrides.
+    #
+    # This is handed to spawn as its env argument rather than swapped into ENV,
+    # which is what Bundler.with_unbundled_env does (ENV.replace, twice, around
+    # the block). That is process-global mutable state, and `every dev` now runs
+    # the iOS and Android builds concurrently: two overlapping swaps race so that
+    # one child inherits the CLI's bundle after all — the exact thing unbundling
+    # exists to prevent — and ENV is left wrong for the rest of the session.
+    #
+    # A nil value tells spawn to REMOVE that key, which is most of what
+    # unbundling is. The resulting child environment is identical to what
+    # with_unbundled_env produced, since Bundler.unbundled_env is derived from
+    # the snapshot taken before Bundler was activated either way.
+    def child_env(overrides = {})
+      base = unbundled_base
+      delta = {}
+      ENV.each_key { |key| delta[key] = nil unless base.key?(key) }
+      base.each { |key, value| delta[key] = value unless ENV[key] == value }
+      delta.merge(overrides.transform_keys(&:to_s))
+    end
+
+    # Bundler.unbundled_env derives from `original_env`, a snapshot frozen at
+    # load time, so this is genuinely constant for the life of the process.
+    def unbundled_base
+      @unbundled_base ||= defined?(Bundler) ? Bundler.unbundled_env : ENV.to_h
     end
 
     def run!(env, *cmd, chdir: Dir.pwd)
-      success = unbundled { system(env, *cmd, chdir: chdir) }
+      success = system(child_env(env), *cmd, chdir: chdir)
       UI.die!("command failed: #{cmd.join(" ")}") unless success
     end
 
+    # quiet also detaches stdin. A quiet command is by definition one that has
+    # nothing to say to the terminal, and `every dev` reads single keystrokes
+    # from that same terminal — a child left holding stdin silently eats the
+    # keypresses the menu is waiting on.
     def run?(*cmd, chdir: Dir.pwd, quiet: false)
       opts = { chdir: chdir }
-      opts.update(out: File::NULL, err: File::NULL) if quiet
-      unbundled { system(*cmd, **opts) }
+      opts.update(in: File::NULL, out: File::NULL, err: File::NULL) if quiet
+      system(child_env, *cmd, **opts)
     end
 
     # Run a command and capture its combined stdout+stderr. Returns
     # [output_string, Process::Status]. For probing tool output (codesign,
-    # stapler, notarytool) rather than driving a build.
+    # stapler, notarytool) rather than driving a build. A leading Hash is env
+    # overrides, matching Open3's own convention.
     def capture(*cmd)
       require "open3"
-      unbundled { Open3.capture2e(*cmd) }
+      overrides = cmd.first.is_a?(Hash) ? cmd.shift : {}
+      Open3.capture2e(child_env(overrides), *cmd)
     rescue Errno::ENOENT
       ["", nil]
     end
@@ -40,18 +72,32 @@ module Everywhere
     # 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.
+    #
+    # The signature is deliberately unchanged: the builder tests stub this with
+    # fixed-signature lambdas, and cancellation is wired up out of band through
+    # ChildProcesses instead.
     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
+      File.open(log, "w") do |logf|
+        # Inside an `every dev` worker the build leads its own process group,
+        # for two reasons: a Ctrl-C at the terminal no longer reaches
+        # xcodebuild/gradlew behind the CLI's back (the CLI decides when a build
+        # dies), and teardown can TERM the whole compile tree with one signal.
+        # Outside dev this stays off, so Ctrl-C during `every build` still stops
+        # the compiler as it always has.
+        opts = ChildProcesses.isolated? ? { pgroup: true } : {}
+        Open3.popen2e(child_env(env), *cmd, **opts) do |stdin, out, wait|
+          stdin.close
+          ChildProcesses.track(wait.pid)
+          begin
             out.each_line do |raw|
               logf.write(raw)
               emit(raw, filter)
             end
             success = wait.value.success?
+          ensure
+            ChildProcesses.untrack(wait.pid)
           end
         end
       end
@@ -61,13 +107,13 @@ module Everywhere
     # 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
+      return Console.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)
+      when nil          then Console.puts("    #{UI.gray(UI.short_path(raw.rstrip))}")
+      else                   Console.puts(shown)
       end
     end
     private_class_method :emit
@@ -75,7 +121,36 @@ module Everywhere
     # pgroup: the child leads its own process group so teardown can TERM the
     # whole tree (foreman + watchers) without signalling the CLI itself.
     def spawn(env, cmd, chdir:)
-      unbundled { Process.spawn(env, cmd, chdir: chdir, pgroup: true) }
+      Process.spawn(child_env(env), cmd, chdir: chdir, pgroup: true)
+    end
+
+    # Same, but on a pseudo-terminal, returning [master_io, pid].
+    #
+    # `every dev` relays the dev server's and desktop shell's output itself so
+    # it can tag each line with its source and keep the dock pinned at the
+    # bottom. A plain pipe would work, but the children would see a non-TTY and
+    # foreman, cargo and friends would drop their colors and progress output; on
+    # a pty they behave exactly as they do when you run them by hand.
+    #
+    # PTY.spawn calls setsid, so the child leads its own session: a terminal
+    # SIGINT can't reach it, and Process.kill("TERM", -pid) still takes down the
+    # whole tree.
+    def spawn_pty(env, cmd, chdir:)
+      require "pty"
+      # PTY.spawn hands back the read and write ends of the pty MASTER. We never
+      # forward stdin, so the write end is closed immediately — the child keeps
+      # running because the read end still holds the master open.
+      reader, writer, pid = PTY.spawn(child_env(env), cmd, chdir: chdir)
+      writer.close
+      [reader, pid]
+    end
+
+    # PTY is POSIX-only. Callers fall back to spawn + inherited fds.
+    def pty?
+      require "pty"
+      true
+    rescue LoadError
+      false
     end
   end
 end

data/lib/everywhere/task_pool.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "console"
+require_relative "child_processes"
+
+module Everywhere
+  # Named background tasks for the `every dev` key loop.
+  #
+  # Three guarantees, each of which fixes a specific way the old synchronous
+  # command misbehaved:
+  #
+  #   * At most one live task per name. Pressing `i` twice must not run two
+  #     iOS builds over the same staged work dir, which Builders::Ios rm_rf's
+  #     and re-copies on every run.
+  #   * No task failure can reach the main thread. A Swift compile error used to
+  #     unwind through the key loop into Dev#call's `ensure teardown` and take
+  #     the Rails server down with it.
+  #   * Every task is cancellable. Its children lead their own process groups
+  #     and are TERMed (then KILLed) at shutdown.
+  class TaskPool
+    # A task's failure is data, not control flow — hence `rescue Exception`, one
+    # of the few places it is the correct choice. MRI enqueues a SystemExit that
+    # escapes a non-main thread onto the MAIN thread and re-raises it there,
+    # wherever that thread happens to be. Since UI.die! raises Everywhere::Fatal
+    # (a SystemExit), `rescue StandardError` here would leave the original bug
+    # fully intact, just relocated. Verified:
+    #
+    #   ruby -e 'Thread.new { raise SystemExit.new(2) }; sleep 1; puts "alive"'
+    #   # => exits 2, never prints
+    GRACE = 5
+
+    def initialize(on_error: nil)
+      @lock = Mutex.new
+      @threads = {}
+      @failed = []
+      @stopping = false
+      @on_error = on_error
+    end
+
+    # :started, :busy or :stopping.
+    def start(name, &block)
+      @lock.synchronize do
+        return :stopping if @stopping
+        return :busy if @threads[name]&.alive?
+
+        @threads[name] = spawn_worker(name, &block)
+        retag
+        :started
+      end
+    end
+
+    def busy?(name) = @lock.synchronize { !!@threads[name]&.alive? }
+
+    def failed = @lock.synchronize { @failed.dup }
+
+    def any_running? = @lock.synchronize { @threads.each_value.any?(&:alive?) }
+
+    # Join every live task. Used by the headless path, where there is no key
+    # loop to keep the process alive and a failed build still has to be news.
+    def wait_all
+      loop do
+        live = @lock.synchronize { @threads.each_value.select(&:alive?) }
+        break if live.empty?
+
+        live.each(&:join)
+      end
+      Console.multiplexed = false
+    end
+
+    # Kill the tasks' children first, then the threads. Ordering matters: a
+    # worker blocked reading a build's output only unwinds once that build is
+    # gone, so signalling the children is what actually makes the joins return.
+    def shutdown(grace: GRACE)
+      live = @lock.synchronize do
+        @stopping = true
+        @threads.each_value.select(&:alive?)
+      end
+      return if live.empty?
+
+      live.each { |thread| ChildProcesses.terminate(thread, grace: grace) }
+      deadline = now + grace
+      live.each { |thread| thread.join([deadline - now, 0].max) }
+      live.select(&:alive?).each(&:kill)
+      Console.multiplexed = false
+    end
+
+    private
+
+    # Called while holding @lock; the new thread also takes @lock in its ensure.
+    # That is not a deadlock — the worker simply blocks until start returns —
+    # but it is why these two must not be collapsed into one synchronize block.
+    def spawn_worker(name, &block)
+      Thread.new do
+        # Set from inside the thread, as its first statement: assigning it after
+        # Thread.new returns races a task that fails immediately.
+        Thread.current.name = name.to_s
+        Thread.current.report_on_exception = false
+        Console.tag = name
+        ChildProcesses.isolate!
+
+        begin
+          block.call
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          stopping = @lock.synchronize { @failed << name; @stopping }
+          @on_error&.call(name, e, stopping)
+        ensure
+          @lock.synchronize { retag }
+        end
+      end
+    end
+
+    # Tag output by source only while two or more tasks are live: with one build
+    # running, the output is exactly what it has always been. Thread.current is
+    # excluded because a worker calling this from its own ensure is still
+    # #alive? and would keep tagging on for the task that just finished.
+    def retag
+      live = @threads.each_value.count { |t| t.alive? && t != Thread.current }
+      Console.multiplexed = live > 1
+    end
+
+    def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end

data/lib/everywhere/ui.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "fatal"
+require_relative "console"
+
 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.
@@ -69,14 +72,18 @@ module Everywhere
     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))
+    # Everything prints through Console, which serializes concurrent writers and
+    # gives the `every dev` dock a chance to repaint around each line. With no
+    # dock installed it is a plain $stdout.write, resolved per call so
+    # capture_io still works.
+    def phase(msg)   = Console.puts(phase_line(msg))
+    def step(msg)    = Console.puts(step_line(msg))
+    def substep(msg) = Console.puts(substep_line(msg))
+    def detail(msg)  = Console.puts(detail_line(msg))
+    def ok(msg)      = Console.puts(ok_line(msg))
+    def bad(msg)     = Console.puts(bad_line(msg))
+    def warn(msg)    = Console.puts(warn_line(msg))
+    def success(msg) = Console.puts(success_line(msg))
 
     # An indented, dim outcome under a substep — e.g. "accepted", "valid on disk".
     def note_line(msg, marker: "·", color: :gray)
@@ -84,15 +91,28 @@ module Everywhere
       "    #{tint.call(marker)} #{tint.call(msg)}"
     end
 
-    def note(msg, marker: "·", color: :gray) = puts(note_line(msg, marker: marker, color: color))
+    def note(msg, marker: "·", color: :gray) = Console.puts(note_line(msg, marker: marker, color: color))
 
+    # Ends the current unit of work. At the top level Ruby exits 1 and prints
+    # nothing extra, so this behaves exactly like the Kernel#abort it replaced —
+    # but inside `every dev` the worker thread running the build catches the
+    # Fatal, marks that target failed, and hands you back the key menu with the
+    # dev server still serving. The message is the same string abort received,
+    # so every assert_raises(SystemExit) reading err.message is unaffected.
     def die!(msg)
-      abort "#{red("✗")} #{red(msg)}"
+      line = "#{red("✗")} #{red(msg)}"
+      Console.error(line)
+      raise Everywhere::Fatal.new(1, line)
     end
 
     # A yes/no fact, colored by truthiness (for signing receipts).
     def yn(bool) = bool ? green("yes") : red("no")
 
+    # Braille spinner frames, shared by the transient Status line and the
+    # `every dev` dock. Ten frames at ~200ms is one revolution every two
+    # seconds — legible as motion without being distracting.
+    FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+
     # --- transient status line -------------------------------------------------
 
     # A single self-rewriting line for waits that produce no output — chiefly
@@ -104,8 +124,12 @@ module Everywhere
     # line every HEADLESS_INTERVAL seconds. Callers MUST `clear` before writing
     # anything else — `update` tracks whether a line is currently on screen so
     # `clear` is cheap and idempotent.
+    #
+    # NOTE: this writes to its `io:` directly, NOT through Console, so it is not
+    # serialized against other writers. That's fine for its one caller
+    # (`every platform build`, single-threaded) — do not reuse it concurrently.
     class Status
-      FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+      FRAMES = UI::FRAMES
       HEADLESS_INTERVAL = 30 # seconds between plain lines when not a TTY
 
       def initialize(io: $stdout)
@@ -157,6 +181,25 @@ module Everywhere
       "#{secs / 3600}h #{(secs % 3600) / 60}m"
     end
 
+    # --- ANSI ------------------------------------------------------------------
+
+    # Escape sequences a tool writes when it thinks it's on a terminal — which,
+    # since `every dev` relays its children over a pty, they all do. Two forms
+    # matter in practice: SGR color (CSI), and OSC-8 hyperlinks, which cargo
+    # wraps around the profile name in its own status lines.
+    ANSI = /
+      \e\][^\a\e]*(?:\a|\e\\)     # OSC ... terminated by BEL or ST
+      |
+      \e\[[0-9;?]*[ -\/]*[@-~]    # CSI ... final byte
+      |
+      \e[@-Z\\-_]                 # two-character escapes
+    /x
+
+    # For MATCHING, never for display: a filter that pattern-matches colored
+    # output has to look past the codes, but the colors are still what the
+    # developer wants to read.
+    def strip_ansi(str) = str.to_s.gsub(ANSI, "")
+
     # --- path shortening ------------------------------------------------------
 
     # Collapse the noisy machine paths that external tools echo (codesign,

data/lib/everywhere/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 
   # Version of the @rubyeverywhere/bridge JS this gem ships. bridge/ in the
   # gem IS the npm package (served to Rails apps by Everywhere::Engine,