onair-cli 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4350eed5352315ed4c6591c3ae03bdfb6648986d844a749051fed27506427b9
-  data.tar.gz: 9193566d1ea45893c68ff3d10340d80b6c1845a9e5f71eb21ece94df935e4a22
+  metadata.gz: 1faf09e85aa982fd64a664e4d1f566c4aaf836cc3f196cde37ef9477a42c498f
+  data.tar.gz: 41404044b99b5624b947bc726cefb8e85910622f95ff31b2419bd12c612b56bb
 SHA512:
-  metadata.gz: a72e23588254686e5154cf43fc8253a67fd16b524f67e1d75fcd3088281af2ba23272045a14f0f6517007ab1f9d4a7c790425fa8c33d4f21834219d414ddb999
-  data.tar.gz: f95b6452f90d13d024f8a4d432ea2bddb39b805149a6918cc78b4274e02aa0a965246c6758d20acb71531fc69b44def03d496afa3ea41e7bea0cd2998848ec5d
+  metadata.gz: 2343601742f56a59b9141dd06d597f040ca1f55eae53295dd34dad9da10127372cb544b5bf9ff6bff98fdcaf1b2d938eab0e3ea0c9309f93ebd000da9a298566
+  data.tar.gz: 4ae9c7a4348ded957fb88a922cc44d8ebebeba36f6c870303663fe922be631bed2b2ac5ea82acbfc4ac2111bffdeefc0e8ac05c60e8dbb8d9068c51a33fb1eee

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [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,25 @@ 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.
+- **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 +109,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 +129,7 @@ additively:
     "author": "Eugene", "task": null
   },
   "pending": null,
+  "release": null,
   "delta": { "status": "current", "behind_by": 0 },
   "pinned": null,
   "yours": null
@@ -134,6 +139,10 @@ 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"`.
 - `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

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

@@ -17,7 +17,7 @@ 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)

data/lib/onair/platform/base.rb

@@ -25,6 +25,8 @@ 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
     #

data/lib/onair/platform/heroku.rb

@@ -8,14 +8,16 @@ module Onair
   module Platform
     class Heroku < Base
       HOST = "api.heroku.com"
+      RELEASE_WINDOW = 10
+      IN_FLIGHT_STATUSES = %w[pending failed].freeze
 
       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
+        deployed, release = releases_thread.value
         pending, succeeded_shas = builds_thread.value
-        Snapshot.new(deployed: deployed, pending: pending,
+        Snapshot.new(deployed: deployed, pending: pending, release: release,
                      latest_built_sha: succeeded_shas.first, succeeded_shas: succeeded_shas)
       end
 
@@ -35,28 +37,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?
 
@@ -112,7 +133,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/renderer/json.rb

@@ -30,6 +30,7 @@ module Onair
           remote_head: @report.remote_head,
           deployed: deployed_payload,
           pending: pending_payload,
+          release: release_payload,
           delta: delta_payload,
           pinned: pinned_payload,
           yours: yours_payload
@@ -61,6 +62,19 @@ module Onair
         { 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 delta_payload
         case @report.delta
         when :current then { status: "current", behind_by: 0 }

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,7 +49,23 @@ 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
@@ -68,7 +87,7 @@ module Onair
 
         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,7 +95,8 @@ 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)}"]
       end
@@ -93,7 +113,7 @@ module Onair
 
       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

@@ -16,15 +16,15 @@ module Onair
       # 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
@@ -34,16 +34,21 @@ module Onair
     # 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 +56,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 +90,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?
   end
 end

data/lib/onair/version.rb

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

data/lib/onair.rb

@@ -14,10 +14,14 @@ 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)
+
   # 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)
 
   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.2.0
 platform: ruby
 authors:
 - Eugene