hac-client-cli 0.1.0__py3-none-any.whl

hac_client_cli/commands_env.py

@@ -0,0 +1,219 @@
+"""Environment management commands."""
+
+import sys
+import json
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+
+from hac_client_cli.environment_manager import EnvironmentManager
+
+env_app = typer.Typer(help="Manage HAC environments", no_args_is_help=True)
+console = Console()
+
+
+@env_app.command("list")
+def list_environments(
+    format: str = typer.Option("table", "--format", "-f", help="Output format: table, json"),
+    no_headers: bool = typer.Option(False, "--no-headers", help="Suppress column headers"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Minimal output (names only)")
+):
+    """List all configured environments."""
+    try:
+        manager = EnvironmentManager()
+        environments = manager.list_environments()
+        default = manager.get_default_environment()
+        
+        if not environments:
+            if format != "json":
+                console.print("[yellow]No environments configured[/yellow]")
+                console.print("\nAdd an environment with endpoints:")
+                console.print("  hac env add local")
+                console.print("  hac endpoint add local hac --url https://localhost:9002")
+            else:
+                print("[]")
+            return
+        
+        # JSON output
+        if format == "json":
+            output = [
+                {
+                    "name": env.name,
+                    "endpoints": {
+                        ep_name: {
+                            "url": ep.url,
+                            "ignore_ssl": ep.ignore_ssl,
+                            "timeout": ep.timeout
+                        }
+                        for ep_name, ep in env.endpoints.items()
+                    },
+                    "default_endpoint": env.default_endpoint,
+                    "is_default": env.name == default
+                }
+                for env in environments
+            ]
+            print(json.dumps(output, indent=2))
+            return
+        
+        # Quiet output (names only)
+        if quiet:
+            for env in environments:
+                print(env.name)
+            return
+        
+        # Table format (default)
+        table = Table(show_header=not no_headers)
+        table.add_column("NAME", style="cyan")
+        table.add_column("ENDPOINTS", justify="right")
+        table.add_column("DEFAULT-ENDPOINT")
+        table.add_column("DEFAULT", justify="center")
+        
+        for env in environments:
+            default_marker = "✓" if env.name == default else ""
+            endpoint_count = str(len(env.endpoints))
+            default_ep = env.default_endpoint or "-"
+            
+            table.add_row(
+                env.name,
+                endpoint_count,
+                default_ep,
+                default_marker
+            )
+        
+        console.print(table)
+    
+    except Exception as e:
+        console.print(f"[red]ERROR: {e}[/red]", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+@env_app.command("show")
+def show_environment(
+    name: str = typer.Argument(..., help="Environment name"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON")
+):
+    """Show details of a specific environment with all endpoints."""
+    try:
+        manager = EnvironmentManager()
+        env = manager.get_environment(name)
+        
+        if not env:
+            print(f"ERROR: Environment '{name}' not found", file=sys.stderr)
+            raise typer.Exit(1)
+        
+        default = manager.get_default_environment()
+        
+        if json_output:
+            output = {
+                "name": env.name,
+                "endpoints": {
+                    ep_name: {
+                        "url": ep.url,
+                        "username": ep.username,
+                        "ignore_ssl": ep.ignore_ssl,
+                        "timeout": ep.timeout
+                    }
+                    for ep_name, ep in env.endpoints.items()
+                },
+                "default_endpoint": env.default_endpoint,
+                "is_default": env.name == default
+            }
+            print(json.dumps(output, indent=2))
+        else:
+            marker = " (default)" if env.name == default else ""
+            print(f"Environment: {env.name}{marker}")
+            print()
+            
+            if not env.endpoints:
+                print("  No endpoints configured")
+                print(f"\n  Add an endpoint: hac endpoint add {env.name} hac --url https://...")
+            else:
+                print(f"  Endpoints ({len(env.endpoints)}):")
+                print()
+                for ep_name, ep in sorted(env.endpoints.items()):
+                    default_marker = " (default)" if ep_name == env.default_endpoint else ""
+                    print(f"    {ep_name}{default_marker}")
+                    print(f"      URL:        {ep.url}")
+                    print(f"      Ignore SSL: {ep.ignore_ssl}")
+                    print(f"      Timeout:    {ep.timeout}s")
+                    print()
+                
+                if env.default_endpoint:
+                    print(f"  Start session: hac session start {env.name} --username <user>")
+                else:
+                    print(f"  Start session: hac session start {env.name} --endpoint <endpoint-name> --username <user>")
+    
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+@env_app.command("add")
+def add_environment(
+    name: str = typer.Argument(..., help="Environment name"),
+    set_default: bool = typer.Option(False, "--set-default", "-d", help="Set as default environment")
+):
+    """Add a new environment (add endpoints separately with 'hac endpoint add')."""
+    try:
+        manager = EnvironmentManager()
+        manager.add_environment(
+            name=name,
+            set_default=set_default
+        )
+        
+        marker = " (set as default)" if set_default else ""
+        print(f"✓ Environment '{name}' added{marker}")
+        print(f"\nNext: Add endpoints to this environment")
+        print(f"  hac endpoint add {name} <endpoint-name> --url https://...")
+    
+    except ValueError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+
+
+@env_app.command("remove")
+def remove_environment(
+    name: str = typer.Argument(..., help="Environment name")
+):
+    """Remove an environment."""
+    try:
+        manager = EnvironmentManager()
+        
+        if not manager.get_environment(name):
+            print(f"ERROR: Environment '{name}' not found", file=sys.stderr)
+            raise typer.Exit(1)
+        
+        manager.remove_environment(name)
+        print(f"✓ Environment '{name}' removed")
+    
+    except ValueError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+@env_app.command("set-default")
+def set_default(
+    name: str = typer.Argument(..., help="Environment name")
+):
+    """Set the default environment."""
+    try:
+        manager = EnvironmentManager()
+        manager.set_default_environment(name)
+        print(f"✓ Default environment set to '{name}'")
+    
+    except ValueError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+

hac_client_cli/commands_session.py

@@ -0,0 +1,417 @@
+"""Session management commands."""
+
+import sys
+import json
+import os
+import typer
+from typing import Optional
+from datetime import timedelta
+from rich.console import Console
+from rich.table import Table
+
+from hac_client_core.session import SessionManager
+from hac_client_core.client import HacClient
+from hac_client_core.auth import BasicAuthHandler
+
+session_app = typer.Typer(help="Manage HAC sessions", no_args_is_help=True)
+console = Console()
+
+
+def format_duration(seconds: float) -> str:
+    """Format duration in human-readable format."""
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        return f"{int(seconds/60)}m {int(seconds%60)}s"
+    else:
+        hours = int(seconds / 3600)
+        minutes = int((seconds % 3600) / 60)
+        return f"{hours}h {minutes}m"
+
+
+@session_app.command("start")
+def start_session(
+    environment: str = typer.Argument(..., help="Environment name"),
+    endpoint: Optional[str] = typer.Option(None, "--endpoint", "-n", help="Endpoint name (uses default if not specified)"),
+    username: Optional[str] = typer.Option(None, "--username", "-u", help="Username (or use env var)"),
+    password: Optional[str] = typer.Option(None, "--password", "-p", help="Password (or use stdin/env var)")
+):
+    """Start a new HAC session (authenticate and create session).
+    
+    Username can be provided via:
+    - Command option: --username <user>
+    - Environment variable: HAC_USERNAME or HAC_USERNAME_<ENV>_<ENDPOINT>
+    - Interactive prompt: if not provided
+    
+    Password can be provided via:
+    - Command option: --password <pass> (not recommended)
+    - Environment variable: HAC_PASSWORD or HAC_PASSWORD_<ENV>_<ENDPOINT>
+    - Standard input: echo 'password' | hac session start <env> --username <user>
+    - Interactive prompt: if none of the above
+    
+    Examples:
+        hac session start local --username admin
+        hac session start local --endpoint hac --username admin
+        HAC_USERNAME=admin HAC_PASSWORD=secret hac session start local
+        echo 'secret' | hac session start local --username admin
+    """
+    try:
+        from hac_client_cli.config_loader import get_endpoint_config
+        
+        # Get endpoint configuration
+        env_name, endpoint_name, ep_config = get_endpoint_config(environment, endpoint)
+        
+        # Create session identifier
+        session_id = f"{env_name}/{endpoint_name}"
+        
+        # Get username from various sources
+        if not username:
+            # Try environment variable (specific to env/endpoint, then env, then generic)
+            env_ep_var = f"HAC_USERNAME_{env_name.upper()}_{endpoint_name.upper()}"
+            env_var = f"HAC_USERNAME_{env_name.upper()}"
+            username = os.environ.get(env_ep_var) or os.environ.get(env_var) or os.environ.get("HAC_USERNAME")
+        
+        if not username:
+            print("ERROR: Username not provided", file=sys.stderr)
+            print("\nProvide username via:", file=sys.stderr)
+            print(f"  --username <user>", file=sys.stderr)
+            print(f"  HAC_USERNAME environment variable", file=sys.stderr)
+            print(f"  HAC_USERNAME_{env_name.upper()}_{endpoint_name.upper()} environment variable", file=sys.stderr)
+            raise typer.Exit(1)
+        
+        # Get password from various sources
+        if not password:
+            # Try environment variable (specific to env/endpoint, then env, then generic)
+            env_ep_var = f"HAC_PASSWORD_{env_name.upper()}_{endpoint_name.upper()}"
+            env_var = f"HAC_PASSWORD_{env_name.upper()}"
+            password = os.environ.get(env_ep_var) or os.environ.get(env_var) or os.environ.get("HAC_PASSWORD")
+        
+        if not password:
+            # Try stdin (non-interactive)
+            if not sys.stdin.isatty():
+                password = sys.stdin.read().strip()
+        
+        if not password:
+            print("ERROR: Password not provided", file=sys.stderr)
+            print("\nProvide password via:", file=sys.stderr)
+            print(f"  HAC_PASSWORD environment variable", file=sys.stderr)
+            print(f"  HAC_PASSWORD_{env_name.upper()}_{endpoint_name.upper()} environment variable", file=sys.stderr)
+            print(f"  stdin: echo 'password' | hac session start {env_name} --endpoint {endpoint_name} --username {username}", file=sys.stderr)
+            raise typer.Exit(1)
+        
+        try:
+            # Create client and authenticate
+            auth = BasicAuthHandler(username, password)
+            client = HacClient(
+                base_url=ep_config.url,
+                auth_handler=auth,
+                environment=session_id,  # Use composite key
+                timeout=ep_config.timeout,
+                ignore_ssl=ep_config.ignore_ssl,
+                session_persistence=True,
+                quiet=False
+            )
+            
+            # Force login to create session
+            client.login()
+            
+            print(f"✓ Session started for '{session_id}'")
+            print(f"  User: {username}")
+            print(f"  URL: {ep_config.url}")
+        
+        finally:
+            # Clear password from memory immediately
+            if password:
+                password = None
+                del password
+    
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+@session_app.command("import")
+def import_session(
+    environment: str = typer.Argument(..., help="Environment name"),
+    endpoint: Optional[str] = typer.Option(None, "--endpoint", "-n", help="Endpoint name (uses default if not specified)"),
+    username: Optional[str] = typer.Option(None, "--username", "-u", help="Username (or use env var)"),
+    session_id: Optional[str] = typer.Option(None, "--session-id", help="Session ID (JSESSIONID)"),
+    csrf_token: Optional[str] = typer.Option(None, "--csrf-token", help="CSRF token"),
+    route_cookie: Optional[str] = typer.Option(None, "--route-cookie", help="ROUTE cookie (optional)")
+):
+    """Import an existing HAC session from tokens.
+    
+    Username can be provided via:
+    - Command option: --username <user>
+    - Environment variable: HAC_USERNAME or HAC_USERNAME_<ENV>_<ENDPOINT>
+    
+    Tokens can be provided via:
+    - Command options (not recommended for security)
+    - Environment variables:
+      - HAC_SESSION_ID or HAC_SESSION_ID_<ENV>_<ENDPOINT>
+      - HAC_CSRF_TOKEN or HAC_CSRF_TOKEN_<ENV>_<ENDPOINT>
+      - HAC_ROUTE_COOKIE or HAC_ROUTE_COOKIE_<ENV>_<ENDPOINT>
+    - Standard input (JSON format with username, session_id, csrf_token fields)
+    
+    Examples:
+        # Via environment variables
+        HAC_USERNAME=admin HAC_SESSION_ID=abc123 HAC_CSRF_TOKEN=def456 hac session import local
+        
+        # Via stdin (JSON)
+        echo '{"username":"admin","session_id":"abc","csrf_token":"def"}' | hac session import local --endpoint hac
+        
+        # Via command options
+        hac session import local --endpoint hac --username admin --session-id abc123 --csrf-token def456
+    """
+    try:
+        from hac_client_cli.config_loader import get_endpoint_config
+        
+        # Get endpoint configuration
+        env_name, endpoint_name, ep_config = get_endpoint_config(environment, endpoint)
+        
+        # Create session identifier
+        sess_id = f"{env_name}/{endpoint_name}"
+        
+        # Get username from various sources
+        if not username:
+            # Try environment variables
+            env_ep_var = f"HAC_USERNAME_{env_name.upper()}_{endpoint_name.upper()}"
+            env_var = f"HAC_USERNAME_{env_name.upper()}"
+            username = os.environ.get(env_ep_var) or os.environ.get(env_var) or os.environ.get("HAC_USERNAME")
+        
+        # Get tokens from various sources
+        if not session_id or not csrf_token or not username:
+            # Try stdin (JSON)
+            if not sys.stdin.isatty():
+                import json
+                data = json.load(sys.stdin)
+                username = username or data.get("username")
+                session_id = session_id or data.get("session_id")
+                csrf_token = csrf_token or data.get("csrf_token")
+                route_cookie = route_cookie or data.get("route_cookie")
+        
+        if not session_id or not csrf_token:
+            # Try environment variables
+            env_ep_prefix = f"{env_name.upper()}_{endpoint_name.upper()}"
+            env_prefix = env_name.upper()
+            session_id = session_id or os.environ.get(f"HAC_SESSION_ID_{env_ep_prefix}") or os.environ.get(f"HAC_SESSION_ID_{env_prefix}") or os.environ.get("HAC_SESSION_ID")
+            csrf_token = csrf_token or os.environ.get(f"HAC_CSRF_TOKEN_{env_ep_prefix}") or os.environ.get(f"HAC_CSRF_TOKEN_{env_prefix}") or os.environ.get("HAC_CSRF_TOKEN")
+            route_cookie = route_cookie or os.environ.get(f"HAC_ROUTE_COOKIE_{env_ep_prefix}") or os.environ.get(f"HAC_ROUTE_COOKIE_{env_prefix}") or os.environ.get("HAC_ROUTE_COOKIE")
+        
+        if not username:
+            print("ERROR: Username not provided", file=sys.stderr)
+            print("Provide via --username, HAC_USERNAME env var, or stdin (JSON)", file=sys.stderr)
+            raise typer.Exit(1)
+        
+        if not session_id:
+            print("ERROR: Session ID not provided", file=sys.stderr)
+            print("Provide via --session-id, HAC_SESSION_ID env var, or stdin (JSON)", file=sys.stderr)
+            raise typer.Exit(1)
+        
+        if not csrf_token:
+            print("ERROR: CSRF token not provided", file=sys.stderr)
+            print("Provide via --csrf-token, HAC_CSRF_TOKEN env var, or stdin (JSON)", file=sys.stderr)
+            raise typer.Exit(1)
+        
+        # Import session
+        session_manager = SessionManager()
+        session_manager.save_session(
+            base_url=ep_config.url,
+            username=username,
+            environment=sess_id,  # Use composite key
+            session_id=session_id,
+            csrf_token=csrf_token,
+            route_cookie=route_cookie
+        )
+        
+        print(f"✓ Session imported for '{sess_id}'")
+        print(f"  User: {username}")
+        print(f"  URL: {ep_config.url}")
+        print(f"  Session ID: {session_id[:16]}...")
+    
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+@session_app.command("list")
+def list_sessions(
+    format: str = typer.Option("table", "--format", "-f", help="Output format: table, json"),
+    no_headers: bool = typer.Option(False, "--no-headers", help="Suppress column headers"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Minimal output (environment IDs only)")
+):
+    """List all active sessions."""
+    try:
+        manager = SessionManager()
+        sessions = manager.list_sessions()
+        
+        if not sessions:
+            if format != "json":
+                console.print("[yellow]No active sessions[/yellow]")
+                console.print("\nCreate a session: hac session start <environment> --username <user>")
+            else:
+                print("[]")
+            return
+        
+        # JSON output
+        if format == "json":
+            output = [
+                {
+                    "environment": s.environment,
+                    "url": s.base_url,
+                    "username": s.username,
+                    "session_id": s.session_id[:16] + "...",
+                    "created_at": s.created_at_formatted,
+                    "last_used_at": s.last_used_at_formatted,
+                    "age_seconds": s.age_seconds,
+                    "idle_seconds": s.idle_seconds,
+                    "is_authenticated": s.is_authenticated
+                }
+                for s in sessions
+            ]
+            print(json.dumps(output, indent=2))
+            return
+        
+        # Quiet output (environment IDs only)
+        if quiet:
+            for s in sessions:
+                print(s.environment)
+            return
+        
+        # Table format (default)
+        table = Table(show_header=not no_headers)
+        table.add_column("ENVIRONMENT", style="cyan")
+        table.add_column("USERNAME")
+        table.add_column("URL")
+        table.add_column("AUTH", justify="center")
+        table.add_column("AGE", justify="right")
+        table.add_column("IDLE", justify="right")
+        
+        for s in sessions:
+            age = format_duration(s.age_seconds)
+            idle = format_duration(s.idle_seconds)
+            auth_marker = "[green]✓[/green]" if s.is_authenticated else "[red]✗[/red]"
+            
+            table.add_row(
+                s.environment,
+                s.username,
+                s.base_url,
+                auth_marker,
+                age,
+                idle
+            )
+        
+        console.print(table)
+    
+    except Exception as e:
+        console.print(f"[red]ERROR: {e}[/red]", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+@session_app.command("show")
+def show_session(
+    environment: str = typer.Argument(..., help="Environment name"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON")
+):
+    """Show details of a specific session."""
+    try:
+        from hac_client_cli.environment_manager import EnvironmentManager
+        
+        env_manager = EnvironmentManager()
+        env = env_manager.get_environment(environment)
+        
+        if not env:
+            print(f"ERROR: Environment '{environment}' not found", file=sys.stderr)
+            raise typer.Exit(1)
+        
+        session_manager = SessionManager()
+        session = session_manager.load_session(env.url, env.username, environment)
+        
+        if not session:
+            print(f"No active session for environment '{environment}'")
+            return
+        
+        if json_output:
+            output = {
+                "environment": session.environment,
+                "url": session.base_url,
+                "username": session.username,
+                "session_id": session.session_id,
+                "csrf_token": session.csrf_token[:16] + "...",
+                "route_cookie": session.route_cookie,
+                "created_at": session.created_at_formatted,
+                "last_used_at": session.last_used_at_formatted,
+                "age_seconds": session.age_seconds,
+                "idle_seconds": session.idle_seconds,
+                "is_authenticated": session.is_authenticated
+            }
+            print(json.dumps(output, indent=2))
+        else:
+            age = format_duration(session.age_seconds)
+            idle = format_duration(session.idle_seconds)
+            auth_marker = "✓ authenticated" if session.is_authenticated else "✗ not authenticated"
+            
+            print(f"Session: {session.environment}")
+            print(f"  URL: {session.base_url}")
+            print(f"  Username: {session.username}")
+            print(f"  Status: {auth_marker}")
+            print(f"  Session ID: {session.session_id}")
+            print(f"  CSRF Token: {session.csrf_token[:32]}...")
+            if session.route_cookie:
+                print(f"  Route Cookie: {session.route_cookie}")
+            print(f"\n  Created: {session.created_at_formatted}")
+            print(f"  Last used: {session.last_used_at_formatted}")
+            print(f"  Age: {age}")
+            print(f"  Idle: {idle}")
+    
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+@session_app.command("clear")
+def clear_session(
+    environment: str = typer.Argument(..., help="Environment name")
+):
+    """Clear session for a specific environment."""
+    try:
+        from hac_client_cli.environment_manager import EnvironmentManager
+        
+        env_manager = EnvironmentManager()
+        env = env_manager.get_environment(environment)
+        
+        if not env:
+            print(f"ERROR: Environment '{environment}' not found", file=sys.stderr)
+            raise typer.Exit(1)
+        
+        session_manager = SessionManager()
+        session_manager.remove_session(env.url, env.username, environment)
+        
+        print(f"✓ Session cleared for environment '{environment}'")
+    
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+
+@session_app.command("clear-all")
+def clear_all_sessions(
+    force: bool = typer.Option(False, "--force", "-f", help="Force without confirmation")
+):
+    """Clear all sessions."""
+    try:
+        if not force:
+            confirm = typer.confirm("Clear all sessions?")
+            if not confirm:
+                print("Cancelled")
+                return
+        
+        session_manager = SessionManager()
+        count = session_manager.clear_all_sessions()
+        
+        print(f"✓ Cleared {count} session(s)")
+    
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+