| |
| """Fetch Antigravity sandbox artifacts with retries and a log-based fallback. |
| |
| ``fetch`` regularly fails with HTTP 503 "Environment snapshot is temporarily |
| unavailable". It is transient: the same session usually fetches fine a minute |
| later. This wrapper retries with exponential backoff and, if the snapshot never |
| comes back, recovers the agent's final message from the run log so the analysis |
| is not lost. |
| |
| Usage: |
| python scripts/ag_fetch.py --state /tmp/ag_task.json --out /tmp/ag_task_fetch |
| python scripts/ag_fetch.py --state ... --out ... --retries 8 --base-delay 15 |
| python scripts/ag_fetch.py --log logs/.../antigravity_task.log --out /tmp/ag_task_fetch --recover-only |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import random |
| import subprocess |
| import sys |
| import time |
| from pathlib import Path |
|
|
| DEFAULT_WRAPPER = Path.home() / ".config" / "opencode" / "antigravity" / "antigravity.py" |
|
|
| TRANSIENT = ( |
| "503", |
| "UNAVAILABLE", |
| "temporarily unavailable", |
| "502", |
| "504", |
| "deadline", |
| "timeout", |
| "connection reset", |
| "ECONNRESET", |
| ) |
|
|
|
|
| def is_transient(output: str) -> bool: |
| text = output.lower() |
| return any(marker.lower() in text for marker in TRANSIENT) |
|
|
|
|
| def json_objects(text: str): |
| """Yield every top-level JSON object embedded in a log, in order.""" |
| decoder = json.JSONDecoder() |
| index = 0 |
| while True: |
| start = text.find("{", index) |
| if start < 0: |
| return |
| try: |
| value, end = decoder.raw_decode(text, start) |
| except json.JSONDecodeError: |
| index = start + 1 |
| continue |
| yield value |
| index = end |
|
|
|
|
| def last_final(log_path: Path) -> str | None: |
| if not log_path.exists(): |
| return None |
| final = None |
| for payload in json_objects(log_path.read_text(encoding="utf-8", errors="replace")): |
| if isinstance(payload, dict) and isinstance(payload.get("final"), str) and payload["final"].strip(): |
| final = payload["final"] |
| return final |
|
|
|
|
| def log_completed(log_path: Path) -> bool: |
| """True when the run log already holds a completed response. |
| |
| The wrapper writes its state file only after the process returns, so a dead |
| pid plus no state is not proof of failure: the log often has the result. |
| """ |
| if not log_path.exists(): |
| return False |
| for payload in json_objects(log_path.read_text(encoding="utf-8", errors="replace")): |
| if isinstance(payload, dict) and payload.get("status") == "completed": |
| return True |
| return False |
|
|
|
|
| def recover_from_log(log_path: Path, out_dir: Path) -> Path | None: |
| final = last_final(log_path) |
| if not final: |
| return None |
| target = out_dir / "final.md" |
| target.parent.mkdir(parents=True, exist_ok=True) |
| target.write_text(final + "\n", encoding="utf-8") |
| return target |
|
|
|
|
| def wrapper_fetch(wrapper: Path, state: Path, out_dir: Path) -> tuple[int, str]: |
| command = [sys.executable, str(wrapper), "--state", str(state), "fetch", "--out", str(out_dir)] |
| process = subprocess.run(command, text=True, capture_output=True, check=False) |
| return process.returncode, (process.stdout or "") + (process.stderr or "") |
|
|
|
|
| def fetch_with_retry( |
| wrapper: Path, |
| state: Path, |
| out_dir: Path, |
| log_path: Path | None = None, |
| retries: int = 6, |
| base_delay: float = 15.0, |
| max_delay: float = 180.0, |
| sleep=time.sleep, |
| ) -> dict: |
| """Returns {"status": ok|recovered|failed, "attempts": n, "final": path|None}.""" |
| last_output = "" |
| attempts_made = 0 |
| for attempt in range(1, retries + 1): |
| attempts_made = attempt |
| code, output = wrapper_fetch(wrapper, state, out_dir) |
| last_output = output |
| extracted = out_dir / "extracted" |
| has_files = extracted.exists() and any(extracted.rglob("*")) |
| if code == 0 and has_files: |
| return {"status": "ok", "attempts": attempt, "final": None} |
| if code == 0 and extracted.exists() and not has_files: |
| output += "\nempty snapshot (no files extracted)" |
| if not is_transient(output) and code != 0: |
| print(f"fetch failed with a non-transient error (attempt {attempt}): {output.strip()[:300]}") |
| break |
| if attempt < retries: |
| delay = min(max_delay, base_delay * (2 ** (attempt - 1))) |
| delay *= 1 + random.uniform(-0.1, 0.1) |
| print(f"fetch attempt {attempt} failed (503/transient); retrying in {delay:.0f}s", flush=True) |
| sleep(delay) |
|
|
| print("fetch exhausted; trying log-based recovery", flush=True) |
| recovered = recover_from_log(log_path, out_dir) if log_path else None |
| if recovered: |
| print(f"recovered final message from log -> {recovered}", flush=True) |
| return {"status": "recovered", "attempts": attempts_made, "final": str(recovered)} |
| return {"status": "failed", "attempts": attempts_made, "final": None, "error": last_output[-500:]} |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("--state", type=Path, required=True) |
| parser.add_argument("--out", type=Path, required=True) |
| parser.add_argument("--log", type=Path, default=None, help="run log, used for recovery") |
| parser.add_argument("--wrapper", type=Path, default=DEFAULT_WRAPPER) |
| parser.add_argument("--retries", type=int, default=6) |
| parser.add_argument("--base-delay", type=float, default=15.0) |
| parser.add_argument("--max-delay", type=float, default=180.0) |
| parser.add_argument("--recover-only", action="store_true") |
| args = parser.parse_args() |
|
|
| if args.recover_only: |
| recovered = recover_from_log(args.log, args.out) if args.log else None |
| if not recovered: |
| raise SystemExit("nothing to recover") |
| print(f"recovered -> {recovered}") |
| return |
|
|
| result = fetch_with_retry( |
| args.wrapper, |
| args.state, |
| args.out, |
| log_path=args.log, |
| retries=args.retries, |
| base_delay=args.base_delay, |
| max_delay=args.max_delay, |
| ) |
| print(json.dumps(result, indent=2)) |
| if result["status"] == "failed": |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
