onair-cli 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4350eed5352315ed4c6591c3ae03bdfb6648986d844a749051fed27506427b9
-  data.tar.gz: 9193566d1ea45893c68ff3d10340d80b6c1845a9e5f71eb21ece94df935e4a22
+  metadata.gz: 1eb5f2eb79c1eb2da95ef69cb65f8bef60b72dc3d98563a6235573b4ae139fd6
+  data.tar.gz: f5a38c5ef53340a88e41c9c007e68c34d1035d0427b953ac7b4193421201dde7
 SHA512:
-  metadata.gz: a72e23588254686e5154cf43fc8253a67fd16b524f67e1d75fcd3088281af2ba23272045a14f0f6517007ab1f9d4a7c790425fa8c33d4f21834219d414ddb999
-  data.tar.gz: f95b6452f90d13d024f8a4d432ea2bddb39b805149a6918cc78b4274e02aa0a965246c6758d20acb71531fc69b44def03d496afa3ea41e7bea0cd2998848ec5d
+  metadata.gz: 133e4480b8e8c22835294d0c2b18e79f9ee6ba065ee080c7c5f0e0c61a1a8bf92aecc6ee2e6092bce8ba095ffe7937ce8b6cb6526ca20938ae3d3d54dc39062e
+  data.tar.gz: b4e08f469025a62273c6c848b4d790e8b9a1520a6ce6ab24f0b845bcd7453cfa2040b1d40b3d0a29fe73c13e9c3d4242779022b0b2c43ba11c968f0e5ae74be5

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-10-08
+
+- Heroku: a rollout line under Deployed counts the dynos of each process type
+  running the deployed release (`web 1/3, 2 starting`) and says when every
+  dyno is up on it. With preboot on, the handoff from the previous web dynos
+  shows as an estimate. `--json` gains a `rollout` object.
+
+## [0.2.0] - 2026-10-07
+
+- Heroku: Deployed is the release Heroku is serving, not the newest one. A
+  newer release still in its release phase shows as `Releasing`, a failed one
+  as `Failed`, and neither counts as on air. While such a release carries a
+  different commit, `pinned` and `★ current` stay quiet. `--json` gains a
+  `release` object.
+
 ## [0.1.0]
 
 - Initial release: Heroku adapter with netrc auth, full behavior parity with

data/README.md

@@ -4,7 +4,7 @@
 
 <div align="center">
 
-### See what's on air — which commit is actually running in production.
+### See what's on air - which commit is actually running in production.
 
 [![Gem Version](https://img.shields.io/gem/v/onair-cli)](https://rubygems.org/gems/onair-cli)
 [![CI](https://github.com/amberpixels/onair-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/amberpixels/onair-cli/actions/workflows/ci.yml)
@@ -16,12 +16,12 @@
 
 <p align="center">
   <img src="assets/demo.svg"
-       alt="onair report: a pending build, the deployed release one commit behind origin/main, and your commit absorbed by the current deploy"
+       alt="onair report: a release still in its release phase, the deployed release one commit behind origin/main, and your commit absorbed by the current deploy"
        width="760">
 </p>
 
 `onair` answers one question fast and truthfully. The deployed commit comes
-from the running release's *slug*, never from "newest build" — after a
+from the running release's *slug*, never from "newest build" - after a
 rollback those differ, and the whole point of this tool is to not lie in that
 case.
 
@@ -33,7 +33,7 @@ case.
    an explicit lazy `git fetch`.
 4. **Platform-agnostic core.** Heroku is the first adapter, not the
    architecture.
-5. **Degrade gracefully.** Offline, missing commits, no color support — every
+5. **Degrade gracefully.** Offline, missing commits, no color support - every
    failure mode renders something useful, never a stack trace.
 
 ## Installation
@@ -61,21 +61,30 @@ is not a TTY or `NO_COLOR` is set.
 ### Speed
 
 The remote head of `origin/<branch>` is resolved through the GitHub API
-(~0.4s) when a token is ambient — `GH_TOKEN`, `GITHUB_TOKEN`, or a logged-in
-`gh` CLI — with `git ls-remote` always racing alongside as the fallback
+(~0.4s) when a token is ambient - `GH_TOKEN`, `GITHUB_TOKEN`, or a logged-in
+`gh` CLI - with `git ls-remote` always racing alongside as the fallback
 (no token, non-GitHub remote, API failure). Both report the live remote ref;
 the API is a faster transport, never a cache.
 
 ### What the report shows
 
-- **Deployed** — the commit the running release was built from, its age,
+- **Deployed** - the commit the running release was built from, its age,
   author, and a delta against `origin/main`: `★ current` or
   `↓ N commits behind`. If the relationship is unknown (diverged history,
-  commits unavailable), no marker is shown — silence over speculation.
-- **Pending** — an in-flight build that's about to replace the deploy.
-- **⏸ pinned** — a newer build succeeded but is *not* what's running
+  commits unavailable), no marker is shown - silence over speculation.
+- **Rollout** - under the Deployed row, how many dynos of each process type
+  run that release: `⟳ rolling out v1234: web 1/3, 2 starting` while dynos
+  restart, `✓ rolled out` once every dyno is up on it. With preboot on, the
+  previous web dynos keep serving for about three minutes after the new ones
+  are up; that window shows as an estimate.
+- **Pending** - an in-flight build that's about to replace the deploy.
+- **Releasing** - a newer release whose release phase (e.g. migrations) is
+  still running; production still serves the Deployed row until it finishes.
+- **Failed** - the newest release failed its release phase and never went
+  live. It stays until a newer release succeeds.
+- **⏸ pinned** - a newer build succeeded but is *not* what's running
   (rollback / pinned release).
-- **Yours** — when someone else's commit is deployed but yours sits just
+- **Yours** - when someone else's commit is deployed but yours sits just
   below it: your merge made it to prod, absorbed by a later deploy.
 
 ## Configuration
@@ -105,7 +114,7 @@ task:
 
 Matched ids in commit subjects become clickable terminal hyperlinks (the text
 stays identical), and `--json` gains a `task` object (`{ "id", "url" }`) per
-commit. No `task:` section — no behavior, nothing to opt out of.
+commit. No `task:` section - no behavior, nothing to opt out of.
 
 ## JSON schema
 
@@ -125,6 +134,14 @@ additively:
     "author": "Eugene", "task": null
   },
   "pending": null,
+  "release": null,
+  "rollout": {
+    "version": 1234, "complete": true,
+    "processes": [
+      { "type": "web", "up": 3, "total": 3, "waiting": {}, "previous": 0 }
+    ],
+    "overlap_until": null
+  },
   "delta": { "status": "current", "behind_by": 0 },
   "pinned": null,
   "yours": null
@@ -134,6 +151,16 @@ additively:
 - `delta.status` is `"current"`, `"behind"`, or `"unknown"`.
 - `pending`: `{ "sha", "started_at", "subject", "author" }` when a build is
   in flight.
+- `release`: `{ "sha", "version", "description", "status", "started_at",
+  "subject", "author" }` when a release newer than the running one is not
+  live; `status` is `"pending"` (release phase running) or `"failed"`. While
+  it carries a different sha, `delta.status` is never `"current"`.
+- `rollout`: dynos per process type against the running release. `up`
+  counts dynos serving it, `waiting` counts the rest of its dynos by state
+  (`starting`, `crashed`, ...), `previous` counts dynos on an older release.
+  `overlap_until` is an estimated end of the preboot handoff while it lasts,
+  otherwise `null`. `complete` is true once every dyno serves the running
+  release and no handoff remains. `null` when the dynos can't be read.
 - `pinned`: `{ "version", "description", "latest_built_sha" }` when a newer
   build succeeded but is not running.
 - `yours`: `{ "sha", "had_own_build", "subject", "author" }` when your commit
@@ -146,7 +173,7 @@ additively:
 
 ```sh
 bundle install
-bundle exec rake        # specs + rubocop
+bundle exec rake        # specs + standard
 ```
 
 The behavioral source of truth is `reference/prod-release.sh`, the

data/lib/onair/cli.rb

@@ -64,16 +64,17 @@ module Onair
       git = Git.new(fetch_allowed: config.fetch)
       adapter = Platform.build(config)
       repo = config.repo || git.origin_repo
-      report = Orchestrator.new(config: config, adapter: adapter, git: git, repo: repo).run
+      now = Time.now
+      report = Orchestrator.new(config: config, adapter: adapter, git: git, repo: repo, now: now).run
 
       if flags[:json]
         puts Renderer::Json.new(report: report, app: config.app, platform: config.platform,
-                                branch: config.branch, repo: repo, task: config.task).render
+          branch: config.branch, repo: repo, task: config.task).render
       else
         tty = $stdout.tty?
         print Renderer::Tty.new(report: report, app: config.app, platform_label: adapter.display_name,
-                                branch: config.branch, repo: repo, task: config.task,
-                                color: tty && !no_color?, hyperlinks: tty, now: Time.now).render
+          branch: config.branch, repo: repo, task: config.task,
+          color: tty && !no_color?, hyperlinks: tty, now: now).render
       end
     end
 

data/lib/onair/config.rb

@@ -22,7 +22,7 @@ module Onair
     def self.resolve(flags = {}, env: ENV, dir: Dir.pwd)
       file = find_file(dir) || {}
       app = flags[:app] || env["HEROKU_APP"] || file["app"]
-      raise Error, "no app configured — pass --app NAME, set HEROKU_APP, or run `onair init`" if app.nil?
+      raise Error, "no app configured - pass --app NAME, set HEROKU_APP, or run `onair init`" if app.nil?
 
       new(
         platform: file["platform"] || "heroku",

data/lib/onair/git.rb

@@ -91,7 +91,7 @@ module Onair
     end
 
     def opts
-      @dir ? { chdir: @dir } : {}
+      @dir ? {chdir: @dir} : {}
     end
   end
 end

data/lib/onair/orchestrator.rb

@@ -4,11 +4,12 @@ module Onair
   # Runs the platform adapter and git concurrently, lazily fetches missing
   # commits at most once, and assembles the Report.
   class Orchestrator
-    def initialize(config:, adapter:, git:, repo: nil)
+    def initialize(config:, adapter:, git:, repo: nil, now: Time.now)
       @config = config
       @adapter = adapter
       @git = git
       @repo = repo
+      @now = now
     end
 
     def run
@@ -17,10 +18,10 @@ module Onair
       snapshot = snapshot_thread.value
       remote_head = head_thread.value
 
-      needed = [snapshot.deployed&.sha, snapshot.pending&.sha, remote_head].compact
+      needed = [snapshot.deployed&.sha, snapshot.pending&.sha, snapshot.release&.sha, remote_head].compact
       @git.fetch_once! if needed.any? { |sha| !@git.has_commit?(sha) }
 
-      Report.build(snapshot: snapshot, remote_head: remote_head, git: @git)
+      Report.build(snapshot: snapshot, remote_head: remote_head, git: @git, now: @now)
     end
 
     private

data/lib/onair/platform/base.rb

@@ -13,7 +13,7 @@ module Onair
         klass = @registry[config.platform]
         if klass.nil?
           raise Error,
-                "unknown platform #{config.platform.inspect} (available: #{@registry.keys.join(', ')})"
+            "unknown platform #{config.platform.inspect} (available: #{@registry.keys.join(", ")})"
         end
 
         klass.new(config)
@@ -25,8 +25,13 @@ module Onair
     #   deployed:         the release CURRENTLY RUNNING (nil sha only if
     #                     truly unresolvable)
     #   pending:          newest in-flight build, or nil
+    #   release:          newest release above the running one that is not
+    #                     running (release phase pending or failed), or nil
     #   latest_built_sha: newest successfully built sha, or nil
     #   succeeded_shas:   recent succeeded build shas, newest first
+    #   rollout:          per process type, how many dynos run the running
+    #                     release, plus an optional estimate of when the
+    #                     previous release stops serving; nil when unknown
     #
     # Adapters own their internal concurrency and auth. Everything above
     # (delta, pinned, mine, rendering) is platform-agnostic and must not

data/lib/onair/platform/heroku.rb

@@ -8,15 +8,26 @@ module Onair
   module Platform
     class Heroku < Base
       HOST = "api.heroku.com"
+      RELEASE_WINDOW = 10
+      IN_FLIGHT_STATUSES = %w[pending failed].freeze
+      ONE_OFF_TYPES = %w[run scheduler release].freeze
+      # An eco dyno asleep on the running release boots that release on wake.
+      SERVING_STATES = %w[up idle].freeze
+      # With preboot, Heroku keeps routing to the previous web dynos for about
+      # three minutes after the new ones come up.
+      PREBOOT_HANDOFF = 180
 
       def snapshot
         token = resolve_token
-        release_thread = quiet_thread { deployed(token) }
+        releases_thread = quiet_thread { releases(token) }
         builds_thread = quiet_thread { builds(token) }
-        deployed = release_thread.value
+        dynos_thread = quiet_thread { dynos(token) }
+        deployed, release = releases_thread.value
         pending, succeeded_shas = builds_thread.value
-        Snapshot.new(deployed: deployed, pending: pending,
-                     latest_built_sha: succeeded_shas.first, succeeded_shas: succeeded_shas)
+        dyno_rows, preboot = dynos_thread.value
+        Snapshot.new(deployed: deployed, pending: pending, release: release,
+          latest_built_sha: succeeded_shas.first, succeeded_shas: succeeded_shas,
+          rollout: rollout(dyno_rows, preboot, deployed.version))
       end
 
       private
@@ -35,28 +46,47 @@ module Onair
       def resolve_token
         token = Auth::Netrc.token(HOST)
         token = Auth::HerokuCli.token if token.nil? || token.empty?
-        raise Error, "no Heroku credentials found — run `heroku login`" if token.nil? || token.empty?
+        raise Error, "no Heroku credentials found - run `heroku login`" if token.nil? || token.empty?
 
         token
       end
 
-      # The slug records the commit the running release was built from — the
-      # only reliable source after a rollback, when the builds list still
-      # shows the newer (no-longer-running) build on top.
-      def deployed(token)
+      # The running release is the one Heroku routes to (`current`), not the
+      # newest: while a release phase runs, or after it fails, the previous
+      # release keeps serving. The slug records the commit a release was built
+      # from - the only reliable source after a rollback, when the builds list
+      # still shows the newer (no-longer-running) build on top.
+      def releases(token)
         with_http do |http|
-          release = get(http, token, "/apps/#{app}/releases", range: "version ..; order=desc, max=1").first
-          raise Error, "no releases found for app #{app}" if release.nil?
-
-          Deployed.new(
-            sha: slug_commit(http, token, release.dig("slug", "id")),
-            version: release["version"],
-            description: release["description"],
-            deployed_at: parse_time(release["created_at"])
-          )
+          rows = get(http, token, "/apps/#{app}/releases", range: "version ..; order=desc, max=#{RELEASE_WINDOW}")
+          raise Error, "no releases found for app #{app}" if rows.empty?
+
+          running = rows.find { |row| row["current"] } || rows.find { |row| row["status"] == "succeeded" }
+          raise Error, "no succeeded release among the last #{RELEASE_WINDOW} for app #{app}" if running.nil?
+
+          deployed_sha = slug_commit(http, token, running.dig("slug", "id"))
+          [deployed(running, deployed_sha), in_flight(http, token, rows.first, running, deployed_sha)]
         end
       end
 
+      def deployed(row, sha)
+        Deployed.new(sha: sha, version: row["version"], description: row["description"],
+          deployed_at: parse_time(row["created_at"]))
+      end
+
+      # Only the newest release counts: an older failed one was superseded by
+      # whatever came after it. Without a commit there is no row to render.
+      def in_flight(http, token, newest, running, running_sha)
+        return nil if newest.equal?(running) || !IN_FLIGHT_STATUSES.include?(newest["status"])
+
+        slug_id = newest.dig("slug", "id")
+        sha = (slug_id == running.dig("slug", "id")) ? running_sha : slug_commit(http, token, slug_id)
+        return nil if sha.nil?
+
+        Release.new(sha: sha, version: newest["version"], description: newest["description"],
+          status: newest["status"].to_sym, started_at: parse_time(newest["created_at"]))
+      end
+
       def slug_commit(http, token, slug_id)
         return nil if slug_id.nil?
 
@@ -75,12 +105,62 @@ module Onair
         pending_sha = pending_build&.dig("source_blob", "version")
         pending = pending_sha && Pending.new(sha: pending_sha, started_at: parse_time(pending_build["created_at"]))
         succeeded = builds.select { |build| build["status"] == "succeeded" }
-                          .filter_map { |build| build.dig("source_blob", "version") }
+          .filter_map { |build| build.dig("source_blob", "version") }
         [pending, succeeded]
       rescue Error
         [nil, []]
       end
 
+      # A failed dynos call drops the rollout and nothing else; a failed
+      # preboot lookup only drops the handoff estimate.
+      def dynos(token)
+        with_http do |http|
+          rows = get(http, token, "/apps/#{app}/dynos")
+          [rows, preboot?(http, token)]
+        end
+      rescue Error
+        [nil, false]
+      end
+
+      def preboot?(http, token)
+        get(http, token, "/apps/#{app}/features/preboot")["enabled"] == true
+      rescue Error
+        false
+      end
+
+      def rollout(rows, preboot, version)
+        return nil if rows.nil? || version.nil?
+
+        formation = rows.reject { |dyno| ONE_OFF_TYPES.include?(dyno["type"]) }
+        return nil if formation.empty?
+
+        processes = formation.group_by { |dyno| dyno["type"] }
+          .sort_by { |type, _| [(type == "web") ? 0 : 1, type] }
+          .map { |type, dynos| process_rollout(type, dynos, version) }
+        Rollout.new(version: version, processes: processes,
+          overlap_until: preboot ? preboot_handoff(formation, version) : nil)
+      end
+
+      def process_rollout(type, dynos, version)
+        current, previous = dynos.partition { |dyno| dyno.dig("release", "version") == version }
+        waiting = current.map { |dyno| dyno["state"] }.reject { |state| SERVING_STATES.include?(state) }.tally
+        ProcessRollout.new(type: type, total: dynos.size, up: current.size - waiting.values.sum,
+          waiting: waiting, previous: previous.size)
+      end
+
+      # Old web dynos still listed are already counted as previous; the
+      # estimate covers only the handoff the dynos list does not show.
+      def preboot_handoff(formation, version)
+        web = formation.select { |dyno| dyno["type"] == "web" }
+        return nil if web.empty?
+        return nil unless web.all? do |dyno|
+          dyno.dig("release", "version") == version && SERVING_STATES.include?(dyno["state"])
+        end
+
+        last_up = web.filter_map { |dyno| parse_time(dyno["updated_at"]) }.max
+        last_up && (last_up + PREBOOT_HANDOFF)
+      end
+
       # One connection per thread — the dependent releases → slug pair must
       # not pay a second TLS handshake.
       def with_http(&)
@@ -112,7 +192,7 @@ module Onair
 
       def error_message(response, path)
         case response.code.to_i
-        when 401 then "Heroku rejected the token (401) — run `heroku login`"
+        when 401 then "Heroku rejected the token (401) - run `heroku login`"
         when 404 then "Heroku app not found: #{app}"
         else "Heroku API returned #{response.code} for #{path}"
         end

data/lib/onair/remote_head.rb

@@ -38,7 +38,7 @@ module Onair
 
       sha = JSON.parse(response.body).dig("object", "sha")
       sha&.match?(/\A\h{40}\z/) ? sha : nil
-    rescue StandardError
+    rescue
       nil
     end
     private_class_method :api_head

data/lib/onair/renderer/json.rb

@@ -30,6 +30,8 @@ module Onair
           remote_head: @report.remote_head,
           deployed: deployed_payload,
           pending: pending_payload,
+          release: release_payload,
+          rollout: rollout_payload,
           delta: delta_payload,
           pinned: pinned_payload,
           yours: yours_payload
@@ -58,14 +60,42 @@ module Onair
         pending = snapshot.pending
         return nil if pending.nil?
 
-        { sha: pending.sha, started_at: iso(pending.started_at) }.merge(commit_fields(pending.sha))
+        {sha: pending.sha, started_at: iso(pending.started_at)}.merge(commit_fields(pending.sha))
+      end
+
+      def release_payload
+        release = snapshot.release
+        return nil if release.nil?
+
+        {
+          sha: release.sha,
+          version: release.version,
+          description: release.description,
+          status: release.status.to_s,
+          started_at: iso(release.started_at)
+        }.merge(commit_fields(release.sha))
+      end
+
+      def rollout_payload
+        rollout = @report.rollout
+        return nil if rollout.nil?
+
+        {
+          version: rollout.version,
+          complete: rollout.complete?,
+          processes: rollout.processes.map do |process|
+            {type: process.type, up: process.up, total: process.total,
+             waiting: process.waiting, previous: process.previous}
+          end,
+          overlap_until: iso(rollout.overlap_until)
+        }
       end
 
       def delta_payload
         case @report.delta
-        when :current then { status: "current", behind_by: 0 }
-        when Integer then { status: "behind", behind_by: @report.delta }
-        else { status: "unknown", behind_by: nil }
+        when :current then {status: "current", behind_by: 0}
+        when Integer then {status: "behind", behind_by: @report.delta}
+        else {status: "unknown", behind_by: nil}
         end
       end
 
@@ -84,19 +114,19 @@ module Onair
         mine = @report.mine
         return nil if mine.nil?
 
-        { sha: mine.sha, had_own_build: mine.had_own_build }.merge(commit_fields(mine.sha))
+        {sha: mine.sha, had_own_build: mine.had_own_build}.merge(commit_fields(mine.sha))
       end
 
       def commit_fields(sha)
         info = sha && @report.commits[sha]
-        { subject: info&.subject, author: info&.author_name, task: task_fields(info&.subject) }
+        {subject: info&.subject, author: info&.author_name, task: task_fields(info&.subject)}
       end
 
       def task_fields(subject)
         task_id = @task&.find(subject)
         return nil if task_id.nil?
 
-        { id: task_id, url: @task.url_for(task_id) }
+        {id: task_id, url: @task.url_for(task_id)}
       end
 
       def iso(time)

data/lib/onair/renderer/tty.rb

@@ -7,6 +7,7 @@ module Onair
       COLORS = {
         bold: "\e[1m",
         green: "\e[0;32m",
+        red: "\e[0;31m",
         yellow: "\e[1;33m",
         dim: "\e[2m",
         purple: "\e[38;5;176m",
@@ -15,6 +16,7 @@ module Onair
       }.freeze
 
       NOT_FOUND_SUBJECT = "(commit not found in local git)"
+      LABEL_WIDTH = "Releasing:".length
 
       def initialize(report:, app:, platform_label:, branch:, repo:, color:, hyperlinks:, now:, task: nil)
         @report = report
@@ -31,6 +33,7 @@ module Onair
       def render
         lines = ["", "  #{code(:purple)}#{@platform_label} #{code(:bold)}#{@app}#{code(:reset)}", ""]
         lines.concat(pending_lines)
+        lines.concat(release_lines)
         lines.concat(deployed_lines)
         lines << ""
         "#{lines.join("\n")}\n"
@@ -46,13 +49,30 @@ module Onair
         pending = snapshot.pending
         return [] if pending.nil?
 
-        row_lines("Pending: ", :yellow, pending.sha, age(pending.started_at)) + [""]
+        row_lines("Pending:", :yellow, pending.sha, age(pending.started_at)) + [""]
+      end
+
+      # Same-commit releases (config changes, rollbacks) name what they are,
+      # since the sha alone would look like the deploy below.
+      def release_lines
+        release = snapshot.release
+        return [] if release.nil?
+
+        detail = "v#{release.version}"
+        detail = "#{detail}: #{release.description}" if release.sha == snapshot.deployed&.sha
+        label, color, note = if release.status == :failed
+          ["Failed:", :red, "✗ release phase failed (#{detail})"]
+        else
+          ["Releasing:", :yellow, "⟳ release phase (#{detail})"]
+        end
+        row_lines(label, color, release.sha, age(release.started_at), extra: paint(note, color)) + [""]
       end
 
       def deployed_lines
         deployed = snapshot.deployed
         if deployed&.sha
           lines = row_lines("Deployed:", :green, deployed.sha, age(deployed.deployed_at), extra: delta_text)
+          lines << rollout_line if @report.rollout
           lines << pinned_line if @report.pinned
           lines.concat(yours_lines)
           lines
@@ -62,13 +82,42 @@ module Onair
         end
       end
 
+      # The dynos list can look finished while preboot still routes some
+      # traffic to the previous release, so that window gets its own line.
+      def rollout_line
+        rollout = @report.rollout
+        text, color = if rollout.complete?
+          ["✓ rolled out v#{rollout.version}: #{process_counts(rollout)}", :dim]
+        elsif rollout.processes.all?(&:complete?)
+          ["⟳ preboot: previous web dynos may still serve for " \
+           "~#{remaining(rollout.overlap_until)} (estimate)", :yellow]
+        else
+          ["⟳ rolling out v#{rollout.version}: #{process_counts(rollout)}", :yellow]
+        end
+        "  #{paint(text, color)}"
+      end
+
+      def process_counts(rollout)
+        rollout.processes.map do |process|
+          parts = ["#{process.type} #{process.up}/#{process.total}"]
+          parts.concat(process.waiting.map { |state, count| "#{count} #{state}" })
+          parts << "#{process.previous} on older release" if process.previous.positive?
+          parts.join(", ")
+        end.join(" · ")
+      end
+
+      def remaining(time)
+        seconds = (time - @now).ceil.clamp(0..)
+        (seconds < 60) ? "#{seconds}s" : "#{(seconds / 60.0).ceil}m"
+      end
+
       def yours_lines
         mine = @report.mine
         return [] if mine.nil?
 
         note = mine.had_own_build ? "✓ released, then absorbed by current" : "✓ absorbed by current deploy"
         committed_at = @report.commits[mine.sha]&.committed_at
-        [""] + row_lines("Yours:   ", :cyan, mine.sha, age(committed_at), extra: paint(note, :cyan))
+        [""] + row_lines("Yours:", :cyan, mine.sha, age(committed_at), extra: paint(note, :cyan))
       end
 
       def row_lines(label, color_key, sha, age, extra: nil)
@@ -76,9 +125,10 @@ module Onair
         subject = info&.subject || NOT_FOUND_SUBJECT
         author = info&.author_name || "?"
         age_blurb = age ? "(#{age}) " : ""
-        first = "  #{paint(label, color_key)}  #{paint(sha[0, 9], :bold)}  #{paint("#{age_blurb}by #{author}", :dim)}"
+        padded = label.ljust(LABEL_WIDTH)
+        first = "  #{paint(padded, color_key)}  #{paint(sha[0, 9], :bold)}  #{paint("#{age_blurb}by #{author}", :dim)}"
         first = "#{first}  #{extra}" if extra
-        [first, "  #{paint('→', :dim)} #{linkify(subject, info ? sha : nil)}"]
+        [first, "  #{paint("→", :dim)} #{linkify(subject, info ? sha : nil)}"]
       end
 
       def delta_text
@@ -87,13 +137,13 @@ module Onair
           paint("★ current", :green)
         when Integer
           count = @report.delta
-          paint("↓ #{count} #{count == 1 ? 'commit' : 'commits'} behind origin/#{@branch}", :yellow)
+          paint("↓ #{count} #{(count == 1) ? "commit" : "commits"} behind origin/#{@branch}", :yellow)
         end
       end
 
       def pinned_line
         deployed = snapshot.deployed
-        "  #{paint("⏸ v#{deployed.version} (#{deployed.description}) — newer build " \
+        "  #{paint("⏸ v#{deployed.version} (#{deployed.description}) - newer build " \
                    "#{snapshot.latest_built_sha[0, 9]} succeeded but is not running", :yellow)}"
       end
 

data/lib/onair/report.rb

@@ -10,40 +10,54 @@ module Onair
   # mine:    the local user's commit just below someone else's deployed head.
   # commits: sha => CommitInfo (or nil when absent locally) for every sha a
   #          renderer may need to describe.
-  Report = Data.define(:snapshot, :remote_head, :delta, :pinned, :mine, :commits) do
-    def self.build(snapshot:, remote_head:, git:)
+  # rollout: the snapshot's rollout, its handoff estimate dropped once `now`
+  #          has passed it, or nil when unknown.
+  Report = Data.define(:snapshot, :remote_head, :delta, :pinned, :mine, :commits, :rollout) do
+    def self.build(snapshot:, remote_head:, git:, now:)
       # Pinned is judged before the stale pending is dropped: during the
       # stale window the newest *succeeded* build is still the previous
       # deploy, which must not read as a rollback.
       pinned = pinned?(snapshot)
-      snapshot = drop_stale_pending(snapshot)
+      snapshot = drop_superseded_pending(snapshot)
       deployed_sha = snapshot.deployed&.sha
       mine = compute_mine(snapshot, git)
-      commits = [deployed_sha, snapshot.pending&.sha, mine&.sha].compact.uniq
-                                                                .to_h { |sha| [sha, git.commit_info(sha)] }
+      commits = [deployed_sha, snapshot.pending&.sha, snapshot.release&.sha, mine&.sha]
+        .compact.uniq.to_h { |sha| [sha, git.commit_info(sha)] }
       new(
         snapshot: snapshot,
         remote_head: remote_head,
-        delta: compute_delta(deployed_sha, remote_head, git),
+        delta: compute_delta(snapshot, remote_head, git),
         pinned: pinned,
         mine: mine,
-        commits: commits
+        commits: commits,
+        rollout: live_rollout(snapshot.rollout, now)
       )
     end
 
+    def self.live_rollout(rollout, now)
+      return rollout if rollout.nil? || rollout.overlap_until.nil? || rollout.overlap_until > now
+
+      rollout.with(overlap_until: nil)
+    end
+
     # Right after a deploy finishes, the platform's builds list can still
     # report the just-released build as pending while the releases endpoint
     # already shows it running — the same commit would render as both
-    # Pending and Deployed. A build that is already on air isn't pending.
-    def self.drop_stale_pending(snapshot)
-      return snapshot unless snapshot.pending && snapshot.pending.sha == snapshot.deployed&.sha
+    # Pending and Deployed. A build that is already on air isn't pending, and
+    # one already in its release phase is shown by the release row.
+    def self.drop_superseded_pending(snapshot)
+      pending_sha = snapshot.pending&.sha
+      return snapshot unless pending_sha && [snapshot.deployed&.sha, snapshot.release&.sha].include?(pending_sha)
 
       snapshot.with(pending: nil)
     end
 
-    def self.compute_delta(sha, head, git)
+    # "Current" compares only the running sha to the head, so it stays silent
+    # while a release of a different commit is in flight or failed.
+    def self.compute_delta(snapshot, head, git)
+      sha = snapshot.deployed&.sha
       return nil if sha.nil? || head.nil?
-      return :current if sha == head
+      return (release_of_other_commit?(snapshot) ? nil : :current) if sha == head
       return nil unless git.has_commit?(sha) && git.has_commit?(head)
       return nil unless git.ancestor?(sha, head)
 
@@ -51,10 +65,16 @@ module Onair
       count&.positive? ? count : nil
     end
 
+    # A release of another commit, in flight or failed, explains the newer
+    # build on its own; a same-commit one (config change) does not.
     def self.pinned?(snapshot)
       sha = snapshot.deployed&.sha
       latest = snapshot.latest_built_sha
-      !sha.nil? && !latest.nil? && latest != sha && snapshot.pending.nil?
+      !sha.nil? && !latest.nil? && latest != sha && snapshot.pending.nil? && !release_of_other_commit?(snapshot)
+    end
+
+    def self.release_of_other_commit?(snapshot)
+      !snapshot.release.nil? && snapshot.release.sha != snapshot.deployed&.sha
     end
 
     # "Did my merge just ship?" — deliberately a 2-commit first-parent window
@@ -79,6 +99,7 @@ module Onair
         (!identity.name.to_s.empty? && name == identity.name)
     end
 
-    private_class_method :drop_stale_pending, :compute_delta, :pinned?, :compute_mine, :identity_match?
+    private_class_method :drop_superseded_pending, :compute_delta, :pinned?, :release_of_other_commit?,
+      :compute_mine, :identity_match?, :live_rollout
   end
 end

data/lib/onair/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Onair
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/onair.rb

@@ -14,10 +14,31 @@ module Onair
 
   Pending = Data.define(:sha, :started_at)
 
+  # A release newer than the running one that is not serving traffic: its
+  # release phase is still running (status :pending) or it failed (:failed).
+  Release = Data.define(:sha, :version, :description, :status, :started_at)
+
+  # Dynos of one process type against the running release. `up` counts dynos
+  # on the running version that serve (or idle until woken); `waiting` counts
+  # the rest of them by state; `previous` counts dynos on an older release.
+  ProcessRollout = Data.define(:type, :total, :up, :waiting, :previous) do
+    def complete?
+      up == total
+    end
+  end
+
+  # How far the running release has reached its dynos. `overlap_until` is an
+  # estimate of when the previous release stops serving traffic, or nil.
+  Rollout = Data.define(:version, :processes, :overlap_until) do
+    def complete?
+      processes.all?(&:complete?) && overlap_until.nil?
+    end
+  end
+
   # What a platform adapter returns. `latest_built_sha` is the newest
   # successfully built sha (rollback detection); `succeeded_shas` lists all
   # recent succeeded build shas, newest first ("yours had its own deploy").
-  Snapshot = Data.define(:deployed, :pending, :latest_built_sha, :succeeded_shas)
+  Snapshot = Data.define(:deployed, :pending, :release, :latest_built_sha, :succeeded_shas, :rollout)
 
   Mine = Data.define(:sha, :had_own_build)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: onair-cli
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Eugene