agyswap-cli 0.1.0__py3-none-any.whl

agyswap/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("agyswap-cli")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

agyswap/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from agyswap.cli import main
+
+sys.exit(main())

agyswap/cli.py

@@ -0,0 +1,368 @@
+"""Multi-account switcher for the Antigravity CLI (agy).
+
+agy keeps its OAuth token in the OS keyring via go-keyring
+(service "gemini", user "antigravity") as a JSON blob. An account is
+a stored copy of that blob; switching writes another copy back.
+"""
+
+from __future__ import annotations
+
+import argparse
+import fcntl
+import json
+import os
+import subprocess
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import contextmanager
+from datetime import UTC, datetime
+from pathlib import Path
+
+from rich.console import Console
+from rich.text import Text
+
+from agyswap import __version__
+from agyswap.usage import UsageError, account_usage, claims, parse_time
+
+SERVICE = "gemini"
+USERNAME = "antigravity"
+
+
+class SwapError(Exception):
+    pass
+
+
+def store_path() -> Path:
+    return Path(os.environ.get("AGYSWAP_HOME", Path.home() / ".agyswap")) / "accounts.json"
+
+
+def load_store() -> dict:
+    p = store_path()
+    if not p.exists():
+        return {"accounts": {}}
+    return json.loads(p.read_text())
+
+
+@contextmanager
+def locked_store():
+    """Load the store under an exclusive lock; hold it for the whole read-modify-write."""
+    lock = store_path().with_name(".lock")
+    lock.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    with open(lock, "w") as f:
+        fcntl.flock(f, fcntl.LOCK_EX)
+        yield load_store()
+
+
+def save_store(store: dict) -> None:
+    p = store_path()
+    p.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    tmp = p.with_suffix(".tmp")
+    # Refresh tokens live here: owner-only from the first byte.
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as f:
+        json.dump(store, f, indent=2)
+    os.replace(tmp, p)
+
+
+def _secret_tool(*args: str, stdin: str | None = None) -> subprocess.CompletedProcess:
+    # ponytail: Linux Secret Service only; macOS Keychain / Windows Credential Manager when needed.
+    try:
+        return subprocess.run(["secret-tool", *args], input=stdin, capture_output=True, text=True, timeout=30)
+    except FileNotFoundError:
+        raise SwapError("secret-tool not found. Install libsecret (e.g. `dnf install libsecret`).") from None
+    except subprocess.TimeoutExpired:
+        raise SwapError("keyring did not answer within 30s (locked?). Unlock it and try again.") from None
+
+
+def read_token() -> str | None:
+    r = _secret_tool("lookup", "service", SERVICE, "username", USERNAME)
+    return r.stdout if r.returncode == 0 and r.stdout else None
+
+
+def write_token(token: str) -> None:
+    r = _secret_tool(
+        "store",
+        f"--label=Password for '{USERNAME}' on '{SERVICE}'",
+        "service",
+        SERVICE,
+        "username",
+        USERNAME,
+        stdin=token,
+    )
+    if r.returncode != 0:
+        raise SwapError(f"Failed to write keyring: {r.stderr.strip()}")
+
+
+def email_of(token: str | None) -> str | None:
+    return claims(token).get("email") or None
+
+
+def agy_running() -> bool:
+    # The background updater never touches the token; any other agy process may refresh it.
+    r = subprocess.run(["pgrep", "-a", "-x", "agy"], capture_output=True, text=True)
+    return any("--bg-updater" not in line for line in r.stdout.splitlines())
+
+
+def find_slot(store: dict, target: str) -> str:
+    accounts = store["accounts"]
+    if target in accounts:
+        return target
+    for slot, acc in accounts.items():
+        if acc["email"].lower() == target.lower():
+            return slot
+    raise SwapError(f"No account matches '{target}'. Run `agyswap list`.")
+
+
+def slot_for_email(store: dict, email: str | None) -> str | None:
+    if not email:
+        return None
+    return next((s for s, a in store["accounts"].items() if a["email"].lower() == email.lower()), None)
+
+
+def next_slot(store: dict) -> str:
+    return str(max(map(int, store["accounts"]), default=0) + 1)
+
+
+def cmd_add(slot: int | None = None) -> str:
+    token = read_token()
+    email = email_of(token)
+    if not email:
+        raise SwapError("agy is not signed in. Run `agy`, sign in, exit, then `agyswap add`.")
+    with locked_store() as store:
+        existing = slot_for_email(store, email)
+        if slot is None:
+            slot = existing or next_slot(store)
+        else:
+            if slot < 1:
+                raise SwapError("--slot must be 1 or higher.")
+            slot = str(slot)
+            other = store["accounts"].get(slot)
+            if other and other["email"].lower() != email.lower():
+                raise SwapError(f"Slot {slot} holds {other['email']}. Remove it first or pick another slot.")
+            if existing and existing != slot:
+                del store["accounts"][existing]  # move the account to the requested slot
+        store["accounts"][slot] = {"email": email, "token": token}
+        save_store(store)
+    return f"{'Updated' if existing == slot else 'Moved' if existing else 'Added'} account {slot}: {email}"
+
+
+def collect_usage() -> list[dict]:
+    """Quota for every stored account. Refreshed tokens are saved back to the store."""
+    store = load_store()
+    live = read_token()
+    active = email_of(live)
+
+    def one(slot: str) -> dict:
+        acc = store["accounts"][slot]
+        # The keyring copy is the newest for the active account; never write the keyring here.
+        token = live if acc["email"] == active else acc["token"]
+        row = {"slot": slot, "email": acc["email"], "active": acc["email"] == active, "pools": [], "error": None}
+        try:
+            row["pools"], acc["token"] = account_usage(token)
+        except (UsageError, KeyError, ValueError) as e:
+            row["error"] = str(e)
+        except Exception as e:
+            # The message or traceback of an unexpected error may carry token text; keep the type only.
+            row["error"] = f"unexpected error: {type(e).__name__}"
+        return row
+
+    slots = sorted(store["accounts"], key=int)
+    with ThreadPoolExecutor(max_workers=8) as ex:
+        rows = list(ex.map(one, slots))
+    # The fetch ran unlocked for seconds; merge tokens into a fresh read so a
+    # concurrent add/remove/switch is never undone.
+    refreshed = {store["accounts"][r["slot"]]["email"]: store["accounts"][r["slot"]]["token"] for r in rows}
+    with locked_store() as current:
+        for acc in current["accounts"].values():
+            # Only take a token that is still for this account and actually newer.
+            new = refreshed.get(acc["email"])
+            if new and new != acc["token"] and email_of(new) == acc["email"] and _expiry(new) > _expiry(acc["token"]):
+                acc["token"] = new
+        if current["accounts"]:
+            save_store(current)
+    return rows
+
+
+def _expiry(token: str) -> datetime:
+    try:
+        return parse_time(json.loads(token)["token"]["expiry"]) or datetime.min.replace(tzinfo=UTC)
+    except (KeyError, ValueError, TypeError):
+        return datetime.min.replace(tzinfo=UTC)
+
+
+BAR = 30
+
+
+def _countdown(reset: datetime | None) -> str:
+    if not reset:
+        return ""
+    secs = max(0, int((reset - datetime.now(UTC)).total_seconds()))
+    d, h, m = secs // 86400, secs % 86400 // 3600, secs % 3600 // 60
+    return "resets " + (f"{d}d {h}h" if d else f"{h}h {m}m")
+
+
+def _color(used: float) -> str:
+    return "#22c55e" if used < 0.5 else "#eab308" if used < 0.8 else "#ef4444"
+
+
+def account_text(row: dict) -> Text:
+    t = Text()
+    t.append(f"{row['slot']:>2}  ", "bold")
+    t.append(row["email"], "bold")
+    if row["active"]:
+        t.append("  ● active", "bold #ffa62b")
+    prev_group = None
+    width = max([12] + [len(p.group) + 2 for p in row["pools"]])
+    for p in row["pools"]:
+        filled = round(p.used * BAR)
+        # Group name only on its first row; the window column stays aligned.
+        t.append(
+            f"\n    {p.group if p.group != prev_group else '':<{width}}", "bold" if p.group != prev_group else "dim"
+        )
+        prev_group = p.group
+        t.append(f"{p.window:<8}", "dim")
+        t.append("━" * filled, _color(p.used))
+        t.append("━" * (BAR - filled), "grey35")
+        t.append(f" {p.used:>4.0%}", f"bold {_color(p.used)}")
+        if p.reset:
+            t.append(f"  {_countdown(p.reset)}", "dim")
+    if row["error"]:
+        t.append(f"\n    ✕ {row['error']}", "#ef4444")
+    return t
+
+
+def cmd_list() -> None:
+    if not load_store()["accounts"]:
+        print("No accounts stored. Sign in to agy, then run `agyswap add`.")
+        return
+    console = Console()
+    for row in collect_usage():
+        console.print(account_text(row))
+        console.print()
+
+
+def cmd_status() -> None:
+    email = email_of(read_token())
+    if not email:
+        print("Not signed in.")
+        return
+    slot = slot_for_email(load_store(), email)
+    print(f"{email} (account {slot})" if slot else f"{email} (not stored, run `agyswap add`)")
+
+
+def cmd_switch(target: str | None = None, force: bool = False, ignore_running: bool = False) -> str:
+    """Switch the keyring login. `force` skips copying the live token back into its slot,
+    an unstored live login is still saved first."""
+    if agy_running() and not ignore_running:
+        raise SwapError(
+            "agy is running. Exit it first: a running agy refreshes and re-saves "
+            "its own token, undoing the switch. (--ignore-running to override)"
+        )
+    with locked_store() as store:
+        if not store["accounts"]:
+            raise SwapError("No accounts stored. Run `agyswap add` first.")
+        note = ""
+        live = read_token()
+        live_email = email_of(live)
+        current = slot_for_email(store, live_email)
+        if current:
+            if not force:
+                # Capture the live token so refreshes made by agy are not lost.
+                store["accounts"][current]["token"] = live
+        elif live_email:
+            # Never overwrite a login we have no copy of: store it first.
+            current = next_slot(store)
+            store["accounts"][current] = {"email": live_email, "token": live}
+            note = f"Saved unstored login {live_email} as account {current}. "
+        slots = sorted(store["accounts"], key=int)
+        if target is None:
+            target = slots[(slots.index(current) + 1) % len(slots)] if current else slots[0]
+        slot = find_slot(store, target)
+        if slot == current:
+            save_store(store)
+            return note + f"Already on account {slot}: {store['accounts'][slot]['email']}"
+        save_store(store)  # persist synced token before overwriting the keyring
+        write_token(store["accounts"][slot]["token"])
+        return note + f"Switched to account {slot}: {store['accounts'][slot]['email']}"
+
+
+def cmd_remove(target: str) -> str:
+    with locked_store() as store:
+        slot = find_slot(store, target)
+        email = store["accounts"].pop(slot)["email"]
+        save_store(store)
+    return f"Removed account {slot}: {email}"
+
+
+def confirm_remove(target: str) -> bool:
+    """Ask before forgetting an account. Only prompts on a TTY."""
+    store = load_store()
+    slot = find_slot(store, target)
+    email = store["accounts"][slot]["email"]
+    if not sys.stdin.isatty():
+        raise SwapError("Refusing to remove without confirmation. Pass --yes to remove from a script.")
+    if email == email_of(read_token()):
+        print(f"warning: account {slot} ({email}) is currently active", file=sys.stderr)
+    try:
+        answer = input(f"Remove account {slot} ({email})? [y/N] ")
+    except (EOFError, KeyboardInterrupt):
+        print()  # Ctrl-D / Ctrl-C mean "no"; keep the prompt line tidy
+        return False
+    return answer.strip().lower() in ("y", "yes")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="agyswap", description="Multi-account switcher for the Antigravity CLI (agy)")
+    p.add_argument("--version", action="version", version=__version__)
+    sub = p.add_subparsers(dest="cmd")
+    sub.add_parser("tui", help="interactive dashboard (also: bare agyswap)")
+    add = sub.add_parser("add", help="store the account agy is signed in with")
+    add.add_argument("--slot", type=int, help="store into this slot number")
+    sub.add_parser("list", aliases=["ls"], help="list stored accounts with quota usage")
+    sub.add_parser("status", help="show the active account")
+    sw = sub.add_parser("switch", help="switch to next account, or to <num|email>")
+    sw.add_argument("target", nargs="?")
+    sw.add_argument(
+        "--force", action="store_true", help="switch without copying the live login's token back into its slot first"
+    )
+    sw.add_argument("--ignore-running", action="store_true", help="switch even if agy is running")
+    rm = sub.add_parser("remove", aliases=["rm"], help="forget a stored account")
+    rm.add_argument("target")
+    rm.add_argument("-y", "--yes", action="store_true", help="remove without asking")
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.cmd is None:
+        if not (sys.stdin.isatty() and sys.stdout.isatty()):
+            parser.error("no command given — try 'agyswap --help'")
+        args.cmd = "tui"
+    try:
+        match args.cmd:
+            case "tui":
+                from agyswap.tui import AgySwapApp
+
+                AgySwapApp().run()
+            case "add":
+                print(cmd_add(args.slot))
+            case "list" | "ls":
+                cmd_list()
+            case "status":
+                cmd_status()
+            case "switch":
+                print(cmd_switch(args.target, args.force, args.ignore_running))
+            case "remove" | "rm":
+                if not args.yes and not confirm_remove(args.target):
+                    print("Cancelled")
+                    return 0
+                print(cmd_remove(args.target))
+    except SwapError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

agyswap/tui.py

@@ -0,0 +1,199 @@
+"""Interactive dashboard: every account's quota, keyboard-driven switching."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from rich.markup import escape
+from textual import work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.theme import Theme
+from textual.widgets import Footer, Label, ListItem, ListView, Static
+
+from agyswap import cli
+
+REFRESH_SECS = 120
+
+PITCH_BLACK = Theme(
+    name="pitch-black",
+    primary="#0178d4",
+    secondary="#8a8a8a",
+    accent="#ffa62b",
+    foreground="#e5e5e5",
+    background="#000000",
+    surface="#000000",
+    panel="#0a0a0a",
+    success="#22c55e",
+    warning="#eab308",
+    error="#ef4444",
+    dark=True,
+    variables={
+        "block-cursor-foreground": "#e5e5e5",
+        "block-cursor-background": "#000000",
+        "block-cursor-text-style": "none",
+        "block-cursor-blurred-foreground": "#e5e5e5",
+        "block-cursor-blurred-background": "#000000",
+        "block-cursor-blurred-text-style": "none",
+        "block-hover-background": "#000000",
+        "footer-background": "#141414",
+        "footer-item-background": "#141414",
+        "footer-key-background": "#ffa62b",
+        "footer-key-foreground": "#000000",
+        "footer-description-foreground": "#d4d4d4",
+        "scrollbar": "#262626",
+        "scrollbar-background": "#000000",
+    },
+)
+
+
+class Confirm(ModalScreen[bool]):
+    BINDINGS = [Binding("y", "answer(True)", "Yes"), Binding("n,escape", "answer(False)", "No")]
+    DEFAULT_CSS = """
+    Confirm { align: center middle; background: #000000 70%; }
+    Confirm > Vertical { width: 64; height: auto; border: round $error; padding: 1 2; background: #000000; }
+    Confirm .hint { color: $text-muted; margin-top: 1; }
+    """
+
+    def __init__(self, question: str) -> None:
+        super().__init__()
+        self.question = question
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Label(self.question)
+            yield Label("[b $error]y[/] remove   [b]n[/] cancel", classes="hint")
+
+    def action_answer(self, value: bool) -> None:
+        self.dismiss(value)
+
+
+class AgySwapApp(App):
+    TITLE = "agyswap - Antigravity CLI Accounts Swap"
+    ENABLE_COMMAND_PALETTE = False
+    CSS = """
+    Screen { background: #000000; }
+    #title { width: 1fr; height: 3; padding: 1 2; background: #000000; text-align: center; }
+    Footer { background: #141414; padding: 0 2; }
+    FooterKey .footer-key--key, FooterKey.-compact .footer-key--key { padding: 0 1; text-style: bold; }
+    FooterKey .footer-key--description, FooterKey.-compact .footer-key--description { padding: 0 2 0 1; }
+    ListView { height: 1fr; padding: 0 1; background: #000000; }
+    ListView:focus { background-tint: #000000 0%; }
+    ListView > ListItem { height: auto; padding: 1 2; background: #000000; }
+    ListView > ListItem.-highlight, ListView:focus > ListItem.-highlight {
+        background: $primary;
+        color: #ffffff;
+    }
+    #status { height: 1; padding: 0 2; color: $text-muted; background: #000000; }
+    """
+    BINDINGS = [
+        Binding("s", "switch", "Switch"),
+        Binding("a", "add", "Add current"),
+        Binding("d", "remove", "Remove"),
+        Binding("r", "refresh", "Refresh"),
+        Binding("j", "cursor_down", show=False),
+        Binding("k", "cursor_up", show=False),
+        Binding("q", "quit", "Quit"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        yield Static("[b $accent]agyswap[/] [dim]- Antigravity CLI Accounts Swap[/]", id="title")
+        yield ListView()
+        yield Static("Loading…", id="status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.register_theme(PITCH_BLACK)
+        self.theme = "pitch-black"
+        self.rows: list[dict] = []
+        self.action_refresh()
+        self.set_interval(REFRESH_SECS, self.action_refresh)
+
+    # --- data -------------------------------------------------------------
+
+    @work(thread=True, exclusive=True)
+    def action_refresh(self) -> None:
+        self.call_from_thread(self._status, "[dim]⟳ refreshing usage…[/]")
+        # Textual's crash report prints locals, and these hold tokens; show the type only. The UI
+        # calls stay outside the except blocks so a failing call never chains the original error.
+        try:
+            rows, err = cli.collect_usage(), None
+        except cli.SwapError as e:
+            rows, err = [], escape(str(e))
+        except Exception as e:
+            rows, err = [], f"refresh failed: {type(e).__name__}"
+        if err is not None:
+            self.call_from_thread(self._status, f"[$error]{err}[/]")
+            return
+        self.call_from_thread(self._show, rows)
+
+    def _show(self, rows: list[dict]) -> None:
+        lv = self.query_one(ListView)
+        keep = lv.index or 0
+        self.rows = rows
+        lv.clear()
+        for row in rows:
+            lv.append(ListItem(Static(cli.account_text(row))))
+        if rows:
+            lv.index = min(keep, len(rows) - 1)
+            n = len(rows)
+            self._status(
+                f"{n} account{'s' if n != 1 else ''}  ·  updated {datetime.now():%H:%M}"
+                f"  ·  refreshes every {REFRESH_SECS // 60} min"
+            )
+        else:
+            lv.append(ListItem(Static("No accounts yet.\nIn agy: /logout, sign in, exit. Then press [b]a[/b].")))
+            self._status("")
+
+    def _status(self, msg: str) -> None:
+        self.query_one("#status", Static).update(msg)
+
+    def _selected(self) -> dict | None:
+        idx = self.query_one(ListView).index
+        return self.rows[idx] if self.rows and idx is not None and idx < len(self.rows) else None
+
+    def _run(self, fn, *args) -> bool:
+        try:
+            msg, err = fn(*args), None
+        except cli.SwapError as e:
+            msg, err = None, str(e)
+        except Exception as e:
+            msg, err = None, f"failed: {type(e).__name__}"
+        if err is not None:
+            self.notify(err, severity="error", timeout=8)
+            return False
+        self.notify(msg)
+        return True
+
+    # --- actions ----------------------------------------------------------
+
+    def action_switch(self) -> None:
+        row = self._selected()
+        if row and self._run(cli.cmd_switch, row["slot"], False):
+            self.action_refresh()
+
+    def on_list_view_selected(self) -> None:
+        self.action_switch()
+
+    def action_add(self) -> None:
+        if self._run(cli.cmd_add, None):
+            self.action_refresh()
+
+    def action_remove(self) -> None:
+        row = self._selected()
+        if not row:
+            return
+
+        def done(ok: bool | None) -> None:
+            if ok and self._run(cli.cmd_remove, row["slot"]):
+                self.action_refresh()
+
+        self.push_screen(Confirm(f"Remove account {row['slot']}: [b]{row['email']}[/b]?"), done)
+
+    def action_cursor_down(self) -> None:
+        self.query_one(ListView).action_cursor_down()
+
+    def action_cursor_up(self) -> None:
+        self.query_one(ListView).action_cursor_up()

agyswap/usage.py

@@ -0,0 +1,148 @@
+"""Quota for an agy account, read the same way agy's /quota does (Cloud Code retrieveUserQuotaSummary)."""
+
+from __future__ import annotations
+
+import base64
+import http.client
+import json
+import re
+import shutil
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
+from functools import lru_cache
+from pathlib import Path
+
+QUOTA_URL = "https://daily-cloudcode-pa.googleapis.com/v1internal:retrieveUserQuotaSummary"
+WINDOW_ORDER = {"5h": 0, "weekly": 1}
+TOKEN_URL = "https://oauth2.googleapis.com/token"
+
+
+class UsageError(Exception):
+    pass
+
+
+@dataclass
+class Pool:
+    group: str  # model group sharing the quota, e.g. "Gemini", "Claude/GPT"
+    window: str  # "5h" or "weekly"
+    used: float  # 0..1
+    reset: datetime | None  # None while the bucket is full: its reset keeps sliding
+
+
+def _group_name(display: str) -> str:
+    # "Gemini Models" -> "Gemini", "Claude and GPT models" -> "Claude/GPT"
+    return re.sub(r"\s+models$", "", display, flags=re.I).replace(" and ", "/")
+
+
+def claims(token: str | None) -> dict:
+    try:
+        payload = json.loads(token)["id_token"].split(".")[1]
+        return json.loads(base64.urlsafe_b64decode(payload + "=" * (-len(payload) % 4)))
+    except (TypeError, KeyError, IndexError, ValueError):
+        return {}
+
+
+@lru_cache(maxsize=1)
+def _agy_client_secrets() -> tuple[str, ...]:
+    # agy is an installed-app OAuth client and ships its client secret inside the
+    # binary. Read it from there rather than copying Google's credential into this repo.
+    path = Path(shutil.which("agy") or Path.home() / ".local/bin/agy")
+    try:
+        data = path.read_bytes()
+    except OSError:
+        raise UsageError(f"agy binary not found at {path}; needed to refresh tokens") from None
+    return tuple(sorted({m.decode() for m in re.findall(rb"GOCSPX-[A-Za-z0-9_-]{28}", data)}))
+
+
+def parse_time(s: str) -> datetime | None:
+    # Go writes nanoseconds; fromisoformat takes at most microseconds.
+    try:
+        return datetime.fromisoformat(re.sub(r"(\.\d{6})\d+", r"\1", s).replace("Z", "+00:00"))
+    except (TypeError, ValueError):
+        return None
+
+
+def _post(url: str, data: bytes, headers: dict | None = None) -> dict:
+    # Cloud Code rejects the default Python-urllib agent with 403.
+    req = urllib.request.Request(url, data=data, headers={"User-Agent": "antigravity", **(headers or {})})
+    try:
+        with urllib.request.urlopen(req, timeout=20) as r:
+            return json.load(r)
+    except urllib.error.URLError:
+        raise  # callers map HTTP and connect errors
+    except (OSError, http.client.HTTPException) as e:
+        # urlopen only wraps connect errors; a timeout or reset while reading comes through raw.
+        raise UsageError(f"network error: {type(e).__name__}") from None
+
+
+def fresh_token(token: str) -> str:
+    """Return the token JSON with a usable access token, refreshing it if expired.
+
+    Google does not rotate the refresh token here, so the stored copy stays valid.
+    """
+    tok = json.loads(token)
+    now = datetime.now(UTC)
+    expiry = parse_time(tok["token"].get("expiry", ""))
+    if expiry and expiry > now + timedelta(minutes=2):
+        return token
+    client_id = claims(token).get("azp")
+    for secret in _agy_client_secrets():
+        form = urllib.parse.urlencode(
+            {
+                "client_id": client_id,
+                "client_secret": secret,
+                "refresh_token": tok["token"]["refresh_token"],
+                "grant_type": "refresh_token",
+            }
+        ).encode()
+        try:
+            r = _post(TOKEN_URL, form)
+        except urllib.error.HTTPError as e:
+            body = e.read()
+            if b"invalid_client" in body:
+                continue  # the binary carries more than one client; try the next
+            if b"invalid_grant" in body:
+                raise UsageError("token revoked, sign in with agy again and `agyswap add`") from e
+            raise UsageError(f"token refresh failed (HTTP {e.code})") from e
+        except urllib.error.URLError as e:
+            raise UsageError(f"network error: {e.reason}") from e
+        tok["token"]["access_token"] = r["access_token"]
+        tok["token"]["expiry"] = (now + timedelta(seconds=r["expires_in"])).isoformat()
+        if "id_token" in r:
+            tok["id_token"] = r["id_token"]
+        return json.dumps(tok)
+    raise UsageError("no agy OAuth client secret accepted this token")
+
+
+def fetch_pools(token: str) -> list[Pool]:
+    access = json.loads(token)["token"]["access_token"]
+    try:
+        data = _post(
+            QUOTA_URL,
+            b"{}",
+            {"Authorization": f"Bearer {access}", "Content-Type": "application/json"},
+        )
+    except urllib.error.HTTPError as e:
+        raise UsageError(f"quota request failed (HTTP {e.code})") from e
+    except urllib.error.URLError as e:
+        raise UsageError(f"network error: {e.reason}") from e
+    pools = []
+    for group in data.get("groups", []):
+        name = _group_name(group.get("displayName", "?"))
+        buckets = sorted(group.get("buckets", []), key=lambda b: WINDOW_ORDER.get(b.get("window"), 9))
+        for b in buckets:
+            frac = b.get("remainingFraction")
+            # An exhausted bucket has not been observed yet; treat a missing fraction as empty.
+            frac = frac if isinstance(frac, int | float) else 0.0
+            reset = None if frac >= 1 else parse_time(b.get("resetTime", ""))
+            pools.append(Pool(name, b.get("window", "?"), 1 - frac, reset))
+    return pools
+
+
+def account_usage(token: str) -> tuple[list[Pool], str]:
+    """Pools for one account, plus the (possibly refreshed) token to store back."""
+    token = fresh_token(token)
+    return fetch_pools(token), token

agyswap_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.5
+Name: agyswap-cli
+Version: 0.1.0
+Summary: Switch between multiple Antigravity CLI accounts, with a quota dashboard for every account
+Project-URL: Homepage, https://github.com/rasvanjaya21/agyswap
+Project-URL: Repository, https://github.com/rasvanjaya21/agyswap
+Project-URL: Issues, https://github.com/rasvanjaya21/agyswap/issues
+Author-email: rasvanjaya21 <rasvanjaya21@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: account-switcher,agy,antigravity,cli,gemini
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Utilities
+Requires-Python: >=3.12
+Requires-Dist: rich>=15
+Requires-Dist: textual<9,>=8.2.8
+Description-Content-Type: text/markdown
+
+<p align="center">
+    <a href="#"><img src=".github/assets/banner.webp" width="250"></a>
+</p>
+
+<p align="center">
+    <strong>Switch between multiple Antigravity CLI accounts, with a quota dashboard for every account.</strong>
+</p>
+
+<p align="center">
+    <a href="#"><img src="https://img.shields.io/badge/author-rasvanjaya21-white" alt="author-name"></a>
+    <a href="#"><img src="https://img.shields.io/badge/version-0.1.0-blue" alt="project-version"></a>
+    <a href="https://pypi.org/project/agyswap-cli/"><img src="https://img.shields.io/pypi/v/agyswap-cli?label=pip" alt="pypi-version"></a>
+    <a href="https://github.com/rasvanjaya21/agyswap/actions/workflows/ci.yml"><img src="https://github.com/rasvanjaya21/agyswap/actions/workflows/ci.yml/badge.svg" alt="build-status"></a>
+</p>
+
+## Description
+
+agyswap switches the Google account used by the Antigravity CLI (`agy`) without signing in again, and shows the quota left on every account. It does not work with the Antigravity IDE, Gemini CLI, or other Google AI products.
+
+agy keeps its login in the OS keyring as a single OAuth token. agyswap stores a copy of each account's token, and switching writes another account's copy back to the keyring. The next `agy` you start runs as that account.
+
+Inspired by [claude-swap](https://github.com/realiti4/claude-swap).
+
+## Status
+
+**Usable on Linux.** Adding accounts, switching between them, the quota list, and the interactive dashboard all work, and switching between two real accounts without signing in again has been verified.
+
+Not built yet: automatic switching when an account runs low, parallel sessions with different accounts, aliases, enable/disable, export/import, and macOS/Windows keyrings. `TODO.md` lists every open item.
+
+## Techstacks
+
+Python 3.12+ managed with uv. The dashboard uses Textual and Rich; everything else is the standard library, plus `secret-tool` (libsecret) for the keyring.
+
+## Installation
+
+```bash
+$ uv tool install agyswap-cli    # or: pipx install agyswap-cli / pip install agyswap-cli
+$ agyswap --help                 # the command is still agyswap
+```
+
+Until the first release is on PyPI, install from GitHub instead:
+
+```bash
+$ uv tool install git+https://github.com/rasvanjaya21/agyswap
+```
+
+agyswap needs Linux with a Secret Service keyring (GNOME Keyring or KWallet) and `secret-tool` (`dnf install libsecret` or `apt install libsecret-tools`).
+
+## Configuration
+
+| Variable | What it does |
+| --- | --- |
+| `AGYSWAP_HOME` | Where agyswap keeps its account store. Defaults to `~/.agyswap`. The store, `accounts.json`, holds refresh tokens and is written with mode `0600`. |
+
+## Usage
+
+Unlike Claude Code, agy has no account picker. To add an account, sign out of agy, sign in with that account, then store it:
+
+```bash
+$ agy             # /logout, then sign in with account A, then exit
+$ agyswap add
+$ agy             # /logout, then sign in with account B, then exit
+$ agyswap add
+```
+
+Signing out of agy does not revoke the token agyswap already stored.
+
+Run `agyswap` on its own (or `agyswap tui`) for the dashboard. It shows every account's quota for both model groups (Gemini, and Claude/GPT), each with its 5-hour and weekly window and reset times, and marks the active account. Usage refreshes every 2 minutes.
+
+| Key | Action |
+| --- | --- |
+| `enter` / `s` | Switch to the highlighted account |
+| `a` | Add the account agy is signed in with |
+| `d` | Remove the highlighted account |
+| `r` | Refresh usage |
+| `j` / `k` | Move |
+| `q` | Quit |
+
+The same actions are available as commands:
+
+```bash
+$ agyswap switch                  # rotate to the next account
+$ agyswap switch 2                # by slot
+$ agyswap switch user@gmail.com   # by email
+$ agyswap list                    # quota of every account
+$ agyswap status
+$ agyswap remove 2                 # asks first; add --yes (-y) in scripts
+```
+
+Exit agy before you switch. A running agy reads the keyring only when it starts and saves its own token back every hour, which would undo the switch. `agyswap switch` refuses while agy is running; `--ignore-running` overrides that. `--force` switches without first copying the live login's token back into its slot.
+
+## Development
+
+```bash
+$ git clone https://github.com/rasvanjaya21/agyswap && cd agyswap
+$ uv sync          # creates .venv with agyswap installed in editable mode
+$ uv run agyswap
+```
+
+For a manual run against your real agy login, use a throwaway store and shred it afterwards:
+
+```bash
+$ export AGYSWAP_HOME=$(mktemp -d)
+$ uv run agyswap add && uv run agyswap list
+$ shred -u "$AGYSWAP_HOME/accounts.json"
+```
+
+## Testing
+
+```bash
+$ uv run ruff format .    # formatter
+$ uv run ruff check .     # linter
+$ uv run pytest -q        # tests
+$ uv build                # wheel and sdist into dist/
+```
+
+Tests never touch the real keyring, the network, or `~/.agyswap/`. The keyring, the store, and every Google request are faked.
+
+## Deployment
+
+Releases are published to PyPI by `.github/workflows/publish.yml` when a `v*` tag is pushed. The version lives only in `pyproject.toml`.
+
+```bash
+$ uv version --bump patch
+$ uv lock
+$ git commit -am "chore: release v$(uv version --short)"
+$ git push                                  # wait for CI to pass
+$ git tag "v$(uv version --short)" && git push origin "v$(uv version --short)"
+```
+
+A published version cannot be replaced. To roll back, yank it on PyPI and release a patch. The one-time PyPI and GitHub setup is in `CONTRIBUTING.md`.
+
+## Architecture
+
+Design decisions and the reasoning behind them live in `architecture/`, one file per workflow that produced it. `OBSERVE.md` maps how agy stores its login and reports quota, with the evidence for each fact; `SPEC.md` specifies the current version; `PLAN.md` lays out the next tasks; `REVIEW.md` holds the latest code review.
+
+`AGENTS.md` holds the conventions and the development cycle, and is the single channel shared by every agent working here. `TODO.md` holds open findings and is deleted entry by entry as they are resolved.
+
+## Credit
+
+- id: agyswap
+- displayName: agyswap - Antigravity CLI Accounts Swap
+- authorName: rasvanjaya21
+- authorEmail: rasvanjaya21@gmail.com
+- authorURL: https://github.com/rasvanjaya21
+
+## Member
+
+- @rasvanjaya21 [assigned]

agyswap_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+agyswap/__init__.py,sha256=c25PpJKLve8nNALgBZ-Fbw8ClYnzaF7MZzeGji3CL6c,163
+agyswap/__main__.py,sha256=RPGbjy7lS51jzoJc3YgcEnjdiDiannE42MrFubh52Y4,59
+agyswap/cli.py,sha256=_MgPJwz-0oVzI4ioJiye7wcSnWO34bT1o3OzPr0qKxI,13987
+agyswap/tui.py,sha256=vjQHK4EjA7_C7vL0bxThTorfQxGYf02SZX-HgqQY5Mg,7152
+agyswap/usage.py,sha256=kCRzHaleoT_9Gv9hShmyGMRRJCxeph_Vh8v1hRSu5wU,5824
+agyswap_cli-0.1.0.dist-info/METADATA,sha256=6RXxvatKbpr7Sgq0UBp2zhtz7a97maldtOlqqhKJjz4,7317
+agyswap_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+agyswap_cli-0.1.0.dist-info/entry_points.txt,sha256=s0MjB6dQGB3a7To4_1qWAlHQ2CRiLIPLy-7IuJirDXo,45
+agyswap_cli-0.1.0.dist-info/licenses/LICENSE,sha256=5NY_iM5mv3SftsUE_MFwmacUuPGH0rlOvtMdtZSxL4c,1069
+agyswap_cli-0.1.0.dist-info/RECORD,,

agyswap_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

agyswap_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agyswap = agyswap.cli:main

agyswap_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 rasvanjaya21
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.