gpu-dev 0.5.30__tar.gz → 0.5.31__tar.gz

{gpu_dev-0.5.30 → gpu_dev-0.5.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gpu-dev
-Version: 0.5.30
+Version: 0.5.31
 Summary: CLI tool for PyTorch GPU developer server reservations
 Author: PyTorch Team
 Requires-Python: >=3.10

{gpu_dev-0.5.30 → gpu_dev-0.5.31}/cli-tools/gpu-dev-cli/gpu_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gpu-dev
-Version: 0.5.30
+Version: 0.5.31
 Summary: CLI tool for PyTorch GPU developer server reservations
 Author: PyTorch Team
 Requires-Python: >=3.10

{gpu_dev-0.5.30 → gpu_dev-0.5.31}/cli-tools/gpu-dev-cli/gpu_dev.egg-info/SOURCES.txt

@@ -37,8 +37,12 @@ docs/icons8-cursor-ai.svg
 terraform-gpu-devservers/.terraform.lock.hcl
 terraform-gpu-devservers/README.md
 terraform-gpu-devservers/alb.tf
+terraform-gpu-devservers/ami-baker.tf
 terraform-gpu-devservers/availability.tf
 terraform-gpu-devservers/backend.tf
+terraform-gpu-devservers/check_b200.py
+terraform-gpu-devservers/cluster-autoscaler.tf
+terraform-gpu-devservers/cmd_proxy.py
 terraform-gpu-devservers/docker-build.tf
 terraform-gpu-devservers/ecr.tf
 terraform-gpu-devservers/efs.tf
@@ -48,6 +52,7 @@ terraform-gpu-devservers/git-cache.tf
 terraform-gpu-devservers/gpu-dev-pod-irsa.tf
 terraform-gpu-devservers/kubernetes.tf
 terraform-gpu-devservers/lambda.tf
+terraform-gpu-devservers/list_b200.py
 terraform-gpu-devservers/main.tf
 terraform-gpu-devservers/mig-config.tf
 terraform-gpu-devservers/mig-parted-config.yaml
@@ -60,6 +65,7 @@ terraform-gpu-devservers/route53.tf
 terraform-gpu-devservers/s3-disk-contents.tf
 terraform-gpu-devservers/ssh-proxy-service.tf
 terraform-gpu-devservers/ssh-proxy.tf
+terraform-gpu-devservers/subnet-0fe3a2c45570091ad
 terraform-gpu-devservers/switch-to.sh
 terraform-gpu-devservers/variables.tf
 terraform-gpu-devservers/.claude/skills/deploy.md
@@ -114,6 +120,7 @@ terraform-gpu-devservers/ssh-proxy/proxy.py
 terraform-gpu-devservers/ssh-proxy/requirements.txt
 terraform-gpu-devservers/templates/al2023-cpu-user-data.sh
 terraform-gpu-devservers/templates/al2023-user-data.sh
+terraform-gpu-devservers/templates/ami-baker-user-data.sh
 terraform-gpu-devservers/templates/user-data-self-managed.sh
 terraform-gpu-devservers/templates/user-data.sh
 tests/submit/README.md

{gpu_dev-0.5.30 → gpu_dev-0.5.31}/cli-tools/gpu-dev-cli/gpu_dev_cli/cli.py

@@ -41,6 +41,36 @@ from .interactive import (
 console = Console()
 
 
+def _fetch_reservations_cross_region(reservation_mgr, user_filter, statuses, config=None):
+    """Fetch reservations from current region + prod-east1 if on prod."""
+    reservations = reservation_mgr.list_reservations(
+        user_filter=user_filter, statuses_to_include=statuses)
+    # Cross-region fetch
+    try:
+        cfg = config or load_config()
+        if cfg.user_config.get("environment") == "prod":
+            east1_env = Config.ENVIRONMENTS.get("prod-east1", {})
+            if east1_env:
+                import boto3 as _b3
+                east1_ddb = _b3.resource("dynamodb", region_name=east1_env["region"])
+                east1_table = east1_ddb.Table("pytorch-gpu-dev-reservations")
+                for st in (statuses or ["active"]):
+                    resp = east1_table.query(
+                        IndexName="StatusIndex",
+                        KeyConditionExpression="#s = :status",
+                        ExpressionAttributeNames={"#s": "status"},
+                        ExpressionAttributeValues={":status": st},
+                    )
+                    for item in resp.get("Items", []):
+                        if user_filter and item.get("user_id") != user_filter:
+                            continue
+                        item["_region"] = "us-east-1"
+                        reservations.append(item)
+    except Exception:
+        pass
+    return reservations
+
+
 def _format_relative_time(timestamp_str: str, relative_to: str = "now") -> str:
     """Format timestamp as relative time if within 24h, otherwise absolute"""
     if not timestamp_str or timestamp_str == "N/A":
@@ -598,6 +628,7 @@ def reserve(
     preserve_entrypoint: bool,
     disk: Optional[str],
     node_label: tuple,
+    spot: bool = False,
 ) -> None:
     """Reserve GPU development server(s)
 
@@ -688,6 +719,11 @@ def reserve(
             rprint(
                 "[dim]Use --no-interactive flag to disable interactive mode[/dim]\n")
 
+            # Auto-acknowledge spot in spot-only environments so users don't need --spot
+            from .config import Config as _Cfg
+            _env_name = load_config().user_config.get("environment", "prod")
+            _spot_types_env = _Cfg.ENVIRONMENTS.get(_env_name, {}).get("spot_types", [])
+
             # Run auth + SSH validation + availability fetch in parallel — they're independent
             # and total wall-clock time drops from sum to max(each).
             from concurrent.futures import ThreadPoolExecutor
@@ -748,6 +784,31 @@ def reserve(
                     rprint("[yellow]Reservation cancelled.[/yellow]")
                     return
 
+            # Handle spot: prefix from cross-region selection — use a TEMPORARY config
+            # for prod-east1 without persisting the environment change to disk.
+            if isinstance(gpu_type, str) and gpu_type.startswith("spot:"):
+                gpu_type = gpu_type[5:]  # strip prefix
+                spot = True
+                rprint(f"\n[cyan]⚡ Switching to spot cluster (us-east-1) for {gpu_type.upper()}[/cyan]")
+                rprint("[dim]Spot instance: ~70% cheaper, may be preempted, separate disks.[/dim]\n")
+                # Build a temporary Config pointing at prod-east1 WITHOUT touching disk
+                import os as _os
+                east1_cfg = Config.ENVIRONMENTS.get("prod-east1", {})
+                _os.environ["AWS_DEFAULT_REGION"] = east1_cfg["region"]
+                config = Config()
+                config.aws_region = east1_cfg["region"]
+                reservation_mgr = ReservationManager(config)
+                try:
+                    user_info = authenticate_user(config)
+                except RuntimeError as e:
+                    rprint(f"[red]❌ {str(e)}[/red]")
+                    return
+
+            # Auto-acknowledge spot for spot types in this environment
+            if _spot_types_env and gpu_type and gpu_type.lower() in _spot_types_env and not spot:
+                spot = True
+                rprint(f"[dim]{gpu_type.upper()} is a spot instance in this environment — --spot auto-acknowledged. May be preempted by AWS.[/dim]")
+
             # Interactive GPU count selection
             if gpus is None:
                 gpu_type_lower = gpu_type.lower()
@@ -1746,13 +1807,47 @@ def list(ctx: click.Context, user: Optional[str], status: Optional[str], details
                     def fetch_recent_failures():
                         return reservation_mgr.list_reservations(
                             user_filter=user_filter,
-                            statuses_to_include=["failed", "cancelled"],
+                            statuses_to_include=["failed", "cancelled", "expired"],
                             created_after=one_hour_ago)
 
-                    with ThreadPoolExecutor(max_workers=2) as executor:
+                    # Also fetch from prod-east1 (cross-region) if we're on prod
+                    def fetch_east1():
+                        try:
+                            east1_env = Config.ENVIRONMENTS.get("prod-east1", {})
+                            if not east1_env or config.user_config.get("environment") != "prod":
+                                return []
+                            import boto3 as _b3
+                            east1_ddb = _b3.resource("dynamodb", region_name=east1_env["region"])
+                            east1_table = east1_ddb.Table("pytorch-gpu-dev-reservations")
+                            results = []
+                            # Fetch active + recent failures/expired (last 24h) from east1
+                            all_statuses = (statuses_to_include or ["active", "preparing", "queued", "pending"]) + ["failed", "expired", "cancelled"]
+                            for s in all_statuses:
+                                resp = east1_table.query(
+                                    IndexName="StatusIndex",
+                                    KeyConditionExpression="#s = :status",
+                                    ExpressionAttributeNames={"#s": "status"},
+                                    ExpressionAttributeValues={":status": s},
+                                )
+                                for item in resp.get("Items", []):
+                                    if user_filter and item.get("user_id") != user_filter:
+                                        continue
+                                    # For failed/expired/cancelled, only show if ended recently
+                                    if s in ("failed", "expired", "cancelled"):
+                                        ended = item.get("reservation_ended") or item.get("expired_at") or item.get("created_at", "")
+                                        if ended and ended < one_hour_ago:
+                                            continue
+                                    item["_region"] = "us-east-1"
+                                    results.append(item)
+                            return results
+                        except Exception:
+                            return []
+
+                    with ThreadPoolExecutor(max_workers=3) as executor:
                         active_future = executor.submit(fetch_active)
                         failures_future = executor.submit(fetch_recent_failures)
-                        reservations = active_future.result() + failures_future.result()
+                        east1_future = executor.submit(fetch_east1)
+                        reservations = active_future.result() + failures_future.result() + east1_future.result()
                 else:
                     reservations = reservation_mgr.list_reservations(
                         user_filter=user_filter, statuses_to_include=statuses_to_include
@@ -1787,6 +1882,9 @@ def list(ctx: click.Context, user: Optional[str], status: Optional[str], details
             reservations = sorted(reservations, key=sort_key)
 
             # Create table with enhanced columns for queue info
+            # Check if we have cross-region reservations
+            _has_east1 = any(r.get("_region") == "us-east-1" for r in reservations)
+
             table = Table(title="GPU Reservations")
             table.add_column("ID", style="cyan", no_wrap=True)
             table.add_column("User", style="green")
@@ -1796,6 +1894,8 @@ def list(ctx: click.Context, user: Optional[str], status: Optional[str], details
             table.add_column("Queue Info", style="cyan")
             table.add_column("Created", style="blue")
             table.add_column("Expires/ETA", style="red")
+            if _has_east1:
+                table.add_column("Region", style="dim")
             if details:
                 table.add_column("CLI Ver", style="dim", no_wrap=True)
                 table.add_column("Lambda Ver", style="dim", no_wrap=True)
@@ -1842,6 +1942,26 @@ def list(ctx: click.Context, user: Optional[str], status: Optional[str], details
                             expires_formatted = f"~{estimated_wait}min"
                         else:
                             expires_formatted = "Calculating..."
+                    elif res_status in ("expired", "failed", "cancelled"):
+                        reason = reservation.get("failure_reason", "")
+                        ended = reservation.get("reservation_ended") or reservation.get("expired_at", "")
+                        ended_str = ""
+                        if ended:
+                            try:
+                                from datetime import datetime, timezone
+                                ended_dt = datetime.fromisoformat(ended.replace("Z", "+00:00"))
+                                ended_str = ended_dt.astimezone().strftime("%H:%M")
+                            except Exception:
+                                pass
+                        if "preempted" in reason.lower():
+                            expires_formatted = f"Preempted{' @' + ended_str if ended_str else ''}"
+                        elif res_status == "cancelled":
+                            expires_formatted = f"Cancelled{' @' + ended_str if ended_str else ''}"
+                        elif reason:
+                            short = reason.split("\n")[0][:20]
+                            expires_formatted = short
+                        else:
+                            expires_formatted = res_status.capitalize()
                     else:
                         expires_formatted = "N/A"
 
@@ -1979,6 +2099,10 @@ def list(ctx: click.Context, user: Optional[str], status: Optional[str], details
                         row_data.append(
                             f"[dim]{lambda_version_display}[/dim]" if dim_row else lambda_version_display)
 
+                    if _has_east1:
+                        region = reservation.get("_region", "us-east-2")
+                        row_data.append("[yellow]east1[/yellow]" if region == "us-east-1" else "prod")
+
                     table.add_row(*row_data)
 
                 except Exception as row_error:
@@ -2309,12 +2433,10 @@ def cancel(
 
                 reservation_mgr = ReservationManager(config)
 
-                # Get cancellable reservations
-                reservations = reservation_mgr.list_reservations(
-                    user_filter=user_info["user_id"],
-                    statuses_to_include=[
-                        "active", "queued", "pending", "preparing"],
-                )
+                # Get cancellable reservations (cross-region)
+                reservations = _fetch_reservations_cross_region(
+                    reservation_mgr, user_info["user_id"],
+                    ["active", "queued", "pending", "preparing"], config)
 
             live.stop()
 
@@ -2720,7 +2842,25 @@ def _show_availability() -> None:
                 rprint(f"[red]❌ {str(e)}[/red]")
                 return
 
-        # Stop spinner after getting results
+        # Cross-region: fetch spot availability from prod-east1
+        spot_region_info = {}
+        _env_name = config.user_config.get("environment", "prod")
+        _east1_spot_types = frozenset(Config.ENVIRONMENTS.get("prod-east1", {}).get("spot_types", []))
+        if _env_name == "prod" and _east1_spot_types:
+            try:
+                import boto3 as _b3
+                east1_r = Config.ENVIRONMENTS["prod-east1"]["region"]
+                for item in _b3.resource("dynamodb", region_name=east1_r).Table("pytorch-gpu-dev-gpu-availability").scan().get("Items", []):
+                    gt = item.get("gpu_type", "")
+                    if gt in _east1_spot_types:
+                        spot_region_info[gt] = {
+                            "available": int(item.get("available_gpus", 0)),
+                            "total": int(item.get("total_gpus", 0)),
+                            "max_reservable": int(item.get("max_reservable", 0)),
+                            "spot_info": item.get("spot_info", {}),
+                        }
+            except Exception:
+                pass
 
         if availability_info:
             # GPU architecture mapping (for display)
@@ -2762,84 +2902,99 @@ def _show_availability() -> None:
                 "CPU (arm64)": 6,
             }
 
-            # Sort GPU types by architecture priority, then by name
-            sorted_gpu_types = sorted(
-                availability_info.items(),
-                key=lambda x: (
-                    arch_priority.get(
-                        gpu_architectures.get(x[0], "Unknown"), 99),
-                    x[0]
-                )
-            )
-
-            table = Table(
-                title="GPU Availability by Type (numbers are GPUs, not nodes)")
-            table.add_column("GPU Type", style="cyan")
-            table.add_column("Avail", style="green")
-            table.add_column("Max\nReservable", style="bright_green")
-            table.add_column("Total", style="blue")
-            table.add_column("Queue\nLength", style="yellow")
-            table.add_column("Architecture", style="dim")
-            table.add_column("Est. Wait Time", style="magenta")
-
-            last_arch = None
-            for gpu_type, info in sorted_gpu_types:
-                arch = gpu_architectures.get(gpu_type, "Unknown")
-
-                # Add separator before CPU section
-                if last_arch and not last_arch.startswith("CPU") and arch.startswith("CPU"):
-                    table.add_row("---", "---", "---",
-                                  "---", "---", "---", "---")
-
-                last_arch = arch
-                available = info.get("available", 0)
-                max_reservable = info.get("max_reservable", 0)
-                total = info.get("total", 0)
-                full_nodes_available = info.get("full_nodes_available", 0)
-                gpus_per_instance = info.get("gpus_per_instance", 0)
-                queue_length = info.get("queue_length", 0)
-                est_wait = info.get("estimated_wait_minutes", 0)
-
-                # Format wait time
-                if available > 0:
-                    wait_display = "Available now"
-                elif est_wait == 0:
-                    wait_display = "Unknown"
-                elif est_wait < 60:
-                    wait_display = f"{int(est_wait)}min"
-                else:
-                    hours = int(est_wait // 60)
-                    minutes = int(est_wait % 60)
-                    if minutes == 0:
-                        wait_display = f"{hours}h"
+            # Split into categories
+            full_types = {k: v for k, v in availability_info.items() if "mig" not in k}
+            mig_types = {k: v for k, v in availability_info.items() if "mig" in k}
+
+            def _sort_by_arch(items):
+                return sorted(items.items(), key=lambda x: (
+                    arch_priority.get(gpu_architectures.get(x[0], "Unknown"), 99), x[0]))
+
+            def _fmt_wait(available, est_wait):
+                if available > 0: return "Available now"
+                if not est_wait: return "Unknown"
+                if est_wait < 60: return f"{int(est_wait)}min"
+                h, m = int(est_wait // 60), int(est_wait % 60)
+                return f"{h}h{f' {m}min' if m else ''}"
+
+            def _build_avail_table(title, items):
+                t = Table(title=title)
+                t.add_column("GPU Type", style="cyan")
+                t.add_column("Avail", style="green")
+                t.add_column("Max\nReservable", style="bright_green")
+                t.add_column("Total", style="blue")
+                t.add_column("Queue\nLength", style="yellow")
+                t.add_column("Architecture", style="dim")
+                t.add_column("Est. Wait Time", style="magenta")
+                for gpu_type, info in _sort_by_arch(items):
+                    avail = info.get("available", 0)
+                    maint = info.get("maintenance", False)
+                    maint_reason = info.get("maintenance_reason", "")
+                    fn = info.get("full_nodes_available", 0)
+                    if maint:
+                        ad = "[red]MAINTENANCE[/red]"
+                        wd = maint_reason or "Under maintenance"
+                    elif avail == 0:
+                        ad = f"[red]{avail}[/red]"
+                        wd = _fmt_wait(avail, info.get("estimated_wait_minutes", 0))
+                    elif fn > 0:
+                        ad = f"[green]{avail}[/green]"
+                        wd = _fmt_wait(avail, info.get("estimated_wait_minutes", 0))
                     else:
-                        wait_display = f"{hours}h {minutes}min"
-
-                # Check maintenance mode
-                is_maintenance = info.get("maintenance", False)
-                maintenance_reason = info.get("maintenance_reason", "")
-
-                if is_maintenance:
-                    available_display = f"[red]MAINTENANCE[/red]"
-                    wait_display = maintenance_reason or "Under maintenance"
-                elif available == 0:
-                    available_display = f"[red]{available}[/red]"
-                elif full_nodes_available > 0:
-                    available_display = f"[green]{available}[/green]"
-                else:
-                    available_display = f"[yellow]{available}[/yellow]"
-
-                table.add_row(
-                    gpu_type.upper(),
-                    available_display,
-                    str(max_reservable) if not is_maintenance else "-",
-                    str(total),
-                    str(queue_length) if not is_maintenance else "-",
-                    arch,
-                    wait_display,
-                )
-
-            console.print(table)
+                        ad = f"[yellow]{avail}[/yellow]"
+                        wd = _fmt_wait(avail, info.get("estimated_wait_minutes", 0))
+                    t.add_row(
+                        gpu_type.upper(), ad,
+                        "-" if maint else str(info.get("max_reservable", 0)),
+                        str(info.get("total", 0)),
+                        "-" if maint else str(info.get("queue_length", 0)),
+                        gpu_architectures.get(gpu_type, "Unknown"), wd)
+                console.print(t)
+
+            # Section 1: Full GPUs & CPUs
+            _build_avail_table("━━━ Full GPUs & CPUs ━━━", full_types)
+
+            # Section 2: MIG Slices
+            if mig_types:
+                rprint("[dim]  Sliced GPUs — isolated fractions of a physical GPU, perfect for smaller jobs.[/dim]")
+                _build_avail_table("━━━ 🔬 MIG Slices ━━━", mig_types)
+
+            # Spot section from prod-east1
+            if spot_region_info:
+                # Spot GPU configs for max reservable (what you CAN get per node)
+                spot_gpus_per_node = {
+                    "b300": 8, "b200": 8, "h200": 8, "h100": 8, "a100": 8,
+                    "t4": 4, "l4": 4,
+                }
+                spot_table = Table(title="⚡ Spot Instances (us-east-1, ~70% cheaper)")
+                spot_table.add_column("GPU Type", style="cyan")
+                spot_table.add_column("Avail\nNow", style="green")
+                spot_table.add_column("Per\nNode", style="bright_green")
+                spot_table.add_column("Status", style="magenta")
+                spot_table.add_column("Availability", style="dim")
+                _on_demand = {"b300": 95, "b200": 95, "h200": 55, "h100": 98, "a100": 32, "t4": 4.5, "l4": 7}
+                for gt, info in sorted(spot_region_info.items()):
+                    avail = info.get("available", 0)
+                    per_node = spot_gpus_per_node.get(gt, 8)
+                    avail_display = f"[green]{avail}[/green]" if avail > 0 else f"[dim]0[/dim]"
+                    status = "[green]Node up[/green]" if avail > 0 else "Spins up on reserve (~10 min)"
+                    si = info.get("spot_info", {}) or {}
+                    sp = si.get("spot_price", "") if isinstance(si, dict) else ""
+                    if not sp or (isinstance(si, dict) and "No spot data" in str(si.get("spot_signal", ""))):
+                        avail_signal = "[red]Not offered[/red]"
+                    else:
+                        try:
+                            ratio = float(sp) / _on_demand.get(gt, 50)
+                            pct = int((1 - ratio) * 100)
+                            if ratio < 0.4: avail_signal = f"[green]High ({pct}% off)[/green]"
+                            elif ratio < 0.7: avail_signal = f"[yellow]Medium ({pct}% off)[/yellow]"
+                            else: avail_signal = f"[red]Low ({pct}% off)[/red]"
+                        except (ValueError, TypeError):
+                            avail_signal = "[yellow]Unknown[/yellow]"
+                    spot_table.add_row(f"{gt.upper()} *", avail_display, str(per_node), status, avail_signal)
+                console.print(spot_table)
+                rprint("[dim]* = spot: ~70% cheaper, AWS can reclaim with 2-min notice, fulfillment not guaranteed.[/dim]")
+                rprint("[dim]  Separate cluster (us-east-1) with separate disks. Select via gpu-dev reserve (interactive).[/dim]")
 
             # Show color legend
             rprint("\n[bold]Availability legend:[/bold]")
@@ -2847,7 +3002,7 @@ def _show_availability() -> None:
 
             # Show usage tip
             rprint(
-                "\n[dim]💡 Use 'gpu-dev reserve --gpu-type <type>' to reserve GPUs of a specific type[/dim]"
+                "\n[dim]💡 Use 'gpu-dev reserve' (interactive) to see all options including MIG slices and spot instances[/dim]"
             )
 
         else:
@@ -2858,6 +3013,9 @@ def _show_availability() -> None:
 
 
 def _show_availability_watch(interval: int) -> None:
+    _env_name = load_config().user_config.get("environment", "prod")
+    _spot_types = frozenset(Config.ENVIRONMENTS.get(_env_name, {}).get("spot_types", []))
+
     """Watch mode for GPU availability with auto-refresh"""
     import time
     from datetime import datetime
@@ -2990,8 +3148,9 @@ def _show_availability_watch(interval: int) -> None:
                             else:
                                 available_display = f"[yellow]{available}[/yellow]"
 
+                            type_label = f"{gpu_type.upper()} *" if gpu_type in _spot_types else gpu_type.upper()
                             table.add_row(
-                                gpu_type.upper(),
+                                type_label,
                                 available_display,
                                 str(max_reservable) if not is_maintenance else "-",
                                 str(total),
@@ -3079,10 +3238,8 @@ def connect(ctx: click.Context, reservation_id: Optional[str]) -> None:
 
             # If no reservation ID provided, show interactive selection
             if reservation_id is None:
-                reservations = reservation_mgr.list_reservations(
-                    user_filter=user_info["user_id"],
-                    statuses_to_include=["active"]
-                )
+                reservations = _fetch_reservations_cross_region(
+                    reservation_mgr, user_info["user_id"], ["active"], config)
 
                 live.stop()
 
@@ -3109,6 +3266,16 @@ def connect(ctx: click.Context, reservation_id: Optional[str]) -> None:
 
                 live.start()
 
+            # If the selected reservation is from east1, switch to east1 reservation_mgr
+            _sel = next((r for r in (locals().get("reservations") or []) if r.get("reservation_id", "").startswith(reservation_id)), None)
+            if _sel and _sel.get("_region") == "us-east-1":
+                import os as _os
+                east1_cfg = Config.ENVIRONMENTS.get("prod-east1", {})
+                _os.environ["AWS_DEFAULT_REGION"] = east1_cfg["region"]
+                _east1_config = Config()
+                _east1_config.aws_region = east1_cfg["region"]
+                reservation_mgr = ReservationManager(_east1_config)
+
             # Get connection info
             connection_info = reservation_mgr.get_connection_info(
                 reservation_id, user_info["user_id"]
@@ -3320,10 +3487,8 @@ def get_ssh_config_cmd(ctx: click.Context, reservation_id: Optional[str]) -> Non
 
             # If no reservation ID provided, show interactive selection
             if reservation_id is None:
-                reservations = reservation_mgr.list_reservations(
-                    user_filter=user_info["user_id"],
-                    statuses_to_include=["active"]
-                )
+                reservations = _fetch_reservations_cross_region(
+                    reservation_mgr, user_info["user_id"], ["active"], config)
 
                 live.stop()
 
@@ -3698,10 +3863,7 @@ def environment(env_name: str) -> None:
         rprint(f"[dim]Configuration saved to {cfg.CONFIG_FILE}[/dim]")
 
         # Instructions for shell export
-        rprint(f"\n[yellow]💡 To apply in your current shell:[/yellow]")
-        rprint(f"   export AWS_DEFAULT_REGION={env_config['region']}")
-        rprint(f"\n[yellow]💡 Or use the switch-to.sh script:[/yellow]")
-        rprint(f"   ./switch-to.sh {env_name}")
+        rprint(f"\n[dim]Region saved. All gpu-dev commands now target {env_config['region']}.[/dim]")
 
     except Exception as e:
         rprint(f"[red]❌ Error setting environment: {str(e)}[/red]")

{gpu_dev-0.5.30 → gpu_dev-0.5.31}/cli-tools/gpu-dev-cli/gpu_dev_cli/config.py

@@ -26,6 +26,7 @@ class Config:
             "region": "us-east-1",
             "workspace": "prod-east1",
             "description": "Spot-only us-east-1 environment (T4/L4/CPU)",
+            "spot_types": ["b300", "b200", "h200", "h100", "a100"],
         },
     }
     DEFAULT_ENVIRONMENT = "prod"