bt-cli 0.4.13__py3-none-any.whl

bt_cli/epmw/commands/quick.py

@@ -0,0 +1,348 @@
+"""Quick commands for EPM Windows - combine multiple API calls into single operations."""
+
+from datetime import datetime, timezone
+from typing import Optional
+import json
+
+import httpx
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ...core.output import print_api_error, print_error, print_warning, print_success
+
+app = typer.Typer(no_args_is_help=True, help="Quick commands - common multi-step operations in one command")
+console = Console()
+
+
+@app.command("stale")
+def stale_computers(
+    hours: int = typer.Option(24, "--hours", "-h", help="Hours since last checkin (default: 24)"),
+    group: Optional[str] = typer.Option(None, "--group", "-g", help="Filter by group name (partial match)"),
+    delete: bool = typer.Option(False, "--delete", help="Delete stale computers after listing"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation when deleting"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table or json"),
+) -> None:
+    """Find computers that haven't checked in recently.
+
+    Shows computers that haven't connected in the specified number of hours.
+    Optionally filter by group name. Use --delete to remove stale computers.
+
+    Examples:
+        bt epmw quick stale                          # Not checked in for 24+ hours
+        bt epmw quick stale --hours 48               # Not checked in for 48+ hours
+        bt epmw quick stale -h 12 -g "Workstations"  # Workstations not seen for 12+ hours
+        bt epmw quick stale -o json                  # JSON output for scripting
+        bt epmw quick stale --hours 72 --delete      # Delete computers not seen for 72+ hours
+        bt epmw quick stale --delete --force         # Delete without confirmation
+    """
+    from ..client import get_client
+
+    try:
+        client = get_client()
+
+        console.print(f"[dim]Finding computers not seen in {hours}+ hours...[/dim]")
+        computers = client.list_computers()
+
+        now = datetime.now(timezone.utc)
+        stale_computers = []
+
+        for comp in computers:
+            # Parse last connected time
+            last_connected_str = comp.get("lastConnected")
+            if not last_connected_str:
+                # Never connected - consider stale
+                stale_computers.append(comp)
+                continue
+
+            try:
+                # Parse ISO format datetime
+                last_connected = datetime.fromisoformat(last_connected_str.replace("Z", "+00:00"))
+                hours_since = (now - last_connected).total_seconds() / 3600
+
+                if hours_since >= hours:
+                    comp["_hours_since"] = round(hours_since, 1)
+                    stale_computers.append(comp)
+            except (ValueError, TypeError):
+                # Can't parse date - include it
+                comp["_hours_since"] = None
+                stale_computers.append(comp)
+
+        # Filter by group if specified
+        if group:
+            group_lower = group.lower()
+            stale_computers = [
+                c for c in stale_computers
+                if group_lower in (c.get("groupName") or "").lower()
+            ]
+
+        if output == "json":
+            # Clean up internal field for JSON output
+            for comp in stale_computers:
+                if "_hours_since" in comp:
+                    comp["hoursSinceLastCheckin"] = comp.pop("_hours_since")
+            console.print_json(json.dumps(stale_computers, default=str))
+        else:
+            if stale_computers:
+                title = f"Computers not seen in {hours}+ hours"
+                if group:
+                    title += f" (group: {group})"
+
+                table = Table(title=title)
+                table.add_column("Host", style="cyan")
+                table.add_column("Domain", style="yellow")
+                table.add_column("Group", style="green")
+                table.add_column("Hours Since", style="red", justify="right")
+                table.add_column("Last Connected", style="dim")
+                table.add_column("Status", style="magenta")
+
+                for comp in stale_computers:
+                    hours_since = comp.get("_hours_since")
+                    hours_display = f"{hours_since:.1f}" if hours_since is not None else "N/A"
+
+                    last_connected = comp.get("lastConnected", "Never")
+                    if last_connected and last_connected != "Never":
+                        # Format to readable date
+                        try:
+                            dt = datetime.fromisoformat(last_connected.replace("Z", "+00:00"))
+                            last_connected = dt.strftime("%Y-%m-%d %H:%M")
+                        except (ValueError, TypeError):
+                            pass
+
+                    table.add_row(
+                        comp.get("host", ""),
+                        comp.get("domain", "") or "-",
+                        comp.get("groupName", "") or "-",
+                        hours_display,
+                        last_connected,
+                        comp.get("connectionStatus", ""),
+                    )
+
+                console.print(table)
+                console.print(f"\n[dim]Total: {len(stale_computers)} computer(s)[/dim]")
+
+                # Delete stale computers if requested
+                if delete and stale_computers:
+                    console.print()
+                    if not force:
+                        confirm = typer.confirm(
+                            f"Delete {len(stale_computers)} stale computer(s)?"
+                        )
+                        if not confirm:
+                            console.print("[yellow]Deletion cancelled.[/yellow]")
+                            raise typer.Exit(0)
+
+                    console.print("[dim]Deleting stale computers...[/dim]")
+                    deleted_count = 0
+                    failed_count = 0
+                    for comp in stale_computers:
+                        comp_id = comp.get("id")
+                        comp_host = comp.get("host", "Unknown")
+                        try:
+                            client.delete_computer(comp_id)
+                            console.print(f"  [green]Deleted:[/green] {comp_host}")
+                            deleted_count += 1
+                        except Exception as e:
+                            console.print(f"  [red]Failed:[/red] {comp_host} - {e}")
+                            failed_count += 1
+
+                    console.print()
+                    print_success(f"Deleted {deleted_count} computer(s)")
+                    if failed_count > 0:
+                        print_warning(f"Failed to delete {failed_count} computer(s)")
+            else:
+                msg = f"All computers have checked in within the last {hours} hours"
+                if group:
+                    msg += f" (in group matching '{group}')"
+                console.print(f"[green]{msg}[/green]")
+
+    except httpx.HTTPStatusError as e:
+        print_api_error(e, "quick stale")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        print_api_error(e, "quick stale")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_api_error(e, "quick stale")
+        raise typer.Exit(1)
+
+
+@app.command("disconnected")
+def disconnected_computers(
+    group: Optional[str] = typer.Option(None, "--group", "-g", help="Filter by group name (partial match)"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table or json"),
+) -> None:
+    """Find computers with disconnected status.
+
+    Shows all computers that are currently marked as disconnected.
+
+    Examples:
+        bt epmw quick disconnected
+        bt epmw quick disconnected -g "Servers"
+        bt epmw quick disconnected -o json
+    """
+    from ..client import get_client
+
+    try:
+        client = get_client()
+
+        console.print("[dim]Finding disconnected computers...[/dim]")
+        computers = client.list_computers()
+
+        # Filter to disconnected status
+        disconnected = [
+            c for c in computers
+            if c.get("connectionStatus", "").lower() == "disconnected"
+        ]
+
+        # Filter by group if specified
+        if group:
+            group_lower = group.lower()
+            disconnected = [
+                c for c in disconnected
+                if group_lower in (c.get("groupName") or "").lower()
+            ]
+
+        if output == "json":
+            console.print_json(json.dumps(disconnected, default=str))
+        else:
+            if disconnected:
+                title = "Disconnected Computers"
+                if group:
+                    title += f" (group: {group})"
+
+                table = Table(title=title)
+                table.add_column("Host", style="cyan")
+                table.add_column("Domain", style="yellow")
+                table.add_column("Group", style="green")
+                table.add_column("Days Disconnected", style="red", justify="right")
+                table.add_column("Last Connected", style="dim")
+
+                for comp in disconnected:
+                    days_disc = comp.get("daysDisconnected", 0)
+
+                    last_connected = comp.get("lastConnected", "Never")
+                    if last_connected and last_connected != "Never":
+                        try:
+                            dt = datetime.fromisoformat(last_connected.replace("Z", "+00:00"))
+                            last_connected = dt.strftime("%Y-%m-%d %H:%M")
+                        except (ValueError, TypeError):
+                            pass
+
+                    table.add_row(
+                        comp.get("host", ""),
+                        comp.get("domain", "") or "-",
+                        comp.get("groupName", "") or "-",
+                        str(days_disc),
+                        last_connected,
+                    )
+
+                console.print(table)
+                console.print(f"\n[dim]Total: {len(disconnected)} computer(s)[/dim]")
+            else:
+                msg = "No disconnected computers found"
+                if group:
+                    msg += f" in group matching '{group}'"
+                console.print(f"[green]{msg}[/green]")
+
+    except httpx.HTTPStatusError as e:
+        print_api_error(e, "quick disconnected")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        print_api_error(e, "quick disconnected")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_api_error(e, "quick disconnected")
+        raise typer.Exit(1)
+
+
+@app.command("status")
+def group_status(
+    group: Optional[str] = typer.Option(None, "--group", "-g", help="Filter by group name (partial match)"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table or json"),
+) -> None:
+    """Show computer status summary by group.
+
+    Displays counts of connected/disconnected computers per group.
+
+    Examples:
+        bt epmw quick status
+        bt epmw quick status -g "Datacenter"
+        bt epmw quick status -o json
+    """
+    from ..client import get_client
+
+    try:
+        client = get_client()
+
+        console.print("[dim]Getting computer status by group...[/dim]")
+        computers = client.list_computers()
+
+        # Filter by group if specified
+        if group:
+            group_lower = group.lower()
+            computers = [
+                c for c in computers
+                if group_lower in (c.get("groupName") or "").lower()
+            ]
+
+        # Group by group name
+        groups: dict = {}
+        for comp in computers:
+            group_name = comp.get("groupName") or "(No Group)"
+            if group_name not in groups:
+                groups[group_name] = {"connected": 0, "disconnected": 0, "total": 0}
+
+            groups[group_name]["total"] += 1
+            status = comp.get("connectionStatus", "").lower()
+            if status == "connected":
+                groups[group_name]["connected"] += 1
+            else:
+                groups[group_name]["disconnected"] += 1
+
+        if output == "json":
+            console.print_json(json.dumps(groups, default=str))
+        else:
+            if groups:
+                table = Table(title="Computer Status by Group")
+                table.add_column("Group", style="cyan")
+                table.add_column("Connected", style="green", justify="right")
+                table.add_column("Disconnected", style="red", justify="right")
+                table.add_column("Total", style="bold", justify="right")
+
+                total_connected = 0
+                total_disconnected = 0
+                total_all = 0
+
+                for group_name, counts in sorted(groups.items()):
+                    table.add_row(
+                        group_name,
+                        str(counts["connected"]),
+                        str(counts["disconnected"]),
+                        str(counts["total"]),
+                    )
+                    total_connected += counts["connected"]
+                    total_disconnected += counts["disconnected"]
+                    total_all += counts["total"]
+
+                # Add totals row
+                table.add_row(
+                    "[bold]TOTAL[/bold]",
+                    f"[bold green]{total_connected}[/bold green]",
+                    f"[bold red]{total_disconnected}[/bold red]",
+                    f"[bold]{total_all}[/bold]",
+                )
+
+                console.print(table)
+            else:
+                console.print("[yellow]No computers found[/yellow]")
+
+    except httpx.HTTPStatusError as e:
+        print_api_error(e, "quick status")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        print_api_error(e, "quick status")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_api_error(e, "quick status")
+        raise typer.Exit(1)

bt_cli/epmw/commands/requests.py

@@ -0,0 +1,224 @@
+"""EPMW admin access request commands."""
+
+from typing import Optional
+
+import httpx
+import typer
+
+from bt_cli.core.output import OutputFormat, print_api_error, print_json, print_table
+
+app = typer.Typer(no_args_is_help=True, help="Admin access requests")
+
+
+@app.command("list")
+def list_requests(
+    output: OutputFormat = typer.Option(
+        OutputFormat.TABLE, "--output", "-o", help="Output format"
+    ),
+):
+    """List admin access requests."""
+    from bt_cli.epmw.client import get_client
+
+    try:
+        client = get_client()
+        requests = client.list_admin_requests()
+
+        if output == OutputFormat.JSON:
+            print_json(requests)
+        else:
+            # Flatten the nested structure for table display
+            rows = []
+            for req in requests:
+                info = req.get("requestInfo", {})
+                decision = req.get("accessDecision", {})
+                rows.append({
+                    "ticketId": info.get("ticketId"),
+                    "userName": info.get("userName"),
+                    "reason": info.get("reason", "")[:50],
+                    "status": decision.get("status"),
+                    "duration": decision.get("duration"),
+                    "requestId": info.get("requestId"),
+                })
+            columns = [
+                ("Ticket", "ticketId"),
+                ("Request ID", "requestId"),
+                ("User", "userName"),
+                ("Reason", "reason"),
+                ("Status", "status"),
+                ("Duration", "duration"),
+            ]
+            print_table(rows, columns, title="Admin Access Requests (use Request ID for approve/deny)")
+    except httpx.HTTPStatusError as e:
+        print_api_error(e, "list requests")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        print_api_error(e, "list requests")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_api_error(e, "list requests")
+        raise typer.Exit(1)
+
+
+@app.command("get")
+def get_request(
+    request_id: str = typer.Argument(..., help="Request ID"),
+    output: OutputFormat = typer.Option(
+        OutputFormat.JSON, "--output", "-o", help="Output format"
+    ),
+):
+    """Get admin access request details."""
+    from bt_cli.epmw.client import get_client
+
+    try:
+        client = get_client()
+        request = client.get_admin_request(request_id)
+
+        if output == OutputFormat.JSON:
+            print_json(request)
+        else:
+            info = request.get("requestInfo", {})
+            decision = request.get("accessDecision", {})
+            typer.echo(f"Request ID: {info.get('requestId')}")
+            typer.echo(f"Ticket ID: {info.get('ticketId')}")
+            typer.echo(f"User: {info.get('userName')}")
+            typer.echo(f"Reason: {info.get('reason')}")
+            typer.echo(f"Duration Requested: {info.get('durationRequested')} seconds")
+            typer.echo(f"Status: {decision.get('status')}")
+            typer.echo(f"Duration: {decision.get('duration')}")
+            if decision.get('startTime'):
+                typer.echo(f"Start Time: {decision.get('startTime')}")
+            if decision.get('endTime'):
+                typer.echo(f"End Time: {decision.get('endTime')}")
+    except httpx.HTTPStatusError as e:
+        print_api_error(e, "get request")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        print_api_error(e, "get request")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_api_error(e, "get request")
+        raise typer.Exit(1)
+
+
+@app.command("create")
+def create_request(
+    computer_id: str = typer.Option(..., "--computer", "-c", help="Computer ID"),
+    user_id: str = typer.Option(..., "--user-id", "-u", help="User SID (e.g., S-1-5-21-...)"),
+    user_name: str = typer.Option(..., "--user-name", "-n", help="User name (e.g., DOMAIN\\username)"),
+    reason: str = typer.Option(..., "--reason", "-r", help="Reason for request"),
+    duration: int = typer.Option(1800, "--duration", "-d", help="Duration in seconds (default: 1800 = 30 min)"),
+    output: OutputFormat = typer.Option(
+        OutputFormat.JSON, "--output", "-o", help="Output format"
+    ),
+):
+    """Create an admin access request.
+
+    Note: This creates a request on behalf of a user. You need the user's
+    SID and domain\\username from the target computer.
+
+    Examples:
+
+        # 30 minute request (default)
+        bt epmw requests create \\
+            -c e4b4453a-302c-45c4-b64d-272e632f2beb \\
+            -u "S-1-5-21-1897974175-2172897935-264522243-4835" \\
+            -n "NEXUSDYN\\\\stan.power" \\
+            -r "Need to install software"
+
+        # 1 hour request
+        bt epmw requests create ... --duration 3600
+    """
+    from bt_cli.epmw.client import get_client
+
+    try:
+        client = get_client()
+        data = {
+            "computerId": computer_id,
+            "userId": user_id,
+            "userName": user_name,
+            "reason": reason,
+            "duration": str(duration),  # API expects string
+        }
+        request = client.create_admin_request(data)
+
+        typer.echo(f"Created admin access request: {request.get('requestId', 'OK')}")
+        if output == OutputFormat.JSON:
+            print_json(request)
+    except httpx.HTTPStatusError as e:
+        print_api_error(e, "create request")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        print_api_error(e, "create request")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_api_error(e, "create request")
+        raise typer.Exit(1)
+
+
+@app.command("approve")
+def approve_request(
+    request_id: str = typer.Argument(..., help="Request ID (UUID from 'requests list')"),
+    message: str = typer.Option(..., "--message", "-m", help="Approval message (required)"),
+    duration: int = typer.Option(1800, "--duration", "-d", help="Approval duration in seconds (default: 1800 = 30 min)"),
+    performed_by: str = typer.Option("api-admin", "--performed-by", "-p", help="Username performing the decision"),
+):
+    """Approve an admin access request.
+
+    Use the Request ID (UUID) from 'bt epmw requests list', not the ticket ID.
+
+    Examples:
+
+        bt epmw requests approve 26c08294-9d58-4927-99a4-477186a125f4 -m "Approved for maintenance"
+
+        bt epmw requests approve <request-id> -m "Approved" -d 3600  # 1 hour
+
+        bt epmw requests approve <request-id> -m "Approved" -p "admin@example.com"
+    """
+    from bt_cli.epmw.client import get_client
+
+    try:
+        client = get_client()
+        result = client.approve_admin_request(request_id, message, duration, performed_by)
+        typer.echo(f"Approved request: {result.get('requestId', request_id)}")
+    except httpx.HTTPStatusError as e:
+        print_api_error(e, "approve request")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        print_api_error(e, "approve request")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_api_error(e, "approve request")
+        raise typer.Exit(1)
+
+
+@app.command("deny")
+def deny_request(
+    request_id: str = typer.Argument(..., help="Request ID (UUID from 'requests list')"),
+    message: str = typer.Option(..., "--message", "-m", help="Denial message (required)"),
+    performed_by: str = typer.Option("api-admin", "--performed-by", "-p", help="Username performing the decision"),
+):
+    """Deny an admin access request.
+
+    Use the Request ID (UUID) from 'bt epmw requests list', not the ticket ID.
+
+    Examples:
+
+        bt epmw requests deny ab2b60d8-5375-459a-89a5-64565ef21691 -m "Not authorized"
+
+        bt epmw requests deny <request-id> -m "Denied" -p "admin@example.com"
+    """
+    from bt_cli.epmw.client import get_client
+
+    try:
+        client = get_client()
+        result = client.deny_admin_request(request_id, message, performed_by)
+        typer.echo(f"Denied request: {result.get('requestId', request_id)}")
+    except httpx.HTTPStatusError as e:
+        print_api_error(e, "deny request")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        print_api_error(e, "deny request")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_api_error(e, "deny request")
+        raise typer.Exit(1)

bt_cli/epmw/commands/roles.py

@@ -0,0 +1,78 @@
+"""EPMW roles commands (read-only)."""
+
+import httpx
+import typer
+
+from bt_cli.core.output import OutputFormat, print_api_error, print_json, print_table
+
+app = typer.Typer(no_args_is_help=True, help="User roles and permissions")
+
+
+@app.command("list")
+def list_roles(
+    output: OutputFormat = typer.Option(
+        OutputFormat.TABLE, "--output", "-o", help="Output format"
+    ),
+):
+    """List all roles."""
+    from bt_cli.epmw.client import get_client
+
+    try:
+        client = get_client()
+        roles = client.list_roles()
+
+        if output == OutputFormat.JSON:
+            print_json(roles)
+        else:
+            columns = [
+                ("ID", "id"),
+                ("Name", "name"),
+            ]
+            print_table(roles, columns, title="Roles")
+    except httpx.HTTPStatusError as e:
+        print_api_error(e, "list roles")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        print_api_error(e, "list roles")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_api_error(e, "list roles")
+        raise typer.Exit(1)
+
+
+@app.command("get")
+def get_role(
+    role_id: str = typer.Argument(..., help="Role ID"),
+    output: OutputFormat = typer.Option(
+        OutputFormat.JSON, "--output", "-o", help="Output format"
+    ),
+):
+    """Get role details."""
+    from bt_cli.epmw.client import get_client
+
+    try:
+        client = get_client()
+        role = client.get_role(role_id)
+
+        if output == OutputFormat.JSON:
+            print_json(role)
+        else:
+            typer.echo(f"ID: {role.get('id')}")
+            typer.echo(f"Name: {role.get('name')}")
+            if role.get('allowPermissions'):
+                typer.echo("Allow Permissions:")
+                for perm in role['allowPermissions']:
+                    typer.echo(f"  - {perm.get('resource')}: {perm.get('action')}")
+            if role.get('denyPermissions'):
+                typer.echo("Deny Permissions:")
+                for perm in role['denyPermissions']:
+                    typer.echo(f"  - {perm.get('resource')}: {perm.get('action')}")
+    except httpx.HTTPStatusError as e:
+        print_api_error(e, "get role")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        print_api_error(e, "get role")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_api_error(e, "get role")
+        raise typer.Exit(1)

bt_cli/epmw/commands/tasks.py

@@ -0,0 +1,38 @@
+"""EPMW task commands."""
+
+import httpx
+import typer
+
+from bt_cli.core.output import OutputFormat, print_api_error, print_json
+
+app = typer.Typer(no_args_is_help=True, help="Async task status")
+
+
+@app.command("get")
+def get_task(
+    task_id: str = typer.Argument(..., help="Task ID"),
+    output: OutputFormat = typer.Option(
+        OutputFormat.JSON, "--output", "-o", help="Output format"
+    ),
+):
+    """Get task status."""
+    from bt_cli.epmw.client import get_client
+
+    try:
+        client = get_client()
+        task = client.get_task(task_id)
+
+        if output == OutputFormat.JSON:
+            print_json(task)
+        else:
+            for key, value in task.items():
+                typer.echo(f"{key}: {value}")
+    except httpx.HTTPStatusError as e:
+        print_api_error(e, "get task")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        print_api_error(e, "get task")
+        raise typer.Exit(1)
+    except Exception as e:
+        print_api_error(e, "get task")
+        raise typer.Exit(1)