playmaker-cli 0.7.0__tar.gz → 0.7.1__tar.gz

{playmaker_cli-0.7.0 → playmaker_cli-0.7.1}/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.1] - 2026-08-18
+
+### Fixed
+
+- **The Antigravity quota probe knocked on every port on the machine, and one
+  of them answered in TLS.** `playmaker quotas` had shown
+  `Antigravity (agy) error: BadStatusLine` for a week: the daemon lookup ran
+  `lsof -p <pid> -iTCP -sTCP:LISTEN` without `-a`, and lsof ORs its selectors
+  unless told otherwise — so "agy's listening sockets" was actually every
+  LISTEN socket on the box (hence the old `!= 5432` Postgres carve-out). The
+  probe then POSTed the quota RPC to Steam, chromedriver, a Logi plugin, …
+  until a TLS-only listener sorted below agy's ports answered a plaintext
+  request with a TLS alert record. urllib raises that as
+  `http.client.BadStatusLine`, which is not an `OSError`, so it escaped the
+  per-port `except`, escaped `antigravity_probe`, and the aggregator recorded
+  the whole provider as an error — with the working local daemon two ports
+  away. lsof now gets `-a` (one call, all pids), the `pgrep` for `agy` is
+  anchored so playmaker's own dispatches with `playmaker-agy-*.log` in their
+  arguments don't count as the daemon, anything a port says only disqualifies
+  that port, and any failure on the local path falls back to the remote
+  Gemini-only probe rather than to `error`. The refresh also stopped spending
+  ~30 s in timeouts on strangers' ports (1.3 s now).
+
 ## [0.7.0] - 2026-08-05
 
 ### Fixed

{playmaker_cli-0.7.0 → playmaker_cli-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: playmaker-cli
-Version: 0.7.0
+Version: 0.7.1
 Summary: Playing-coach CLI for orchestrating Claude Code, Codex, Antigravity and opencode sub-agents in parallel.
 Project-URL: Homepage, https://github.com/vladsafedev/playmaker
 Project-URL: Repository, https://github.com/vladsafedev/playmaker

{playmaker_cli-0.7.0 → playmaker_cli-0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "playmaker-cli"
-version = "0.7.0"
+version = "0.7.1"
 description = "Playing-coach CLI for orchestrating Claude Code, Codex, Antigravity and opencode sub-agents in parallel."
 readme = "README.md"
 requires-python = ">=3.11"

{playmaker_cli-0.7.0 → playmaker_cli-0.7.1}/src/playmaker/quotas.py

@@ -612,39 +612,48 @@ def gemini_probe() -> dict:
 _ANTIGRAVITY_QUOTA_SUMMARY_PATH = (
     "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary"
 )
-_ANTIGRAVITY_PROC_NAMES = ("agy", "language_server")
+# `pgrep -f` regexes over the full command line. The agy one is anchored so a
+# process whose *arguments* merely mention agy — playmaker's own dispatch, with
+# its `--log-file .../playmaker-agy-*.log` — doesn't count as the daemon.
+_ANTIGRAVITY_PROC_PATTERNS = (r"(^|/)agy( |$)", r"language_server")
 
 
 def _antigravity_daemon_ports() -> list[int]:
     """Local TCP ports that a running agy/language_server daemon is listening on."""
     pids: set[int] = set()
-    for name in _ANTIGRAVITY_PROC_NAMES:
+    for pattern in _ANTIGRAVITY_PROC_PATTERNS:
         try:
             proc = subprocess.run(
-                ["pgrep", "-f", name], capture_output=True, text=True, timeout=5
+                ["pgrep", "-f", pattern], capture_output=True, text=True, timeout=5
             )
         except (OSError, subprocess.SubprocessError):
             continue
         for line in proc.stdout.split():
             if line.isdigit():
                 pids.add(int(line))
+    if not pids:
+        return []
+    # `-a` ANDs lsof's selectors. Without it they are ORed, and the listing is
+    # every LISTEN socket on the machine — Steam, chromedriver, whatever else
+    # sits on 127.0.0.1 — so the probe went knocking on strangers' ports.
+    try:
+        proc = subprocess.run(
+            [
+                "lsof", "-nP", "-a",
+                "-p", ",".join(str(pid) for pid in sorted(pids)),
+                "-iTCP", "-sTCP:LISTEN",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return []
     ports: set[int] = set()
-    for pid in pids:
-        try:
-            proc = subprocess.run(
-                ["lsof", "-nP", "-p", str(pid), "-iTCP", "-sTCP:LISTEN"],
-                capture_output=True,
-                text=True,
-                timeout=5,
-            )
-        except (OSError, subprocess.SubprocessError):
-            continue
-        for line in proc.stdout.splitlines():
-            m = re.search(r"127\.0\.0\.1:(\d+)", line)
-            if m:
-                port = int(m.group(1))
-                if port != 5432:  # skip an unrelated Postgres LISTEN
-                    ports.add(port)
+    for line in proc.stdout.splitlines():
+        m = re.search(r"127\.0\.0\.1:(\d+)", line)
+        if m:
+            ports.add(int(m.group(1)))
     return sorted(ports)
 
 
@@ -664,12 +673,19 @@ def _antigravity_local_summary(ports: list[int], timeout: float = 5.0) -> dict |
                 method="POST",
                 headers={"Content-Type": "application/json", "Connect-Protocol-Version": "1"},
             )
+            # Whatever a port says, it only ever disqualifies that port. Not
+            # every refusal is an OSError: a TLS-only listener answers a
+            # plaintext POST with a TLS alert record, which urllib raises as
+            # http.client.BadStatusLine — an HTTPException that used to escape
+            # this loop and sink the whole probe.
             try:
                 with urllib.request.urlopen(req, timeout=timeout, context=ctx) as resp:
                     data = json.loads(resp.read().decode("utf-8"))
-            except (urllib.error.URLError, ssl.SSLError, OSError, json.JSONDecodeError):
+                if not isinstance(data, dict):
+                    continue
+                payload = data.get("response") or data.get("summary") or data
+            except Exception:
                 continue
-            payload = data.get("response") or data.get("summary") or data
             if isinstance(payload, dict) and payload.get("groups"):
                 return payload
     return None
@@ -756,29 +772,36 @@ def antigravity_probe() -> dict:
     back to the OAuth retrieveUserQuota, which only surfaces coarse Gemini daily
     buckets (source: "remote") — the Claude/GPT windows are simply not available
     to a plain OAuth token. The local path needs a running agy/CodexBar daemon.
+
+    The local path is a bonus, so it degrades to remote rather than to an
+    error: whatever goes wrong there — a stray listener, a daemon mid-start,
+    a payload we don't recognise — the user still gets a quota row.
     """
-    ports = _antigravity_daemon_ports()
-    if ports:
-        payload = _antigravity_local_summary(ports)
+    windows: list[dict] = []
+    try:
+        ports = _antigravity_daemon_ports()
+        payload = _antigravity_local_summary(ports) if ports else None
         if payload:
             windows = _antigravity_windows_from_summary(payload)
-            if windows:
-                out = {
-                    "status": "ok",
-                    "account_email": None,
-                    "tier": None,
-                    "windows": windows,
-                    "source": "local",
-                }
-                # Enrich email/tier from the cheap OAuth loadCodeAssist call;
-                # never let that failure sink the rich local windows.
-                try:
-                    meta = _antigravity_account_meta()
-                    out["account_email"] = meta.get("email")
-                    out["tier"] = meta.get("tier")
-                except Exception:
-                    pass
-                return out
+    except Exception:
+        windows = []
+    if windows:
+        out = {
+            "status": "ok",
+            "account_email": None,
+            "tier": None,
+            "windows": windows,
+            "source": "local",
+        }
+        # Enrich email/tier from the cheap OAuth loadCodeAssist call;
+        # never let that failure sink the rich local windows.
+        try:
+            meta = _antigravity_account_meta()
+            out["account_email"] = meta.get("email")
+            out["tier"] = meta.get("tier")
+        except Exception:
+            pass
+        return out
 
     result = _google_code_assist_probe(_ANTIGRAVITY_CLOUDCODE_BASE, "ANTIGRAVITY")
     result["source"] = "remote"

{playmaker_cli-0.7.0 → playmaker_cli-0.7.1}/tests/test_quotas_antigravity.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import http.client
+import json
 import sys
 from pathlib import Path
 
@@ -98,3 +100,110 @@ def test_local_summary_returns_none_when_no_port_answers(monkeypatch) -> None:
     monkeypatch.setattr(quotas.urllib.request, "urlopen", boom)
 
     assert quotas._antigravity_local_summary([49999]) is None
+
+
+class _Response:
+    def __init__(self, body: bytes) -> None:
+        self._body = body
+
+    def read(self) -> bytes:
+        return self._body
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc) -> None:
+        return None
+
+
+def test_local_summary_skips_a_port_that_does_not_speak_http(monkeypatch) -> None:
+    # A TLS-only listener answers a plaintext POST with a TLS alert record;
+    # urllib surfaces that as http.client.BadStatusLine, which is not an
+    # OSError. It disqualifies that port — it must not sink the probe.
+    tls_alert = "\x15\x03\x03\x00\x02\x022"
+
+    def urlopen(req, timeout=None, context=None):
+        if ":50652/" in req.full_url:
+            if req.full_url.startswith("https"):
+                raise TimeoutError("The read operation timed out")
+            raise http.client.BadStatusLine(tls_alert)
+        return _Response(json.dumps({"response": _SUMMARY}).encode())
+
+    monkeypatch.setattr(quotas.urllib.request, "urlopen", urlopen)
+
+    assert quotas._antigravity_local_summary([50652, 51802]) == _SUMMARY
+
+
+def test_local_summary_ignores_a_port_that_answers_non_object_json(monkeypatch) -> None:
+    def urlopen(req, timeout=None, context=None):
+        return _Response(b"[]")
+
+    monkeypatch.setattr(quotas.urllib.request, "urlopen", urlopen)
+
+    assert quotas._antigravity_local_summary([49999]) is None
+
+
+def test_daemon_ports_lists_only_the_daemon_sockets(monkeypatch) -> None:
+    # lsof ORs its selectors unless told otherwise, so `-p PID -iTCP` without
+    # `-a` is every LISTEN socket on the machine — that is how the probe ended
+    # up POSTing to Steam and chromedriver. The lookup must AND them and ask
+    # for exactly the pids pgrep found.
+    calls: list[list[str]] = []
+
+    class _Proc:
+        def __init__(self, stdout: str) -> None:
+            self.stdout = stdout
+            self.returncode = 0
+
+    def run(cmd, **kwargs):
+        calls.append(cmd)
+        if cmd[0] == "pgrep":
+            return _Proc("8577\n" if "agy" in cmd[-1] else "")
+        assert cmd[0] == "lsof"
+        return _Proc(
+            "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\n"
+            "agy 8577 me 10u IPv4 0x1 0t0 TCP 127.0.0.1:51802 (LISTEN)\n"
+            "agy 8577 me 11u IPv4 0x2 0t0 TCP 127.0.0.1:51803 (LISTEN)\n"
+        )
+
+    monkeypatch.setattr(quotas.subprocess, "run", run)
+
+    assert quotas._antigravity_daemon_ports() == [51802, 51803]
+    lsof = [c for c in calls if c[0] == "lsof"]
+    assert len(lsof) == 1
+    assert "-a" in lsof[0]
+    assert lsof[0][lsof[0].index("-p") + 1] == "8577"
+
+
+def test_daemon_ports_is_empty_without_a_daemon(monkeypatch) -> None:
+    calls: list[list[str]] = []
+
+    class _Proc:
+        stdout = ""
+        returncode = 1
+
+    def run(cmd, **kwargs):
+        calls.append(cmd)
+        return _Proc()
+
+    monkeypatch.setattr(quotas.subprocess, "run", run)
+
+    assert quotas._antigravity_daemon_ports() == []
+    # No pids → no lsof at all (an unfiltered lsof is the whole-machine listing).
+    assert all(c[0] == "pgrep" for c in calls)
+
+
+def test_antigravity_probe_falls_back_to_remote_when_the_local_path_blows_up(
+    monkeypatch,
+) -> None:
+    def boom():
+        raise http.client.BadStatusLine("\x15\x03\x03\x00\x02\x022")
+
+    monkeypatch.setattr(quotas, "_antigravity_daemon_ports", boom)
+    remote = {"status": "ok", "windows": [{"name": "Flash", "pct_left": 100}]}
+    monkeypatch.setattr(quotas, "_google_code_assist_probe", lambda base_url, ide_type: remote)
+
+    result = quotas.antigravity_probe()
+
+    assert result["status"] == "ok"
+    assert result["source"] == "remote"