bmsdna-devtools 0.41.0__tar.gz → 0.42.0__tar.gz

{bmsdna_devtools-0.41.0 → bmsdna_devtools-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bmsdna-devtools
-Version: 0.41.0
+Version: 0.42.0
 Summary: Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects
 Requires-Python: >=3.14
 Requires-Dist: pgdevkit[db]>=0.7.1
@@ -50,7 +50,7 @@ Find the PR opened from the current branch and report build/check status
 GitHub — whichever `origin` points at.
 
 ```bash
-bdt pr status [--target-branch BRANCH] [--wait]
+bdt pr status [--target-branch BRANCH] [--pr-id N] [--wait [--timeout SECONDS]]
 ```
 
 Every command that acts on an existing PR (`pr status/info/retry/publish/update/comment`, `issue take` without
@@ -75,6 +75,12 @@ stage/check needs a reviewer plus a link to act on it, and exits **3**
 build/check has already failed, that's reported instead (exit 1) even when
 one is also waiting on approval.
 
+`--wait --timeout SECONDS` gives up after that long when the checks are still running: it prints the current
+state of every pipeline/check, ends with `Still running after N s. Re-run ... to keep waiting.` (the command pins `--pr-id` to the PR it watched) and exits **4**
+(like `issue watch`). Use it where the caller's own limit is shorter than CI, e.g. an agent's shell tool, which
+kills the command after a few minutes and discards its output; re-run the same command to keep waiting.
+Without `--timeout` (or with `0`) it waits until everything is done, as before. `--timeout` needs `--wait`.
+
 On Azure DevOps, `--wait` on a PR with no builds yet also checks that the target branch has an enabled
 Build validation policy; if it doesn't, no build will ever run, so it exits 1 with an error instead of
 polling forever (a failed policy lookup is ignored and the wait continues).

{bmsdna_devtools-0.41.0 → bmsdna_devtools-0.42.0}/README.md

@@ -36,7 +36,7 @@ Find the PR opened from the current branch and report build/check status
 GitHub — whichever `origin` points at.
 
 ```bash
-bdt pr status [--target-branch BRANCH] [--wait]
+bdt pr status [--target-branch BRANCH] [--pr-id N] [--wait [--timeout SECONDS]]
 ```
 
 Every command that acts on an existing PR (`pr status/info/retry/publish/update/comment`, `issue take` without
@@ -61,6 +61,12 @@ stage/check needs a reviewer plus a link to act on it, and exits **3**
 build/check has already failed, that's reported instead (exit 1) even when
 one is also waiting on approval.
 
+`--wait --timeout SECONDS` gives up after that long when the checks are still running: it prints the current
+state of every pipeline/check, ends with `Still running after N s. Re-run ... to keep waiting.` (the command pins `--pr-id` to the PR it watched) and exits **4**
+(like `issue watch`). Use it where the caller's own limit is shorter than CI, e.g. an agent's shell tool, which
+kills the command after a few minutes and discards its output; re-run the same command to keep waiting.
+Without `--timeout` (or with `0`) it waits until everything is done, as before. `--timeout` needs `--wait`.
+
 On Azure DevOps, `--wait` on a PR with no builds yet also checks that the target branch has an enabled
 Build validation policy; if it doesn't, no build will ever run, so it exits 1 with an error instead of
 polling forever (a failed policy lookup is ignored and the wait continues).

{bmsdna_devtools-0.41.0 → bmsdna_devtools-0.42.0}/bmsdna/devtools/cli.py

@@ -34,7 +34,7 @@ from . import translate as translate_mod
 from . import pr_build, pr_info as pr_info_mod, pr_issue_link, pr_labels, pull as pull_mod, worktree as worktree_mod
 from .ado_auth import auth_header
 from .bdt_config import find_pyproject, load_bdt_table
-from .cli_tools import CLI_TIMEOUT_SECS, detect_agent_session, require_az, require_gh
+from .cli_tools import CLI_TIMEOUT_SECS, EXIT_WAIT_TIMEOUT, detect_agent_session, require_az, require_gh
 from .gitrepo import (
     AdoRemote,
     GitHubRemote,
@@ -468,18 +468,28 @@ def pr_publish(
 def pr_status(
     target_branch: str | None = typer.Option(None, "--target-branch", help=_LOOKUP_TARGET_HELP),
     wait: bool = typer.Option(False, "--wait", help="Poll until all pipelines/checks are completed; stops early and reports status if one needs manual approval"),
+    timeout: float = typer.Option(
+        0,
+        "--timeout",
+        help="With --wait: stop after this many seconds if the checks are still running, print their current state and exit "
+        f"{EXIT_WAIT_TIMEOUT} (0 = wait forever, the default). Use it where the caller's own time limit is shorter than CI, "
+        "e.g. an agent's shell tool, then re-run the same command to keep waiting",
+    ),
     pr_id: int | None = typer.Option(None, "--pr-id", help=_PR_ID_HELP),
     pat: str | None = typer.Option(None, "--pat", envvar=["AZURE_DEVOPS_EXT_PAT", "AZURE_DEVOPS_PAT"], help="Azure DevOps PAT (else falls back to `az` login)"),
 ) -> None:
     """Show build/check status for the PR opened from the current branch, or for --pr-id
     directly (Azure DevOps or GitHub, auto-detected).
     """
+    if timeout and not wait:
+        raise typer.BadParameter("--timeout only works together with --wait", param_hint="--timeout")
+    _check_poll_options(None, timeout)
     remote = current_remote()
     if isinstance(remote, GitHubRemote):
         gh = require_gh()
-        gh_pr.run(gh, wait, pr_id=gh_pr.resolve_pr_id(gh, pr_id, target_branch))
+        gh_pr.run(gh, wait, pr_id=gh_pr.resolve_pr_id(gh, pr_id, target_branch), timeout=timeout)
         return
-    pr_build.run(remote, pat, target_branch, wait, pr_id=pr_id)
+    pr_build.run(remote, pat, target_branch, wait, pr_id=pr_id, timeout=timeout)
 
 
 @pr_app.command("info")

{bmsdna_devtools-0.41.0 → bmsdna_devtools-0.42.0}/bmsdna/devtools/cli_tools.py

@@ -13,7 +13,9 @@ import os
 import shutil
 import sys
 import time
+from collections.abc import Callable
 from dataclasses import dataclass
+from typing import NoReturn
 
 AZ_INSTALL_HINT = "Install the Azure CLI: https://learn.microsoft.com/cli/azure/install-azure-cli"
 GH_INSTALL_HINT = "Install the GitHub CLI: https://cli.github.com"
@@ -26,6 +28,11 @@ PSQL_INSTALL_HINT = "Install the PostgreSQL client tools (psql): https://www.pos
 # this tool), and callers branching on exit code shouldn't confuse the two.
 EXIT_NEEDS_APPROVAL = 3
 
+# `pr status --wait --timeout N` exits with this code when the checks are still running after N seconds
+# (same code as `issue watch` / `issue search --wait` use for "gave up waiting"). The caller learns the
+# current state from the output and can simply run the same command again to keep waiting.
+EXIT_WAIT_TIMEOUT = 4
+
 # How long a `--wait` poll loop may go without printing anything before `PollHeartbeat`
 # forces a line out anyway. Every `--wait` loop in this tool polls every 30s but used to
 # print only when the status text changed -- for a check/build that sits in the same
@@ -73,6 +80,42 @@ class PollHeartbeat:
         self._last_print = now
 
 
+class WaitDeadline:
+    """Optional overall time limit of a `--wait` poll loop (`timeout_secs` of 0 / None = wait forever).
+
+    Exists because a caller often can't wait as long as CI takes: an agent's shell tool kills a command
+    after a few minutes and throws its output away. Giving up on our own terms lets us report where things
+    stand and exit with `EXIT_WAIT_TIMEOUT` so the caller knows to re-run.
+    """
+
+    def __init__(self, timeout_secs: float | None) -> None:
+        self.timeout_secs = timeout_secs or 0.0
+        self._end = time.monotonic() + self.timeout_secs if self.timeout_secs else None
+
+    def expired(self) -> bool:
+        return self._end is not None and time.monotonic() >= self._end
+
+    def sleep(self, secs: float) -> None:
+        """`time.sleep(secs)`, cut short so the loop wakes up right at the deadline."""
+        time.sleep(secs if self._end is None else max(0.0, min(secs, self._end - time.monotonic())))
+
+
+def status_rerun_cmd(pr_id: int | None, timeout_secs: float) -> str:
+    """The command that keeps waiting where a timed-out `pr status --wait` stopped. Pins `--pr-id` to the PR that
+    was being watched, so re-running can't resolve to a different PR (e.g. another branch checked out since)."""
+    return f"bdt pr status --pr-id {pr_id} --wait --timeout {timeout_secs:g}" if pr_id else f"bdt pr status --wait --timeout {timeout_secs:g}"
+
+
+def exit_wait_timeout(msg: str, print_details: Callable[[], object], deadline: WaitDeadline, rerun_cmd: str) -> NoReturn:
+    """Report where a `--wait` loop stands when its `deadline` ran out (status line, per-item details), then
+    exit `EXIT_WAIT_TIMEOUT`. The last line tells the caller what to run to keep waiting."""
+    print(msg)
+    print("\nDetails:")
+    print_details()
+    print(f"\nStill running after {deadline.timeout_secs:g} s. Re-run `{rerun_cmd}` to keep waiting.")
+    sys.exit(EXIT_WAIT_TIMEOUT)
+
+
 def is_claude_code() -> bool:
     """True if this process is running as a subprocess of Claude Code.
 

{bmsdna_devtools-0.41.0 → bmsdna_devtools-0.42.0}/bmsdna/devtools/gh_pr.py

@@ -20,7 +20,17 @@ from pathlib import Path
 from typing import Any
 
 from . import pr_issue_link
-from .cli_tools import CLI_TIMEOUT_SECS, EXIT_NEEDS_APPROVAL, PollHeartbeat, detect_agent_session, ensure_agent_session_note, is_claude_code
+from .cli_tools import (
+    CLI_TIMEOUT_SECS,
+    EXIT_NEEDS_APPROVAL,
+    PollHeartbeat,
+    WaitDeadline,
+    detect_agent_session,
+    ensure_agent_session_note,
+    exit_wait_timeout,
+    is_claude_code,
+    status_rerun_cmd,
+)
 from .gitrepo import current_branch
 from .pr_choice import PrCandidate, choose_pr
 from .pr_markdown import build_attachments_section, build_comment_content, build_screenshots_section
@@ -308,8 +318,11 @@ def exit_needs_approval(msg: str, item_lines: list[str], rerun_cmd: str) -> None
     sys.exit(EXIT_NEEDS_APPROVAL)
 
 
-def run(gh: str, wait: bool, pr_id: int | None = None) -> None:
+def run(gh: str, wait: bool, pr_id: int | None = None, timeout: float = 0) -> None:
+    """`timeout` (seconds, only with `wait`): stop polling after that long and exit `EXIT_WAIT_TIMEOUT`
+    with the current state; 0 = wait until every check is done."""
     heartbeat = PollHeartbeat()
+    deadline = WaitDeadline(timeout)
     draft_notice_shown = False
     while True:
         pr = get_pr(gh, pr_id)
@@ -368,7 +381,9 @@ def run(gh: str, wait: bool, pr_id: int | None = None) -> None:
         # must not keep polling forever waiting for it to become unstuck.
         if "pending" in buckets and wait and not waiting_approval:
             heartbeat.show(msg)
-            time.sleep(30)
+            if deadline.expired():
+                exit_wait_timeout(msg, lambda: [print_check(c) for c in checks], deadline, status_rerun_cmd(pr_number, timeout))
+            deadline.sleep(30)
             continue
 
         print(msg)

{bmsdna_devtools-0.41.0 → bmsdna_devtools-0.42.0}/bmsdna/devtools/pr_build.py

@@ -6,12 +6,13 @@ import re
 import sys
 import time
 from pathlib import Path
+from typing import NoReturn
 from urllib.parse import quote
 
 import requests
 
 from .ado_auth import auth_header
-from .cli_tools import EXIT_NEEDS_APPROVAL, HTTP_TIMEOUT_SECS, PollHeartbeat, detect_agent_session, ensure_agent_session_note, is_claude_code
+from .cli_tools import EXIT_NEEDS_APPROVAL, HTTP_TIMEOUT_SECS, PollHeartbeat, WaitDeadline, detect_agent_session, ensure_agent_session_note, exit_wait_timeout, is_claude_code, status_rerun_cmd
 from .gitrepo import AdoRemote, current_branch
 from .pr_choice import PrCandidate, choose_pr
 from .pr_markdown import build_attachments_section, build_comment_content, build_screenshots_section
@@ -766,7 +767,10 @@ def run(
     wait: bool,
     source_branch: str | None = None,
     pr_id: int | None = None,
+    timeout: float = 0,
 ) -> None:
+    """`timeout` (seconds, only with `wait`): stop polling after that long and exit `EXIT_WAIT_TIMEOUT`
+    with the current state; 0 = wait until every pipeline is done."""
     session = requests.Session()
     session.headers.update(auth_header(pat))
 
@@ -804,8 +808,14 @@ def run(
     draft_notice_shown = False
     policy_checked = False
     heartbeat = PollHeartbeat()
+    deadline = WaitDeadline(timeout)
+
+    def time_out(msg: str, builds: list, pr_number: int) -> NoReturn:
+        exit_wait_timeout(msg, lambda: [print_build(session, remote, b) for b in builds], deadline, status_rerun_cmd(pr_number, timeout))
+
     while True:
         pr = _poll_or_exit(fetch_pr)
+        pipeline_builds: list = []
         if not draft_notice_shown:
             draft_msg = draft_notice(pr)
             if draft_msg:
@@ -827,7 +837,9 @@ def run(
                         b.get("definition", {}).get("name", "?") for b in stale
                     )
                     heartbeat.show(msg)
-                    time.sleep(30)
+                    if deadline.expired():
+                        time_out(msg, [b for b in pipeline_builds if b not in stale], pr_number)
+                    deadline.sleep(30)
                     continue
             msg += " | " + ", ".join(
                 f"{b.get('definition', {}).get('name', '?')} #{b['id']} {b.get('status')} ({b.get('result') or '—'})"
@@ -889,7 +901,9 @@ def run(
         heartbeat.show(msg)
 
         if wait:
-            time.sleep(30)
+            if deadline.expired():
+                time_out(msg, pipeline_builds, pr_number)
+            deadline.sleep(30)
 
 
 def run_watch_deploy(remote: AdoRemote, pat: str | None, target_branch: str, wait: bool) -> None:

{bmsdna_devtools-0.41.0 → bmsdna_devtools-0.42.0}/pyproject.toml

@@ -10,7 +10,7 @@ packages = ["bmsdna"]
 
 [project]
 name = "bmsdna-devtools"
-version = "0.41.0"
+version = "0.42.0"
 description = "Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects"
 readme = "README.md"
 requires-python = ">=3.14"  # pgdevkit>=0.7.1 requires 3.14; was >=3.11 before adding it as a dependency

{bmsdna_devtools-0.41.0 → bmsdna_devtools-0.42.0}/skills/bmsdna-devtools/SKILL.md

@@ -35,7 +35,7 @@ CLI to install rather than trying to work around it.
 ## Checking PR build/check status
 
 ```bash
-bdt pr status [--target-branch BRANCH] [--pr-id N] [--wait]
+bdt pr status [--target-branch BRANCH] [--pr-id N] [--wait [--timeout SECONDS]]
 ```
 
 Finds the PR opened from the current branch and prints build/check status,
@@ -48,6 +48,10 @@ error message for `mergeStatus=conflicts` (ADO) or `mergeable=CONFLICTING`
 (GitHub) and tell the user to resolve conflicts rather than assuming CI is
 just slow.
 
+Where your shell tool has a time limit shorter than CI (it kills the command and drops its output), run
+`bdt pr status --wait --timeout 540` (seconds, below the limit): after that long it prints the current state and
+exits 4 — just run the same command again to keep waiting. Exit 3 = a stage needs a human's approval.
+
 `pr status`, `info`, `retry`, `publish`, `update`, `comment` (and `issue take`
 without a number) find the PR opened from the current branch into **any**
 target; `--target`/`--target-branch` only narrows it. With several open PRs

{bmsdna_devtools-0.41.0 → bmsdna_devtools-0.42.0}/tests/test_cli_pr_id.py

@@ -32,7 +32,7 @@ def test_pr_status_with_pr_id_passes_it_to_gh_pr_run(monkeypatch) -> None:
     monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: GITHUB_REMOTE)
     monkeypatch.setattr("bmsdna.devtools.cli.require_gh", lambda: "gh")
     captured = {}
-    monkeypatch.setattr("bmsdna.devtools.cli.gh_pr.run", lambda gh, wait, pr_id=None: captured.update(gh=gh, wait=wait, pr_id=pr_id))
+    monkeypatch.setattr("bmsdna.devtools.cli.gh_pr.run", lambda gh, wait, pr_id=None, timeout=0: captured.update(gh=gh, wait=wait, pr_id=pr_id))
 
     result = runner.invoke(app, ["pr", "status", "--pr-id", "99"])
 
@@ -144,7 +144,7 @@ def test_pr_status_with_pr_id_skips_branch_resolution_for_ado(monkeypatch) -> No
     captured = {}
     monkeypatch.setattr(
         "bmsdna.devtools.cli.pr_build.run",
-        lambda remote, pat, target_branch, wait, pr_id=None: captured.update(remote=remote, pr_id=pr_id),
+        lambda remote, pat, target_branch, wait, pr_id=None, timeout=0: captured.update(remote=remote, pr_id=pr_id),
     )
 
     result = runner.invoke(app, ["pr", "status", "--pr-id", "99"])

{bmsdna_devtools-0.41.0 → bmsdna_devtools-0.42.0}/tests/test_pr_choice.py

@@ -230,7 +230,7 @@ def test_cli_pr_status_interactive_with_several_prs_acts_on_the_chosen_one(monke
     _github_cli(monkeypatch, [GH_INTO_MAIN, GH_INTO_DEV])
     monkeypatch.setattr(pr_choice, "_interactive", lambda: True)
     seen = {}
-    monkeypatch.setattr("bmsdna.devtools.cli.gh_pr.run", lambda gh, wait, pr_id=None: seen.update(pr_id=pr_id))
+    monkeypatch.setattr("bmsdna.devtools.cli.gh_pr.run", lambda gh, wait, pr_id=None, timeout=0: seen.update(pr_id=pr_id))
 
     result = runner.invoke(app, ["pr", "status"], input="1\n")
 
@@ -241,7 +241,7 @@ def test_cli_pr_status_interactive_with_several_prs_acts_on_the_chosen_one(monke
 def test_cli_pr_status_with_a_single_pr_into_main_does_not_ask(monkeypatch, never_asks) -> None:
     _github_cli(monkeypatch, [GH_INTO_MAIN])
     seen = {}
-    monkeypatch.setattr("bmsdna.devtools.cli.gh_pr.run", lambda gh, wait, pr_id=None: seen.update(pr_id=pr_id))
+    monkeypatch.setattr("bmsdna.devtools.cli.gh_pr.run", lambda gh, wait, pr_id=None, timeout=0: seen.update(pr_id=pr_id))
 
     result = runner.invoke(app, ["pr", "status"])
 

bmsdna_devtools-0.42.0/tests/test_wait_timeout.py

@@ -0,0 +1,187 @@
+"""`pr status --wait --timeout N`: give up after N seconds with the current state and exit code 4, so a caller
+whose own time limit is shorter than CI (an agent's shell tool, say) gets a result instead of being cut off."""
+
+from __future__ import annotations
+
+import re
+import time
+from unittest.mock import MagicMock
+
+import pytest
+from typer.testing import CliRunner
+
+from bmsdna.devtools.cli import app
+from bmsdna.devtools.cli_tools import EXIT_WAIT_TIMEOUT, WaitDeadline
+from bmsdna.devtools.gh_pr import run as gh_run
+from bmsdna.devtools.gitrepo import AdoRemote, GitHubRemote
+from bmsdna.devtools.issue_watch import EXIT_TIMEOUT
+from bmsdna.devtools.pr_build import run as ado_run
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def sleeps(monkeypatch) -> list[float]:
+    """A fake clock: `time.sleep` only advances `time.monotonic`, and records what it was asked for."""
+    now = [1000.0]
+    slept: list[float] = []
+
+    def fake_sleep(secs: float) -> None:
+        slept.append(secs)
+        now[0] += secs
+        if len(slept) > 500:
+            pytest.fail("polled forever: the --timeout deadline never fired")
+
+    monkeypatch.setattr(time, "monotonic", lambda: now[0])
+    monkeypatch.setattr(time, "sleep", fake_sleep)
+    return slept
+
+
+def test_exit_code_matches_the_other_wait_commands() -> None:
+    assert EXIT_WAIT_TIMEOUT == EXIT_TIMEOUT == 4
+
+
+def test_deadline_without_timeout_never_expires_and_sleeps_in_full(sleeps) -> None:
+    deadline = WaitDeadline(0)
+    deadline.sleep(30)
+    deadline.sleep(30)
+
+    assert sleeps == [30, 30]
+    assert not deadline.expired()
+
+
+def test_deadline_cuts_the_last_sleep_short(sleeps) -> None:
+    deadline = WaitDeadline(70)
+    while not deadline.expired():
+        deadline.sleep(30)
+
+    assert sleeps == [30, 30, 10]
+
+
+# -- GitHub -------------------------------------------------------------------
+
+
+def _gh_pr(checks: list[dict]) -> dict:
+    return {"number": 42, "title": "feat: widgets", "baseRefName": "main", "mergeable": "MERGEABLE", "isDraft": False, "statusCheckRollup": checks}
+
+
+PENDING = {"__typename": "CheckRun", "name": "build", "status": "IN_PROGRESS", "workflowName": "CI"}
+PASSED = {"__typename": "CheckRun", "name": "lint", "status": "COMPLETED", "conclusion": "SUCCESS", "workflowName": "CI"}
+
+
+def test_gh_wait_times_out_with_exit_4_and_reports_every_check(monkeypatch, sleeps, capsys) -> None:
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.get_pr", lambda gh, pr_id=None: _gh_pr([PASSED, PENDING]))
+
+    with pytest.raises(SystemExit) as exc:
+        gh_run("gh", wait=True, timeout=70)
+
+    out = capsys.readouterr().out
+    assert exc.value.code == EXIT_WAIT_TIMEOUT
+    assert sleeps == [30, 30, 10]
+    assert "[✓ PASS] CI / lint" in out and "[… PENDING] CI / build" in out
+    assert out.rstrip().endswith("Still running after 70 s. Re-run `bdt pr status --pr-id 42 --wait --timeout 70` to keep waiting.")
+
+
+def test_gh_wait_without_timeout_keeps_polling(monkeypatch, sleeps) -> None:
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.get_pr", lambda gh, pr_id=None: _gh_pr([PENDING]))
+
+    class Enough(Exception):
+        pass
+
+    def sleep_a_few_times(secs: float) -> None:
+        sleeps.append(secs)
+        if len(sleeps) > 200:
+            raise Enough
+
+    monkeypatch.setattr(time, "sleep", sleep_a_few_times)
+
+    with pytest.raises(Enough):
+        gh_run("gh", wait=True)
+
+    assert len(sleeps) > 200
+
+
+def test_gh_wait_returns_normally_when_checks_finish_before_the_deadline(monkeypatch, sleeps, capsys) -> None:
+    polls = iter([_gh_pr([PENDING]), _gh_pr([{**PENDING, "status": "COMPLETED", "conclusion": "SUCCESS"}])])
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.get_pr", lambda gh, pr_id=None: next(polls))
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.deploy_run_hint", lambda gh, base: None)
+
+    gh_run("gh", wait=True, timeout=300)
+
+    assert sleeps == [30]
+    assert "Still running" not in capsys.readouterr().out
+
+
+# -- Azure DevOps ---------------------------------------------------------------
+
+
+def _ado_env(monkeypatch, builds: list[dict]) -> None:
+    monkeypatch.setattr("bmsdna.devtools.pr_build.requests.Session", lambda: MagicMock())
+    monkeypatch.setattr("bmsdna.devtools.pr_build.auth_header", lambda pat: {})
+    monkeypatch.setattr("bmsdna.devtools.pr_build.get_pr", lambda *a, **k: {"pullRequestId": 42, "title": "feat: widgets", "status": "active", "isDraft": False})
+    monkeypatch.setattr("bmsdna.devtools.pr_build.get_builds_for_pr", lambda *a, **k: builds)
+    monkeypatch.setattr("bmsdna.devtools.pr_build.find_pending_approvals", lambda *a, **k: [])
+    monkeypatch.setattr("bmsdna.devtools.pr_build.print_build", lambda session, remote, b: print(f"  build #{b['id']} {b['status']}"))
+
+
+def test_ado_wait_times_out_with_exit_4_and_reports_the_running_builds(monkeypatch, sleeps, capsys) -> None:
+    _ado_env(monkeypatch, [{"id": 200, "status": "inProgress", "result": None, "definition": {"id": 2, "name": "ci"}}])
+
+    with pytest.raises(SystemExit) as exc:
+        ado_run(AdoRemote("myorg", "MyProj", "myrepo"), None, "main", wait=True, source_branch="feature-x", timeout=45)
+
+    out = capsys.readouterr().out
+    assert exc.value.code == EXIT_WAIT_TIMEOUT
+    assert sleeps == [30, 15]
+    assert "ci #200 inProgress" in out and "build #200 inProgress" in out
+    assert out.rstrip().endswith("Still running after 45 s. Re-run `bdt pr status --pr-id 42 --wait --timeout 45` to keep waiting.")
+
+
+def test_ado_wait_times_out_while_no_build_has_been_queued_yet(monkeypatch, sleeps, capsys) -> None:
+    _ado_env(monkeypatch, [])
+    monkeypatch.setattr("bmsdna.devtools.pr_build.lacks_build_policy", lambda *a: False)
+
+    with pytest.raises(SystemExit) as exc:
+        ado_run(AdoRemote("myorg", "MyProj", "myrepo"), None, "main", wait=True, source_branch="feature-x", timeout=60)
+
+    assert exc.value.code == EXIT_WAIT_TIMEOUT
+    assert "No builds found." in capsys.readouterr().out
+
+
+# -- CLI ----------------------------------------------------------------------
+
+
+def test_cli_passes_timeout_on(monkeypatch) -> None:
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: GitHubRemote("owner", "repo"))
+    monkeypatch.setattr("bmsdna.devtools.cli.require_gh", lambda: "gh")
+    monkeypatch.setattr("bmsdna.devtools.cli.gh_pr.resolve_pr_id", lambda gh, pr_id, target: pr_id)
+    seen: dict = {}
+    monkeypatch.setattr("bmsdna.devtools.cli.gh_pr.run", lambda gh, wait, pr_id=None, timeout=0: seen.update(wait=wait, timeout=timeout))
+
+    result = runner.invoke(app, ["pr", "status", "--wait", "--timeout", "540"])
+
+    assert result.exit_code == 0, result.output
+    assert seen == {"wait": True, "timeout": 540}
+
+
+def _plain(output: str) -> str:
+    """Rich colors and boxes the error panel on CI terminals; reduce it to the bare words."""
+    return " ".join(re.sub(r"[│╭╮╰╯─]", " ", re.sub(r"\x1b\[[0-9;]*m", "", output)).split())
+
+
+def test_cli_timeout_needs_wait(monkeypatch) -> None:
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: pytest.fail("must be rejected before anything runs"))
+
+    result = runner.invoke(app, ["pr", "status", "--timeout", "540"])
+
+    assert result.exit_code == 2
+    assert "--timeout only works together with --wait" in _plain(result.output)
+
+
+@pytest.mark.parametrize("bad", ["-1", "nan", "inf"])
+def test_cli_rejects_a_timeout_that_is_not_a_finite_number(monkeypatch, bad) -> None:
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: pytest.fail("must be rejected before anything runs"))
+
+    result = runner.invoke(app, ["pr", "status", "--wait", "--timeout", bad])
+
+    assert result.exit_code == 2

{bmsdna_devtools-0.41.0 → bmsdna_devtools-0.42.0}/uv.lock

@@ -22,7 +22,7 @@ wheels = [
 
 [[package]]
 name = "bmsdna-devtools"
-version = "0.41.0"
+version = "0.42.0"
 source = { editable = "." }
 dependencies = [
     { name = "pgdevkit", extra = ["db"] },