ruby_everywhere 0.6.0 → 0.8.0

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
@@ -56,6 +57,7 @@ module Everywhere
       end
 
       def install_sinatra
+        add_puma_gem
         vendor_bridge_to_public
         guide_rack_manual_steps(
           db: "point your production SQLite path at ENV.fetch(\"NATIVE_STORAGE_DIR\", \"storage\")",
@@ -65,6 +67,7 @@ module Everywhere
       end
 
       def install_hanami
+        add_puma_gem
         vendor_bridge_to_public
         guide_rack_manual_steps(
           db: "override DATABASE_URL from ENV[\"NATIVE_STORAGE_DIR\"] in config.ru when NATIVE_PACKAGED",
@@ -100,14 +103,35 @@ module Everywhere
         made ? UI.ok(label) : UI.step("#{label} #{UI.dim("(already done, skipped)")}")
       end
 
+      # A step whose file this app doesn't have. Every one of these is a shape a
+      # real app legitimately ships in (API-only, DATABASE_URL, no
+      # config/puma.rb), so say what was skipped — never raise on it.
+      def skip(label, reason)
+        UI.step("#{label} #{UI.dim("(skipped — #{reason})")}")
+      end
+
       def add_gem
+        UI.die!("no Gemfile in #{@root} — run `every install` inside your app") unless File.exist?(app_file("Gemfile"))
+
+        add_gemfile_gem("ruby_everywhere",
+                        comment: "# Desktop apps from this #{@framework.name.capitalize} app — https://rubyeverywhere.com")
+      end
+
+      # Packaged Rack apps serve through Puma at runtime (Framework#serve_rack
+      # requires it), so a missing gem surfaces as a LoadError on the end user's
+      # machine at first launch rather than here.
+      def add_puma_gem
+        add_gemfile_gem("puma", comment: "# Packaged RubyEverywhere apps serve through puma.")
+      end
+
+      def add_gemfile_gem(name, comment:)
         gemfile = app_file("Gemfile")
         contents = File.read(gemfile)
-        return change("add ruby_everywhere to Gemfile", false) if contents.match?(/gem ["']ruby_everywhere["']/)
+        return change("add #{name} to Gemfile", false) if contents.match?(/gem ["']#{name}["']/)
 
-        File.write(gemfile, "#{contents.chomp}\n\n# Desktop apps from this #{@framework.name.capitalize} app — https://rubyeverywhere.com\ngem \"ruby_everywhere\"\n")
+        File.write(gemfile, "#{contents.chomp}\n\n#{comment}\ngem \"#{name}\"\n")
         Shellout.run!({}, "bundle", "install", "--quiet", chdir: @root)
-        change("add ruby_everywhere to Gemfile", true)
+        change("add #{name} to Gemfile", true)
       end
 
       def write_config
@@ -214,9 +238,10 @@ module Everywhere
           #   targets:               # the platforms you ship — the CI matrix, expressed once
           #     - macos-arm64
           #     # - ios-arm64         # Hotwire Native shell; remote mode only. Local builds
-          #     #                     # (`every build` / `every dev --ios`) work today;
-          #     #                     # hosted platform builds for iOS aren't live yet.
-          #     # - android-arm64     # future — mobile is remote mode only
+          #     #                     # (`every build` / `every dev --ios`) and hosted
+          #     #                     # platform builds are both live.
+          #     # - ios-arm64:testflight   # optional per-target distribution channel
+          #     # - android-arm64     # Hotwire Native shell; remote mode only, hosted builds live
           #   capabilities: [notifications, filesystem:read, clipboard]  # desktop OS integration
 
           # Per-platform overrides. Keys are platform names (macos / ios / android /
@@ -321,6 +346,8 @@ module Everywhere
 
       def guard_bootsnap
         boot = app_file("config", "boot.rb")
+        return skip("guard bootsnap for packaged runs", "no config/boot.rb") unless File.exist?(boot)
+
         contents = File.read(boot)
         return change("guard bootsnap for packaged runs", false) if contents.include?("NATIVE_PACKAGED")
 
@@ -328,12 +355,16 @@ module Everywhere
           "# Bootsnap writes its cache to tmp/, which is read-only inside the packaged filesystem.\n" \
           "require \"bootsnap/setup\" unless ENV[\"NATIVE_PACKAGED\"]"
         end
-        File.write(boot, contents) if made
-        change("guard bootsnap for packaged runs", !!made)
+        return skip("guard bootsnap for packaged runs", "this app doesn't load bootsnap") unless made
+
+        File.write(boot, contents)
+        change("guard bootsnap for packaged runs", true)
       end
 
       def disable_force_ssl
         production = app_file("config", "environments", "production.rb")
+        return skip("disable force_ssl for localhost", "no config/environments/production.rb") unless File.exist?(production)
+
         contents = File.read(production)
         made = false
         made |= !!contents.gsub!(/^(\s*config\.assume_ssl\s*=\s*)true/) { "#{Regexp.last_match(1)}false # desktop: webview talks plain HTTP to 127.0.0.1" }
@@ -416,6 +447,11 @@ module Everywhere
       # connection was lost" (-1005). Single local user: keep-alives off.
       def disable_puma_keep_alives
         puma = app_file("config", "puma.rb")
+        unless File.exist?(puma)
+          return skip("disable puma keep-alives when packaged",
+                      "no config/puma.rb — add `enable_keep_alives false if ENV[\"NATIVE_PACKAGED\"]` to yours if you add one")
+        end
+
         contents = File.read(puma)
         return change("disable puma keep-alives when packaged", false) if contents.include?("enable_keep_alives")
 
@@ -431,6 +467,11 @@ module Everywhere
 
       def point_database_at_app_data
         db = app_file("config", "database.yml")
+        unless File.exist?(db)
+          return skip("point production SQLite at app-data dir",
+                      "no config/database.yml — point the packaged database at ENV[\"NATIVE_STORAGE_DIR\"] yourself")
+        end
+
         contents = File.read(db)
         return change("point production SQLite at app-data dir", false) if contents.include?("NATIVE_STORAGE_DIR")
 

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"
@@ -21,8 +22,8 @@ module Everywhere
 
       option :root,    default: ".",       desc: "App root directory"
       option :url,     default: nil,       desc: "Platform base URL"
-      option :target,  default: nil,       desc: "Targets (comma-separated os-arch); overrides everywhere.yml"
-      option :channel, default: "direct",  desc: "Distribution channel"
+      option :target,  default: nil,       desc: "Targets (comma-separated os-arch[:channel]); overrides everywhere.yml"
+      option :channel, default: "direct",  desc: "Default distribution channel for targets without a :channel suffix"
       option :ruby,    default: nil,       desc: "Ruby version (default: build.ruby or 4.0.6)"
       option :output,  default: nil,       desc: "Where to save artifacts (default: <root>/dist)"
       option :wait,        type: :boolean, default: true,  desc: "Wait for the build and download results"
@@ -38,29 +39,26 @@ module Everywhere
 
         client = Everywhere::Platform::Client.new(base, token: creds["token"])
         framework = config.remote? ? nil : Everywhere::Framework.detect(root_path)
-        targets = resolve_targets(target, config)
+        specs = resolve_targets(target, config, channel)
         ruby ||= config.build_ruby || "4.0.6"
 
         Dir.mktmpdir("every-snapshot") do |tmp|
           signed_id = snapshot_and_upload(client, root_path, tmp)
-          manifest = Everywhere::Receipt.new(
-            root: root_path, config: config, framework: framework, ruby: ruby,
-            target: targets.first, channel: channel
-          ).manifest
+          manifests = build_manifests(root_path, config, framework, ruby, specs)
 
-          build = submit(client, targets, channel, signed_id, manifest)
-          UI.success("submitted #{UI.bold(build["id"])} for #{targets.map { |t| UI.target_label(t) }.join(", ")}")
+          build = submit(client, specs, channel, signed_id, manifests)
+          UI.success("submitted #{UI.bold(build["id"])} for #{specs.map(&:display_label).join(", ")}")
           if (build_url = build["url"] || "#{client.base_url}/builds/#{build["id"]}")
             UI.substep("watch it live → #{UI.cyan(build_url)}")
           end
 
           return unless wait
 
-          # Set expectations before the quiet part: a hosted macOS runner is not
+          # Set expectations before the quiet part: a hosted runner is not
           # instant, and knowing that up front is the difference between "slow"
           # and "broken".
-          UI.substep(UI.dim("hosted macOS runners usually start within a few minutes"))
-          final = poll_and_tail(client, build["id"])
+          UI.substep(UI.dim("#{runner_wait_subject(specs)} usually start within a few minutes"))
+          final = poll_and_tail(client, build["id"], build_url)
           report(client, final, output || File.join(root_path, "dist"), download)
         end
       rescue Everywhere::Error => e
@@ -69,6 +67,30 @@ module Everywhere
 
       private
 
+      # Which hosted runner OS each target builds on — not the target's own OS
+      # (iOS builds on macOS, Android on Linux).
+      RUNNER_OS_LABELS = {
+        "macos" => "macOS", "ios" => "macOS",
+        "android" => "Linux", "linux" => "Linux", "windows" => "Windows"
+      }.freeze
+
+      # One requested target. `token` is the literal string the user wrote
+      # ("ios-arm64:testflight") and is what keys the per-target manifests on the
+      # wire; `os_arch` is the bare form everything else (receipts, labels,
+      # filenames) is built from.
+      TargetSpec = Struct.new(:token, :os, :arch, :channel) do
+        def os_arch = "#{os}-#{arch}"
+        def label = UI.target_label(os_arch)
+        def display_label = channel == "direct" ? label : "#{label} (#{channel})"
+      end
+
+      def runner_wait_subject(specs)
+        kinds = specs.filter_map { |s| RUNNER_OS_LABELS[s.os] }.uniq
+        return "hosted build runners" if kinds.empty?
+
+        "hosted #{kinds.join("/")} runners"
+      end
+
       def snapshot_and_upload(client, root_path, tmp)
         path = File.join(tmp, "snapshot.tar.gz")
         UI.step("snapshotting source #{UI.dim("(honoring .everywhereignore)")}")
@@ -79,6 +101,7 @@ module Everywhere
         reservation = client.post("/cli/direct_uploads",
           filename: "snapshot.tar.gz", byte_size: size,
           checksum: Everywhere::Platform::Snapshot.md5_base64(path), content_type: "application/gzip")
+        die_unauthorized! if reservation.unauthorized?
         UI.die!("couldn't reserve upload (HTTP #{reservation.status})") unless reservation.ok?
 
         upload = reservation.body["direct_upload"] || {}
@@ -89,21 +112,49 @@ module Everywhere
         reservation.body["signed_id"]
       end
 
-      def submit(client, targets, channel, signed_id, manifest)
+      # `manifests` is keyed by the literal target token; `manifest` (singular)
+      # stays = the first target's, which is all an older Platform reads.
+      def submit(client, specs, channel, signed_id, manifests)
         res = client.post("/cli/builds",
-          targets: targets.join(","), channel: channel, snapshot_signed_id: signed_id, manifest: manifest)
+          targets: specs.map(&:token).join(","), channel: channel, snapshot_signed_id: signed_id,
+          manifest: manifests.values.first, manifests: manifests)
         return res.body if res.ok?
 
-        if res.status == 422 && res.body["error"] == "missing_credentials"
+        die_unauthorized! if res.unauthorized?
+        render_submit_error!(res)
+      end
+
+      def render_submit_error!(res)
+        body = res.body.is_a?(Hash) ? res.body : {}
+
+        case body["error"]
+        when "missing_credentials"
           UI.bad("can't build yet — missing signing credentials:")
-          Array(res.body["targets"]).each do |t|
-            tgt = t["target"] || {}
-            UI.step("#{UI.os_label(tgt["os"])}-#{tgt["arch"]}/#{tgt["distribution_channel"]}: add #{Array(t["missing"]).join(", ")}")
+          Array(body["targets"]).each do |t|
+            UI.step("#{server_target_label(t["target"])}: add #{Array(t["missing"]).join(", ")}")
+          end
+          UI.step("set them up → #{UI.cyan(body["manage_url"])}")
+          exit 1
+        when "invalid_targets"
+          UI.bad(body["message"] || "some targets can't be built as configured:")
+          Array(body["targets"]).each do |t|
+            UI.step("#{server_target_label(t["target"])}: #{Array(t["errors"]).join("; ")}")
           end
-          UI.step("set them up → #{UI.cyan(res.body["manage_url"])}")
           exit 1
+        when "unsupported_targets"
+          UI.step("supported: #{Array(body["supported"]).join(", ")}") if body["supported"]
         end
-        UI.die!("build submission failed (HTTP #{res.status}) #{res.body["error"]}")
+
+        UI.die!("build submission failed (HTTP #{res.status}) #{body["message"] || body["error"]}")
+      end
+
+      def server_target_label(target)
+        target ||= {}
+        "#{UI.os_label(target["os"])}-#{target["arch"]}/#{target["distribution_channel"]}"
+      end
+
+      def die_unauthorized!
+        UI.die!("token expired or revoked — run `every platform login`")
       end
 
       # How often we ask the Platform for new logs. A build spends most of its
@@ -114,14 +165,30 @@ module Everywhere
       ACTIVE_POLL  = 2
       SPINNER_TICK = 0.2
 
-      def poll_and_tail(client, build_id)
+      # The build keeps running on the Platform whether or not we can reach it,
+      # so a blip mid-tail must not end the wait. Give up only after this many
+      # polls in a row have failed.
+      MAX_POLL_ERRORS = 5
+
+      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
 
         loop do
-          res = client.get("/cli/builds/#{build_id}/logs")
+          begin
+            res = client.get("/cli/builds/#{build_id}/logs")
+            errors = 0
+          rescue Everywhere::Error => e
+            errors += 1
+            status.clear
+            detach!(build_id, build_url, e) if errors >= MAX_POLL_ERRORS
+            UI.warn("lost contact with the Platform (#{e.message}) — retrying #{errors}/#{MAX_POLL_ERRORS}")
+            spin(status, [], started, IDLE_POLL)
+            next
+          end
           artifacts = res.ok? ? (res.body["artifacts"] || []) : []
 
           status.clear
@@ -140,14 +207,24 @@ module Everywhere
         status&.clear
       end
 
+      # We stopped watching; the build didn't stop. Leave the user everything
+      # they need to re-attach or grab the artifacts later.
+      def detach!(build_id, build_url, error)
+        UI.bad("gave up tailing #{UI.bold(build_id)} after #{MAX_POLL_ERRORS} failed polls — #{error.message}")
+        UI.step("the build is still running on the Platform")
+        UI.step("watch it → #{UI.cyan(build_url)}") if build_url
+        UI.die!("re-attach with `every platform build --wait` once you're back online, " \
+                "or download the artifacts from the build page")
+      end
+
       # Hold the status line alive for `interval` seconds. The spinner ticks far
       # faster than we poll so the line reads as "alive" during the multi-minute
       # pre-runner wait rather than freezing between requests.
       def spin(status, artifacts, started, interval)
-        deadline = now + interval
+        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)
@@ -172,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"]]
@@ -224,11 +299,44 @@ module Everywhere
         end
       end
 
-      # everywhere.yml build.targets, or --target, or the macOS default.
-      def resolve_targets(override, config)
-        list = override ? override.split(",") : config.targets
-        list = ["macos-arm64"] if list.nil? || list.empty?
-        list.map(&:strip).reject(&:empty?)
+      # everywhere.yml build.targets, or --target, or the macOS default. Each
+      # entry is "os-arch" with an optional ":channel" suffix; --channel is the
+      # default for the ones that leave it off. No channel allowlist here — the
+      # Platform owns which channels exist and says so in its 422.
+      def resolve_targets(override, config, default_channel)
+        list = override ? override.split(",") : config.build_target_specs
+        list = Array(list).map { |t| t.to_s.strip }.reject(&:empty?)
+        list = ["macos-arm64"] if list.empty?
+        list.map { |token| parse_target_spec(token, default_channel) }
+      end
+
+      def parse_target_spec(token, default_channel)
+        os_arch, channel, extra = token.split(":", -1)
+        if !extra.nil? || os_arch.to_s.empty? || (!channel.nil? && channel.empty?)
+          UI.die!("invalid target #{token.inspect} — expected os-arch[:channel], e.g. ios-arm64:testflight")
+        end
+
+        os, arch = os_arch.split("-", 2)
+        TargetSpec.new(token, os, arch, channel || default_channel)
+      end
+
+      # One manifest per target — they differ in `target`, and may differ in
+      # bundle_id/name/version via `platforms:` overrides. The source digest is
+      # the same for all of them, so hash the tree once and thread it through.
+      def build_manifests(root_path, config, framework, ruby, specs)
+        source = nil
+        lockfile = nil
+
+        specs.each_with_object({}) do |spec, out|
+          manifest = Everywhere::Receipt.new(
+            root: root_path, config: config, framework: framework, ruby: ruby,
+            target: spec.os_arch, channel: spec.channel,
+            source_checksum: source, lockfile_checksum: lockfile
+          ).manifest
+          source ||= manifest.dig("source", "checksum")
+          lockfile ||= manifest.dig("source", "lockfile_checksum")
+          out[spec.token] = manifest
+        end
       end
 
       def label(target)

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"
@@ -23,6 +25,14 @@ module Everywhere
         start = client.post("/cli/device_authorizations", client_name: client_name)
         UI.die!("couldn't start login — HTTP #{start.status}") unless start.ok?
 
+        # A captive portal or a misconfigured proxy answers 200 with HTML, which
+        # parses to {} — without this we'd print an empty code and poll nothing
+        # for ten minutes.
+        unless start.body["user_code"] && start.body["device_code"]
+          UI.die!("#{base} answered without a device code — check EVERYWHERE_PLATFORM_URL " \
+                  "(a captive portal or proxy may be intercepting the request)")
+        end
+
         verify_url = start.body["verification_uri_complete"] || start.body["verification_uri"]
         UI.step("confirmation code: #{UI.bold(start.body["user_code"])}")
         UI.step("opening #{UI.cyan(verify_url)}")
@@ -43,14 +53,20 @@ 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
 
-          res = client.post("/cli/device_authorizations/token", device_code: device_code)
+          # The user is mid-approval in a browser; a dropped connection here must
+          # not kill the login. Keep polling until the deadline instead.
+          res = begin
+            client.post("/cli/device_authorizations/token", device_code: device_code)
+          rescue Everywhere::Error
+            next
+          end
           UI.die!("login failed — #{res.body["error"] || "invalid request"}") if res.status == 400
-          next unless res.ok? # transient 5xx/network: keep polling until the deadline
+          next unless res.ok? # transient 5xx: keep polling until the deadline
 
           case res.body["status"]
           when "approved" then return res.body
@@ -61,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"