git-buckets 0.3.0__tar.gz → 0.4.0__tar.gz

{git_buckets-0.3.0 → git_buckets-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: git-buckets
-Version: 0.3.0
+Version: 0.4.0
 Summary: Git over S3: clone, fetch and push repositories backed by an S3 bucket.
 Author: Full Duplex Media
 Author-email: Full Duplex Media <contact@fullduplex.media>
@@ -123,6 +123,19 @@ gb repo delete my-bucket/tools/cli/my-project --yes  # without --yes it only pri
 Delete takes the repo's LFS objects, locks, bundles, packages and rendered web tree with it. The undo path is S3
 versioning on the operator's side, not a `gb` command. There is no rename.
 
+## Package lifecycle
+
+Published files are immutable, so a bad release is yanked rather than replaced: it stays downloadable for anything
+that already pinned it, and every other resolve skips it.
+
+```sh
+gb package list                                          # every bucket, grouped by repo
+gb package list -b my-bucket -r tools/cli/my-project     # one repo; -v lists every file with size and sha256
+gb package yank my-bucket/tools/cli/my-project my-project 1.2.0 --reason "bad wheel"
+gb package unyank my-bucket/tools/cli/my-project my-project 1.2.0
+gb package delete my-bucket/tools/cli/my-project my-project 1.2.0 --yes  # the bytes go; lockfiles that pin it 404
+```
+
 ## Where the secrets live
 
 The refresh token (one year, fixed from sign-in) goes in your OS keyring, or in `~/.config/gb/hosts.yml` at 0600 when no

{git_buckets-0.3.0 → git_buckets-0.4.0}/README.md

@@ -108,6 +108,19 @@ gb repo delete my-bucket/tools/cli/my-project --yes  # without --yes it only pri
 Delete takes the repo's LFS objects, locks, bundles, packages and rendered web tree with it. The undo path is S3
 versioning on the operator's side, not a `gb` command. There is no rename.
 
+## Package lifecycle
+
+Published files are immutable, so a bad release is yanked rather than replaced: it stays downloadable for anything
+that already pinned it, and every other resolve skips it.
+
+```sh
+gb package list                                          # every bucket, grouped by repo
+gb package list -b my-bucket -r tools/cli/my-project     # one repo; -v lists every file with size and sha256
+gb package yank my-bucket/tools/cli/my-project my-project 1.2.0 --reason "bad wheel"
+gb package unyank my-bucket/tools/cli/my-project my-project 1.2.0
+gb package delete my-bucket/tools/cli/my-project my-project 1.2.0 --yes  # the bytes go; lockfiles that pin it 404
+```
+
 ## Where the secrets live
 
 The refresh token (one year, fixed from sign-in) goes in your OS keyring, or in `~/.config/gb/hosts.yml` at 0600 when no

{git_buckets-0.3.0 → git_buckets-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "git-buckets"
-version = "0.3.0"
+version = "0.4.0"
 description = "Git over S3: clone, fetch and push repositories backed by an S3 bucket."
 readme = "README.md"
 requires-python = ">=3.14"

{git_buckets-0.3.0 → git_buckets-0.4.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "git-buckets"
-version = "0.3.0"
+version = "0.4.0"
 description = "Git over S3: clone, fetch and push repositories backed by an S3 bucket."
 authors = [
   { name = 'Full Duplex Media', email = 'contact@fullduplex.media' }

{git_buckets-0.3.0 → git_buckets-0.4.0}/src/git_buckets/cli.py

@@ -231,6 +231,125 @@ def repo_unprotect_command(name: str, ref: str, host: str | None) -> None:
     _protect('unprotect', name, ref, host)
 
 
+@cli.group(name='package')
+def package_group() -> None:
+    """Manage published packages: list them, yank a bad release, delete one."""
+
+
+def _print_versions(versions: list[dict], verbose: bool) -> None:
+    for release in versions:
+        yanked = release.get('yanked')
+        suffix = f'  (yanked: {yanked})' if isinstance(yanked, str) and yanked else '  (yanked)' if yanked else ''
+        # A file whose name declares no version still lists, grouped under a null version by the API.
+        version = release.get('version') or '(unversioned)'
+        click.echo(f'    {version}{suffix}')
+        if verbose:
+            for entry in release.get('files', []):
+                click.echo(f'      {entry["filename"]}  {_human_bytes(entry["size"])}  {entry["sha256"]}')
+
+
+@package_group.command(name='list')
+@_HOST_OPTION
+@click.option('-b', '--bucket', default=None, help='One bucket; every bucket you can see if omitted.')
+@click.option('-r', '--repo', 'repo_path', default=None, help='One repo inside the bucket; needs --bucket.')
+@click.option('-v', '--verbose', is_flag=True, help='Also list every file with its size and sha256.')
+@click.argument('name', required=False)
+def package_list_command(
+    host: str | None, bucket: str | None, repo_path: str | None, verbose: bool, name: str | None
+) -> None:
+    """List published packages: gb package list [-b BUCKET] [-r REPO] [NAME]."""
+    from . import package as package_module, repo as repo_module
+
+    if repo_path and not bucket:
+        raise click.UsageError('--repo needs --bucket: packages live in a bucket, and repo paths are not unique.')
+    try:
+        domain, entry = repo_module.select_host(host)
+        labels = [bucket] if bucket else package_module.buckets(domain, entry)
+        listings = [(label, package_module.listing(domain, entry, label, repo_path, name)) for label in labels]
+    except Exception as x:
+        raise click.ClickException(str(x)) from None
+    if not listings:
+        click.echo('No buckets. Run: gb login <deployment-domain>')
+        return
+    for label, packages in listings:
+        click.echo(label)
+        if not packages:
+            click.echo('  (no packages)')
+        for project in sorted(packages, key=lambda item: (item['repo'], item['name'])):
+            click.echo(f'  {project["repo"]}  {project["name"]}')
+            _print_versions(project.get('versions', []), verbose)
+
+
+@package_group.command(name='yank')
+@_HOST_OPTION
+@click.option('--reason', default=None, help='Why it was yanked; resolvers and gb package list show it.')
+@click.argument('repo_name', metavar='BUCKET/REPO')
+@click.argument('package', metavar='NAME')
+@click.argument('version')
+def package_yank_command(repo_name: str, package: str, version: str, host: str | None, reason: str | None) -> None:
+    """Yank a release.
+
+    The files stay downloadable, so anything that already pinned the version keeps resolving; every other
+    resolve skips it.
+    """
+    from . import package as package_module, repo as repo_module
+
+    try:
+        bucket, path = repo_module.parse_name(repo_name)
+        domain, entry = repo_module.select_host(host)
+        result = package_module.yank(domain, entry, bucket, path, package, version, reason)
+    except Exception as x:
+        raise click.ClickException(str(x)) from None
+    click.echo(f'Yanked {package} {version} in {repo_name}: {len(result.get("files", []))} file(s).')
+
+
+@package_group.command(name='unyank')
+@_HOST_OPTION
+@click.argument('repo_name', metavar='BUCKET/REPO')
+@click.argument('package', metavar='NAME')
+@click.argument('version')
+def package_unyank_command(repo_name: str, package: str, version: str, host: str | None) -> None:
+    """Put a yanked release back."""
+    from . import package as package_module, repo as repo_module
+
+    try:
+        bucket, path = repo_module.parse_name(repo_name)
+        domain, entry = repo_module.select_host(host)
+        result = package_module.unyank(domain, entry, bucket, path, package, version)
+    except Exception as x:
+        raise click.ClickException(str(x)) from None
+    click.echo(f'Unyanked {package} {version} in {repo_name}: {len(result.get("files", []))} file(s).')
+
+
+@package_group.command(name='delete')
+@_HOST_OPTION
+@click.option('--yes', is_flag=True, help='Actually delete; without it, nothing is touched.')
+@click.argument('repo_name', metavar='BUCKET/REPO')
+@click.argument('package', metavar='NAME')
+@click.argument('version')
+def package_delete_command(repo_name: str, package: str, version: str, host: str | None, yes: bool) -> None:
+    """Delete a release's files."""
+    from . import package as package_module, repo as repo_module
+
+    try:
+        bucket, path = repo_module.parse_name(repo_name)
+        domain, entry = repo_module.select_host(host)
+    except Exception as x:
+        raise click.ClickException(str(x)) from None
+    if not yes:
+        click.echo(f'This deletes {package} {version} from {repo_name}. Lockfiles that pin it will 404.')
+        click.echo('Prefer `gb package yank` unless the bytes must not exist.')
+        raise click.ClickException('refusing to delete without confirmation; re-run with --yes')
+    try:
+        result = package_module.delete(domain, entry, bucket, path, package, version)
+    except Exception as x:
+        raise click.ClickException(str(x)) from None
+    deleted = result.get('deleted', [])
+    click.echo(f'Deleted {package} {version} from {repo_name}: {len(deleted)} file(s).')
+    for filename in deleted:
+        click.echo(f'  {filename}')
+
+
 @cli.command(name='credential', hidden=True)
 @click.argument('operation')
 def credential_command(operation: str) -> None:

{git_buckets-0.3.0 → git_buckets-0.4.0}/src/git_buckets/credential.py

@@ -3,7 +3,8 @@
 Deliberately importless beyond the client's own small modules: this runs on every git operation against the
 deployment. A warm session token is one cached-file read; a live MicroVM behind it is not something the cache
 can promise, which is what ``wake.probe`` is for -- one cheap authenticated request, silent unless the bucket
-turns out to be cold. ``GB_NO_WAKE_PROBE=1`` drops back to the old zero-network warm path.
+turns out to be cold, and at most once per host per minute so a burst of fills costs one probe.
+``GB_NO_WAKE_PROBE=1`` drops back to the old zero-network warm path.
 """
 
 import sys
@@ -41,7 +42,7 @@ def get(fields: dict[str, str]) -> str | None:
     token = session.token(domain, entry)
     # The bucket's own host, not the deployment domain the token was minted against: that is what git is
     # about to talk to, and the only host the launcher's cold path answers for.
-    wake.probe(fields.get('host', domain).partition(':')[0], token)
+    wake.probe(fields.get('host', domain).partition(':')[0], token, domain=domain)
     return f'username={_USERNAME}\npassword={token}\n'
 
 

git_buckets-0.4.0/src/git_buckets/package.py

@@ -0,0 +1,74 @@
+"""``gb package``: list, yank/unyank and delete releases against a deployment's package API.
+
+Click-free like :mod:`repo`, and deliberately built on its helpers: host selection, the session cookie and the
+error mapping are the same ones ``/api/repo/*`` uses, so :class:`~.repo.RepoError` is the error type here too.
+"""
+
+import re
+from typing import Any
+from urllib.parse import urlencode
+
+from . import net
+from .hosts import Entry
+from .repo import RepoError, _headers, _raise_mapped, list_repos
+
+
+def normalize(name: str) -> str:
+    """The PEP 503 normalized project name, which is what the index is keyed by."""
+    return re.sub(r'[-_.]+', '-', name).lower()
+
+
+def buckets(domain: str, entry: Entry) -> list[str]:
+    """Every bucket label the token can see. ``/api/packages`` is per bucket, so listing them all starts here."""
+    listing = list_repos(domain, entry)
+    return sorted({bucket['bucket'] for bucket in listing.get('buckets', [])})
+
+
+def listing(domain: str, entry: Entry, bucket: str, repo: str | None = None, name: str | None = None) -> list[Any]:
+    query: dict[str, str] = {'bucket': bucket}
+    if repo:
+        query['repo'] = repo
+    if name:
+        query['name'] = normalize(name)
+    url = f'https://{domain}/api/packages?{urlencode(query)}'
+    try:
+        result = net.get_json(url, headers=_headers(domain, entry))
+    except net.HttpError as x:
+        if x.status == 404:
+            raise RepoError(f'{bucket} is not a bucket on {domain}') from None
+        if x.status == 403:
+            raise RepoError(f'not entitled to list packages in {bucket}') from None
+        _raise_mapped(domain, x)
+        raise
+    return result.get('packages', [])
+
+
+def _call(
+    operation: str, domain: str, entry: Entry, bucket: str, repo: str, name: str, version: str, **extra: str
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {'bucket': bucket, 'repo': repo, 'name': normalize(name), 'version': version, **extra}
+    try:
+        return net.post_json(f'https://{domain}/api/package/{operation}', payload, headers=_headers(domain, entry))
+    except net.HttpError as x:
+        if x.status == 403:
+            raise RepoError(f'not entitled to {operation} packages in {bucket}/{repo}') from None
+        if x.status == 404:
+            state = 'is not yanked in' if operation == 'unyank' else 'not found in'
+            raise RepoError(f'{name} {version} {state} {bucket}/{repo} on {domain}') from None
+        _raise_mapped(domain, x)
+        raise
+
+
+def yank(
+    domain: str, entry: Entry, bucket: str, repo: str, name: str, version: str, reason: str | None = None
+) -> dict[str, Any]:
+    extra = {'reason': reason} if reason else {}
+    return _call('yank', domain, entry, bucket, repo, name, version, **extra)
+
+
+def unyank(domain: str, entry: Entry, bucket: str, repo: str, name: str, version: str) -> dict[str, Any]:
+    return _call('unyank', domain, entry, bucket, repo, name, version)
+
+
+def delete(domain: str, entry: Entry, bucket: str, repo: str, name: str, version: str) -> dict[str, Any]:
+    return _call('delete', domain, entry, bucket, repo, name, version)

git_buckets-0.4.0/src/git_buckets/wake.py

@@ -0,0 +1,213 @@
+"""The cold-start wake probe: one cheap authenticated GET, run once before ``get`` hands git a credential.
+
+Warm is the common case and it has to cost exactly what it costs today: one request, answered fast, nothing
+printed. Cold is the case this exists for -- a bucket with no live instance yet means the request lands on the
+launcher, which holds the connection for up to its own hold (tens of seconds) before it either answers or
+307s to the same URL with a growing hop count. A plain request with a long timeout would sit there silently
+for that whole stretch, and a user watching a hung ``git fetch`` has no way to tell a cold start from a stall.
+
+So the probe is a single request carrying the whole budget, with a timer running alongside it: if the answer
+has not landed by ``warn_after_s`` the timer prints the "waking it up" line and the request keeps going. The
+request is never abandoned and retried -- an abandoned probe is still served, so on a cold bucket it leaves a
+launcher holding the launch lock and the retry starts a second launcher chain for the same wake. Everything
+else -- a network error, a redirect with no ``Location``, the whole deadline elapsing -- is swallowed: this
+fronts for a credential that has to reach git either way, so nothing here may block or fail a clone that
+would otherwise have worked.
+
+One 200 also resets the server's idle timer, so a probe is worth suppressing for a short while afterwards:
+``wake-probes.json`` in the deployment's state dir records ``{host: expires_at}`` and collapses a burst of
+credential fills (an LFS lock/verify/locks/unlock sequence, a submodule walk) into one probe.
+"""
+
+import os
+import sys
+from base64 import b64encode
+from contextlib import suppress
+from threading import Lock, Timer
+from time import monotonic, time
+from typing import Any
+
+from . import hosts, net
+
+HEALTH_PATH = '/_gb/health'
+_NO_PROBE_ENV = 'GB_NO_WAKE_PROBE'
+_TTL_ENV = 'GB_WAKE_PROBE_TTL_S'
+_PROBE_MARKER = 'wake-probes.json'
+_TTL_S = 60.0
+_WARN_AFTER_S = 1.0
+_DEADLINE_S = 90.0
+# Mirrors the launcher's own GB_HOP_BUDGET default; the deadline is what actually stops a runaway chain.
+_MAX_HOPS = 8
+_REDIRECT_STATUSES = (301, 302, 303, 307, 308)
+_WAKE_MESSAGE = 'gb: your git-bucket was asleep, waking it up...'
+_ALREADY_AWAKE_MESSAGE = 'gb: ready (bucket was already awake; slow network)'
+# How much of the server's uptime can predate this probe and still count as "it came up for us".
+_UPTIME_SLACK_S = 2.0
+_BOOT_LABELS = {'launch': 'cold launch', 'resume': 'resumed'}
+
+
+def probe(
+    host: str,
+    token: str,
+    *,
+    domain: str | None = None,
+    transport: Any = None,
+    clock: Any = monotonic,
+    warn_after_s: float = _WARN_AFTER_S,
+    deadline_s: float = _DEADLINE_S,
+    max_hops: int = _MAX_HOPS,
+    stderr: Any = None,
+    alarm: Any = None,
+) -> None:
+    """Warm ``host``'s bucket with ``token`` before the caller prints a credential back to git.
+
+    Skippable with ``GB_NO_WAKE_PROBE=1``, and suppressed for ``GB_WAKE_PROBE_TTL_S`` seconds (default 60,
+    0 disables suppression) after a 200 for the same host under ``domain``. Every exception is caught here,
+    not just the network ones: a bug in this module must never turn into a broken ``git fetch``. ``transport``,
+    ``stderr`` and ``alarm`` all default to ``None`` and are resolved inside the call rather than bound as
+    defaults, so a caller that patches ``net.request_raw`` or swaps ``sys.stderr`` (as the test suite does with
+    capsys) is not shadowed by a reference captured at import time.
+    """
+    if os.environ.get(_NO_PROBE_ENV) == '1':
+        return
+    ttl_s = _TTL_S
+    suppressed = False
+    # A state dir that cannot even be named is not a reason to skip the probe: anything raising here means
+    # "not suppressed", and the probe runs as if no marker had ever been written.
+    with suppress(Exception):
+        ttl_s = _ttl_s()
+        suppressed = bool(domain) and ttl_s > 0 and _suppressed(str(domain), host)
+    if suppressed:
+        return
+    answered = False
+    with suppress(Exception):
+        answered = _probe(
+            host,
+            token,
+            transport or net.request_raw,
+            clock,
+            warn_after_s,
+            deadline_s,
+            max_hops,
+            stderr if stderr is not None else sys.stderr,
+            alarm or _timer,
+        )
+    if answered and domain and ttl_s > 0:
+        with suppress(Exception):
+            _record(domain, host, ttl_s)
+
+
+def _probe(
+    host: str,
+    token: str,
+    transport: Any,
+    clock: Any,
+    warn_after_s: float,
+    deadline_s: float,
+    max_hops: int,
+    stderr: Any,
+    alarm: Any,
+) -> bool:
+    start = clock()
+    deadline = start + deadline_s
+    url = f'https://{host}{HEALTH_PATH}'
+    request_headers = {'Authorization': _basic(token)}
+    lock = Lock()
+    state = {'warned': False, 'done': False}
+    status: int | None = None
+    response_headers: dict[str, str] = {}
+    hops = 0
+
+    def _warn() -> None:
+        # Under the same lock the main thread takes before it announces, so an answer that lands while the
+        # timer is already running never gets narrated as if it had been slow.
+        with lock:
+            if state['done']:
+                return
+            print(_WAKE_MESSAGE, file=stderr)
+            state['warned'] = True
+
+    countdown = alarm(warn_after_s, _warn)
+    countdown.start()
+    try:
+        while True:
+            remaining = deadline - clock()
+            if remaining <= 0:
+                return False
+            try:
+                status, response_headers, _ = transport(url, headers=request_headers, timeout=remaining)
+            except (net.HttpTimeout, net.HttpError):
+                return False
+            if status not in _REDIRECT_STATUSES or hops >= max_hops:
+                break
+            location = response_headers.get('Location') or response_headers.get('location')
+            if not location:
+                break
+            url = location
+            hops += 1
+    finally:
+        countdown.cancel()
+        with lock:
+            state['done'] = True
+
+    if status != 200:
+        return False
+    if state['warned']:
+        _announce(clock() - start, response_headers, stderr)
+    return True
+
+
+def _timer(delay: float, callback: Any) -> Timer:
+    countdown = Timer(delay, callback)
+    countdown.daemon = True
+    return countdown
+
+
+def _announce(elapsed: float, response_headers: dict[str, str], stderr: Any) -> None:
+    # A slow DNS lookup or a slow link trips the timer just as well as a cold bucket does, and calling that
+    # a wake would be a lie: the server's uptime says whether this process came up during the probe.
+    uptime_s = _uptime_s(response_headers)
+    if uptime_s is not None and uptime_s > elapsed + _UPTIME_SLACK_S:
+        print(_ALREADY_AWAKE_MESSAGE, file=stderr)
+        return
+    kind = response_headers.get('x-gb-boot') or response_headers.get('X-Gb-Boot') or ''
+    label = _BOOT_LABELS.get(kind)
+    suffix = f'{label}, {elapsed:.1f}s' if label else f'{elapsed:.1f}s'
+    print(f'gb: ready ({suffix})', file=stderr)
+
+
+def _uptime_s(response_headers: dict[str, str]) -> float | None:
+    raw = response_headers.get('x-gb-uptime-s') or response_headers.get('X-Gb-Uptime-S')
+    if raw is None:
+        return None
+    try:
+        return float(raw)
+    except (TypeError, ValueError):
+        return None
+
+
+def _ttl_s() -> float:
+    raw = os.environ.get(_TTL_ENV)
+    if raw is None:
+        return _TTL_S
+    try:
+        return float(raw)
+    except ValueError:
+        return _TTL_S
+
+
+def _suppressed(domain: str, host: str) -> bool:
+    expires_at = (hosts.read_cache(domain, _PROBE_MARKER) or {}).get(host)
+    return isinstance(expires_at, int | float) and expires_at > time()
+
+
+def _record(domain: str, host: str, ttl_s: float) -> None:
+    now = time()
+    marker = hosts.read_cache(domain, _PROBE_MARKER) or {}
+    live = {key: value for key, value in marker.items() if isinstance(value, int | float) and value > now}
+    live[host] = now + ttl_s
+    hosts.write_cache(domain, _PROBE_MARKER, live)
+
+
+def _basic(token: str) -> str:
+    return 'Basic ' + b64encode(f'gb:{token}'.encode()).decode()

git_buckets-0.3.0/src/git_buckets/wake.py

@@ -1,127 +0,0 @@
-"""The cold-start wake probe: one cheap authenticated GET, run once before ``get`` hands git a credential.
-
-Warm is the common case and it has to cost exactly what it costs today: one request, answered fast, nothing
-printed. Cold is the case this exists for -- a bucket with no live instance yet means the request lands on the
-launcher, which holds the connection for up to its own hold (tens of seconds) before it either answers or
-307s to the same URL with a growing hop count. A plain request with a long timeout would sit there silently
-for that whole stretch, and a user watching a hung ``git fetch`` has no way to tell a cold start from a stall.
-
-So the probe leads with a short, cheap attempt (``warn_after_s``) whose only job is to notice slowness. A
-timeout there is not a failure -- it is exactly what a cold bucket looks like -- and it is the one signal that
-prints the "waking it up" line before switching to the launcher's own long-poll rhythm for the rest of the
-budget. Everything else -- a network error, a redirect with no ``Location``, the whole deadline elapsing -- is
-swallowed: this fronts for a credential that has to reach git either way, so nothing here may block or fail a
-clone that would otherwise have worked.
-"""
-
-import os
-import sys
-from base64 import b64encode
-from contextlib import suppress
-from time import monotonic
-from typing import Any
-
-from . import net
-
-HEALTH_PATH = '/_gb/health'
-_NO_PROBE_ENV = 'GB_NO_WAKE_PROBE'
-_WARN_AFTER_S = 1.0
-_DEADLINE_S = 90.0
-_MAX_HOPS = 20
-_REDIRECT_STATUSES = (301, 302, 303, 307, 308)
-_WAKE_MESSAGE = 'gb: your git-bucket was asleep, waking it up...'
-_BOOT_LABELS = {'launch': 'cold launch', 'resume': 'resumed'}
-
-
-def probe(
-    host: str,
-    token: str,
-    *,
-    transport: Any = None,
-    clock: Any = monotonic,
-    warn_after_s: float = _WARN_AFTER_S,
-    deadline_s: float = _DEADLINE_S,
-    max_hops: int = _MAX_HOPS,
-    stderr: Any = None,
-) -> None:
-    """Warm ``host``'s bucket with ``token`` before the caller prints a credential back to git.
-
-    Skippable with ``GB_NO_WAKE_PROBE=1``. Every exception is caught here, not just the network ones: a bug
-    in this module must never turn into a broken ``git fetch``. ``transport`` and ``stderr`` both default to
-    ``None`` and are resolved inside the call rather than bound as defaults, so a caller that patches
-    ``net.request_raw`` or swaps ``sys.stderr`` (as the test suite does with capsys) is not shadowed by a
-    reference captured at import time.
-    """
-    if os.environ.get(_NO_PROBE_ENV) == '1':
-        return
-    with suppress(Exception):
-        _probe(
-            host,
-            token,
-            transport or net.request_raw,
-            clock,
-            warn_after_s,
-            deadline_s,
-            max_hops,
-            stderr if stderr is not None else sys.stderr,
-        )
-
-
-def _probe(
-    host: str,
-    token: str,
-    transport: Any,
-    clock: Any,
-    warn_after_s: float,
-    deadline_s: float,
-    max_hops: int,
-    stderr: Any,
-) -> None:
-    start = clock()
-    deadline = start + deadline_s
-    url = f'https://{host}{HEALTH_PATH}'
-    request_headers = {'Authorization': _basic(token)}
-    warned = False
-    first = True
-    status: int | None = None
-    response_headers: dict[str, str] = {}
-    hops = 0
-
-    while True:
-        remaining = deadline - clock()
-        if remaining <= 0:
-            return
-        timeout = min(warn_after_s, remaining) if first else remaining
-        try:
-            status, response_headers, _ = transport(url, headers=request_headers, timeout=timeout)
-        except net.HttpTimeout:
-            if not first:
-                return
-            print(_WAKE_MESSAGE, file=stderr)
-            warned = True
-            first = False
-            continue
-        except net.HttpError:
-            return
-        first = False
-        if status not in _REDIRECT_STATUSES or hops >= max_hops:
-            break
-        location = response_headers.get('Location') or response_headers.get('location')
-        if not location:
-            break
-        url = location
-        hops += 1
-
-    if warned and status == 200:
-        _announce(clock() - start, response_headers, stderr)
-
-
-def _announce(elapsed: float, response_headers: dict[str, str], stderr: Any) -> None:
-    kind = response_headers.get('x-gb-boot') or response_headers.get('X-Gb-Boot') or ''
-    label = _BOOT_LABELS.get(kind)
-    suffix = f'{label}, {elapsed:.1f}s' if label else f'{elapsed:.1f}s'
-    print(f'gb: ready ({suffix})', file=stderr)
-
-
-def _basic(token: str) -> str:
-    return 'Basic ' + b64encode(f'gb:{token}'.encode()).decode()