agy-switch 0.1.0__py3-none-any.whl

agy_switch/__init__.py

@@ -0,0 +1,428 @@
+"""agy-switch: switch between Antigravity CLI (agy) accounts."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from datetime import datetime, timezone
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+try:
+    __version__ = version("agy-switch")
+except PackageNotFoundError:  # running from a source tree that isn't installed
+    __version__ = "0+unknown"
+
+# agy keeps its login in the system keyring, and only falls back to this file (in
+# the agy directory) when no keyring is available. Profiles always use this file name.
+TOKEN_FILE = "antigravity-oauth-token"
+KEYRING_ATTRIBUTES = {"service": "gemini", "username": "antigravity"}
+KEYRING_LABEL = "Password for 'antigravity' on 'gemini'"
+NAME_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$")
+
+
+class SwitchError(Exception):
+    pass
+
+
+# --------------------------------------------------------------------------- paths
+
+
+def agy_home() -> Path:
+    return Path(
+        os.environ.get("AGY_HOME", Path.home() / ".gemini" / "antigravity-cli")
+    ).expanduser()
+
+
+def store_home() -> Path:
+    return Path(
+        os.environ.get("AGY_SWITCH_HOME", Path.home() / ".agy-switch")
+    ).expanduser()
+
+
+def profiles_dir() -> Path:
+    return store_home() / "profiles"
+
+
+def state_file() -> Path:
+    return store_home() / "state.json"
+
+
+def profile_dir(name: str) -> Path:
+    return profiles_dir() / name
+
+
+# --------------------------------------------------------------------------- helpers
+
+
+def validate_name(name: str) -> str:
+    if not NAME_RE.match(name):
+        raise SwitchError(
+            f"invalid profile name: {name!r} "
+            "(use letters, digits, '.', '_' or '-')"
+        )
+    return name
+
+
+def _ensure_private_dir(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+    os.chmod(path, 0o700)
+
+
+def _atomic_write(dst: Path, data: bytes) -> None:
+    """Atomically write data to dst with 0600 permissions."""
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=dst.parent, prefix=f".{dst.name}.")
+    try:
+        with os.fdopen(fd, "wb") as out:
+            out.write(data)
+        os.chmod(tmp, 0o600)
+        os.replace(tmp, dst)
+    except BaseException:
+        Path(tmp).unlink(missing_ok=True)
+        raise
+
+
+def _write_json(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.")
+    with os.fdopen(fd, "w") as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+    os.chmod(tmp, 0o600)
+    os.replace(tmp, path)
+
+
+def _read_json(path: Path) -> dict:
+    try:
+        return json.loads(path.read_text())
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+
+def _keyring_collection():
+    """Return the unlocked default keyring, or None if this system has no keyring."""
+    try:
+        import secretstorage
+    except ImportError:
+        return None
+    try:
+        conn = secretstorage.dbus_init()
+        if not secretstorage.check_service_availability(conn):
+            return None
+        collection = secretstorage.get_default_collection(conn)
+    except (secretstorage.exceptions.SecretStorageException, OSError):
+        return None
+    # A locked keyring must not fall through to the file: agy would ignore it.
+    if collection.is_locked() and collection.unlock():
+        raise SwitchError("the system keyring is locked; unlock it and try again")
+    return collection
+
+
+def read_live_token() -> bytes | None:
+    """Return the current agy login: the keyring if it has one, else the file."""
+    collection = _keyring_collection()
+    if collection is not None:
+        for item in collection.search_items(KEYRING_ATTRIBUTES):
+            return item.get_secret()
+    try:
+        return (agy_home() / TOKEN_FILE).read_bytes()
+    except FileNotFoundError:
+        return None
+
+
+def write_live_token(data: bytes) -> None:
+    collection = _keyring_collection()
+    if collection is None:
+        _atomic_write(agy_home() / TOKEN_FILE, data)
+    else:
+        collection.create_item(KEYRING_LABEL, KEYRING_ATTRIBUTES, data, replace=True)
+
+
+def clear_live_token() -> None:
+    collection = _keyring_collection()
+    if collection is not None:
+        for item in collection.search_items(KEYRING_ATTRIBUTES):
+            item.delete()
+    (agy_home() / TOKEN_FILE).unlink(missing_ok=True)
+
+
+def _email_from_token(data: bytes | None) -> str | None:
+    try:
+        return json.loads(data or b"{}").get("id_token_email")
+    except ValueError:
+        return None
+
+
+def token_email(token_path: Path) -> str | None:
+    return _read_json(token_path).get("id_token_email")
+
+
+def load_state() -> dict:
+    return _read_json(state_file())
+
+
+def save_state(state: dict) -> None:
+    _ensure_private_dir(store_home())
+    _write_json(state_file(), state)
+
+
+def active_profile() -> str | None:
+    name = load_state().get("active")
+    if name and profile_dir(name).is_dir():
+        return name
+    return None
+
+
+def list_profiles() -> list[str]:
+    if not profiles_dir().is_dir():
+        return []
+    return sorted(
+        p.name for p in profiles_dir().iterdir()
+        if p.is_dir() and (p / TOKEN_FILE).is_file()
+    )
+
+
+def profile_email(name: str) -> str | None:
+    return token_email(profile_dir(name) / TOKEN_FILE)
+
+
+def live_email() -> str | None:
+    return _email_from_token(read_live_token())
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+# --------------------------------------------------------------------------- core
+
+
+def snapshot_live(name: str) -> None:
+    """Copy the current agy credentials into profile `name`."""
+    data = read_live_token()
+    if data is None:
+        raise SwitchError(
+            f"no login found in the system keyring or at {agy_home() / TOKEN_FILE}. "
+            "Log in to agy first (or use `agy-switch add NAME --login`)."
+        )
+    dst_dir = profile_dir(name)
+    _ensure_private_dir(profiles_dir())
+    _ensure_private_dir(dst_dir)
+    _atomic_write(dst_dir / TOKEN_FILE, data)
+    meta = _read_json(dst_dir / "meta.json")
+    meta.setdefault("created_at", _now())
+    meta["updated_at"] = _now()
+    meta["email"] = token_email(dst_dir / TOKEN_FILE)
+    _write_json(dst_dir / "meta.json", meta)
+
+
+def sync_active_back() -> None:
+    """agy refreshes its token on its own; save the newest version back into the
+    active profile (only if the live login is still the same account)."""
+    active = active_profile()
+    if not active:
+        return
+    live = live_email()
+    if live and live == profile_email(active):
+        snapshot_live(active)
+
+
+def restore_profile(name: str) -> None:
+    write_live_token((profile_dir(name) / TOKEN_FILE).read_bytes())
+
+
+def backup_live() -> Path | None:
+    data = read_live_token()
+    if data is None:
+        return None
+    bdir = store_home() / "backups"
+    _ensure_private_dir(bdir)
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f")
+    dst = bdir / f"{TOKEN_FILE}.{stamp}"
+    _atomic_write(dst, data)
+    # keep only the 10 most recent backups
+    old = sorted(bdir.glob(f"{TOKEN_FILE}.*"))[:-10]
+    for p in old:
+        p.unlink(missing_ok=True)
+    return dst
+
+
+# --------------------------------------------------------------------------- commands
+
+
+def cmd_add(args: argparse.Namespace) -> int:
+    name = validate_name(args.name)
+    exists = (profile_dir(name) / TOKEN_FILE).is_file()
+    if exists and not args.force:
+        raise SwitchError(
+            f"profile {name!r} already exists (use --force to overwrite)"
+        )
+
+    if args.login:
+        sync_active_back()
+        backup = backup_live()
+        clear_live_token()
+        print(
+            "Opening agy to log in. Sign in with the desired account and, once "
+            "logged in, exit agy (/exit or Ctrl+C)."
+        )
+        try:
+            subprocess.run([args.agy_bin], check=False)
+        except FileNotFoundError:
+            if backup:
+                write_live_token(backup.read_bytes())
+            raise SwitchError(f"executable {args.agy_bin!r} not found")
+        except KeyboardInterrupt:
+            pass
+        if read_live_token() is None:
+            if backup:
+                write_live_token(backup.read_bytes())
+            raise SwitchError("login not completed; previous credentials restored")
+
+    email = live_email()
+    for other in list_profiles():
+        if other != name and email and profile_email(other) == email:
+            print(
+                f"warning: account {email} is already saved in profile {other!r}",
+                file=sys.stderr,
+            )
+    snapshot_live(name)
+    state = load_state()
+    state["active"] = name
+    save_state(state)
+    print(f"Profile {name!r} {'updated' if exists else 'added'} ({email or 'unknown email'}) and set as active.")
+    return 0
+
+
+def cmd_list(args: argparse.Namespace) -> int:
+    names = list_profiles()
+    if not names:
+        print("No saved profiles. Use `agy-switch add NAME`.")
+        return 0
+    active = active_profile()
+    width = max(len(n) for n in names)
+    for n in names:
+        mark = "*" if n == active else " "
+        print(f"{mark} {n.ljust(width)}  {profile_email(n) or '-'}")
+    return 0
+
+
+def cmd_use(args: argparse.Namespace) -> int:
+    name = validate_name(args.name)
+    if name not in list_profiles():
+        raise SwitchError(f"profile {name!r} does not exist (see `agy-switch list`)")
+    if name == active_profile() and live_email() == profile_email(name):
+        print(f"Already using {name!r} ({profile_email(name)}).")
+        return 0
+    sync_active_back()
+    backup_live()
+    restore_profile(name)
+    state = load_state()
+    state["active"] = name
+    save_state(state)
+    print(f"Now using {name!r} ({profile_email(name) or 'unknown email'}).")
+    return 0
+
+
+def cmd_current(args: argparse.Namespace) -> int:
+    active = active_profile()
+    live = live_email()
+    if not active:
+        if live:
+            print(f"No active profile (agy is logged in as {live}, not saved).")
+        else:
+            print("No active profile.")
+        return 1
+    expected = profile_email(active)
+    print(f"{active} ({expected or 'unknown email'})")
+    if live != expected:
+        print(
+            f"warning: agy is logged in as {live or 'nobody'}, "
+            f"which differs from profile {active!r}",
+            file=sys.stderr,
+        )
+    return 0
+
+
+def cmd_remove(args: argparse.Namespace) -> int:
+    name = validate_name(args.name)
+    pdir = profile_dir(name)
+    if not pdir.is_dir():
+        raise SwitchError(f"profile {name!r} does not exist")
+    if not args.yes:
+        answer = input(f"Remove profile {name!r} ({profile_email(name) or '-'})? [y/N] ")
+        if answer.strip().lower() not in ("y", "yes"):
+            print("Cancelled.")
+            return 1
+    shutil.rmtree(pdir)
+    state = load_state()
+    if state.get("active") == name:
+        state["active"] = None
+        save_state(state)
+        print(
+            f"Profile {name!r} removed. It was the active one; the current agy "
+            "login was left unchanged."
+        )
+    else:
+        print(f"Profile {name!r} removed.")
+    return 0
+
+
+# --------------------------------------------------------------------------- cli
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="agy-switch",
+        description="Switch between Antigravity CLI (agy) accounts.",
+    )
+    p.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = p.add_subparsers(dest="command", required=True, metavar="COMMAND")
+
+    a = sub.add_parser("add", help="save the account currently logged in to agy as a profile")
+    a.add_argument("name", metavar="NAME")
+    a.add_argument(
+        "--login", action="store_true",
+        help="log out, open agy to sign in to another account, and save the result",
+    )
+    a.add_argument("-f", "--force", action="store_true", help="overwrite an existing profile")
+    a.add_argument("--agy-bin", default=os.environ.get("AGY_BIN", "agy"), help=argparse.SUPPRESS)
+    a.set_defaults(func=cmd_add)
+
+    ls = sub.add_parser("list", aliases=["ls"], help="list saved profiles")
+    ls.set_defaults(func=cmd_list)
+
+    u = sub.add_parser("use", aliases=["switch"], help="switch to the given profile")
+    u.add_argument("name", metavar="NAME")
+    u.set_defaults(func=cmd_use)
+
+    c = sub.add_parser("current", help="show the active profile")
+    c.set_defaults(func=cmd_current)
+
+    r = sub.add_parser("remove", aliases=["rm"], help="remove a saved profile")
+    r.add_argument("name", metavar="NAME")
+    r.add_argument("-y", "--yes", action="store_true", help="do not ask for confirmation")
+    r.set_defaults(func=cmd_remove)
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except SwitchError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())

agy_switch-0.1.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: agy-switch
+Version: 0.1.0
+Summary: Switch between Antigravity CLI (agy) accounts
+Keywords: agy,antigravity,cli,accounts,profiles
+Author: renatormc
+Author-email: renatormc <renatomartinsrmc@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Utilities
+Requires-Dist: secretstorage>=3.3 ; sys_platform == 'linux'
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/renatormc/agy-switcher
+Project-URL: Repository, https://github.com/renatormc/agy-switcher
+Project-URL: Issues, https://github.com/renatormc/agy-switcher/issues
+Description-Content-Type: text/markdown
+
+# agy-switch
+
+Switch between multiple **Antigravity CLI** (`agy`) accounts.
+
+On Linux, `agy` stores its login in the system keyring (GNOME Keyring, KWallet or another
+Secret Service provider). If no keyring is available, it uses
+`~/.gemini/antigravity-cli/antigravity-oauth-token` instead. `agy-switch` keeps a copy of the
+login for each profile in `~/.agy-switch/profiles/<name>/` and puts the right one back in
+place when you switch accounts.
+
+Saved profiles are unencrypted files, protected only by their permissions (0700/0600), even
+when `agy` itself uses the keyring.
+
+## Requirements
+
+- Linux or macOS
+- Python 3.12 or newer
+- [pipx](https://pipx.pypa.io/)
+- Antigravity CLI (`agy`) installed and on your `PATH`
+
+## Installation
+
+```bash
+pipx install agy-switch
+```
+
+This installs the `agy-switch` command into `~/.local/bin`. If the shell can't find it,
+add that directory to your `PATH`:
+
+```bash
+pipx ensurepath   # then open a new terminal
+```
+
+If your default Python is older than 3.12, point pipx to a newer one:
+
+```bash
+pipx install --python python3.12 agy-switch
+```
+
+Check the installation:
+
+```bash
+agy-switch --version
+```
+
+To update:
+
+```bash
+pipx upgrade agy-switch
+```
+
+To uninstall:
+
+```bash
+pipx uninstall agy-switch
+```
+
+Saved profiles in `~/.agy-switch` are not removed. Delete that directory if you don't need them.
+
+## Usage
+
+```bash
+# 1. With agy logged in to your personal account:
+agy-switch add personal
+
+# 2. Add another account (logs out, opens agy so you can sign in, then saves it):
+agy-switch add work --login
+
+agy-switch list            # * marks the active profile
+agy-switch use personal
+agy-switch use work
+agy-switch current
+agy-switch remove personal # asks for confirmation (-y to skip)
+```
+
+| Command | Description |
+| --- | --- |
+| `add NAME [--login] [--force]` | Save the current agy login as a profile. `--login` signs in to a new account first. `--force` overwrites an existing profile. |
+| `list` (`ls`) | List profiles and their emails. |
+| `use NAME` (`switch`) | Switch agy to the given profile. |
+| `current` | Show the active profile and warn if agy is logged in to a different account. |
+| `remove NAME [-y]` (`rm`) | Delete a saved profile. |
+
+## Details
+
+- `agy` refreshes its token on its own. Before switching accounts, `agy-switch` saves the
+  current token back into the active profile, as long as the email still matches. This
+  keeps profiles from holding an expired token.
+- Before overwriting the login, `agy-switch` saves a backup to `~/.agy-switch/backups/`
+  (keeps the 10 most recent).
+- Close any running `agy` sessions before switching accounts.
+- On macOS, only the file is supported. A login that `agy` keeps in the Keychain isn't detected.
+- Environment variables: `AGY_HOME` (default `~/.gemini/antigravity-cli`) and
+  `AGY_SWITCH_HOME` (default `~/.agy-switch`).
+
+## Development
+
+Run from a clone with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv run agy-switch --help
+```
+
+To publish a release, set the new version, then build and upload it:
+
+```bash
+uv version --bump patch   # or minor / major
+rm -rf dist
+uv build
+uv publish                # needs a PyPI token in UV_PUBLISH_TOKEN
+```

agy_switch-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+agy_switch/__init__.py,sha256=si2Bj6iOrnXsv5G5xR3uGP6bU2yRRTN6P5ScVYneK9k,13254
+agy_switch-0.1.0.dist-info/licenses/LICENSE,sha256=O9bh88qiZLyAjVjMMThOVB9uqIPbcoPdCcO56GdmuvY,1066
+agy_switch-0.1.0.dist-info/WHEEL,sha256=MWx7psoF7KNST9G72pGtiBYuaXRXQXBk9pw5R6FzYko,80
+agy_switch-0.1.0.dist-info/entry_points.txt,sha256=toLwT8nHpuhktLK6_D0jWKNWp0XWhKySlhWGXswuAkU,48
+agy_switch-0.1.0.dist-info/METADATA,sha256=GwPKYN5k2hKsKuqjX0cBYOYhL2yE7-sPoFV6-1_RX9Y,4264
+agy_switch-0.1.0.dist-info/RECORD,,

agy_switch-0.1.0.dist-info/WHEEL

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

agy_switch-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+agy-switch = agy_switch:main
+

agy_switch-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 renatormc
+
+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.