ruby_everywhere 0.7.0 → 0.8.0

data/lib/everywhere/commands/dev.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
 require "dry/cli"
-require "socket"
 require "shellwords"
 require "fileutils"
 require_relative "../shellout"
-require_relative "../paths"
-require_relative "../icon"
-require_relative "../desktop_assets"
+require_relative "../host"
+require_relative "../desktop_dev_app"
+require_relative "../raw_tty"
 require_relative "../builders/ios"
 require_relative "../builders/android"
 require_relative "../builders/desktop"
@@ -15,8 +14,8 @@ require_relative "../simulator"
 require_relative "../emulator"
 require_relative "../console"
 require_relative "../child_processes"
+require_relative "../child_supervision"
 require_relative "../task_pool"
-require_relative "../relay"
 require_relative "../dock"
 require_relative "../log_filter"
 require_relative "logs"
@@ -37,6 +36,8 @@ module Everywhere
     # Dock keeps the keymap and every target's state pinned to the bottom of the
     # terminal while the logs scroll above it.
     class Dev < Dry::CLI::Command
+      include ChildSupervision
+
       desc "Run the dev server with native shells on demand (live reload, no packaging)"
 
       IOS_TARGET = "ios-arm64"
@@ -60,10 +61,7 @@ module Everywhere
         @shell_dir = shell_dir
         port = @port = validate_port!(port)
         @dev_url_override = dev_url
-        # Children are spawned from pool threads as well as the main one.
-        @pids = {}
-        @relays = {}
-        @children = Mutex.new
+        init_children!
         targets = requested_targets(target, desktop: desktop, ios: ios, android: android,
                                             mobile: mobile, browser: browser)
         @framework, @config = detect_app
@@ -127,6 +125,12 @@ module Everywhere
           UI.die!("no supported framework here (Rails, Hanami, Sinatra) and no remote.url in " \
                   "config/everywhere.yml — nothing to run")
         end
+
+        # The bundle id keys every per-app dir under ~/.rubyeverywhere that the
+        # session stages into, so it's checked before anything is written.
+        errors = config.identity_errors
+        UI.die!("app: in config/everywhere.yml:\n#{errors.join("\n")}") unless errors.empty?
+
         [framework, config]
       end
 
@@ -186,6 +190,15 @@ module Everywhere
         end
       end
 
+      # Everything the running desktop shell is staged out of: the assets, the
+      # Dock icon, the throwaway .app it runs from. Memoized because a restart
+      # restages all of it against the same config.
+      def desktop_dev_app = @desktop_dev_app ||= DesktopDevApp.new(config: @config)
+
+      def dev_bundle_name = desktop_dev_app.dev_bundle_name
+
+      def dev_info_plist = desktop_dev_app.dev_info_plist
+
       # `d` relaunches, the same way `i` and `a` do — quit the running window and
       # open a fresh one. Refusing with "already running" made the desktop the
       # odd one out, and left no way to restart a shell that had wedged or was
@@ -193,84 +206,6 @@ module Everywhere
       #
       # The rebuild is free either way: a warm `cargo run` re-checks the crate
       # graph in well under a second before handing off.
-      # native/desktop/assets/** → the staged flat folder the running shell
-      # reads. Runs the same compiler `every build` does, so an asset that
-      # resolves in dev resolves in the packaged app too. Returns
-      # [dir, errors]; the dir is returned even when the app ships no assets,
-      # because the shell only has to cope with it not existing.
-      def stage_desktop_assets
-        dest = Everywhere::Paths.desktop_assets_dir(@config.bundle_id)
-        source = File.join(@config.root, "native", "desktop", "assets")
-        _names, errors = Everywhere::DesktopAssets.write!(source, dest)
-        [dest, errors]
-      end
-
-      # A minimal .app around the dev binary, so macOS has a CFBundleName to
-      # read. Without it every menu that names the app says "example-shell" —
-      # the crate name — because an unbundled process has nothing else to go on.
-      # (Setting NSProcessInfo's processName at runtime does NOT fix this: the
-      # menu bar and the predefined About/Hide/Quit items are built from the
-      # bundle, and macOS has already decided by the time any Rust runs.)
-      #
-      # Only the plist matters here. No icon is stamped: the shell sets the Dock
-      # icon at runtime from NATIVE_ICON_PATH, because Tauri applies its own
-      # compiled-in icon after launch and would win over a bundle icns anyway.
-      # `every build` writes the real, complete plist — this is the dev subset.
-      def stage_dev_bundle
-        app = File.join(Everywhere::Paths.desktop_dev_app_dir(@config.bundle_id),
-                        "#{@config.name}.app")
-        macos = File.join(app, "Contents", "MacOS")
-        FileUtils.mkdir_p(macos)
-        File.write(File.join(app, "Contents", "Info.plist"), dev_info_plist)
-        [app, File.join(macos, dev_exe_name)]
-      end
-
-      # Spaces are legal in CFBundleExecutable but a nuisance in every shell
-      # command that names it, so the executable follows the packaged app's
-      # convention and drops them.
-      def dev_exe_name = @config.name.gsub(/\s+/, "")
-
-      def dev_info_plist
-        <<~PLIST
-          <?xml version="1.0" encoding="UTF-8"?>
-          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-          <plist version="1.0">
-          <dict>
-            <key>CFBundleName</key><string>#{@config.name}</string>
-            <key>CFBundleDisplayName</key><string>#{@config.name}</string>
-            <key>CFBundleExecutable</key><string>#{dev_exe_name}</string>
-            <key>CFBundleIdentifier</key><string>#{@config.bundle_id}</string>
-            <key>CFBundlePackageType</key><string>APPL</string>
-            <key>CFBundleShortVersionString</key><string>#{@config.version}</string>
-            <key>NSHighResolutionCapable</key><true/>
-          </dict>
-          </plist>
-        PLIST
-      end
-
-      # The Dock icon for the running shell. `cargo run` produces a bare binary
-      # with no .app around it, so macOS has nothing to read an icon from and
-      # Tauri's compiled-in placeholder wins — which is how you end up staring
-      # at the gem's icon while testing your own app.
-      #
-      # Shaped with the same Big Sur inset + squircle the packaged .icns gets
-      # (Icon.macos_master), so the Dock looks identical in dev and in a release
-      # build rather than subtly rounder in one of them. Returns "" when the app
-      # has no icon — the shell reads that as "leave it alone".
-      def stage_desktop_icon
-        source = @config.icon
-        return "" unless source && File.exist?(source)
-
-        dest = File.join(Everywhere::Paths.desktop_icon_dir(@config.bundle_id), "icon.png")
-        FileUtils.mkdir_p(File.dirname(dest))
-        FileUtils.cp(source, dest) unless Everywhere::Icon.macos_master(source, dest)
-        dest
-      rescue StandardError => e
-        # A Dock icon is never worth failing a dev session over.
-        UI.warn("couldn't prepare the Dock icon (#{e.class}) — using the default")
-        ""
-      end
-
       def launch_desktop
         # Checked before anything is staged: without cargo the build dies deep
         # in a relayed `sh: cargo: command not found`, after a dock entry and a
@@ -290,7 +225,7 @@ module Everywhere
           return
         end
 
-        assets_dir, asset_errors = stage_desktop_assets
+        assets_dir, asset_errors = desktop_dev_app.stage_desktop_assets
         unless asset_errors.empty?
           asset_errors.each { |error| UI.warn(error) }
           @dock.set(:desktop, :failed, detail: "native/desktop/assets")
@@ -326,10 +261,10 @@ module Everywhere
         supervise(:desktop,
                   { "NATIVE_DEV_URL" => @dev_url, "NATIVE_CONFIG" => @config.to_shell_json,
                     "NATIVE_ASSETS_DIR" => assets_dir,
-                    "NATIVE_ICON_PATH" => stage_desktop_icon,
+                    "NATIVE_ICON_PATH" => desktop_dev_app.stage_desktop_icon,
                     "CARGO_TARGET_DIR" => prepared.target_dir,
                     "CARGO_TERM_COLOR" => "always" },
-                  desktop_command(prepared), chdir: prepared.dir,
+                  desktop_dev_app.desktop_command(prepared), chdir: prepared.dir,
                   filter: LogFilter.for(:cargo), log: dist_log("desktop-dev.log"),
                   # cargo colors its status lines, so the marker has to be
                   # matched past the escape codes. "Finished" is cargo's last
@@ -340,31 +275,6 @@ module Everywhere
                   })
       end
 
-      # macOS runs the shell from inside a throwaway .app so it has a name;
-      # everywhere else `cargo run` is still the whole story.
-      #
-      # Three steps in one command rather than three Ruby calls, because the
-      # link has to happen between the compile and the launch and we want ONE
-      # supervised child: cargo's progress relays into the dock, and exec then
-      # replaces it with the app, so the pid we're tracking is the window.
-      #
-      # A hard link, not a copy: same volume (both under ~/.rubyeverywhere), so
-      # it's free and instant, where copying a debug Tauri binary is ~100MB on
-      # every launch. cargo replaces the file on rebuild rather than writing
-      # through it, so the link is remade each time — hence `ln -f`.
-      def desktop_command(prepared)
-        return "cargo run" unless RUBY_PLATFORM.include?("darwin")
-
-        _app, exe = stage_dev_bundle
-        built = File.join(prepared.target_dir, "debug", "example-shell")
-        [
-          "cargo build",
-          "{ ln -f #{built.shellescape} #{exe.shellescape} 2>/dev/null || " \
-            "cp -f #{built.shellescape} #{exe.shellescape}; }",
-          "exec #{exe.shellescape}"
-        ].join(" && ")
-      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
@@ -374,7 +284,7 @@ module Everywhere
         # xcodebuild and simctl are macOS-only, so `i` elsewhere can only ever
         # produce a long build that fails at the first tool. Android stays
         # available everywhere — its toolchain genuinely is cross-platform.
-        unless RUBY_PLATFORM.include?("darwin")
+        unless Host.darwin?
           UI.warn("iOS builds need macOS and Xcode — #{UI.dim("nothing to do on this platform")}")
           @dock.set(:ios, :idle, detail: "needs macOS")
           return
@@ -429,7 +339,7 @@ module Everywhere
           return
         end
 
-        opener = RUBY_PLATFORM.include?("darwin") ? "open" : "xdg-open"
+        opener = Host.darwin? ? "open" : "xdg-open"
         # A headless Linux box (or WSL) has no xdg-open, and run? would just
         # return nil — the key would look broken. Print the URL instead.
         unless Shellout.tool?(opener)
@@ -461,124 +371,51 @@ module Everywhere
 
       # --- child supervision ----------------------------------------------------
 
-      # Spawn a long-lived child on a pty and relay its output, one tagged line
-      # at a time. A pty rather than a pipe so foreman, cargo and friends still
-      # believe they're on a terminal and keep their colors; PTY.spawn also
-      # setsids, so a Ctrl-C at our terminal can't reach them and teardown
-      # decides when they die.
-      def supervise(key, env, cmd, chdir:, filter: nil, log: nil, on_line: nil)
-        if Shellout.pty?
-          io, pid = Shellout.spawn_pty(env, cmd, chdir: chdir)
-          thread = relay_thread(key, io, pid, filter: filter, log: log, on_line: on_line)
-        else
-          # Windows, or any platform without a pty: fall back to inherited fds.
-          # No tags and no dock framing, but everything else works.
-          pid = Shellout.spawn(env, cmd, chdir: chdir)
-        end
-        Process.detach(pid)
-        @children.synchronize do
-          @pids[key] = pid
-          @relays[key] = thread if thread
-        end
-        pid
-      end
+      def spawn_child(env, cmd, chdir:)
+        return Shellout.spawn_pty(env, cmd, chdir: chdir) if Shellout.pty?
 
-      def relay_thread(key, io, pid, filter:, log:, on_line:)
-        Thread.new do
-          Thread.current.name = "relay-#{key}"
-          Thread.current.report_on_exception = false
-          begin
-            Relay.new(io, source: key, log: log, filter: filter, on_line: on_line).run
-          rescue StandardError => e
-            # Losing a relay costs us that child's output, nothing more. It must
-            # not surface later out of the join in teardown.
-            Kernel.warn("#{key} output relay stopped: #{e.class}: #{e.message}")
-          end
-          # Only report a death we didn't ask for. stop_child removes the pid
-          # BEFORE it signals, so a deliberate restart can never match here —
-          # what does match is a shell that quit or crashed on its own, which is
-          # exactly what the dock should show.
-          @dock.set(key, :stopped) if !@stopping && @children.synchronize { @pids[key] } == pid
-        end
+        # Windows, or any platform without a pty: fall back to inherited fds.
+        # No tags and no dock framing, but everything else works.
+        [nil, Shellout.spawn(env, cmd, chdir: chdir)]
       end
 
-      # TERM the child's whole process group, escalate to KILL, and wait for the
-      # relay to drain so its last lines aren't lost. The pid is dropped from
-      # the registry FIRST, so the relay knows this death was asked for.
-      def stop_child(key, grace: 5)
-        pid, thread = @children.synchronize { [@pids.delete(key), @relays.delete(key)] }
-        return unless pid
-
-        reap([pid], grace: grace)
-        thread&.join(1)
+      # The extra advice an `every dev` failure carries: this is the app's own
+      # bin/dev, run from the app's own checkout, so the two usual explanations
+      # are worth naming.
+      def wait_for_port(port, pid: nil, timeout: 60,
+                        dead_hint: " (did `bundle install` run? does bin/dev's foreman exist?)",
+                        slow_hint: " — it may just be slow to boot; check its output above")
+        super
       end
 
-      # TERM each process group, wait for them together rather than serially,
-      # then KILL the stragglers.
-      def reap(pids, grace: 5)
-        live = pids.compact.select { |pid| ChildProcesses.alive?(pid) }
-        return if live.empty?
-
-        live.each { |pid| ChildProcesses.signal(pid, "TERM") }
-        deadline = monotonic + grace
-        sleep(0.1) while live.any? { |pid| ChildProcesses.alive?(pid) } && monotonic < deadline
-        live.select { |pid| ChildProcesses.alive?(pid) }.each { |pid| ChildProcesses.signal(pid, "KILL") }
+      # Only report a death we didn't ask for. stop_child removes the pid
+      # BEFORE it signals, so a deliberate restart can never match here —
+      # what does match is a shell that quit or crashed on its own, which is
+      # exactly what the dock should show.
+      def on_child_exit(key, pid)
+        @dock.set(key, :stopped) if !@stopping && @children.synchronize { @pids[key] } == pid
       end
 
-      def child_pid(key) = @children.synchronize { @pids[key] }
-
       # --- the key menu ---------------------------------------------------------
 
-      # io/console's getch holds full raw mode while blocked, which clears OPOST
-      # and stair-steps every log line we relay; stty -icanon -echo disables only
-      # line buffering and echo, leaving output processing (and Ctrl-C as SIGINT)
-      # intact. Builds no longer run on this thread, so the menu stays responsive
+      # Builds no longer run on this thread, so the menu stays responsive
       # while one is going — including `q`.
       def interact
         @dock.announce_keys
-        # stty is POSIX-only, and the non-pty spawn path otherwise works on
-        # Windows: without it the menu simply stays line-buffered (press d,
-        # then Enter) rather than the session dying on Errno::ENOENT.
-        saved_tty = saved_tty_state
-        system("stty", "-icanon", "-echo") if saved_tty
-        trap_exit_signals
-        loop do
-          case $stdin.getc
-          when "d"                then background(:desktop) { launch_desktop }
-          when "i"                then background(:ios)     { launch_ios }
-          when "a"                then background(:android) { launch_android }
-          when "b"                then launch_browser
-          when "l"                then toggle_logs
-          when "r"                then background(:web)     { restart_server }
-          when "?"                then @dock.toggle_help
-          when "q", "\u0004", nil then break # q, Ctrl-D, EOF (Ctrl-C stays a real SIGINT)
+        RawTty.with do
+          loop do
+            case $stdin.getc
+            when "d"                then background(:desktop) { launch_desktop }
+            when "i"                then background(:ios)     { launch_ios }
+            when "a"                then background(:android) { launch_android }
+            when "b"                then launch_browser
+            when "l"                then toggle_logs
+            when "r"                then background(:web)     { restart_server }
+            when "?"                then @dock.toggle_help
+            when "q", "\u0004", nil then break # q, Ctrl-D, EOF (Ctrl-C stays a real SIGINT)
+            end
           end
         end
-      ensure
-        system("stty", saved_tty) if saved_tty
-      end
-
-      # The tty settings to put back on the way out, or nil when there's no
-      # usable stty to read them with — the one signal both the raw-mode setup
-      # and its restore key off.
-      def saved_tty_state
-        return nil unless Shellout.tool?("stty")
-
-        state = `stty -g`.chomp
-        state.empty? ? nil : state
-      rescue StandardError
-        nil
-      end
-
-      # The dock hides the cursor and the key loop puts the tty in -icanon
-      # -echo; a SIGTERM that skipped our ensure blocks would leave the user's
-      # shell in that state. exit(1) from a trap unwinds normally, which is all
-      # this needs to do — a handler must stay this small, because anything that
-      # takes a lock (Console, the dock) raises ThreadError in trap context.
-      def trap_exit_signals
-        %w[TERM HUP].each { |sig| Signal.trap(sig) { exit(1) } }
-      rescue ArgumentError
-        nil
       end
 
       # --- headless -------------------------------------------------------------
@@ -624,26 +461,8 @@ module Everywhere
 
       # --- teardown -------------------------------------------------------------
 
-      # Teardown must never raise — it runs from an ensure, where an exception
-      # would mask whatever actually ended the session — and one failed step
-      # must not skip the rest, or a child survives the CLI that spawned it.
       def teardown
-        @stopping = true
-        pids, relays = @children ? @children.synchronize { [@pids.values, @relays.values] } : [[], []]
-        [
-          -> { @dock&.close },
-          -> { @pool&.shutdown },
-          # TERM everything, then give it a moment and KILL whatever is left.
-          # The CLI exits the instant this returns, so anything still alive is
-          # orphaned — and a windowed shell is exactly the kind of child that
-          # doesn't drop dead on the first signal.
-          -> { reap(pids, grace: 2) },
-          -> { relays.each { |thread| thread.join(1) } }
-        ].each do |step|
-          step.call
-        rescue StandardError => e
-          Kernel.warn("teardown: #{e.class}: #{e.message}")
-        end
+        teardown_children(before: [-> { @dock&.close }, -> { @pool&.shutdown }])
       end
 
       # --- helpers --------------------------------------------------------------
@@ -655,50 +474,6 @@ module Everywhere
       rescue StandardError
         nil
       end
-
-      def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-      # Checked once, up front: Integer() would otherwise raise from inside
-      # port_open? — an ArgumentError backtrace after the dock has already
-      # taken over the terminal.
-      def validate_port!(port)
-        number = begin
-          Integer(port.to_s, 10)
-        rescue ArgumentError, TypeError
-          UI.die!("--port must be a number (got #{port.inspect})")
-        end
-        UI.die!("--port must be between 1 and 65535 (got #{number})") unless (1..65_535).cover?(number)
-        number.to_s
-      end
-
-      # Any connect error means "nothing listening yet" for our purposes —
-      # ECONNREFUSED is the common one, but a firewall or an exhausted fd table
-      # answers differently and must not abort the session.
-      def port_open?(port)
-        TCPSocket.new("127.0.0.1", Integer(port)).close
-        true
-      rescue SystemCallError
-        false
-      end
-
-      # Watches the child as well as the port: a dev server that dies on
-      # startup (no `bundle install`, a bin/dev whose foreman isn't installed)
-      # never opens the port, and waiting out the full timeout for it buries
-      # the error it already printed under a minute of silence.
-      def wait_for_port(port, pid: nil, timeout: 60)
-        deadline = monotonic + timeout
-        until port_open?(port)
-          if pid && !ChildProcesses.alive?(pid)
-            UI.die!("the dev server exited before it finished booting — scroll up for its output " \
-                    "(did `bundle install` run? does bin/dev's foreman exist?)")
-          end
-          if monotonic > deadline
-            UI.die!("dev server never came up on port #{port} after #{timeout}s — it may just be slow " \
-                    "to boot; check its output above")
-          end
-          sleep 0.25
-        end
-      end
     end
   end
 end

data/lib/everywhere/commands/doctor.rb

@@ -2,6 +2,7 @@
 
 require "dry/cli"
 require_relative "../shellout"
+require_relative "../host"
 require_relative "../paths"
 require_relative "../config"
 require_relative "../android_sdk"
@@ -60,7 +61,6 @@ module Everywhere
         required ? name : "#{name} #{UI.dim("(not in build.targets — informational)")}"
       end
 
-      def macos? = RUBY_PLATFORM.include?("darwin")
 
       # Desktop is the implicit default: an app with no build.targets presses
       # for the host. Any non-mobile target (or --target) counts as desktop,
@@ -79,7 +79,7 @@ module Everywhere
         UI.step(section_label("Desktop target", required))
         # Mirrors the gate in `every build`: pressing is macOS-only today, so
         # probing for its toolchain elsewhere would only mislead.
-        unless macos?
+        unless Host.darwin?
           return fix_check("macOS", "desktop builds are macOS-only for now") { false } if required
 
           UI.warn("desktop builds are macOS-only for now — skipped")
@@ -101,14 +101,14 @@ module Everywhere
       # it, since it stays off PATH (keg-only). Everywhere else the package
       # manager installs a current bison normally.
       def bison?
-        return Shellout.tool?("bison") unless macos?
+        return Shellout.tool?("bison") unless Host.darwin?
 
         out, status = Shellout.capture("brew", "--prefix", "bison")
         !status.nil? && status.success? && !out.strip.empty?
       end
 
-      def bison_label = macos? ? "homebrew bison" : "bison"
-      def bison_hint  = macos? ? "brew install bison" : "install bison with your package manager"
+      def bison_label = Host.darwin? ? "homebrew bison" : "bison"
+      def bison_hint  = Host.darwin? ? "brew install bison" : "install bison with your package manager"
 
       # Config.load raises on an unparseable everywhere.yml; doctor reports it
       # as its first check and carries on with an empty config, so the machine
@@ -152,7 +152,7 @@ module Everywhere
         UI.step(section_label("iOS target", required))
         # Off macOS every tool below is guaranteed absent — one honest line
         # beats four unfixable ✗s.
-        unless macos?
+        unless Host.darwin?
           return fix_check("macOS with Xcode", "iOS apps can only be built on a Mac") { false } if required
 
           UI.warn("needs macOS and Xcode — skipped")

data/lib/everywhere/commands/install.rb

@@ -4,6 +4,7 @@ require "dry/cli"
 require "fileutils"
 require_relative "../shellout"
 require_relative "../config"
+require_relative "../framework"
 require_relative "../agents_guide"
 
 module Everywhere

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "dry/cli"
+require_relative "../../error"
 require_relative "../../ui"
 require_relative "../../platform/client"
 require_relative "../../platform/credentials"

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

@@ -3,6 +3,7 @@
 require "dry/cli"
 require "tmpdir"
 require "fileutils"
+require_relative "../../clock"
 require_relative "../../ui"
 require_relative "../../config"
 require_relative "../../framework"
@@ -172,7 +173,7 @@ module Everywhere
       def poll_and_tail(client, build_id, build_url = nil)
         printed = Hash.new("")
         last = {}
-        started = now
+        started = Clock.monotonic
         status = UI::Status.new
         errors = 0
 
@@ -220,10 +221,10 @@ module Everywhere
       # 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
+        deadline = Clock.monotonic + interval
         loop do
-          status.update("#{waiting_summary(artifacts)} · #{UI.elapsed(now - started)} elapsed")
-          remaining = deadline - now
+          status.update("#{waiting_summary(artifacts)} · #{UI.elapsed(Clock.monotonic - started)} elapsed")
+          remaining = deadline - Clock.monotonic
           break if remaining <= 0
 
           sleep([remaining, SPINNER_TICK].min)
@@ -248,8 +249,6 @@ module Everywhere
         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"]]

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

@@ -2,6 +2,8 @@
 
 require "dry/cli"
 require "socket"
+require_relative "../../clock"
+require_relative "../../error"
 require_relative "../../ui"
 require_relative "../../platform/client"
 require_relative "../../platform/credentials"
@@ -51,10 +53,10 @@ module Everywhere
       private
 
       def poll(client, device_code, interval, expires_in)
-        deadline = monotonic + (expires_in.positive? ? expires_in : 600)
+        deadline = Clock.monotonic + (expires_in.positive? ? expires_in : 600)
         loop do
           sleep(interval)
-          UI.die!("login timed out — run `every platform login` again") if monotonic > deadline
+          UI.die!("login timed out — run `every platform login` again") if Clock.monotonic > deadline
 
           # The user is mid-approval in a browser; a dropped connection here must
           # not kill the login. Keep polling until the deadline instead.
@@ -75,8 +77,6 @@ module Everywhere
         end
       end
 
-      def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
       # Shown on the approval page + used as the token's name, so a user can tell
       # their machines apart when reviewing/revoking tokens.
       def client_name

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "dry/cli"
+require_relative "../../error"
 require_relative "../../ui"
 require_relative "../../platform/client"
 require_relative "../../platform/credentials"