agent-peer 0.2.1__py3-none-any.whl

agent_peer/__init__.py

@@ -0,0 +1,3 @@
+"""agent-peer: Real-time IPC gateway between Claude Code sessions and external agents."""
+
+__version__ = "0.2.1"

agent_peer/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

agent_peer/agy_live.py

@@ -0,0 +1,102 @@
+"""On-demand fetch of agy's 5-hour quota via Google's internal
+fetchAvailableModels API. See docs/status.md for the full rationale."""
+
+from __future__ import annotations
+
+import base64
+import json
+import subprocess
+import urllib.error
+import urllib.request
+from datetime import datetime, timezone
+
+QUOTA_API = "https://daily-cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels"
+KEYCHAIN_PREFIX = "go-keyring-base64:"
+
+# Required so the backend recognizes the caller as Antigravity — without
+# these, Gemini's own numbers still come back but Claude/GPT models 404.
+_HEADERS = {
+    "Content-Type": "application/json",
+    "User-Agent": (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Antigravity/1.0.0 Chrome/138.0.7204.235 Electron/37.3.1 Safari/537.36"
+    ),
+    "Client-Metadata": '{"ideType":"ANTIGRAVITY","platform":"WINDOWS","pluginType":"GEMINI"}',
+}
+
+_GEMINI_PROVIDER = "API_PROVIDER_GOOGLE_GEMINI"
+_THIRD_PARTY_PROVIDERS = {"API_PROVIDER_ANTHROPIC_VERTEX", "API_PROVIDER_OPENAI_VERTEX"}
+
+
+def _read_agy_access_token() -> str | None:
+    try:
+        raw = subprocess.run(
+            ["security", "find-generic-password", "-s", "gemini", "-a", "antigravity", "-w"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if raw.returncode != 0 or not raw.stdout.strip():
+            return None
+        val = raw.stdout.strip()
+        token_raw = (
+            base64.b64decode(val[len(KEYCHAIN_PREFIX):]).decode("utf-8")
+            if val.startswith(KEYCHAIN_PREFIX)
+            else val
+        )
+        return json.loads(token_raw)["token"]["access_token"]
+    except Exception:
+        return None
+
+
+def _reset_in_seconds(reset_time: str | None) -> int | None:
+    if not reset_time:
+        return None
+    try:
+        dt = datetime.strptime(reset_time, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
+    except ValueError:
+        return None
+    return max(0, int((dt - datetime.now(timezone.utc)).total_seconds()))
+
+
+def fetch_live_5h_quota() -> tuple[dict | None, str | None]:
+    """Returns ({"gemini_5h": {...} | None, "claude_gpt_5h": {...} | None}, None)
+    on a successful call, or (None, error) if anything went wrong."""
+    access_token = _read_agy_access_token()
+    if not access_token:
+        return None, "No agy OAuth token found in keychain."
+
+    req = urllib.request.Request(
+        QUOTA_API,
+        data=b"{}",
+        headers={**_HEADERS, "Authorization": f"Bearer {access_token}"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read().decode())
+    except urllib.error.HTTPError as e:
+        return None, f"fetchAvailableModels failed: HTTP {e.code}"
+    except Exception as e:
+        return None, f"fetchAvailableModels failed: {e}"
+
+    # Keep the most-constrained model per group (lowest remainingFraction) -
+    # a quota-exempt model reports 100%/no-reset, masking a partially-used pool.
+    buckets: dict[str, list[dict]] = {"gemini_5h": [], "claude_gpt_5h": []}
+    for model in (data.get("models") or {}).values():
+        quota_info = model.get("quotaInfo")
+        if not quota_info:
+            continue
+        entry = {
+            "remaining_pct": round((quota_info.get("remainingFraction") or 0) * 100, 1),
+            "resets_in_s": _reset_in_seconds(quota_info.get("resetTime")),
+        }
+        provider = model.get("apiProvider", "")
+        if provider == _GEMINI_PROVIDER:
+            buckets["gemini_5h"].append(entry)
+        elif provider in _THIRD_PARTY_PROVIDERS:
+            buckets["claude_gpt_5h"].append(entry)
+
+    result = {
+        key: (min(entries, key=lambda e: e["remaining_pct"]) if entries else None)
+        for key, entries in buckets.items()
+    }
+    return result, None

agent_peer/agy_status.py

@@ -0,0 +1,148 @@
+"""Reads agy's cached quota/context snapshot and freshens the 5h quota
+numbers live (see agy_live.py). See docs/status.md for the full rationale."""
+
+import os
+import time
+from datetime import datetime, timezone
+import json
+
+from . import agy_live
+from .protocol import AGENT_PEER_DIR
+
+AGY_STATUS_FILE = os.path.join(AGENT_PEER_DIR, "agy_status.json")
+
+STALE_AFTER_SECONDS = 15 * 60  # agy only writes this when it actually renders a statusline
+
+# Raw payload keys -> the short, JSON-friendly names used in the trimmed dict.
+_QUOTA_KEYS = {
+    "gemini_5h": "gemini-5h",
+    "gemini_weekly": "gemini-weekly",
+    "claude_gpt_5h": "3p-5h",
+    "claude_gpt_weekly": "3p-weekly",
+}
+
+
+def read_agy_status():
+    """Returns (payload: dict | None, age_seconds: float | None, error: str | None)."""
+    if not os.path.exists(AGY_STATUS_FILE):
+        return None, None, "No agy status captured yet — open an interactive `agy` session at least once."
+    try:
+        with open(AGY_STATUS_FILE, "r", encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError) as e:
+        return None, None, f"Could not read {AGY_STATUS_FILE}: {e}"
+
+    captured_at = data.get("captured_at")
+    age_seconds = None
+    if captured_at:
+        try:
+            dt = datetime.strptime(captured_at, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
+            age_seconds = time.time() - dt.timestamp()
+        except ValueError:
+            pass
+
+    return data.get("payload"), age_seconds, None
+
+
+def _fmt_age(seconds):
+    if seconds is None:
+        return "unknown"
+    if seconds < 60:
+        return f"{int(seconds)}s ago"
+    if seconds < 3600:
+        return f"{int(seconds // 60)}m ago"
+    return f"{seconds / 3600:.1f}h ago"
+
+
+def fmt_duration(seconds):
+    if seconds is None:
+        return "?"
+    seconds = int(seconds)
+    h, m = seconds // 3600, (seconds % 3600) // 60
+    return f"{h}h{m}m" if h else f"{m}m"
+
+
+def get_agy_status_dict() -> dict:
+    """JSON shape where remaining_pct is directly comparable to
+    get_claude_status_dict()'s, regardless of each provider's raw convention."""
+    payload, age_seconds, error = read_agy_status()
+    if error:
+        return {"error": error}
+
+    ctx = payload.get("context_window") or {}
+    raw_quota = payload.get("quota") or {}
+
+    quota = {}
+    for short_name, raw_key in _QUOTA_KEYS.items():
+        entry = raw_quota.get(raw_key)
+        quota[short_name] = (
+            {
+                "remaining_pct": round((entry.get("remaining_fraction") or 0) * 100, 1),
+                "resets_in_s": entry.get("reset_in_seconds"),
+                "source": "cached",
+            }
+            if entry
+            else None
+        )
+
+    # Freshen just the 5h numbers live; weekly + context have no API source.
+    live, live_error = agy_live.fetch_live_5h_quota()
+    if live:
+        for key in ("gemini_5h", "claude_gpt_5h"):
+            if live.get(key):
+                quota[key] = {**live[key], "source": "live"}
+
+    return {
+        "email": payload.get("email"),
+        "plan": payload.get("plan_tier"),
+        "model": (payload.get("model") or {}).get("display_name"),
+        "snapshot_age_s": round(age_seconds, 1) if age_seconds is not None else None,
+        "live_5h_fetch_error": live_error,
+        "context": {
+            "used_pct": ctx.get("used_percentage", 0),
+            "input_tokens": ctx.get("total_input_tokens", 0),
+            "output_tokens": ctx.get("total_output_tokens", 0),
+            "window_size": ctx.get("context_window_size", 0),
+        },
+        "quota": quota,
+    }
+
+
+def format_agy_status(as_json: bool = False) -> str:
+    status = get_agy_status_dict()
+    if "error" in status:
+        return status["error"]
+    if as_json:
+        return json.dumps(status, indent=2)
+
+    age_s = status["snapshot_age_s"]
+    ctx = status["context"]
+    lines = [
+        f"agy status  (email: {status['email'] or '?'} · plan: {status['plan'] or '?'} · model: {status['model'] or '?'})",
+        f"  snapshot age: {_fmt_age(age_s)}"
+        + ("  ⚠ stale (agy not run recently)" if (age_s or 0) > STALE_AFTER_SECONDS else ""),
+        "",
+        f"  context: {ctx['used_pct']:.1f}% used "
+        f"({ctx['input_tokens']} in / {ctx['output_tokens']} out / {ctx['window_size']} window)"
+        "  [cached, no live source]",
+        "",
+        "  quota:",
+    ]
+    labels = {
+        "gemini_5h": "gemini   5h  ",
+        "gemini_weekly": "gemini   week",
+        "claude_gpt_5h": "claude/gpt 5h",
+        "claude_gpt_weekly": "claude/gpt wk",
+    }
+    for key, label in labels.items():
+        q = status["quota"].get(key)
+        if not q:
+            lines.append(f"    {label}  n/a")
+            continue
+        tag = "live" if q.get("source") == "live" else "cached"
+        lines.append(
+            f"    {label}  {q['remaining_pct']:>5.1f}% remaining  (resets in {fmt_duration(q['resets_in_s'])})  [{tag}]"
+        )
+    if status.get("live_5h_fetch_error"):
+        lines.append(f"\n  ⚠ live 5h refresh failed, showing cached numbers instead: {status['live_5h_fetch_error']}")
+    return "\n".join(lines)

agent_peer/claude_status.py

@@ -0,0 +1,195 @@
+"""Fetches Claude Code's own usage/quota from Anthropic's API using its
+OAuth token from the macOS Keychain. See docs/status.md for the rationale."""
+
+import hashlib
+import json
+import os
+import subprocess
+import unicodedata
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+USAGE_URL = "https://api.anthropic.com/api/oauth/usage"
+TOKEN_URL = "https://platform.claude.com/v1/oauth/token"
+CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
+DEFAULT_KEYCHAIN_SERVICE = "Claude Code-credentials"
+CREDENTIALS_FILE = Path.home() / ".claude" / ".credentials.json"
+
+
+def _hashed_keychain_service(config_dir: str) -> str:
+    """Mirrors Claude Code's own hashing of CLAUDE_CONFIG_DIR - must hash the
+    exact exported string, not a resolved path, or it names an empty keychain item."""
+    normalized = unicodedata.normalize("NFC", config_dir)
+    digest = hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:8]
+    return f"{DEFAULT_KEYCHAIN_SERVICE}-{digest}"
+
+
+def _active_keychain_services() -> list[str]:
+    """Which keychain service holds this environment's active credential,
+    following the same CLAUDE_CONFIG_DIR resolution order Claude Code itself uses."""
+    secure_env = os.environ.get("CLAUDE_SECURESTORAGE_CONFIG_DIR")
+    if secure_env is not None:
+        return [DEFAULT_KEYCHAIN_SERVICE] if not secure_env else [_hashed_keychain_service(secure_env)]
+
+    config_dir = os.environ.get("CLAUDE_CONFIG_DIR")
+    if not config_dir:
+        return [DEFAULT_KEYCHAIN_SERVICE]
+    return [_hashed_keychain_service(config_dir), DEFAULT_KEYCHAIN_SERVICE]
+
+
+def _read_keychain(service: str) -> dict | None:
+    try:
+        user = os.environ.get("USER") or __import__("pwd").getpwuid(os.geteuid()).pw_name
+        raw = subprocess.run(
+            ["security", "find-generic-password", "-s", service, "-a", user, "-w"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if raw.returncode == 0 and raw.stdout.strip():
+            return json.loads(raw.stdout).get("claudeAiOauth")
+    except Exception:
+        pass
+    return None
+
+
+def _read_credentials() -> dict | None:
+    for service in _active_keychain_services():
+        oauth = _read_keychain(service)
+        if oauth:
+            return oauth
+    try:
+        return json.loads(CREDENTIALS_FILE.read_text()).get("claudeAiOauth")
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def _refresh(refresh_token: str) -> str | None:
+    body = json.dumps(
+        {"grant_type": "refresh_token", "refresh_token": refresh_token, "client_id": CLIENT_ID}
+    ).encode()
+    req = urllib.request.Request(
+        TOKEN_URL, data=body, headers={"Content-Type": "application/json"}, method="POST"
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            return json.loads(resp.read().decode()).get("access_token")
+    except Exception:
+        return None
+
+
+def _request_usage(access_token: str) -> dict:
+    req = urllib.request.Request(
+        USAGE_URL,
+        headers={
+            "Authorization": f"Bearer {access_token}",
+            "anthropic-beta": "oauth-2025-04-20",
+            "User-Agent": "agent-peer/0.1.0",
+        },
+    )
+    with urllib.request.urlopen(req, timeout=10) as resp:
+        return json.loads(resp.read().decode())
+
+
+def _fetch_email(access_token: str) -> str | None:
+    """Whose token this is — confirms which active account got read, rather
+    than trusting the keychain-slot resolution silently."""
+    req = urllib.request.Request(
+        "https://api.anthropic.com/api/oauth/profile",
+        headers={"Authorization": f"Bearer {access_token}", "User-Agent": "agent-peer/0.1.0"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            account = json.loads(resp.read().decode()).get("account") or {}
+            return account.get("email")
+    except Exception:
+        return None
+
+
+def fetch_claude_usage():
+    """Returns (usage: dict | None, meta: dict | None, error: str | None)."""
+    oauth = _read_credentials()
+    if not oauth or not oauth.get("accessToken"):
+        return None, None, "No Claude Code credentials found (keychain or ~/.claude/.credentials.json)."
+
+    access_token = oauth["accessToken"]
+    try:
+        data = _request_usage(access_token)
+    except urllib.error.HTTPError as e:
+        if e.code == 401 and oauth.get("refreshToken"):
+            fresh = _refresh(oauth["refreshToken"])
+            if not fresh:
+                return None, None, "Access token expired and refresh failed."
+            access_token = fresh
+            try:
+                data = _request_usage(access_token)
+            except Exception as e2:
+                return None, None, f"Usage fetch failed after refresh: {e2}"
+        else:
+            return None, None, f"Usage fetch failed: HTTP {e.code}"
+    except Exception as e:
+        return None, None, f"Usage fetch failed: {e}"
+
+    meta = {"subscription_type": oauth.get("subscriptionType"), "email": _fetch_email(access_token)}
+    return data, meta, None
+
+
+def _reset_in_seconds(resets_at: str | None) -> int | None:
+    if not resets_at:
+        return None
+    from datetime import datetime, timezone
+
+    try:
+        dt = datetime.fromisoformat(resets_at)
+    except ValueError:
+        return None
+    return max(0, int((dt - datetime.now(timezone.utc)).total_seconds()))
+
+
+def get_claude_status_dict() -> dict:
+    """JSON shape normalized to remaining_pct, flipping Anthropic's raw
+    utilization% and dropping unreleased-feature placeholder fields."""
+    data, meta, error = fetch_claude_usage()
+    if error:
+        return {"error": error}
+
+    def window(entry: dict) -> dict:
+        used_pct = entry.get("utilization") or 0
+        return {
+            "remaining_pct": round(100 - used_pct, 1),
+            "resets_in_s": _reset_in_seconds(entry.get("resets_at")),
+        }
+
+    quota = {
+        "session_5h": window(data.get("five_hour") or {}),
+        "weekly_all": window(data.get("seven_day") or {}),
+    }
+    for lim in data.get("limits") or []:
+        if lim.get("kind") != "weekly_scoped":
+            continue
+        model = ((lim.get("scope") or {}).get("model") or {}).get("display_name")
+        if not model:
+            continue
+        quota[f"weekly_{model.lower()}"] = window({"utilization": lim.get("percent"), "resets_at": lim.get("resets_at")})
+
+    return {
+        "email": meta.get("email"),
+        "plan": meta.get("subscription_type"),
+        "quota": quota,
+    }
+
+
+def format_claude_status(as_json: bool = False) -> str:
+    from .agy_status import fmt_duration
+
+    status = get_claude_status_dict()
+    if "error" in status:
+        return status["error"]
+    if as_json:
+        return json.dumps(status, indent=2)
+
+    lines = [f"claude status  (email: {status['email'] or '?'} · plan: {status['plan'] or '?'})", "", "  quota:"]
+    labels = {"session_5h": "session   5h  ", "weekly_all": "weekly    all "}
+    for key, q in status["quota"].items():
+        label = labels.get(key, f"weekly    {key.removeprefix('weekly_'):<5}")
+        lines.append(f"    {label} {q['remaining_pct']:>5.1f}% remaining  (resets in {fmt_duration(q['resets_in_s'])})")
+    return "\n".join(lines)