claude-account 0.1.0__tar.gz

claude_account-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.9', '3.12']
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Run tests
+        run: uv run --group dev pytest -q

claude_account-0.1.0/.github/workflows/publish-pypi.yml

@@ -0,0 +1,46 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ['v*']
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - name: Run tests
+        run: uv run --group dev pytest -q
+
+  build:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - name: Build sdist and wheel
+        run: uv build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    # Trusted Publishing (OIDC) — must match the PyPI publisher config.
+    environment:
+      name: pypi
+      url: https://pypi.org/p/claude-account
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

claude_account-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+# build artifacts
+dist/
+build/
+*.egg-info/
+__pycache__/
+*.pyc
+.venv/
+uv.lock
+.pytest_cache/
+.ruff_cache/
+
+# NEVER commit real Claude credentials / captured slots
+.claude-accounts/
+*.credentials.json
+.last-active.json

claude_account-0.1.0/LICENSE

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

claude_account-0.1.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: claude-account
+Version: 0.1.0
+Summary: Manually switch between multiple Claude Code accounts by swapping local credentials.
+Project-URL: Homepage, https://github.com/Barsoomx/claude-account
+Project-URL: Repository, https://github.com/Barsoomx/claude-account
+Project-URL: Issues, https://github.com/Barsoomx/claude-account/issues
+Author: Filipp Balakin
+License-Expression: MIT
+License-File: LICENSE
+Keywords: account,claude,claude-code,cli,credentials,oauth
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# claude-account
+
+[![PyPI](https://img.shields.io/pypi/v/claude-account.svg)](https://pypi.org/project/claude-account/)
+[![Python versions](https://img.shields.io/pypi/pyversions/claude-account.svg)](https://pypi.org/project/claude-account/)
+[![CI](https://github.com/Barsoomx/claude-account/actions/workflows/ci.yml/badge.svg)](https://github.com/Barsoomx/claude-account/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Manually switch between multiple **Claude Code** accounts (e.g. a personal and a
+work subscription) from the terminal — without signing out and back in.
+
+It swaps **only** the subscription token and account identity, leaving your MCP
+server auth and all project state untouched:
+
+- `claudeAiOauth` in `~/.claude/.credentials.json` — the subscription token
+- `oauthAccount` in `~/.claude.json` — the account identity
+
+Everything else — `mcpOAuth`, project history, settings — is preserved. Each
+switch backs up your host files first.
+
+> **Disclaimer.** This is an unofficial, community tool. It is **not affiliated
+> with, endorsed by, or sponsored by Anthropic**. "Claude" and "Anthropic" are
+> trademarks of Anthropic, PBC. It only shuffles credential files that already
+> live on your own machine; it talks to no Anthropic service itself. Use it to
+> switch between accounts **you personally own**, manually. Don't use it to
+> automate around usage limits.
+
+## Install
+
+```bash
+# run without installing
+uvx claude-account status
+
+# or install as a persistent tool
+uv tool install claude-account
+# or
+pipx install claude-account
+```
+
+Requires the [`claude`](https://claude.com/claude-code) CLI on your `PATH`
+(only for `capture`) and Python 3.9+.
+
+## Quick start
+
+Two accounts, called `primary` and `backup`:
+
+```bash
+claude-account snapshot primary   # store the account you're already on
+claude-account capture  backup    # opens an isolated login for the 2nd account
+claude-account swap               # flip between them
+```
+
+Handy shell aliases:
+
+```bash
+alias cas='claude-account swap'
+alias cass='claude-account status'
+```
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `snapshot <slot>` | Store the account you are **already** logged into (no re-login). |
+| `capture <slot>` | Open an isolated login booth and store **another** account. |
+| `status` | Show the active account and stored slots. |
+| `swap` | Toggle between the two stored slots. |
+| `use <slot>` | Activate a specific slot. |
+
+Slots live in `~/.claude-accounts/`; host backups in
+`~/.claude-accounts/backups/`. Paths can be overridden with
+`CLAUDE_CRED_FILE`, `CLAUDE_CONFIG_FILE`, and `CLAUDE_ACCOUNTS_DIR`.
+
+## How it works
+
+`capture` logs in inside a throwaway `CLAUDE_CONFIG_DIR`, so your host login is
+never touched, then copies out just that account's `claudeAiOauth` +
+`oauthAccount`. `swap`/`use` do the reverse surgically: they write the target
+slot's `claudeAiOauth` into `.credentials.json` and its `oauthAccount` into
+`.claude.json`, preserving every other key. Before switching away, the current
+account's live tokens are saved back into its slot (Claude Code rotates refresh
+tokens, so stale copies would eventually stop working).
+
+Do a switch **between** `claude` sessions — a running session holds its token in
+memory. Slot files contain refresh tokens; treat them as secrets (they are
+written `0600` and `~/.claude-accounts/` is `0700`).
+
+## Development
+
+```bash
+uv run --group dev pytest -q
+uv build
+```
+
+## Releasing
+
+Tag a version and push; CI builds and publishes to PyPI via
+[Trusted Publishing](https://docs.pypi.org/trusted-publishers/) (OIDC, no
+tokens):
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

claude_account-0.1.0/README.md

@@ -0,0 +1,107 @@
+# claude-account
+
+[![PyPI](https://img.shields.io/pypi/v/claude-account.svg)](https://pypi.org/project/claude-account/)
+[![Python versions](https://img.shields.io/pypi/pyversions/claude-account.svg)](https://pypi.org/project/claude-account/)
+[![CI](https://github.com/Barsoomx/claude-account/actions/workflows/ci.yml/badge.svg)](https://github.com/Barsoomx/claude-account/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Manually switch between multiple **Claude Code** accounts (e.g. a personal and a
+work subscription) from the terminal — without signing out and back in.
+
+It swaps **only** the subscription token and account identity, leaving your MCP
+server auth and all project state untouched:
+
+- `claudeAiOauth` in `~/.claude/.credentials.json` — the subscription token
+- `oauthAccount` in `~/.claude.json` — the account identity
+
+Everything else — `mcpOAuth`, project history, settings — is preserved. Each
+switch backs up your host files first.
+
+> **Disclaimer.** This is an unofficial, community tool. It is **not affiliated
+> with, endorsed by, or sponsored by Anthropic**. "Claude" and "Anthropic" are
+> trademarks of Anthropic, PBC. It only shuffles credential files that already
+> live on your own machine; it talks to no Anthropic service itself. Use it to
+> switch between accounts **you personally own**, manually. Don't use it to
+> automate around usage limits.
+
+## Install
+
+```bash
+# run without installing
+uvx claude-account status
+
+# or install as a persistent tool
+uv tool install claude-account
+# or
+pipx install claude-account
+```
+
+Requires the [`claude`](https://claude.com/claude-code) CLI on your `PATH`
+(only for `capture`) and Python 3.9+.
+
+## Quick start
+
+Two accounts, called `primary` and `backup`:
+
+```bash
+claude-account snapshot primary   # store the account you're already on
+claude-account capture  backup    # opens an isolated login for the 2nd account
+claude-account swap               # flip between them
+```
+
+Handy shell aliases:
+
+```bash
+alias cas='claude-account swap'
+alias cass='claude-account status'
+```
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `snapshot <slot>` | Store the account you are **already** logged into (no re-login). |
+| `capture <slot>` | Open an isolated login booth and store **another** account. |
+| `status` | Show the active account and stored slots. |
+| `swap` | Toggle between the two stored slots. |
+| `use <slot>` | Activate a specific slot. |
+
+Slots live in `~/.claude-accounts/`; host backups in
+`~/.claude-accounts/backups/`. Paths can be overridden with
+`CLAUDE_CRED_FILE`, `CLAUDE_CONFIG_FILE`, and `CLAUDE_ACCOUNTS_DIR`.
+
+## How it works
+
+`capture` logs in inside a throwaway `CLAUDE_CONFIG_DIR`, so your host login is
+never touched, then copies out just that account's `claudeAiOauth` +
+`oauthAccount`. `swap`/`use` do the reverse surgically: they write the target
+slot's `claudeAiOauth` into `.credentials.json` and its `oauthAccount` into
+`.claude.json`, preserving every other key. Before switching away, the current
+account's live tokens are saved back into its slot (Claude Code rotates refresh
+tokens, so stale copies would eventually stop working).
+
+Do a switch **between** `claude` sessions — a running session holds its token in
+memory. Slot files contain refresh tokens; treat them as secrets (they are
+written `0600` and `~/.claude-accounts/` is `0700`).
+
+## Development
+
+```bash
+uv run --group dev pytest -q
+uv build
+```
+
+## Releasing
+
+Tag a version and push; CI builds and publishes to PyPI via
+[Trusted Publishing](https://docs.pypi.org/trusted-publishers/) (OIDC, no
+tokens):
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

claude_account-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ['hatchling']
+build-backend = 'hatchling.build'
+
+[project]
+name = 'claude-account'
+version = '0.1.0'
+description = 'Manually switch between multiple Claude Code accounts by swapping local credentials.'
+readme = 'README.md'
+requires-python = '>=3.9'
+license = 'MIT'
+license-files = ['LICENSE']
+authors = [{ name = 'Filipp Balakin' }]
+keywords = ['claude', 'claude-code', 'cli', 'account', 'credentials', 'oauth']
+classifiers = [
+    'Environment :: Console',
+    'Intended Audience :: Developers',
+    'License :: OSI Approved :: MIT License',
+    'Operating System :: POSIX',
+    'Programming Language :: Python :: 3',
+    'Topic :: Utilities',
+]
+dependencies = []
+
+[project.urls]
+Homepage = 'https://github.com/Barsoomx/claude-account'
+Repository = 'https://github.com/Barsoomx/claude-account'
+Issues = 'https://github.com/Barsoomx/claude-account/issues'
+
+[project.scripts]
+claude-account = 'claude_account.cli:main'
+
+[dependency-groups]
+dev = ['pytest>=8']
+
+[tool.hatch.build.targets.wheel]
+packages = ['src/claude_account']

claude_account-0.1.0/src/claude_account/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.1.0'

claude_account-0.1.0/src/claude_account/cli.py

@@ -0,0 +1,348 @@
+"""Switch between multiple Claude Code accounts by swapping local credentials.
+
+Only the subscription token (``claudeAiOauth``) and the account identity
+(``oauthAccount``) are swapped. MCP auth (``mcpOAuth``) and all project state
+in ``~/.claude.json`` are preserved.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from datetime import datetime
+from pathlib import Path
+
+from claude_account import __version__
+
+_SLOT_RE = re.compile(r'[a-z0-9_-]+')
+
+
+class AccountError(Exception):
+    pass
+
+
+def _home() -> Path:
+    return Path.home()
+
+
+def cred_file() -> Path:
+    return Path(os.environ.get('CLAUDE_CRED_FILE', _home() / '.claude' / '.credentials.json'))
+
+
+def config_file() -> Path:
+    return Path(os.environ.get('CLAUDE_CONFIG_FILE', _home() / '.claude.json'))
+
+
+def accounts_dir() -> Path:
+    return Path(os.environ.get('CLAUDE_ACCOUNTS_DIR', _home() / '.claude-accounts'))
+
+
+def backups_dir() -> Path:
+    return accounts_dir() / 'backups'
+
+
+def _ts() -> str:
+    return datetime.now().strftime('%Y%m%d-%H%M%S')
+
+
+def _valid_slot(name: str) -> bool:
+    return bool(name) and _SLOT_RE.fullmatch(name) is not None
+
+
+def _load_json(path: Path):
+    try:
+        with path.open() as fh:
+            return json.load(fh)
+    except FileNotFoundError:
+        return None
+
+
+def _atomic_write_json(path: Path, obj) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=str(path.parent), prefix='.tmp.')
+    try:
+        with os.fdopen(fd, 'w') as fh:
+            json.dump(obj, fh, indent=2)
+            fh.write('\n')
+        os.chmod(tmp, 0o600)
+        os.replace(tmp, path)
+    except BaseException:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+
+        raise
+
+
+def _dig(obj, *keys):
+    for key in keys:
+        if not isinstance(obj, dict):
+            return None
+
+        obj = obj.get(key)
+
+    return obj
+
+
+def _ensure_accounts_dir() -> None:
+    accounts_dir().mkdir(parents=True, exist_ok=True)
+    try:
+        os.chmod(accounts_dir(), 0o700)
+    except OSError:
+        pass
+
+
+def _slot_path(name: str) -> Path:
+    return accounts_dir() / f'{name}.json'
+
+
+def _iter_slots() -> list[Path]:
+    directory = accounts_dir()
+    if not directory.is_dir():
+        return []
+
+    return sorted(p for p in directory.glob('*.json') if not p.name.startswith('.'))
+
+
+def _slot_for_uuid(uuid: str):
+    if not uuid:
+        return None
+
+    for path in _iter_slots():
+        data = _load_json(path) or {}
+        if data.get('accountUuid') == uuid:
+            return path.stem
+
+    return None
+
+
+def _build_slot(cred, cfg, slot: str) -> dict:
+    return {
+        'slot': slot,
+        'label': _dig(cfg, 'oauthAccount', 'emailAddress') or 'unknown',
+        'accountUuid': _dig(cfg, 'oauthAccount', 'accountUuid') or '',
+        'subscriptionType': _dig(cred, 'claudeAiOauth', 'subscriptionType') or 'unknown',
+        'capturedAt': _ts(),
+        'claudeAiOauth': _dig(cred, 'claudeAiOauth'),
+        'oauthAccount': _dig(cfg, 'oauthAccount'),
+    }
+
+
+def _prune_backups(keep: int = 10) -> None:
+    directory = backups_dir()
+    if not directory.is_dir():
+        return
+
+    dirs = sorted(
+        (p for p in directory.iterdir() if p.is_dir()),
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    )
+    for path in dirs[keep:]:
+        shutil.rmtree(path, ignore_errors=True)
+
+
+def cmd_capture(slot: str) -> None:
+    if not _valid_slot(slot):
+        raise AccountError('usage: claude-account capture <slot>  (slot = lowercase letters/digits/-/_)')
+
+    if not shutil.which('claude'):
+        raise AccountError("'claude' CLI not found in PATH")
+
+    _ensure_accounts_dir()
+    booth = Path(tempfile.mkdtemp(prefix='claude-booth.'))
+    try:
+        print(f"== Login booth for slot '{slot}' ==", file=sys.stderr)
+        print('A fresh, isolated Claude Code will open — your host login is NOT touched.', file=sys.stderr)
+        print(f"  1) Log in with the account you want to store in '{slot}'.", file=sys.stderr)
+        print('  2) At the prompt, type /exit (or Ctrl+C) to come back here.', file=sys.stderr)
+        env = dict(os.environ, CLAUDE_CONFIG_DIR=str(booth))
+        subprocess.run(['claude'], env=env)
+        cred = _load_json(booth / '.credentials.json')
+        if not _dig(cred, 'claudeAiOauth', 'accessToken'):
+            raise AccountError('login not completed (no OAuth token captured)')
+
+        cfg = _load_json(booth / '.claude.json')
+        slot_obj = _build_slot(cred, cfg, slot)
+        _atomic_write_json(_slot_path(slot), slot_obj)
+        print(f"captured slot '{slot}': {slot_obj['label']}  [{slot_obj['subscriptionType']}]")
+    finally:
+        shutil.rmtree(booth, ignore_errors=True)
+
+
+def cmd_snapshot(slot: str) -> None:
+    if not _valid_slot(slot):
+        raise AccountError('usage: claude-account snapshot <slot>')
+
+    cred = _load_json(cred_file())
+    if not _dig(cred, 'claudeAiOauth', 'accessToken'):
+        raise AccountError(f"no active credentials at {cred_file()} — log in with 'claude' first")
+
+    cfg = _load_json(config_file())
+    _ensure_accounts_dir()
+    slot_obj = _build_slot(cred, cfg, slot)
+    _atomic_write_json(_slot_path(slot), slot_obj)
+    print(f"snapshotted current host account into slot '{slot}': {slot_obj['label']}")
+
+
+def cmd_status() -> None:
+    _ensure_accounts_dir()
+    cfg = _load_json(config_file())
+    huuid = _dig(cfg, 'oauthAccount', 'accountUuid') or ''
+    hemail = _dig(cfg, 'oauthAccount', 'emailAddress') or ''
+    active = _slot_for_uuid(huuid)
+    print(f"host active account: {hemail or '<none>'}")
+    if huuid and not active:
+        print('  (not captured in any slot — run: claude-account capture <slot>)')
+
+    print()
+    print(f'slots in {accounts_dir()}:')
+    slots = _iter_slots()
+    if not slots:
+        print('  (none yet)')
+
+        return
+
+    for path in slots:
+        data = _load_json(path) or {}
+        mark = '*' if path.stem == active else ' '
+        label = data.get('label', '?')
+        sub = data.get('subscriptionType', '?')
+        at = data.get('capturedAt', '?')
+        print(f'  {mark} {path.stem:<10} {label:<30} [{sub}]  captured {at}')
+
+
+def cmd_apply(target: str) -> None:
+    if not _valid_slot(target):
+        raise AccountError(f"invalid slot name '{target}'")
+
+    tobj = _load_json(_slot_path(target))
+    if tobj is None:
+        raise AccountError(f"slot '{target}' not found (capture it first: claude-account capture {target})")
+
+    cfg = _load_json(config_file())
+    if cfg is None:
+        raise AccountError(f'host config {config_file()} not found')
+
+    tuuid = tobj.get('accountUuid') or ''
+    tlabel = tobj.get('label') or 'unknown'
+    huuid = _dig(cfg, 'oauthAccount', 'accountUuid') or ''
+    if huuid and huuid == tuuid:
+        print(f"already on '{target}' ({tlabel}) — nothing to do")
+
+        return
+
+    _ensure_accounts_dir()
+    cred = _load_json(cred_file())
+
+    if cred is not None:
+        _atomic_write_json(accounts_dir() / '.last-active.json', _build_slot(cred, cfg, '_last-active'))
+
+    cur = _slot_for_uuid(huuid)
+    if cur and cred is not None:
+        _atomic_write_json(_slot_path(cur), _build_slot(cred, cfg, cur))
+        print(f"saved current live tokens back into slot '{cur}'", file=sys.stderr)
+    elif huuid:
+        print(
+            "warning: current host account isn't in any slot; "
+            'its live tokens are only in .last-active.json',
+            file=sys.stderr,
+        )
+
+    bdir = backups_dir() / _ts()
+    bdir.mkdir(parents=True, exist_ok=True)
+    if cred_file().exists():
+        shutil.copy2(cred_file(), bdir / 'credentials.json')
+
+    shutil.copy2(config_file(), bdir / 'claude.json')
+    _prune_backups(keep=10)
+
+    new_cred = cred if isinstance(cred, dict) else {}
+    new_cred['claudeAiOauth'] = tobj.get('claudeAiOauth')
+    _atomic_write_json(cred_file(), new_cred)
+
+    cfg['oauthAccount'] = tobj.get('oauthAccount')
+    _atomic_write_json(config_file(), cfg)
+
+    print(f"switched to '{target}' ({tlabel})")
+    print("restart any running 'claude' session for the change to take effect", file=sys.stderr)
+
+
+def cmd_swap() -> None:
+    slots = _iter_slots()
+    if len(slots) < 2:
+        raise AccountError(
+            f'swap needs 2 captured slots (have {len(slots)}). Run: claude-account capture <slot>'
+        )
+
+    if len(slots) > 2:
+        raise AccountError('more than 2 slots present — pick one: claude-account use <slot>')
+
+    cfg = _load_json(config_file())
+    huuid = _dig(cfg, 'oauthAccount', 'accountUuid') or ''
+    cur = _slot_for_uuid(huuid)
+    if not cur:
+        raise AccountError('current host account matches no slot — pick explicitly: claude-account use <slot>')
+
+    target = next(p.stem for p in slots if p.stem != cur)
+    cmd_apply(target)
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog='claude-account',
+        description='Manually switch between multiple Claude Code accounts (subscriptions).',
+    )
+    parser.add_argument('-V', '--version', action='version', version=f'claude-account {__version__}')
+    sub = parser.add_subparsers(dest='cmd')
+
+    p_capture = sub.add_parser('capture', help='log in (isolated) and store ANOTHER account into <slot>')
+    p_capture.add_argument('slot')
+
+    p_snapshot = sub.add_parser('snapshot', aliases=['save'], help='store the account you are ALREADY logged into')
+    p_snapshot.add_argument('slot')
+
+    sub.add_parser('status', aliases=['st'], help='show the active account and stored slots')
+    sub.add_parser('swap', aliases=['toggle'], help='toggle between the two stored slots')
+
+    p_use = sub.add_parser('use', aliases=['switch'], help='activate a specific slot')
+    p_use.add_argument('slot')
+
+    return parser
+
+
+def main(argv=None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    try:
+        if args.cmd == 'capture':
+            cmd_capture(args.slot)
+        elif args.cmd in ('snapshot', 'save'):
+            cmd_snapshot(args.slot)
+        elif args.cmd in ('status', 'st'):
+            cmd_status()
+        elif args.cmd in ('swap', 'toggle'):
+            cmd_swap()
+        elif args.cmd in ('use', 'switch'):
+            cmd_apply(args.slot)
+        else:
+            parser.print_help(sys.stderr)
+
+            return 1
+    except AccountError as exc:
+        print(f'error: {exc}', file=sys.stderr)
+
+        return 1
+
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

claude_account-0.1.0/tests/test_cli.py

@@ -0,0 +1,104 @@
+import json
+from pathlib import Path
+
+import pytest
+
+from claude_account import cli
+
+
+def _write(path: Path, obj) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(obj))
+
+
+def _load(path: Path):
+    return json.loads(Path(path).read_text())
+
+
+@pytest.fixture
+def f_env(tmp_path, monkeypatch):
+    cred = tmp_path / 'host' / '.claude' / '.credentials.json'
+    cfg = tmp_path / 'host' / '.claude.json'
+    acc = tmp_path / 'accounts'
+    monkeypatch.setenv('CLAUDE_CRED_FILE', str(cred))
+    monkeypatch.setenv('CLAUDE_CONFIG_FILE', str(cfg))
+    monkeypatch.setenv('CLAUDE_ACCOUNTS_DIR', str(acc))
+
+    _write(cred, {
+        'claudeAiOauth': {
+            'accessToken': 'ACCESS-A', 'refreshToken': 'REFRESH-A', 'subscriptionType': 'max',
+        },
+        'mcpOAuth': {'gitlab': {'access_token': 'MCP-SECRET'}},
+    })
+    _write(cfg, {
+        'oauthAccount': {'accountUuid': 'UUID-A', 'emailAddress': 'a@example.com'},
+        'projects': {'/x': {'history': [1, 2, 3]}},
+        'numStartups': 42,
+    })
+    _write(acc / 'primary.json', {
+        'slot': 'primary', 'label': 'a@example.com', 'accountUuid': 'UUID-A',
+        'subscriptionType': 'max', 'capturedAt': 't0',
+        'claudeAiOauth': {'accessToken': 'ACCESS-A', 'refreshToken': 'REFRESH-A', 'subscriptionType': 'max'},
+        'oauthAccount': {'accountUuid': 'UUID-A', 'emailAddress': 'a@example.com'},
+    })
+    _write(acc / 'backup.json', {
+        'slot': 'backup', 'label': 'b@example.com', 'accountUuid': 'UUID-B',
+        'subscriptionType': 'max', 'capturedAt': 't0',
+        'claudeAiOauth': {'accessToken': 'ACCESS-B', 'refreshToken': 'REFRESH-B', 'subscriptionType': 'max'},
+        'oauthAccount': {'accountUuid': 'UUID-B', 'emailAddress': 'b@example.com'},
+    })
+    return {'cred': cred, 'cfg': cfg, 'acc': acc}
+
+
+def test_swap_switches_subscription_and_preserves_the_rest(f_env):
+    host = _load(f_env['cred'])
+    host['claudeAiOauth']['refreshToken'] = 'REFRESH-A-ROTATED'
+    f_env['cred'].write_text(json.dumps(host))
+
+    assert cli.main(['swap']) == 0
+
+    cred = _load(f_env['cred'])
+    assert cred['claudeAiOauth']['accessToken'] == 'ACCESS-B'
+    assert cred['mcpOAuth']['gitlab']['access_token'] == 'MCP-SECRET'
+
+    cfg = _load(f_env['cfg'])
+    assert cfg['oauthAccount']['emailAddress'] == 'b@example.com'
+    assert cfg['projects']['/x']['history'] == [1, 2, 3]
+    assert cfg['numStartups'] == 42
+
+    primary = _load(f_env['acc'] / 'primary.json')
+    assert primary['claudeAiOauth']['refreshToken'] == 'REFRESH-A-ROTATED'
+
+
+def test_status_marks_active_slot(f_env, capsys):
+    assert cli.main(['status']) == 0
+    assert '* primary' in capsys.readouterr().out
+
+
+def test_swap_roundtrip_returns_to_original(f_env):
+    cli.main(['swap'])
+    cli.main(['swap'])
+    assert _load(f_env['cred'])['claudeAiOauth']['accessToken'] == 'ACCESS-A'
+
+
+def test_use_current_slot_is_noop(f_env, capsys):
+    assert cli.main(['use', 'primary']) == 0
+    assert 'already on' in capsys.readouterr().out
+
+
+def test_snapshot_stores_current_host_account(f_env):
+    assert cli.main(['snapshot', 'third']) == 0
+    third = _load(f_env['acc'] / 'third.json')
+    assert third['accountUuid'] == 'UUID-A'
+    assert third['claudeAiOauth']['accessToken'] == 'ACCESS-A'
+
+
+def test_swap_creates_a_backup(f_env):
+    cli.main(['swap'])
+    backups = f_env['acc'] / 'backups'
+    assert backups.is_dir() and any(backups.iterdir())
+
+
+def test_use_unknown_slot_errors(f_env, capsys):
+    assert cli.main(['use', 'nope']) == 1
+    assert 'not found' in capsys.readouterr().err