pragmatiks-cli 0.5.1__py3-none-any.whl → 0.12.5__py3-none-any.whl

pragma_cli/commands/auth.py

@@ -5,20 +5,46 @@ import webbrowser
 from http.server import BaseHTTPRequestHandler, HTTPServer
 from urllib.parse import parse_qs, urlparse
 
+import httpx
 import typer
+from pragma_sdk import PragmaClient
 from pragma_sdk.config import load_credentials
 from rich import print
+from rich.console import Console
 
-from pragma_cli.config import CREDENTIALS_FILE, get_current_context, load_config
+from pragma_cli.config import CREDENTIALS_FILE, ContextConfig, get_current_context, load_config
+
+
+console = Console()
 
 
 app = typer.Typer()
 
 CALLBACK_PORT = int(os.getenv("PRAGMA_AUTH_CALLBACK_PORT", "8765"))
 CALLBACK_PATH = os.getenv("PRAGMA_AUTH_CALLBACK_PATH", "/auth/callback")
-CLERK_FRONTEND_URL = os.getenv("PRAGMA_CLERK_FRONTEND_URL", "https://app.pragmatiks.io")
-CALLBACK_URL = f"http://localhost:{CALLBACK_PORT}{CALLBACK_PATH}"
-LOGIN_URL = f"{CLERK_FRONTEND_URL}/auth/callback?callback={CALLBACK_URL}"
+
+
+def _get_callback_url() -> str:
+    """Build the local callback URL for OAuth flow.
+
+    Returns:
+        Callback URL for the local OAuth server.
+    """
+    return f"http://localhost:{CALLBACK_PORT}{CALLBACK_PATH}"
+
+
+def _get_login_url(context_config: ContextConfig) -> str:
+    """Build the login URL for a given context.
+
+    Args:
+        context_config: The context configuration to get auth URL from.
+
+    Returns:
+        Full login URL with callback parameter.
+    """
+    auth_url = context_config.get_auth_url()
+    callback_url = _get_callback_url()
+    return f"{auth_url}/auth/callback?callback={callback_url}"
 
 
 class CallbackHandler(BaseHTTPRequestHandler):
@@ -136,41 +162,50 @@ def clear_credentials(context_name: str | None = None):
 
 
 @app.command()
-def login(context: str = typer.Option("default", help="Context to authenticate for")):
+def login(
+    context: str | None = typer.Option(None, help="Context to authenticate for (default: current)"),
+):
     """Authenticate with Pragma using browser-based Clerk login.
 
     Opens your default browser to Clerk authentication page. After successful
     login, your credentials are stored locally in ~/.config/pragma/credentials.
 
     Example:
-        pragma login
-        pragma login --context production
+        pragma auth login
+        pragma auth login --context production
 
     Raises:
         typer.Exit: If context not found or authentication fails/times out.
     """
     config = load_config()
+
+    # Use current context if not specified
+    if context is None:
+        context = config.current_context
+
     if context not in config.contexts:
         print(f"[red]\u2717[/red] Context '{context}' not found")
         print(f"Available contexts: {', '.join(config.contexts.keys())}")
         raise typer.Exit(1)
 
-    api_url = config.contexts[context].api_url
+    context_config = config.contexts[context]
+    auth_url = context_config.get_auth_url()
+    login_url = _get_login_url(context_config)
 
     print(f"[cyan]Authenticating for context:[/cyan] {context}")
-    print(f"[cyan]API URL:[/cyan] {api_url}")
+    print(f"[cyan]API URL:[/cyan] {context_config.api_url}")
     print()
 
     server = HTTPServer(("localhost", CALLBACK_PORT), CallbackHandler)
 
-    print(f"[yellow]Opening browser to:[/yellow] {CLERK_FRONTEND_URL}")
+    print(f"[yellow]Opening browser to:[/yellow] {auth_url}")
     print()
     print("[dim]If browser doesn't open automatically, visit:[/dim]")
-    print(f"[dim]{LOGIN_URL}[/dim]")
+    print(f"[dim]{login_url}[/dim]")
     print()
     print("[yellow]Waiting for authentication...[/yellow]")
 
-    webbrowser.open(LOGIN_URL)
+    webbrowser.open(login_url)
 
     server.timeout = 300
     server.handle_request()
@@ -218,30 +253,49 @@ def logout(
 
 @app.command()
 def whoami():
-    """Show current authentication status.
+    """Show current authentication status and user information.
 
-    Displays which contexts have stored credentials and current authentication state.
+    Displays the current context, authentication state, and user details
+    including email and organization name from the API.
     """
-    config = load_config()
-    current_context_name, _ = get_current_context()
+    current_context_name, current_context_config = get_current_context()
+    token = load_credentials(current_context_name)
+
+    console.print()
+    console.print("[bold]Authentication Status[/bold]")
+    console.print()
+
+    if not token:
+        console.print(f"  Context: [cyan]{current_context_name}[/cyan]")
+        console.print("  Status:  [yellow]Not authenticated[/yellow]")
+        console.print()
+        console.print("[dim]Run 'pragma auth login' to authenticate[/dim]")
+        return
 
-    print()
-    print("[bold]Authentication Status[/bold]")
-    print()
+    console.print(f"  Context: [cyan]{current_context_name}[/cyan]")
+    console.print("  Status:  [green]\u2713 Authenticated[/green]")
 
-    has_any_creds = False
-    for context_name in config.contexts.keys():
-        token = load_credentials(context_name)
-        marker = "[green]*[/green]" if context_name == current_context_name else " "
+    try:
+        client = PragmaClient(base_url=current_context_config.api_url, auth_token=token)
+        user_info = client.get_me()
 
-        if token:
-            has_any_creds = True
-            print(f"{marker} [cyan]{context_name}[/cyan]: [green]\u2713 Authenticated[/green]")
+        console.print()
+        console.print("[bold]User Information[/bold]")
+        console.print()
+        console.print(f"  User ID:      [cyan]{user_info.user_id}[/cyan]")
+        if user_info.email:
+            console.print(f"  Email:        [cyan]{user_info.email}[/cyan]")
         else:
-            print(f"{marker} [cyan]{context_name}[/cyan]: [dim]Not authenticated[/dim]")
+            console.print("  Email:        [dim]Not set[/dim]")
+        console.print(f"  Organization: [cyan]{user_info.organization_name or user_info.organization_id}[/cyan]")
 
-    print()
-
-    if not has_any_creds:
-        print("[yellow]No stored credentials found[/yellow]")
-        print("[dim]Run 'pragma login' to authenticate[/dim]")
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 401:
+            console.print()
+            console.print("[yellow]Token expired or invalid. Run 'pragma auth login' to re-authenticate.[/yellow]")
+        else:
+            console.print()
+            console.print(f"[red]Error fetching user info:[/red] {e.response.text}")
+    except httpx.RequestError as e:
+        console.print()
+        console.print(f"[red]Connection error:[/red] {e}")

pragma_cli/commands/completions.py

@@ -1,10 +1,77 @@
-"""CLI auto-completion functions for resource operations."""
+"""CLI auto-completion functions for resource and provider operations."""
 
 from __future__ import annotations
 
 import typer
+from pragma_sdk import PragmaClient
 
-from pragma_cli import get_client
+from pragma_cli.config import get_current_context
+
+
+def _get_completion_client() -> PragmaClient | None:
+    """Get a client for shell completion context.
+
+    Returns:
+        PragmaClient instance or None if configuration unavailable.
+    """
+    try:
+        context_name, context_config = get_current_context()
+        if context_config is None:
+            return None
+        return PragmaClient(
+            base_url=context_config.api_url,
+            context=context_name,
+            require_auth=False,
+        )
+    except Exception:
+        return None
+
+
+def completion_provider_ids(incomplete: str):
+    """Complete provider identifiers based on deployed providers.
+
+    Args:
+        incomplete: Partial input to complete against available providers.
+
+    Yields:
+        Provider IDs matching the incomplete input.
+    """
+    client = _get_completion_client()
+    if client is None:
+        return
+    try:
+        providers = client.list_providers()
+    except Exception:
+        return
+
+    for provider in providers:
+        if provider.provider_id.lower().startswith(incomplete.lower()):
+            yield provider.provider_id
+
+
+def completion_provider_versions(ctx: typer.Context, incomplete: str):
+    """Complete provider versions based on available builds.
+
+    Args:
+        ctx: Typer context containing parsed parameters including provider_id.
+        incomplete: Partial input to complete against available versions.
+
+    Yields:
+        Version strings matching the incomplete input.
+    """
+    client = _get_completion_client()
+    if client is None:
+        return
+    provider_id = ctx.params.get("provider_id")
+    if not provider_id:
+        return
+    try:
+        builds = client.list_builds(provider_id)
+    except Exception:
+        return
+    for build in builds:
+        if build.version.startswith(incomplete):
+            yield build.version
 
 
 def completion_resource_ids(incomplete: str):
@@ -16,7 +83,9 @@ def completion_resource_ids(incomplete: str):
     Yields:
         Resource identifiers matching the incomplete input.
     """
-    client = get_client()
+    client = _get_completion_client()
+    if client is None:
+        return
     try:
         resources = client.list_resources()
     except Exception:
@@ -40,7 +109,9 @@ def completion_resource_names(ctx: typer.Context, incomplete: str):
     Yields:
         Resource names matching the incomplete input for the selected resource type.
     """
-    client = get_client()
+    client = _get_completion_client()
+    if client is None:
+        return
     resource_id = ctx.params.get("resource_id")
     if not resource_id or "/" not in resource_id:
         return

pragma_cli/commands/config.py

@@ -44,18 +44,25 @@ def current_context():
     context_name, context_config = get_current_context()
     print(f"[bold]Current context:[/bold] [cyan]{context_name}[/cyan]")
     print(f"[bold]API URL:[/bold] {context_config.api_url}")
+    print(f"[bold]Auth URL:[/bold] {context_config.get_auth_url()}")
 
 
 @app.command()
 def set_context(
     name: str = typer.Argument(..., help="Context name"),
     api_url: str = typer.Option(..., help="API endpoint URL"),
+    auth_url: str | None = typer.Option(None, help="Auth endpoint URL (derived from api_url if not set)"),
 ):
     """Create or update a context."""
     config = load_config()
-    config.contexts[name] = ContextConfig(api_url=api_url)
+    config.contexts[name] = ContextConfig(api_url=api_url, auth_url=auth_url)
     save_config(config)
+
+    # Show the effective auth URL
+    effective_auth = config.contexts[name].get_auth_url()
     print(f"[green]\u2713[/green] Context '{name}' configured")
+    print(f"  API URL:  {api_url}")
+    print(f"  Auth URL: {effective_auth}")
 
 
 @app.command()