router-maestro 0.1.2__py3-none-any.whl

router_maestro/cli/client.py

@@ -0,0 +1,322 @@
+"""Admin client for CLI operations.
+
+All CLI commands use HTTP API to communicate with the server.
+This ensures consistent behavior between local and remote contexts.
+"""
+
+import httpx
+
+from router_maestro.config import load_contexts_config
+
+
+class AdminClientError(Exception):
+    """Error from admin client operations."""
+
+    pass
+
+
+class ServerNotRunningError(AdminClientError):
+    """Server is not running."""
+
+    def __init__(self, endpoint: str) -> None:
+        self.endpoint = endpoint
+        super().__init__(
+            f"Server is not running at {endpoint}. Start it with: router-maestro server start"
+        )
+
+
+class AdminClient:
+    """HTTP client for server admin operations.
+
+    All operations go through the HTTP API, ensuring consistent behavior
+    whether connecting to a local or remote server.
+    """
+
+    def __init__(self, endpoint: str, api_key: str | None) -> None:
+        self.endpoint = endpoint.rstrip("/")
+        self.api_key = api_key
+
+    def _get_headers(self) -> dict[str, str]:
+        """Get headers for API requests."""
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+    def _handle_connection_error(self, e: Exception) -> None:
+        """Handle connection errors with helpful messages."""
+        if isinstance(e, httpx.ConnectError):
+            raise ServerNotRunningError(self.endpoint) from e
+        raise AdminClientError(f"Request failed: {e}") from e
+
+    async def list_auth(self) -> list[dict]:
+        """List authenticated providers.
+
+        Returns:
+            List of dicts with provider, auth_type, status
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    f"{self.endpoint}/api/admin/auth",
+                    headers=self._get_headers(),
+                )
+                response.raise_for_status()
+                data = response.json()
+                return data.get("providers", [])
+        except httpx.HTTPError as e:
+            self._handle_connection_error(e)
+            return []  # unreachable, for type checker
+
+    async def login_oauth(self, provider: str) -> dict:
+        """Initiate OAuth login.
+
+        Args:
+            provider: Provider name (e.g., 'github-copilot')
+
+        Returns:
+            Dict with session_id, user_code, verification_uri, expires_in
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    f"{self.endpoint}/api/admin/auth/login",
+                    headers=self._get_headers(),
+                    json={"provider": provider},
+                )
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPError as e:
+            self._handle_connection_error(e)
+            return {}
+
+    async def login_api_key(self, provider: str, api_key: str) -> bool:
+        """Login with API key.
+
+        Args:
+            provider: Provider name
+            api_key: API key
+
+        Returns:
+            True if successful
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    f"{self.endpoint}/api/admin/auth/login",
+                    headers=self._get_headers(),
+                    json={"provider": provider, "api_key": api_key},
+                )
+                response.raise_for_status()
+                data = response.json()
+                return data.get("success", False)
+        except httpx.HTTPError as e:
+            self._handle_connection_error(e)
+            return False
+
+    async def logout(self, provider: str) -> bool:
+        """Logout from a provider.
+
+        Args:
+            provider: Provider name
+
+        Returns:
+            True if successful
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.delete(
+                    f"{self.endpoint}/api/admin/auth/{provider}",
+                    headers=self._get_headers(),
+                )
+                if response.status_code == 404:
+                    return False
+                response.raise_for_status()
+                data = response.json()
+                return data.get("success", False)
+        except httpx.HTTPError as e:
+            self._handle_connection_error(e)
+            return False
+
+    async def poll_oauth_status(self, session_id: str) -> dict:
+        """Poll OAuth session status.
+
+        Args:
+            session_id: Session ID from login_oauth
+
+        Returns:
+            Dict with status ('pending', 'complete', 'expired', 'error') and optional error
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    f"{self.endpoint}/api/admin/auth/oauth/status/{session_id}",
+                    headers=self._get_headers(),
+                )
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPError as e:
+            self._handle_connection_error(e)
+            return {}
+
+    async def list_models(self) -> list[dict]:
+        """List available models.
+
+        Returns:
+            List of dicts with provider, id, name
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    f"{self.endpoint}/api/admin/models",
+                    headers=self._get_headers(),
+                )
+                response.raise_for_status()
+                data = response.json()
+                return data.get("models", [])
+        except httpx.HTTPError as e:
+            self._handle_connection_error(e)
+            return []
+
+    async def refresh_models(self) -> bool:
+        """Refresh the models cache on the server.
+
+        Returns:
+            True if successful
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    f"{self.endpoint}/api/admin/models/refresh",
+                    headers=self._get_headers(),
+                )
+                response.raise_for_status()
+                return True
+        except httpx.HTTPError as e:
+            self._handle_connection_error(e)
+            return False
+
+    async def get_priorities(self) -> dict:
+        """Get priority configuration.
+
+        Returns:
+            Dict with priorities list and fallback config
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    f"{self.endpoint}/api/admin/priorities",
+                    headers=self._get_headers(),
+                )
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPError as e:
+            self._handle_connection_error(e)
+            return {}
+
+    async def set_priorities(self, priorities: list[str], fallback: dict | None = None) -> bool:
+        """Set priority configuration.
+
+        Args:
+            priorities: List of model keys (provider/model)
+            fallback: Optional fallback configuration
+
+        Returns:
+            True if successful
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                payload: dict = {"priorities": priorities}
+                if fallback is not None:
+                    payload["fallback"] = fallback
+
+                response = await client.put(
+                    f"{self.endpoint}/api/admin/priorities",
+                    headers=self._get_headers(),
+                    json=payload,
+                )
+                response.raise_for_status()
+                return True
+        except httpx.HTTPError as e:
+            self._handle_connection_error(e)
+            return False
+
+    async def get_stats(
+        self, days: int = 7, provider: str | None = None, model: str | None = None
+    ) -> dict:
+        """Get usage statistics.
+
+        Args:
+            days: Number of days to query
+            provider: Optional provider filter
+            model: Optional model filter
+
+        Returns:
+            Stats dict with total_requests, total_tokens, by_provider, by_model
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                params: dict = {"days": days}
+                if provider:
+                    params["provider"] = provider
+                if model:
+                    params["model"] = model
+
+                response = await client.get(
+                    f"{self.endpoint}/api/admin/stats",
+                    headers=self._get_headers(),
+                    params=params,
+                )
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPError as e:
+            self._handle_connection_error(e)
+            return {}
+
+    async def test_connection(self) -> dict:
+        """Test connection to the server.
+
+        Returns:
+            Dict with server info (name, version, status)
+
+        Raises:
+            ServerNotRunningError: If server is not running
+        """
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get(
+                    f"{self.endpoint}/",
+                    headers=self._get_headers(),
+                )
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPError as e:
+            self._handle_connection_error(e)
+            return {}
+
+
+def get_admin_client() -> AdminClient:
+    """Get admin client for current context.
+
+    Returns:
+        AdminClient configured with current context's endpoint and API key
+    """
+    config = load_contexts_config()
+    ctx = config.contexts.get(config.current)
+
+    if not ctx:
+        # Fallback to default local endpoint
+        return AdminClient("http://localhost:8080", None)
+
+    return AdminClient(ctx.endpoint, ctx.api_key)
+
+
+def get_current_endpoint() -> str:
+    """Get the endpoint for the current context.
+
+    Returns:
+        The endpoint URL
+    """
+    config = load_contexts_config()
+    ctx = config.contexts.get(config.current)
+    return ctx.endpoint if ctx else "http://localhost:8080"

router_maestro/cli/config.py

@@ -0,0 +1,132 @@
+"""Configuration management commands."""
+
+import asyncio
+import json
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from router_maestro.cli.client import ServerNotRunningError, get_admin_client
+from router_maestro.config.server import get_current_context_api_key
+
+app = typer.Typer(no_args_is_help=True)
+console = Console()
+
+
+def get_claude_code_paths() -> dict[str, Path]:
+    """Get Claude Code settings paths."""
+    return {
+        "user": Path.home() / ".claude" / "settings.json",
+        "project": Path.cwd() / ".claude" / "settings.json",
+    }
+
+
+@app.command(name="claude-code")
+def claude_code_config() -> None:
+    """Generate Claude Code CLI settings.json for router-maestro."""
+    # Step 1: Select level
+    console.print("\n[bold]Step 1: Select configuration level[/bold]")
+    console.print("  1. User-level (~/.claude/settings.json)")
+    console.print("  2. Project-level (./.claude/settings.json)")
+    choice = Prompt.ask("Select", choices=["1", "2"], default="1")
+
+    paths = get_claude_code_paths()
+    level = "user" if choice == "1" else "project"
+    settings_path = paths[level]
+
+    # Step 2: Backup if exists
+    if settings_path.exists():
+        console.print(f"\n[yellow]settings.json already exists at {settings_path}[/yellow]")
+        if Confirm.ask("Backup existing file?", default=True):
+            backup_path = settings_path.with_suffix(
+                f".json.backup.{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            )
+            shutil.copy(settings_path, backup_path)
+            console.print(f"[green]Backed up to {backup_path}[/green]")
+
+    # Step 3 & 4: Select models from server
+    try:
+        client = get_admin_client()
+        models = asyncio.run(client.list_models())
+    except ServerNotRunningError as e:
+        console.print(f"[red]{e}[/red]")
+        console.print("[dim]Tip: Start router-maestro server first.[/dim]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+    if not models:
+        console.print("[red]No models available. Please authenticate first.[/red]")
+        raise typer.Exit(1)
+
+    # Display models
+    console.print("\n[bold]Available models:[/bold]")
+    table = Table()
+    table.add_column("#", style="dim")
+    table.add_column("Model Key", style="green")
+    table.add_column("Name", style="white")
+    for i, model in enumerate(models, 1):
+        table.add_row(str(i), f"{model['provider']}/{model['id']}", model["name"])
+    console.print(table)
+
+    # Select main model
+    console.print("\n[bold]Step 3: Select main model[/bold]")
+    main_choice = Prompt.ask("Enter number (or 0 for auto-routing)", default="0")
+    main_model = "router-maestro"
+    if main_choice != "0" and main_choice.isdigit():
+        idx = int(main_choice) - 1
+        if 0 <= idx < len(models):
+            m = models[idx]
+            main_model = f"{m['provider']}/{m['id']}"
+
+    # Select fast model
+    console.print("\n[bold]Step 4: Select small/fast model[/bold]")
+    fast_choice = Prompt.ask("Enter number", default="1")
+    fast_model = "router-maestro"
+    if fast_choice.isdigit():
+        idx = int(fast_choice) - 1
+        if 0 <= idx < len(models):
+            m = models[idx]
+            fast_model = f"{m['provider']}/{m['id']}"
+
+    # Step 5: Generate config
+    auth_token = get_current_context_api_key() or "router-maestro"
+    client = get_admin_client()
+    base_url = (
+        client.endpoint.rstrip("/") if hasattr(client, "endpoint") else "http://localhost:8080"
+    )
+    anthropic_url = f"{base_url}/api/anthropic"
+
+    config = {
+        "env": {
+            "ANTHROPIC_BASE_URL": anthropic_url,
+            "ANTHROPIC_AUTH_TOKEN": auth_token,
+            "ANTHROPIC_MODEL": main_model,
+            "ANTHROPIC_SMALL_FAST_MODEL": fast_model,
+            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
+        }
+    }
+
+    settings_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(settings_path, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)
+
+    console.print(
+        Panel(
+            f"[green]Created {settings_path}[/green]\n\n"
+            f"Main model: {main_model}\n"
+            f"Fast model: {fast_model}\n\n"
+            f"Endpoint: {anthropic_url}\n\n"
+            "[dim]Start router-maestro server before using Claude Code:[/dim]\n"
+            "  router-maestro server start",
+            title="Success",
+            border_style="green",
+        )
+    )

router_maestro/cli/context.py

@@ -0,0 +1,146 @@
+"""Context management commands for remote deployments."""
+
+import asyncio
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from router_maestro.cli.client import AdminClientError, get_admin_client
+from router_maestro.config import (
+    ContextConfig,
+    load_contexts_config,
+    save_contexts_config,
+)
+
+app = typer.Typer(no_args_is_help=True)
+console = Console()
+
+
+@app.command(name="list")
+def list_contexts() -> None:
+    """List all configured contexts."""
+    config = load_contexts_config()
+
+    if not config.contexts:
+        console.print("[dim]No contexts configured.[/dim]")
+        return
+
+    table = Table(title="Deployment Contexts")
+    table.add_column("Name", style="cyan")
+    table.add_column("Endpoint", style="green")
+    table.add_column("API Key", style="yellow")
+    table.add_column("Current", style="magenta")
+
+    for name, ctx in config.contexts.items():
+        is_current = "✓" if name == config.current else ""
+        api_key_display = "****" if ctx.api_key else "-"
+        table.add_row(name, ctx.endpoint, api_key_display, is_current)
+
+    console.print(table)
+
+
+@app.command(name="set")
+def set_context(
+    name: str = typer.Argument(..., help="Context name to switch to"),
+) -> None:
+    """Switch to a different context."""
+    config = load_contexts_config()
+
+    if name not in config.contexts:
+        console.print(f"[red]Context '{name}' not found[/red]")
+        console.print(f"[dim]Available: {', '.join(config.contexts.keys())}[/dim]")
+        raise typer.Exit(1)
+
+    config.current = name
+    save_contexts_config(config)
+    console.print(f"[green]Switched to context: {name}[/green]")
+    console.print(f"  Endpoint: {config.contexts[name].endpoint}")
+
+
+@app.command()
+def add(
+    name: str = typer.Argument(..., help="Name for the new context"),
+    endpoint: str = typer.Option(..., "--endpoint", "-e", help="API endpoint URL"),
+    api_key: str = typer.Option(None, "--api-key", "-k", help="API key (optional)"),
+) -> None:
+    """Add a new context."""
+    config = load_contexts_config()
+
+    if name in config.contexts:
+        console.print(f"[yellow]Context '{name}' already exists. Overwriting...[/yellow]")
+
+    config.contexts[name] = ContextConfig(endpoint=endpoint, api_key=api_key)
+    save_contexts_config(config)
+
+    console.print(f"[green]Added context: {name}[/green]")
+    console.print(f"  Endpoint: {endpoint}")
+    if api_key:
+        console.print("  API Key: ****")
+
+
+@app.command()
+def remove(
+    name: str = typer.Argument(..., help="Context name to remove"),
+) -> None:
+    """Remove a context."""
+    config = load_contexts_config()
+
+    if name not in config.contexts:
+        console.print(f"[red]Context '{name}' not found[/red]")
+        raise typer.Exit(1)
+
+    if name == "local":
+        console.print("[red]Cannot remove the 'local' context[/red]")
+        raise typer.Exit(1)
+
+    if name == config.current:
+        console.print("[yellow]Switching to 'local' context first...[/yellow]")
+        config.current = "local"
+
+    del config.contexts[name]
+    save_contexts_config(config)
+    console.print(f"[green]Removed context: {name}[/green]")
+
+
+@app.command()
+def current() -> None:
+    """Show the current context."""
+    config = load_contexts_config()
+    ctx = config.contexts.get(config.current)
+
+    if ctx:
+        console.print(f"[bold]Current context:[/bold] {config.current}")
+        console.print(f"  Endpoint: {ctx.endpoint}")
+        if ctx.api_key:
+            console.print("  API Key: ****")
+    else:
+        console.print("[yellow]No context selected[/yellow]")
+
+
+@app.command()
+def test() -> None:
+    """Test connection to the current context's server."""
+    config = load_contexts_config()
+    ctx = config.contexts.get(config.current)
+
+    if not ctx:
+        console.print("[red]No context selected[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"[bold]Testing connection to:[/bold] {config.current}")
+    console.print(f"  Endpoint: {ctx.endpoint}")
+
+    client = get_admin_client()
+
+    try:
+        result = asyncio.run(client.test_connection())
+        console.print("\n[green]✓ Connection successful![/green]")
+        console.print(f"  Server: {result.get('name', 'Unknown')}")
+        console.print(f"  Version: {result.get('version', 'Unknown')}")
+    except AdminClientError as e:
+        console.print(f"\n[red]✗ {e}[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"\n[red]✗ Connection failed: {e}[/red]")
+        raise typer.Exit(1)

router_maestro/cli/main.py

@@ -0,0 +1,42 @@
+"""Router-Maestro CLI application."""
+
+import typer
+from rich.console import Console
+
+from router_maestro import __version__
+
+app = typer.Typer(
+    name="router-maestro",
+    help="Multi-model routing and load balancing system with OpenAI-compatible API",
+    no_args_is_help=True,
+)
+
+console = Console()
+
+# Import and register sub-commands
+from router_maestro.cli import auth, config, context, model, server, stats  # noqa: E402
+
+app.add_typer(server.app, name="server", help="Manage the API server")
+app.add_typer(auth.app, name="auth", help="Manage authentication for providers")
+app.add_typer(model.app, name="model", help="Manage models and priorities")
+app.add_typer(context.app, name="context", help="Manage deployment contexts")
+app.add_typer(config.app, name="config", help="Manage configuration")
+app.command(name="stats")(stats.stats)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", "-v", help="Show version and exit"),
+) -> None:
+    """Router-Maestro: Multi-model routing and load balancing system."""
+    if version:
+        console.print(f"router-maestro version {__version__}")
+        raise typer.Exit()
+
+    if ctx.invoked_subcommand is None:
+        console.print("[yellow]Use --help for usage information[/yellow]")
+
+
+if __name__ == "__main__":
+    app()