ruby_everywhere 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19d066bb2584933621929b270c69e6205804d07441a6e4a8bfcc052cc6483e55
-  data.tar.gz: c337dfa569b91412f4cb03027006d3199c9f224ebe63e5c5a066396986729194
+  metadata.gz: e8f07eb6ae976f35ea7ccda33b87bfefd7c2d0ffd39c1b7aa1f7001bedbd482b
+  data.tar.gz: b0b9afc49cdc99e731c5bc7a742f8a90c4a5c94d496749131fa37b403567f91c
 SHA512:
-  metadata.gz: b0865c4cc65cfdc86706332f2d00c704fcd361ffe72ed6bbc51100297640634d246a3537b2f4ed38318fbacacbbd490ff422e4b6449905d06918ce7663dbc2f5
-  data.tar.gz: 119672c4cf55ea3ea05e768c3eba161ee2aa6b81b6f5f68046c6327bc99f2dcd9897658d7320e0a0d7a58cbc64d8ac457a2522d6cd71434f1df8ef974367a783
+  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"
@@ -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/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/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/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.5"
 
   # 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.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