claude-util 0.1.1__py3-none-any.whl

claude_cli/__init__.py

@@ -0,0 +1,3 @@
+"""CLI tool for managing multiple Claude Code subscription accounts."""
+
+__version__ = "0.1.0"

claude_cli/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m claude_cli."""
+
+from claude_cli.main import app
+
+app()

claude_cli/commands/account.py

@@ -0,0 +1,280 @@
+"""claude-cli account — Account management sub-commands."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from claude_cli.core.account import (
+    add_account,
+    get_account_dir,
+    get_default_account,
+    list_accounts,
+    remove_account,
+    rename_account,
+    set_default_account,
+    setup_symlinks,
+    ensure_shared_dir,
+)
+from claude_cli.core.auth import check_auth_status, trigger_login
+from claude_cli.core.config import ACCOUNTS_DIR, SHARED_DIR, load_config
+from claude_cli.ui import console, error, info, print_detail, print_header, success
+from claude_cli.ui.prompts import confirm, select_account, select_from_list, text_input
+from claude_cli.ui.tables import print_accounts_table
+from claude_cli.utils.completers import complete_account_name, complete_tier
+from claude_cli.utils.formatters import format_date
+from claude_cli.utils.validators import validate_account_name, validate_label
+
+app = typer.Typer(no_args_is_help=True)
+
+TIER_CHOICES = ["pro", "max", "team", "enterprise"]
+
+
+@app.command("list")
+def list_command(
+    output: Optional[str] = typer.Option(None, "--output", "-O", help="Output format: table, json"),
+) -> None:
+    """List all configured accounts."""
+    config = load_config()
+    if not config.accounts:
+        info("No accounts configured. Run 'claude-cli init' to get started.")
+        raise typer.Exit(0)
+
+    if output == "json":
+        import json
+
+        data = {
+            name: {
+                "label": acc.label,
+                "tier": acc.tier,
+                "created_at": acc.created_at.isoformat(),
+                "is_default": name == config.default,
+                "auth_status": check_auth_status(name),
+            }
+            for name, acc in config.accounts.items()
+        }
+        console.print_json(json.dumps(data))
+        return
+
+    auth_statuses = {name: check_auth_status(name) for name in config.accounts}
+    print_accounts_table(config, auth_statuses)
+
+
+@app.command("add")
+def add_command(
+    name: Optional[str] = typer.Argument(None, help="Account name slug"),
+    label: Optional[str] = typer.Option(None, "--label", "-l", help="Display label"),
+    tier: Optional[str] = typer.Option(
+        None, "--tier", "-t", help="Subscription tier", autocompletion=complete_tier
+    ),
+) -> None:
+    """Add a new account profile."""
+    accounts = list_accounts()
+
+    if not name:
+        while True:
+            name = text_input("Account name (slug):")
+            if name is None:
+                raise typer.Exit(130)
+            name = name.strip().lower()
+            if not validate_account_name(name):
+                error("Invalid name. Use lowercase letters, digits, hyphens. Cannot be 'shared'.")
+                continue
+            if name in accounts:
+                error(f"Account '{name}' already exists.")
+                continue
+            break
+    else:
+        if not validate_account_name(name):
+            error("Invalid account name. Use lowercase letters, digits, hyphens.")
+            raise typer.Exit(2)
+        if name in accounts:
+            error(f"Account '{name}' already exists.")
+            raise typer.Exit(2)
+
+    if not label:
+        label = text_input("Display label:")
+        if label is None:
+            raise typer.Exit(130)
+        if not validate_label(label):
+            error("Label cannot be empty.")
+            raise typer.Exit(2)
+
+    if not tier:
+        tier = select_from_list("Subscription tier:", TIER_CHOICES)
+        if tier is None:
+            raise typer.Exit(130)
+
+    if tier not in TIER_CHOICES:
+        error(f"Invalid tier '{tier}'. Choose from: {', '.join(TIER_CHOICES)}")
+        raise typer.Exit(2)
+
+    add_account(name, label, tier)
+
+    console.print("\n  Opening browser for Claude login...")
+    if trigger_login(name):
+        success("Authenticated successfully")
+    else:
+        error("Login failed or claude binary not found on PATH")
+        info(f"You can login later with: claude-cli account login {name}")
+
+    success(f'Account "{name}" created')
+
+
+@app.command("remove")
+def remove_command(
+    name: Optional[str] = typer.Argument(
+        None, help="Account name to remove", autocompletion=complete_account_name
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+) -> None:
+    """Remove an account profile (credentials only, shared files untouched)."""
+    accounts = list_accounts()
+    if not accounts:
+        info("No accounts configured.")
+        raise typer.Exit(0)
+
+    if not name:
+        name = select_account("Select account to remove:")
+        if name is None:
+            raise typer.Exit(130)
+
+    if name not in accounts:
+        error(f"Account '{name}' not found.")
+        raise typer.Exit(4)
+
+    if not yes:
+        console.print(f'\n  [warning]\u26a0 This will remove account "{name}" and its credentials.[/warning]')
+        console.print("  Shared settings, rules, and memory are NOT affected.\n")
+        proceed = confirm("Continue?", default=False)
+        if not proceed:
+            info("Cancelled.")
+            raise typer.Exit(0)
+
+    remove_account(name)
+    success(f'Account "{name}" removed')
+
+
+@app.command("rename")
+def rename_command(
+    old_name: Optional[str] = typer.Argument(
+        None, help="Current account name", autocompletion=complete_account_name
+    ),
+    new_name: Optional[str] = typer.Argument(None, help="New account name"),
+) -> None:
+    """Rename an account slug."""
+    accounts = list_accounts()
+    if not accounts:
+        info("No accounts configured.")
+        raise typer.Exit(0)
+
+    if not old_name:
+        old_name = select_account("Select account to rename:")
+        if old_name is None:
+            raise typer.Exit(130)
+
+    if old_name not in accounts:
+        error(f"Account '{old_name}' not found.")
+        raise typer.Exit(4)
+
+    if not new_name:
+        new_name = text_input("New account name (slug):")
+        if new_name is None:
+            raise typer.Exit(130)
+        new_name = new_name.strip().lower()
+
+    if not validate_account_name(new_name):
+        error("Invalid new name. Use lowercase letters, digits, hyphens.")
+        raise typer.Exit(2)
+    if new_name in accounts:
+        error(f"Account '{new_name}' already exists.")
+        raise typer.Exit(2)
+
+    rename_account(old_name, new_name)
+    success(f"Account renamed: {old_name} \u2192 {new_name}")
+
+
+@app.command("login")
+def login_command(
+    name: Optional[str] = typer.Argument(
+        None, help="Account name (default: active account)", autocompletion=complete_account_name
+    ),
+) -> None:
+    """Re-authenticate (refresh OAuth) for an account."""
+    accounts = list_accounts()
+
+    if not name:
+        # Try default first, otherwise interactive select
+        name = get_default_account()
+        if not name:
+            if not accounts:
+                error("No accounts configured. Run 'claude-cli init' first.")
+                raise typer.Exit(2)
+            name = select_account("Select account to login:")
+            if name is None:
+                raise typer.Exit(130)
+
+    if name not in accounts:
+        error(f"Account '{name}' not found.")
+        raise typer.Exit(4)
+
+    console.print(f"\n  Opening browser for Claude login (account: {name})...")
+    if trigger_login(name):
+        success("Authenticated successfully")
+    else:
+        error("Login failed or claude binary not found on PATH")
+        raise typer.Exit(3)
+
+
+@app.command("current")
+def current_command() -> None:
+    """Show the active account configuration."""
+    config = load_config()
+    default = config.default
+
+    if not default or default not in config.accounts:
+        info("No active account. Run 'claude-cli use <name>' to set one.")
+        raise typer.Exit(0)
+
+    account = config.accounts[default]
+    auth = check_auth_status(default)
+    if auth == "valid":
+        status = "\u2713 logged in"
+    elif auth == "expired":
+        status = "\u2717 expired"
+    else:
+        status = "\u2717 none"
+
+    print_header("Current Account")
+    print_detail("Name", default)
+    print_detail("Label", account.label)
+    print_detail("Tier", account.tier)
+    print_detail("Status", status)
+    print_detail("Config Dir", str(get_account_dir(default)))
+    print_detail("Shared Dir", str(SHARED_DIR))
+    print_detail("Created", format_date(account.created_at))
+
+
+@app.command("repair")
+def repair_command(
+    name: Optional[str] = typer.Argument(
+        None, help="Account name (default: all accounts)", autocompletion=complete_account_name
+    ),
+) -> None:
+    """Repair symlinks for account(s) — re-links shared items like commands, skills, etc."""
+    accounts = list_accounts()
+    if not accounts:
+        info("No accounts configured.")
+        raise typer.Exit(0)
+
+    ensure_shared_dir()
+
+    targets = [name] if name else accounts
+    for acct in targets:
+        if acct not in accounts:
+            error(f"Account '{acct}' not found.")
+            raise typer.Exit(4)
+        account_dir = get_account_dir(acct)
+        setup_symlinks(account_dir)
+        success(f"Repaired symlinks for '{acct}'")

claude_cli/commands/config.py

@@ -0,0 +1,28 @@
+"""claude-cli config — Global CLI configuration."""
+
+from __future__ import annotations
+
+import typer
+
+from claude_cli.core.config import ACCOUNTS_DIR, CONFIG_FILE, SHARED_DIR, load_config
+from claude_cli.ui import console, print_detail, print_header
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command("show")
+def show_command() -> None:
+    """Show global configuration details."""
+    config = load_config()
+    print_header("Global Configuration")
+    print_detail("Config File", str(CONFIG_FILE))
+    print_detail("Shared Dir", str(SHARED_DIR))
+    print_detail("Accounts Dir", str(ACCOUNTS_DIR))
+    print_detail("Default Account", config.default or "none")
+    print_detail("Total Accounts", str(len(config.accounts)))
+
+
+@app.command("path")
+def path_command() -> None:
+    """Print the config file path (useful for scripting)."""
+    console.print(str(CONFIG_FILE))

claude_cli/commands/history.py

@@ -0,0 +1,32 @@
+"""claude-cli history — View command history."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from claude_cli.core.history import clear_history, get_history
+from claude_cli.ui import info, success
+from claude_cli.ui.tables import print_history_table
+
+app = typer.Typer(invoke_without_command=True)
+
+
+@app.callback(invoke_without_command=True)
+def history_command(
+    limit: int = typer.Option(20, "--limit", "-n", help="Number of entries to show"),
+    clear: bool = typer.Option(False, "--clear", help="Clear all history"),
+) -> None:
+    """View CLI command history."""
+    if clear:
+        clear_history()
+        success("History cleared.")
+        return
+
+    entries = get_history(limit=limit)
+    if not entries:
+        info("No command history yet.")
+        raise typer.Exit(0)
+
+    print_history_table(entries)

claude_cli/commands/init.py

@@ -0,0 +1,136 @@
+"""claude-cli init — Interactive setup wizard."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+import typer
+
+from claude_cli.core.account import (
+    add_account,
+    ensure_shared_dir,
+    get_account_dir,
+    migrate_existing_claude_dir,
+    set_default_account,
+)
+from claude_cli.core.auth import trigger_login
+from claude_cli.core.config import config_exists
+from claude_cli.ui import console, error, info, success
+from claude_cli.ui.prompts import confirm, select_from_list, text_input
+from claude_cli.utils.validators import validate_account_name, validate_label
+
+TIER_CHOICES = ["pro", "max", "team", "enterprise"]
+
+
+def init_command() -> None:
+    """Interactive setup wizard — create your first (or next) account."""
+    is_first_run = not config_exists()
+
+    if is_first_run:
+        console.print("\n[bold]Welcome to Claude CLI![/bold]")
+        console.print("  Let's set up your first account.\n")
+    else:
+        console.print("\n[bold]Adding a new Claude account profile...[/bold]\n")
+
+    # Migration offer on first run
+    if is_first_run:
+        claude_dir = Path.home() / ".claude"
+        if claude_dir.exists():
+            console.print(f"  Existing Claude config found at [highlight]{claude_dir}[/highlight]\n")
+            migrate = confirm("Migrate existing config to claude-cli?", default=True)
+            if migrate is None:
+                raise typer.Exit(130)
+            if migrate:
+                creds_path = migrate_existing_claude_dir()
+                success("Shared files moved to ~/.claude-cli/shared/")
+                success("Backup saved to ~/.claude.bak/")
+                console.print()
+
+                # Prompt for account name for existing credentials
+                name = _prompt_account_name()
+                label = _prompt_label()
+                tier = _prompt_tier()
+
+                account_dir = add_account(name, label, tier)
+
+                # Move existing credentials into the account
+                if creds_path and creds_path.exists():
+                    shutil.move(str(creds_path), str(account_dir / ".credentials.json"))
+                    success(f'Account "{name}" created from existing config')
+                else:
+                    info("No existing credentials found. Logging in...")
+                    if not trigger_login(name):
+                        error("Login failed or claude binary not found")
+
+                set_default_account(name)
+                success("Set as default")
+
+                # Offer to add another
+                console.print()
+                another = confirm("Add another account now?", default=False)
+                if another:
+                    _add_new_account()
+                return
+
+    # Normal flow: add a new account
+    ensure_shared_dir()
+    _add_new_account()
+
+    # On first run, auto-set as default
+    if is_first_run:
+        return
+
+    set_as_default = confirm("Set as default account?", default=True)
+    if set_as_default is None:
+        raise typer.Exit(130)
+
+
+def _add_new_account() -> None:
+    """Prompt for account details and create it."""
+    name = _prompt_account_name()
+    label = _prompt_label()
+    tier = _prompt_tier()
+
+    add_account(name, label, tier)
+
+    console.print("\n  Opening browser for Claude login...")
+    if trigger_login(name):
+        success("Authenticated successfully")
+    else:
+        error("Login failed or claude binary not found on PATH")
+        info("You can login later with: claude-cli account login " + name)
+
+    set_default_account(name)
+    success(f'Account "{name}" created and set as default')
+
+
+def _prompt_account_name() -> str:
+    """Prompt for a valid account name slug."""
+    while True:
+        name = text_input("Account name (slug):")
+        if name is None:
+            raise typer.Exit(130)
+        name = name.strip().lower()
+        if validate_account_name(name):
+            return name
+        error("Invalid name. Use lowercase letters, digits, hyphens. Cannot be 'shared'.")
+
+
+def _prompt_label() -> str:
+    """Prompt for an account display label."""
+    while True:
+        label = text_input("Display label:")
+        if label is None:
+            raise typer.Exit(130)
+        if validate_label(label):
+            return label.strip()
+        error("Label cannot be empty.")
+
+
+def _prompt_tier() -> str:
+    """Prompt for subscription tier."""
+    tier = select_from_list("Subscription tier:", TIER_CHOICES)
+    if tier is None:
+        raise typer.Exit(130)
+    return tier

claude_cli/commands/run.py

@@ -0,0 +1,78 @@
+"""claude-cli run — Launch Claude Code with account selection."""
+
+from __future__ import annotations
+
+import os
+import shutil
+from typing import Optional
+
+import typer
+
+from claude_cli.core.account import get_account_dir, get_default_account, list_accounts
+from claude_cli.ui import error, info
+from claude_cli.ui.prompts import select_account
+from claude_cli.utils.completers import complete_account_name
+
+
+def _launch(name: str, args: list[str]) -> None:
+    """Exec into claude with the given account's config dir."""
+    accounts = list_accounts()
+    if name not in accounts:
+        error(f"Account '{name}' not found.")
+        raise typer.Exit(4)
+
+    claude_bin = shutil.which("claude")
+    if not claude_bin:
+        error("'claude' binary not found on PATH.")
+        info("Install Claude Code first: https://docs.anthropic.com/en/docs/claude-code")
+        raise typer.Exit(1)
+
+    account_dir = get_account_dir(name)
+    env = os.environ.copy()
+    env["CLAUDE_CONFIG_DIR"] = str(account_dir)
+    os.execvpe(claude_bin, [claude_bin] + args, env)
+
+
+def quick_run_command(
+    args: Optional[list[str]] = typer.Argument(None, help="Arguments passed through to claude"),
+) -> None:
+    """Launch Claude Code with the current default account (no prompt)."""
+    accounts = list_accounts()
+    if not accounts:
+        error("No accounts configured. Run 'claude-cli init' first.")
+        raise typer.Exit(2)
+
+    name = get_default_account()
+    if not name:
+        error("No default account set. Run 'claude-cli use <name>' or 'claude-cli run'.")
+        raise typer.Exit(2)
+
+    _launch(name, list(args) if args else [])
+
+
+def run_command(
+    ctx: typer.Context,
+    account: Optional[str] = typer.Option(
+        None, "--account", "-a",
+        help="Account to use (skip interactive prompt)",
+        autocompletion=complete_account_name,
+    ),
+    args: Optional[list[str]] = typer.Argument(None, help="Arguments passed through to claude"),
+) -> None:
+    """Launch Claude Code — interactively select account (or use -a to specify)."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    accounts = list_accounts()
+    if not accounts:
+        error("No accounts configured. Run 'claude-cli init' first.")
+        raise typer.Exit(2)
+
+    if account:
+        name = account
+    else:
+        name = select_account("Select account:", default=get_default_account())
+        if name is None:
+            raise typer.Exit(130)
+
+    _launch(name, list(args) if args else [])

claude_cli/commands/status.py

@@ -0,0 +1,44 @@
+"""claude-cli status — Dashboard overview of all accounts."""
+
+from __future__ import annotations
+
+import typer
+
+from claude_cli.core.auth import check_auth_status
+from claude_cli.core.config import SHARED_DIR, load_config
+from claude_cli.ui import console, info
+from claude_cli.ui.tables import print_status_table
+
+
+def status_command() -> None:
+    """Quick overview of all accounts — a dashboard view."""
+    config = load_config()
+
+    if not config.accounts:
+        info("No accounts configured. Run 'claude-cli init' to get started.")
+        raise typer.Exit(0)
+
+    auth_statuses = {name: check_auth_status(name) for name in config.accounts}
+    print_status_table(config, auth_statuses)
+
+    # Summary line
+    active = config.default or "none"
+    total = len(config.accounts)
+    console.print(f"  Active: [bold]{active}[/bold] | {total} account(s) configured")
+
+    # Shared files check
+    shared_items = {
+        "settings": SHARED_DIR / "settings.json",
+        "rules": SHARED_DIR / "rules",
+        "agents": SHARED_DIR / "agents",
+        "MCP": SHARED_DIR / ".claude.json",
+    }
+    checks = []
+    for label, path in shared_items.items():
+        marker = "\u2713" if path.exists() else "\u2717"
+        checks.append(f"{label} {marker}")
+    console.print(f"  Shared: {' '.join(checks)}", style="dim")
+
+    console.print()
+    console.print('  Run "claude-cli use <name>" to switch.', style="dim")
+    console.print('  Run "claude-cli account login <name>" to re-authenticate.', style="dim")

claude_cli/commands/usage.py

@@ -0,0 +1,80 @@
+"""claude-cli usage — View usage information."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from claude_cli.core.account import get_default_account, list_accounts
+from claude_cli.core.usage import get_all_usage_info, get_usage_info, open_usage_page
+from claude_cli.ui import console, error, info
+from claude_cli.ui.prompts import select_account
+from claude_cli.ui.tables import print_usage_detail, print_usage_summary_table
+from claude_cli.utils.completers import complete_account_name
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command("show")
+def show_command(
+    name: Optional[str] = typer.Argument(
+        None, help="Account name", autocompletion=complete_account_name
+    ),
+    all_accounts: bool = typer.Option(False, "--all", "-a", help="Show all accounts"),
+    output: Optional[str] = typer.Option(None, "--output", "-O", help="Output format: table, json"),
+) -> None:
+    """Show usage for one or all accounts."""
+    if all_accounts:
+        usage_list = get_all_usage_info()
+        if not usage_list:
+            info("No accounts configured.")
+            raise typer.Exit(0)
+
+        if output == "json":
+            import json
+
+            data = [u.model_dump(mode="json") for u in usage_list]
+            console.print_json(json.dumps(data))
+            return
+
+        print_usage_summary_table(usage_list)
+        return
+
+    # Single account
+    if not name:
+        name = get_default_account()
+        if not name:
+            accounts = list_accounts()
+            if not accounts:
+                error("No accounts configured.")
+                raise typer.Exit(2)
+            name = select_account("Select account:")
+            if name is None:
+                raise typer.Exit(130)
+
+    accounts = list_accounts()
+    if name not in accounts:
+        error(f"Account '{name}' not found.")
+        raise typer.Exit(4)
+
+    usage = get_usage_info(name)
+
+    if output == "json":
+        import json
+
+        console.print_json(json.dumps(usage.model_dump(mode="json")))
+        return
+
+    print_usage_detail(usage)
+
+
+@app.command("open")
+def open_command(
+    name: Optional[str] = typer.Argument(
+        None, help="Account name", autocompletion=complete_account_name
+    ),
+) -> None:
+    """Open the Claude usage page in the browser."""
+    open_usage_page()
+    info("Opened Claude usage page in browser.")