lyceum-cli 1.0.25__py3-none-any.whl → 1.0.27__py3-none-any.whl

lyceum/external/vms/instances.py

@@ -0,0 +1,301 @@
+"""
+VM instance management CLI commands.
+
+Provides commands for:
+- Starting VM instances with specified hardware profiles
+- Listing user's VM instances
+- Getting instance status
+- Terminating instances
+"""
+
+import sys
+from typing import Optional
+
+import httpx
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from lyceum.shared.config import config
+
+app = typer.Typer(help="Manage VM instances")
+console = Console()
+
+
+def get_headers() -> dict[str, str]:
+    """Get authorization headers for API requests."""
+    # Ensure we have a valid token
+    config.get_client()
+    return {"Authorization": f"Bearer {config.api_key}", "Content-Type": "application/json"}
+
+
+@app.command("start")
+def start_instance(
+    hardware_profile: str = typer.Option(
+        ..., "--profile", "-p", help="Hardware profile (e.g., 'a100', 'h100', 'cpu')"
+    ),
+    ssh_key: str = typer.Option(
+        ..., "--key", "-k", help="SSH public key for accessing the instance"
+    ),
+    name: Optional[str] = typer.Option(
+        None, "--name", "-n", help="Optional friendly name for the instance"
+    ),
+    vcpu_min: int = typer.Option(1, "--vcpu", help="Minimum vCPU count"),
+    memory_min: int = typer.Option(8, "--memory", "-m", help="Minimum memory in GB"),
+    disk_min: int = typer.Option(20, "--disk", "-d", help="Minimum disk in GB"),
+    gpu_type: Optional[str] = typer.Option(None, "--gpu-type", help="GPU type (e.g., 'A100', 'H100')"),
+    gpu_count: Optional[int] = typer.Option(None, "--gpu-count", help="Number of GPUs"),
+    gpu_memory: Optional[int] = typer.Option(None, "--gpu-memory", help="GPU memory in GB"),
+):
+    """
+    Start a new VM instance with specified hardware profile.
+
+    Example:
+        lyceum vms start -p a100 -k "ssh-rsa AAAAB3..." -n "training-vm"
+    """
+    console.print(f"[cyan]Starting VM instance with profile: {hardware_profile}...[/cyan]")
+
+    # Construct instance specs
+    instance_specs = {
+        "vcpu": {"min": vcpu_min},
+        "memory": {"min": memory_min},
+        "disk": {"min": disk_min},
+    }
+
+    if gpu_type:
+        instance_specs["gpu_type"] = gpu_type
+    if gpu_count:
+        instance_specs["gpu_count"] = gpu_count
+    if gpu_memory:
+        instance_specs["gpu_memory"] = {"value": gpu_memory}
+
+    payload = {
+        "instance_specs": instance_specs,
+        "user_public_key": ssh_key,
+        "hardware_profile": hardware_profile,
+    }
+
+    if name:
+        payload["name"] = name
+
+    try:
+        base_url = config.base_url
+        url = f"{base_url}/api/v2/external/vms/create"
+
+        with httpx.Client(timeout=30.0) as client:
+            response = client.post(url, json=payload, headers=get_headers())
+            response.raise_for_status()
+            data = response.json()
+
+        console.print("[green]✓[/green] VM instance created successfully!")
+        console.print(f"\n[bold]Instance ID:[/bold] {data['vm_id']}")
+        console.print(f"[bold]Status:[/bold] {data['status']}")
+        if data.get("ip_address"):
+            console.print(f"[bold]IP Address:[/bold] {data['ip_address']}")
+            console.print(f"\n[cyan]Connect via:[/cyan] ssh root@{data['ip_address']}")
+        if data.get("name"):
+            console.print(f"[bold]Name:[/bold] {data['name']}")
+
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 402:
+            console.print("[red]Error:[/red] Insufficient credits")
+            try:
+                detail = e.response.json().get("detail", "")
+                console.print(f"[yellow]{detail}[/yellow]")
+            except Exception:
+                pass
+        else:
+            console.print(f"[red]Error:[/red] HTTP {e.response.status_code}")
+            try:
+                console.print(f"[yellow]{e.response.json().get('detail', e.response.text)}[/yellow]")
+            except Exception:
+                console.print(f"[yellow]{e.response.text}[/yellow]")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        console.print(f"[red]Error:[/red] Failed to connect to API: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_instances():
+    """
+    List all VM instances for the current user.
+
+    Example:
+        lyceum vms list
+    """
+    try:
+        base_url = config.base_url
+        url = f"{base_url}/api/v2/external/vms/list"
+
+        with httpx.Client(timeout=30.0) as client:
+            response = client.get(url, headers=get_headers())
+            response.raise_for_status()
+            data = response.json()
+
+        vms = data.get("vms", [])
+
+        if not vms:
+            console.print("[yellow]No VM instances found.[/yellow]")
+            return
+
+        table = Table(title="Your VM Instances", show_header=True, header_style="bold magenta")
+        table.add_column("VM ID", style="cyan")
+        table.add_column("Name", style="green")
+        table.add_column("Status", style="yellow")
+        table.add_column("IP Address", style="blue")
+        table.add_column("Billed ($)", style="red", justify="right")
+        table.add_column("Created At", style="white")
+
+        for vm in vms:
+            table.add_row(
+                vm.get("vm_id", ""),
+                vm.get("name", "-"),
+                vm.get("status", ""),
+                vm.get("ip_address", "-"),
+                f"{vm.get('billed', 0):.4f}",
+                vm.get("created_at", "")[:19] if vm.get("created_at") else "-",
+            )
+
+        console.print(table)
+        console.print(f"\n[cyan]Total instances: {data.get('total', 0)}[/cyan]")
+
+    except httpx.HTTPStatusError as e:
+        console.print(f"[red]Error:[/red] HTTP {e.response.status_code}")
+        try:
+            console.print(f"[yellow]{e.response.json().get('detail', e.response.text)}[/yellow]")
+        except Exception:
+            console.print(f"[yellow]{e.response.text}[/yellow]")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        console.print(f"[red]Error:[/red] Failed to connect to API: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("status")
+def instance_status(
+    vm_id: str = typer.Argument(..., help="VM instance ID"),
+):
+    """
+    Get detailed status of a specific VM instance.
+
+    Example:
+        lyceum vms status vm-abc123
+    """
+    try:
+        base_url = config.base_url
+        url = f"{base_url}/api/v2/external/vms/{vm_id}/status"
+
+        with httpx.Client(timeout=30.0) as client:
+            response = client.get(url, headers=get_headers())
+            response.raise_for_status()
+            data = response.json()
+
+        console.print(f"\n[bold cyan]VM Instance Details[/bold cyan]")
+        console.print(f"[bold]VM ID:[/bold] {data['vm_id']}")
+        if data.get("name"):
+            console.print(f"[bold]Name:[/bold] {data['name']}")
+        console.print(f"[bold]Status:[/bold] {data['status']}")
+        if data.get("ip_address"):
+            console.print(f"[bold]IP Address:[/bold] {data['ip_address']}")
+        if data.get("uptime_seconds"):
+            hours = data["uptime_seconds"] // 3600
+            minutes = (data["uptime_seconds"] % 3600) // 60
+            seconds = data["uptime_seconds"] % 60
+            console.print(f"[bold]Uptime:[/bold] {hours}h {minutes}m {seconds}s")
+        if data.get("billed") is not None:
+            console.print(f"[bold]Total Billed:[/bold] ${data['billed']:.4f}")
+        console.print(f"[bold]Created At:[/bold] {data.get('created_at', '-')}")
+
+        if data.get("instance_specs"):
+            console.print(f"\n[bold cyan]Hardware Specs:[/bold cyan]")
+            specs = data["instance_specs"]
+            if "vcpu" in specs:
+                console.print(f"  vCPU: {specs['vcpu']}")
+            if "memory" in specs:
+                console.print(f"  Memory: {specs['memory']}")
+            if "disk" in specs:
+                console.print(f"  Disk: {specs['disk']}")
+            if "gpu_type" in specs:
+                console.print(f"  GPU Type: {specs['gpu_type']}")
+            if "gpu_count" in specs:
+                console.print(f"  GPU Count: {specs['gpu_count']}")
+            if "gpu_memory" in specs:
+                console.print(f"  GPU Memory: {specs['gpu_memory']}")
+
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 404:
+            console.print(f"[red]Error:[/red] VM instance '{vm_id}' not found")
+        else:
+            console.print(f"[red]Error:[/red] HTTP {e.response.status_code}")
+            try:
+                console.print(f"[yellow]{e.response.json().get('detail', e.response.text)}[/yellow]")
+            except Exception:
+                console.print(f"[yellow]{e.response.text}[/yellow]")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        console.print(f"[red]Error:[/red] Failed to connect to API: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("terminate")
+def terminate_instance(
+    vm_id: str = typer.Argument(..., help="VM instance ID to terminate"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation prompt"),
+):
+    """
+    Terminate and delete a VM instance permanently.
+
+    Example:
+        lyceum vms terminate vm-abc123
+    """
+    if not force:
+        confirm = typer.confirm(
+            f"Are you sure you want to terminate VM instance '{vm_id}'? This action cannot be undone."
+        )
+        if not confirm:
+            console.print("[yellow]Termination cancelled.[/yellow]")
+            raise typer.Exit(0)
+
+    console.print(f"[cyan]Terminating VM instance {vm_id}...[/cyan]")
+
+    try:
+        base_url = config.base_url
+        url = f"{base_url}/api/v2/external/vms/{vm_id}"
+
+        with httpx.Client(timeout=30.0) as client:
+            response = client.delete(url, headers=get_headers())
+            response.raise_for_status()
+            data = response.json()
+
+        console.print(f"[green]✓[/green] {data.get('message', 'VM instance terminated successfully')}")
+
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 404:
+            console.print(f"[red]Error:[/red] VM instance '{vm_id}' not found")
+        else:
+            console.print(f"[red]Error:[/red] HTTP {e.response.status_code}")
+            try:
+                console.print(f"[yellow]{e.response.json().get('detail', e.response.text)}[/yellow]")
+            except Exception:
+                console.print(f"[yellow]{e.response.text}[/yellow]")
+        raise typer.Exit(1)
+    except httpx.RequestError as e:
+        console.print(f"[red]Error:[/red] Failed to connect to API: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

lyceum/external/vms/management.py

@@ -0,0 +1,383 @@
+"""VM instance management commands"""
+
+import time
+
+import httpx
+import typer
+from rich.console import Console
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.table import Table
+
+from ...shared.config import config
+
+console = Console()
+
+vms_app = typer.Typer(name="vms", help="VM instance management commands")
+
+
+@vms_app.command("start")
+def start_instance(
+    hardware_profile: str = typer.Option(
+        "a100", "--hardware-profile", "-h", help="Hardware profile (cpu, a100, h100, etc.)"
+    ),
+    public_key: str = typer.Option(..., "--key", "-k", help="SSH public key for VM access"),
+    name: str | None = typer.Option(None, "--name", "-n", help="Friendly name for the instance"),
+    cpu: int | None = typer.Option(None, "--cpu", help="Number of CPU cores (uses hardware profile default if not specified)"),
+    memory: int | None = typer.Option(None, "--memory", help="Memory in GB (uses hardware profile default if not specified)"),
+    disk: int | None = typer.Option(None, "--disk", help="Disk size in GB (uses hardware profile default if not specified)"),
+    gpu_count: int | None = typer.Option(None, "--gpu-count", help="Number of GPUs (uses hardware profile default if not specified)"),
+):
+    """Start a new VM instance"""
+    try:
+        # Ensure we have a valid token
+        config.get_client()
+
+        # Create instance specs - only include values that were explicitly provided
+        instance_specs = {}
+        if cpu is not None:
+            instance_specs["cpu"] = cpu
+        if memory is not None:
+            instance_specs["memory"] = memory
+        if disk is not None:
+            instance_specs["disk"] = disk
+        if gpu_count is not None:
+            instance_specs["gpu_count"] = gpu_count
+
+        # Create request payload
+        payload = {
+            "instance_specs": instance_specs,
+            "user_public_key": public_key,
+            "hardware_profile": hardware_profile,
+        }
+
+        if name:
+            payload["name"] = name
+
+        # Make API request
+        console.print("[dim]Creating VM instance...[/dim]")
+        response = httpx.post(
+            f"{config.base_url}/api/v2/external/vms/create",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            json=payload,
+            timeout=60.0,
+        )
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            try:
+                error_data = response.json()
+                console.print(f"[red]{error_data.get('detail', response.text)}[/red]")
+            except Exception:
+                console.print(f"[red]{response.text}[/red]")
+            raise typer.Exit(1)
+
+        data = response.json()
+
+        console.print("[green]✅ VM instance created successfully![/green]")
+        console.print(f"[bold]VM ID:[/bold] {data['vm_id']}")
+        console.print(f"[bold]Status:[/bold] {data['status']}")
+        if data.get("name"):
+            console.print(f"[bold]Name:[/bold] {data['name']}")
+        console.print(f"[dim]Created at: {data['created_at']}[/dim]")
+
+        # If instance is pending, poll for readiness
+        if data['status'] == 'pending':
+            console.print("\n[yellow]Instance is provisioning...[/yellow]")
+
+            vm_id = data['vm_id']
+            poll_interval = 30  # seconds
+            max_attempts = 20  # 10 minutes max
+            attempt = 0
+
+            with Live(Spinner("dots", text="Provisioning instance..."), console=console, refresh_per_second=4) as live:
+                while attempt < max_attempts:
+                    time.sleep(poll_interval)
+                    attempt += 1
+
+                    try:
+                        status_response = httpx.get(
+                            f"{config.base_url}/api/v2/external/vms/{vm_id}/status",
+                            headers={"Authorization": f"Bearer {config.api_key}"},
+                            timeout=30.0,
+                        )
+
+                        if status_response.status_code == 200:
+                            status_data = status_response.json()
+                            current_status = status_data.get('status')
+
+                            if current_status == 'ready' or current_status == 'running':
+                                live.stop()
+                                console.print(f"\n[green]✅ Instance is now {current_status}![/green]")
+
+                                if status_data.get("ip_address"):
+                                    ip_addr = status_data['ip_address']
+                                    console.print(f"[bold]IP Address:[/bold] {ip_addr}")
+
+                                    # Handle IP:PORT format
+                                    if ':' in ip_addr:
+                                        ip, port = ip_addr.split(':', 1)
+                                        console.print(f"\n[cyan]SSH command:[/cyan] ssh -i <your-key> -p {port} ubuntu@{ip}")
+                                    else:
+                                        console.print(f"\n[cyan]SSH command:[/cyan] ssh -i <your-key> ubuntu@{ip_addr}")
+                                break
+                            elif current_status in ['failed', 'terminated', 'error']:
+                                live.stop()
+                                console.print(f"\n[red]❌ Instance provisioning failed with status: {current_status}[/red]")
+                                break
+                            else:
+                                live.update(Spinner("dots", text=f"Provisioning instance... (status: {current_status}, attempt {attempt}/{max_attempts})"))
+                    except Exception as e:
+                        # Continue polling even if status check fails
+                        live.update(Spinner("dots", text=f"Provisioning instance... (attempt {attempt}/{max_attempts})"))
+
+                if attempt >= max_attempts:
+                    live.stop()
+                    console.print(f"\n[yellow]⚠️  Polling timed out. Instance may still be provisioning.[/yellow]")
+                    console.print(f"[dim]Check status with: lyceum vms instance-status {vm_id}[/dim]")
+
+        elif data.get("ip_address"):
+            ip_addr = data['ip_address']
+            console.print(f"[bold]IP Address:[/bold] {ip_addr}")
+
+            # Handle IP:PORT format
+            if ':' in ip_addr:
+                ip, port = ip_addr.split(':', 1)
+                console.print(f"\n[cyan]SSH command:[/cyan] ssh -i <your-key> -p {port} ubuntu@{ip}")
+            else:
+                console.print(f"\n[cyan]SSH command:[/cyan] ssh -i <your-key> ubuntu@{ip_addr}")
+
+    except httpx.TimeoutException:
+        console.print("[red]Error: Request timed out[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@vms_app.command("list")
+def list_instances():
+    """List all your VM instances (both active and inactive)"""
+    try:
+        # Ensure we have a valid token
+        config.get_client()
+
+        # Make API request
+        response = httpx.get(
+            f"{config.base_url}/api/v2/external/vms/list",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            console.print(f"[red]{response.text}[/red]")
+            raise typer.Exit(1)
+
+        data = response.json()
+        vms = data.get("vms", [])
+
+        if not vms:
+            console.print("[yellow]No VM instances found.[/yellow]")
+            return
+
+        # Create table
+        table = Table(title="VM Instances")
+        table.add_column("VM ID", style="cyan")
+        table.add_column("Name", style="green")
+        table.add_column("Status", style="yellow")
+        table.add_column("IP Address", style="blue")
+        table.add_column("Hardware", style="magenta")
+        table.add_column("Billed ($)", style="red")
+        table.add_column("Created At", style="dim")
+
+        for vm in vms:
+            table.add_row(
+                vm["vm_id"],
+                vm.get("name", "-"),
+                vm["status"],
+                vm.get("ip_address", "-"),
+                vm.get("hardware_profile", "-"),
+                f"{vm.get('billed', 0):.4f}" if vm.get("billed") is not None else "-",
+                vm["created_at"],
+            )
+
+        console.print(table)
+
+    except httpx.TimeoutException:
+        console.print("[red]Error: Request timed out[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@vms_app.command("availability")
+def list_availability():
+    """List available VM hardware profiles"""
+    try:
+        # Ensure we have a valid token
+        config.get_client()
+
+        # Make API request
+        response = httpx.get(
+            f"{config.base_url}/api/v2/external/vms/availability",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            console.print(f"[red]{response.text}[/red]")
+            raise typer.Exit(1)
+
+        data = response.json()
+        hardware_profiles = data.get("available_hardware_profiles", [])
+        pool_name = data.get("pool_name", "")
+
+        if not hardware_profiles:
+            console.print("[yellow]No hardware profiles available.[/yellow]")
+            return
+
+        console.print(f"\n[bold cyan]Available Hardware Profiles[/bold cyan] (Pool: {pool_name})\n")
+
+        # Create table
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Hardware Profile", style="cyan")
+        table.add_column("Available", style="green", justify="right")
+        table.add_column("Total", style="yellow", justify="right")
+        table.add_column("GPU Type", style="blue")
+        table.add_column("vCPU", style="white", justify="right")
+        table.add_column("Memory (GB)", style="white", justify="right")
+
+        for profile in hardware_profiles:
+            table.add_row(
+                profile.get("hardware_profile", "-"),
+                str(profile.get("available", 0)),
+                str(profile.get("total", 0)),
+                profile.get("gpu_type", "-"),
+                str(profile.get("vcpu", "-")),
+                str(profile.get("memory_gb", "-")),
+            )
+
+        console.print(table)
+        console.print(f"\n[dim]Use these hardware profile names with: lyceum vms start-instance --hardware-profile <name>[/dim]")
+
+    except httpx.TimeoutException:
+        console.print("[red]Error: Request timed out[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@vms_app.command("status")
+def instance_status(
+    vm_id: str = typer.Argument(..., help="VM instance ID"),
+):
+    """Get detailed status of a VM instance"""
+    try:
+        # Ensure we have a valid token
+        config.get_client()
+
+        # Make API request
+        response = httpx.get(
+            f"{config.base_url}/api/v2/external/vms/{vm_id}/status",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            try:
+                error_data = response.json()
+                console.print(f"[red]{error_data.get('detail', response.text)}[/red]")
+            except Exception:
+                console.print(f"[red]{response.text}[/red]")
+            raise typer.Exit(1)
+
+        data = response.json()
+
+        console.print(f"[bold cyan]VM Instance: {vm_id}[/bold cyan]\n")
+        console.print(f"[bold]Status:[/bold] {data['status']}")
+        if data.get("name"):
+            console.print(f"[bold]Name:[/bold] {data['name']}")
+        if data.get("ip_address"):
+            console.print(f"[bold]IP Address:[/bold] {data['ip_address']}")
+        console.print(f"[bold]Hardware Profile:[/bold] {data.get('hardware_profile', '-')}")
+        if data.get("billed") is not None:
+            console.print(f"[bold]Total Billed:[/bold] ${data['billed']:.4f}")
+        if data.get("uptime_seconds") is not None:
+            hours = data["uptime_seconds"] / 3600
+            console.print(f"[bold]Uptime:[/bold] {hours:.2f} hours")
+        console.print(f"[dim]Created at: {data['created_at']}[/dim]")
+
+        if data.get("instance_specs"):
+            console.print("\n[bold]Instance Specs:[/bold]")
+            specs = data["instance_specs"]
+            console.print(f"  CPU: {specs.get('cpu', '-')} cores")
+            console.print(f"  Memory: {specs.get('memory', '-')} GB")
+            console.print(f"  Disk: {specs.get('disk', '-')} GB")
+            console.print(f"  GPU Count: {specs.get('gpu_count', '-')}")
+
+        if data.get("ip_address"):
+            ip_addr = data['ip_address']
+            # Handle IP:PORT format
+            if ':' in ip_addr:
+                ip, port = ip_addr.split(':', 1)
+                console.print(f"\n[cyan]SSH command:[/cyan] ssh -i <your-key> -p {port} ubuntu@{ip}")
+            else:
+                console.print(f"\n[cyan]SSH command:[/cyan] ssh -i <your-key> ubuntu@{ip_addr}")
+
+    except httpx.TimeoutException:
+        console.print("[red]Error: Request timed out[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@vms_app.command("terminate")
+def terminate_instance(
+    vm_id: str = typer.Argument(..., help="VM instance ID to terminate"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation prompt"),
+):
+    """Terminate (delete) a VM instance"""
+    try:
+        # Ensure we have a valid token
+        config.get_client()
+
+        # Confirm termination unless --force is used
+        if not force:
+            confirm = typer.confirm(f"Are you sure you want to terminate VM {vm_id}?")
+            if not confirm:
+                console.print("[yellow]Termination cancelled.[/yellow]")
+                return
+
+        # Make API request
+        console.print("[dim]Terminating VM instance...[/dim]")
+        response = httpx.delete(
+            f"{config.base_url}/api/v2/external/vms/{vm_id}",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            try:
+                error_data = response.json()
+                console.print(f"[red]{error_data.get('detail', response.text)}[/red]")
+            except Exception:
+                console.print(f"[red]{response.text}[/red]")
+            raise typer.Exit(1)
+
+        data = response.json()
+
+        console.print(f"[green]✅ {data.get('message', 'VM instance terminated successfully')}[/green]")
+
+    except httpx.TimeoutException:
+        console.print("[red]Error: Request timed out[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)