three pushes run three full pipelines and you pay for all of them

"""Estimate CI minutes wasted on runs superseded by a later push.

Reports only. Adding cancel-in-progress to a deploy workflow would leave a
half-finished deploy, so the change is deliberately left to a human who knows
which workflows are safe to interrupt.
"""
import argparse
import collections
import logging
import os
import sys

import requests

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("actions_redundant_runs")

API = "https://api.github.com"
# Billed minutes per wall-clock minute, per runner OS.
MULTIPLIER = {"ubuntu": 1, "windows": 2, "macos": 10}


def find_superseded(runs):
    """Pure decision function.

    A run is superseded when a LATER run exists for the same workflow and branch and
    the earlier one was still going when it started. Grouping by workflow as well as
    branch matters: two different workflows on one branch are not competing.
    """
    by_key = collections.defaultdict(list)
    for r in runs:
        by_key[(r.get("workflow_id"), r.get("head_branch"))].append(r)

    superseded = []
    for group in by_key.values():
        group.sort(key=lambda r: r.get("run_number", 0))
        for earlier, later in zip(group, group[1:]):
            if earlier.get("created_at") and later.get("created_at"):
                if earlier["created_at"] < later["created_at"]:
                    superseded.append(earlier)
    return superseded


def billed_minutes(run, wall_minutes):
    """Apply the runner multiplier. macOS is 10x, which dominates any bill."""
    name = " ".join(run.get("labels", []) or []).lower() or "ubuntu"
    for os_name, mult in MULTIPLIER.items():
        if os_name in name:
            return wall_minutes * mult
    return wall_minutes


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--repo", required=True)
    ap.add_argument("--limit", type=int, default=100)
    args = ap.parse_args()

    token = os.environ.get("GITHUB_TOKEN")
    if not token:
        log.error("set GITHUB_TOKEN")
        return 2
    headers = {"Authorization": f"Bearer {token}",
               "Accept": "application/vnd.github+json"}

    r = requests.get(f"{API}/repos/{args.repo}/actions/runs",
                     headers=headers, params={"per_page": args.limit}, timeout=30)
    r.raise_for_status()
    runs = r.json().get("workflow_runs", [])

    wasted = find_superseded(runs)
    log.info("%d recent run(s), %d superseded by a later push", len(runs), len(wasted))
    by_workflow = collections.Counter(w.get("name") for w in wasted)
    for name, count in by_workflow.most_common():
        log.warning("  %-40s %d redundant run(s)", name, count)
    if wasted:
        log.warning("add a concurrency group to the workflows above:")
        log.warning("  concurrency:")
        log.warning("    group: ${{ github.workflow }}-${{ github.ref }}")
        log.warning("    cancel-in-progress: true")
        log.warning("do NOT add cancel-in-progress to a deploy workflow")
    return 0


if __name__ == "__main__":
    sys.exit(main())

/**
 * Estimate CI minutes wasted on runs superseded by a later push.
 *
 * Reports only. Adding cancel-in-progress to a deploy workflow would leave a
 * half-finished deploy, so the change is left to a human.
 */
const API = 'https://api.github.com';
// Billed minutes per wall-clock minute, per runner OS.
export const MULTIPLIER = { ubuntu: 1, windows: 2, macos: 10 };

/**
 * Pure decision function.
 *
 * A run is superseded when a LATER run exists for the same workflow and branch.
 * Grouping by workflow as well as branch matters: two different workflows on one
 * branch are not competing.
 */
export function findSuperseded(runs) {
  const byKey = new Map();
  for (const r of runs) {
    const key = `${r.workflow_id}::${r.head_branch}`;
    byKey.set(key, [...(byKey.get(key) ?? []), r]);
  }
  const superseded = [];
  for (const group of byKey.values()) {
    group.sort((a, b) => (a.run_number ?? 0) - (b.run_number ?? 0));
    for (let i = 0; i < group.length - 1; i += 1) {
      if (group[i].created_at && group[i + 1].created_at
        && group[i].created_at < group[i + 1].created_at) superseded.push(group[i]);
    }
  }
  return superseded;
}

export function billedMinutes(run, wallMinutes) {
  const name = (run.labels ?? []).join(' ').toLowerCase() || 'ubuntu';
  for (const [os, mult] of Object.entries(MULTIPLIER)) {
    if (name.includes(os)) return wallMinutes * mult;
  }
  return wallMinutes;
}

async function main() {
  const repo = process.argv[process.argv.indexOf('--repo') + 1];
  const token = process.env.GITHUB_TOKEN;
  if (!token) { console.error('set GITHUB_TOKEN'); process.exit(2); }

  const res = await fetch(`${API}/repos/${repo}/actions/runs?per_page=100`, {
    headers: { Authorization: `Bearer ${token}`, Accept: 'application/vnd.github+json' },
  });
  const { workflow_runs: runs = [] } = await res.json();
  const wasted = findSuperseded(runs);
  console.log(`${runs.length} recent run(s), ${wasted.length} superseded by a later push`);

  const counts = {};
  for (const w of wasted) counts[w.name] = (counts[w.name] ?? 0) + 1;
  for (const [name, count] of Object.entries(counts).sort((a, b) => b[1] - a[1])) {
    console.warn(`  ${name.padEnd(40)} ${count} redundant run(s)`);
  }
  if (wasted.length) {
    console.warn('add a concurrency group; do NOT add cancel-in-progress to a deploy workflow');
  }
}

if (import.meta.url === `file://${process.argv[1]}`) main();

from actions_redundant_runs import find_superseded, billed_minutes


def run(n, wf=1, branch="main", created=None):
    return {"run_number": n, "workflow_id": wf, "head_branch": branch,
            "created_at": created or f"2026-08-28T00:{n:02d}:00Z", "name": f"wf{wf}"}


def test_a_single_run_is_not_superseded():
    assert find_superseded([run(1)]) == []


def test_the_earlier_of_two_runs_is_superseded():
    out = find_superseded([run(1), run(2)])
    assert len(out) == 1 and out[0]["run_number"] == 1


def test_different_workflows_do_not_compete():
    """Two workflows on one branch are both meant to run."""
    assert find_superseded([run(1, wf=1), run(2, wf=2)]) == []


def test_different_branches_do_not_compete():
    assert find_superseded([run(1, branch="a"), run(2, branch="b")]) == []


def test_macos_multiplier_applies():
    r = {"labels": ["macos-latest"]}
    assert billed_minutes(r, 10) == 100


def test_linux_is_billed_one_to_one():
    assert billed_minutes({"labels": ["ubuntu-latest"]}, 10) == 10


def test_unknown_runner_does_not_inflate_the_estimate():
    assert billed_minutes({"labels": []}, 10) == 10

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { findSuperseded, billedMinutes } from './actions-redundant-runs.mjs';

const run = (n, { wf = 1, branch = 'main' } = {}) => ({
  run_number: n, workflow_id: wf, head_branch: branch,
  created_at: `2026-08-28T00:${String(n).padStart(2, '0')}:00Z`, name: `wf${wf}`,
});

test('a single run is not superseded', () => {
  assert.deepEqual(findSuperseded([run(1)]), []);
});

test('the earlier of two runs is superseded', () => {
  const out = findSuperseded([run(1), run(2)]);
  assert.equal(out.length, 1);
  assert.equal(out[0].run_number, 1);
});

test('different workflows do not compete', () => {
  assert.deepEqual(findSuperseded([run(1, { wf: 1 }), run(2, { wf: 2 })]), []);
});

test('the macOS multiplier applies', () => {
  assert.equal(billedMinutes({ labels: ['macos-latest'] }, 10), 100);
});

test('linux is billed one to one', () => {
  assert.equal(billedMinutes({ labels: ['ubuntu-latest'] }, 10), 10);
});