ruby_everywhere 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19d066bb2584933621929b270c69e6205804d07441a6e4a8bfcc052cc6483e55
-  data.tar.gz: c337dfa569b91412f4cb03027006d3199c9f224ebe63e5c5a066396986729194
+  metadata.gz: 0e9efcbd721dfa8ec5eb10adcbd9d96970feb860b9bfa20d3d6b761012bb8d1b
+  data.tar.gz: 66a196953da3501c430aa91318d02cc51fc42ff4ebfe294d33a58c44cf7d5333
 SHA512:
-  metadata.gz: b0865c4cc65cfdc86706332f2d00c704fcd361ffe72ed6bbc51100297640634d246a3537b2f4ed38318fbacacbbd490ff422e4b6449905d06918ce7663dbc2f5
-  data.tar.gz: 119672c4cf55ea3ea05e768c3eba161ee2aa6b81b6f5f68046c6327bc99f2dcd9897658d7320e0a0d7a58cbc64d8ac457a2522d6cd71434f1df8ef974367a783
+  metadata.gz: 0644e199416ba7568a78812a83ba97fda7b97a829bca821540ba03f355b5798b2e69765db1aa5bd498e0f537edff73d8cad34ba0ce855261338a1522421b60ef
+  data.tar.gz: 9fb95b8c424cbcc6c82148f4bab93fd07d243e5c2051a0b7b5b056a3ded8fc2a8f43f5e6730b3791edd53d249dde25e001ff2d5d729e4c6a216d44831448cb6b

data/lib/everywhere/cli.rb

@@ -4,11 +4,13 @@ require "dry/cli"
 require_relative "../everywhere"
 require_relative "framework"
 require_relative "commands/build"
+require_relative "commands/clean"
 require_relative "commands/dev"
 require_relative "commands/icon"
 require_relative "commands/doctor"
 require_relative "commands/install"
 require_relative "commands/release"
+require_relative "commands/shell_dir"
 require_relative "commands/platform/login"
 require_relative "commands/platform/logout"
 require_relative "commands/platform/auth_status"
@@ -34,8 +36,10 @@ module Everywhere
     register "install", Commands::Install
     register "dev",     Commands::Dev
     register "build",   Commands::Build
+    register "clean",   Commands::Clean
     register "icon",    Commands::Icon
     register "release", Commands::Release
+    register "shell-dir", Commands::ShellDir
 
     register "platform login",       Commands::PlatformLogin
     register "platform logout",      Commands::PlatformLogout

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"
@@ -89,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.

data/lib/everywhere/commands/clean.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "fileutils"
+
+module Everywhere
+  module Commands
+    # Wipes the shared cargo build cache under ~/.rubyeverywhere (or
+    # $RUBYEVERYWHERE_HOME). Safe to run any time: only compiled shell output
+    # lives there, so the next `every dev`/`every build` just recompiles cold.
+    class Clean < Dry::CLI::Command
+      desc "Remove the cargo shell-build cache (~/.rubyeverywhere/shell-target)"
+
+      def call(**)
+        target = Everywhere::Paths.cargo_target_dir
+        return UI.step("nothing to clean #{UI.dim("(#{target} doesn't exist)")}") unless File.exist?(target)
+
+        size = human_size(dir_bytes(target))
+        FileUtils.rm_rf(target)
+        UI.success("removed #{target} (#{size} freed) — the next build recompiles the shell cold")
+      end
+
+      private
+
+      def dir_bytes(dir)
+        Dir.glob(File.join(dir, "**", "*"), File::FNM_DOTMATCH).sum do |f|
+          File.file?(f) ? File.size(f) : 0
+        end
+      end
+
+      def human_size(bytes)
+        return "#{bytes} B" if bytes < 1024
+
+        units = %w[KB MB GB TB]
+        exp = [(Math.log(bytes) / Math.log(1024)).floor, units.size].min
+        format("%.1f %s", bytes.to_f / (1024**exp), units[exp - 1])
+      end
+    end
+  end
+end

data/lib/everywhere/commands/doctor.rb

@@ -7,7 +7,7 @@ module Everywhere
   module Commands
     # Check that this machine can build desktop apps.
     class Doctor < Dry::CLI::Command
-      desc "Check the toolchain (tebako, rust, brew deps, Xcode 26 shims)"
+      desc "Check the toolchain (rbe-tebako, rust, brew deps)"
 
       def call(**)
         ok = true
@@ -15,23 +15,8 @@ module Everywhere
         ok &= check("cargo installed")    { Shellout.run?("cargo --version > /dev/null 2>&1") }
         ok &= check("homebrew bison")     { !`brew --prefix bison 2>/dev/null`.strip.empty? }
 
-        if RUBY_PLATFORM.include?("darwin") && clang_major >= 21
-          ok &= check("Xcode #{clang_major} CXX shim (~/.tebako-shims/clang++)") do
-            File.executable?(File.expand_path("~/.tebako-shims/clang++"))
-          end
-          ok &= check("tebako force_ruby_platform patch") do
-            helper = `gem contents rbe-tebako 2>/dev/null`.lines.map(&:strip).find { |l| l.end_with?("deploy_helper.rb") }
-            helper.nil? || File.read(helper).include?(%(@force_ruby_platform = "true"
-      @nokogiri_option = "--no-use-system-libraries"))
-          end
-          ok &= check("tebako rbconfig warnflags patch") do
-            stash = Dir[File.expand_path("~/.tebako/deps/stash_*/lib/ruby/*/**/rbconfig.rb")]
-            stash.empty? || stash.all? { |f| File.read(f).include?("default-const-init") }
-          end
-        end
-
         puts
-        ok ? UI.success("ready to build") : UI.bad("fix the items above (see project docs / memory for recipes)")
+        ok ? UI.success("ready to build") : UI.bad("fix the items above (see https://rubyeverywhere.com/docs/diy/requirements)")
         exit(1) unless ok
       end
 
@@ -45,10 +30,6 @@ module Everywhere
         UI.bad(label)
         false
       end
-
-      def clang_major
-        @clang_major ||= `clang --version 2>/dev/null`[/version (\d+)/, 1].to_i
-      end
     end
   end
 end

data/lib/everywhere/commands/install.rb

@@ -12,15 +12,17 @@ module Everywhere
       desc "Prepare this app for RubyEverywhere (boot stub, config/everywhere.yml, config tweaks)"
 
       option :root, default: ".", desc: "App root directory"
-      option :path, default: nil, desc: "Use a local checkout of ruby_everywhere in the Gemfile (path:)"
+      option :local, type: :boolean, default: false, desc: "Configure local mode (compile & ship the app) instead of remote mode"
 
-      def call(root: ".", path: nil, **)
+      def call(root: ".", local: false, **)
+        @mode = local ? "local" : "remote"
         @framework = Framework.detect(root)
         @root = @framework.root
         UI.step("#{UI.bold(@framework.name)} app at #{@root}")
+        UI.warn("local mode: only SQLite databases are supported") if local
 
         # Common to every framework.
-        add_gem(path)
+        add_gem
         write_config
         write_boot_stub
 
@@ -86,13 +88,12 @@ module Everywhere
         made ? UI.ok(label) : UI.step("#{label} #{UI.dim("(already done, skipped)")}")
       end
 
-      def add_gem(path)
+      def add_gem
         gemfile = app_file("Gemfile")
         contents = File.read(gemfile)
         return change("add ruby_everywhere to Gemfile", false) if contents.match?(/gem ["']ruby_everywhere["']/)
 
-        line = path ? "gem \"ruby_everywhere\", path: #{path.inspect}" : "gem \"ruby_everywhere\""
-        File.write(gemfile, "#{contents.chomp}\n\n# Desktop apps from this #{@framework.name.capitalize} app — https://rubyeverywhere.com\n#{line}\n")
+        File.write(gemfile, "#{contents.chomp}\n\n# Desktop apps from this #{@framework.name.capitalize} app — https://rubyeverywhere.com\ngem \"ruby_everywhere\"\n")
         Shellout.run!({}, "bundle", "install", "--quiet", chdir: @root)
         change("add ruby_everywhere to Gemfile", true)
       end
@@ -112,15 +113,12 @@ module Everywhere
             # platform (and the macOS bundle id). Set once, never change it.
             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)
+            mode: #{@mode.ljust(6)}           # "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
+          #{remote_section.chomp}
 
           appearance:
             # Colors take a hex string, or split by system theme:
@@ -171,6 +169,25 @@ module Everywhere
         change("create config/everywhere.yml", true)
       end
 
+      # Remote mode (the default) gets a live remote: block ready to point at the
+      # deployed site; local mode keeps it commented out for later.
+      def remote_section
+        if @mode == "remote"
+          <<~YAML
+            # Remote mode — the deployed URL the native shell opens.
+            remote:
+              url: "https://example.com"
+          YAML
+        else
+          <<~YAML
+            # Remote mode only — the deployed URL the native shell opens.
+            # Set mode: remote above, then uncomment:
+            # remote:
+            #   url: "https://example.com"
+          YAML
+        end
+      end
+
       def write_boot_stub
         stub = app_file("native_boot.rb")
         return change("create native_boot.rb", false) if File.exist?(stub)

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"
@@ -48,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.step("building #{UI.bold(app_name)} for #{UI.cyan(target)}")
+          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
 
@@ -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/commands/shell_dir.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+
+module Everywhere
+  module Commands
+    # Print the absolute path of the gem-bundled Tauri shell (src-tauri).
+    # Output is the bare path so external tooling can capture it — e.g. the
+    # build-runner workflows resolve the shell with `$(every shell-dir)`.
+    class ShellDir < Dry::CLI::Command
+      desc "Print the path of the bundled Tauri shell (src-tauri)"
+
+      def call(**)
+        puts Everywhere::Paths.shell_dir!
+      end
+    end
+  end
+end

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

@@ -12,21 +12,22 @@ module Everywhere
       File.expand_path("../..", __dir__)
     end
 
-    # The generic Tauri shell vendored inside the gem: support/shell/ holds the
-    # src-tauri app and the splash/ dir it serves. This is the shell the CLI
-    # uses unless the caller overrides it with --shell-dir.
+    # 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
+    # `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")
     end
 
-    # Absolute path to the shell's src-tauri directory, or nil if the vendored
+    # 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"))
     end
 
     # Like #shell_dir but aborts with a helpful message when the shell is
-    # missing. The --shell-dir hint covers monorepo dev pointed at build-runner.
+    # 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}; " \
                            "reinstall ruby_everywhere or pass --shell-dir")

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.4"
+  VERSION = "0.1.6"
 
   # Version of the vendored @rubyeverywhere/bridge JS this gem ships. Tracks
   # bridge/package.json — bump it whenever lib/everywhere/javascript/bridge.js is

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_everywhere
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Andrea Fomera
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: dry-cli
   requirement: !ruby/object:Gem::Requirement
@@ -53,6 +67,7 @@ files:
 - lib/everywhere/boot.rb
 - lib/everywhere/cli.rb
 - lib/everywhere/commands/build.rb
+- lib/everywhere/commands/clean.rb
 - lib/everywhere/commands/dev.rb
 - lib/everywhere/commands/doctor.rb
 - lib/everywhere/commands/icon.rb
@@ -63,12 +78,14 @@ files:
 - lib/everywhere/commands/platform/logout.rb
 - lib/everywhere/commands/platform/runner.rb
 - lib/everywhere/commands/release.rb
+- lib/everywhere/commands/shell_dir.rb
 - lib/everywhere/config.rb
 - lib/everywhere/database.rb
 - lib/everywhere/framework.rb
 - lib/everywhere/icon.rb
 - lib/everywhere/ignore.rb
 - lib/everywhere/javascript/bridge.js
+- lib/everywhere/log_filter.rb
 - lib/everywhere/paths.rb
 - lib/everywhere/platform/client.rb
 - lib/everywhere/platform/credentials.rb