dayhoff-tools 1.3.9__tar.gz → 1.3.11__tar.gz

{dayhoff_tools-1.3.9 → dayhoff_tools-1.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dayhoff-tools
-Version: 1.3.9
+Version: 1.3.11
 Summary: Common tools for all the repos at Dayhoff Labs
 Author: Daniel Martin-Alarcon
 Author-email: dma@dayhofflabs.com
@@ -14,7 +14,7 @@ Provides-Extra: embedders
 Provides-Extra: full
 Requires-Dist: biopython (>=1.84) ; extra == "full"
 Requires-Dist: biopython (>=1.85) ; extra == "embedders"
-Requires-Dist: boto3 (>=1.36.8) ; extra == "full"
+Requires-Dist: boto3 (>=1.36.8)
 Requires-Dist: docker (>=7.1.0) ; extra == "full"
 Requires-Dist: fair-esm (>=2.0.0) ; extra == "embedders"
 Requires-Dist: fair-esm (>=2.0.0) ; extra == "full"

{dayhoff_tools-1.3.9 → dayhoff_tools-1.3.11}/dayhoff_tools/cli/engine_commands.py

@@ -3,6 +3,7 @@
 import json
 import subprocess
 import sys
+import time
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
@@ -127,6 +128,95 @@ def format_duration(duration: timedelta) -> str:
         return f"{minutes}m"
 
 
+def get_disk_usage_via_ssm(instance_id: str) -> Optional[str]:
+    """Get disk usage for an engine via SSM.
+    
+    Returns:
+        String like "17/50 GB" or None if failed
+    """
+    try:
+        ssm = boto3.client("ssm", region_name="us-east-1")
+        
+        # Run df command to get disk usage
+        response = ssm.send_command(
+            InstanceIds=[instance_id],
+            DocumentName="AWS-RunShellScript",
+            Parameters={
+                "commands": [
+                    # Get root filesystem usage in GB
+                    "df -BG / | tail -1 | awk '{gsub(/G/, \"\", $2); gsub(/G/, \"\", $3); print $3 \"/\" $2 \" GB\"}'"
+                ],
+                "executionTimeout": ["10"],
+            },
+        )
+        
+        command_id = response["Command"]["CommandId"]
+        
+        # Wait for command to complete (with timeout)
+        for _ in range(5):  # 5 second timeout
+            time.sleep(1)
+            result = ssm.get_command_invocation(
+                CommandId=command_id,
+                InstanceId=instance_id,
+            )
+            if result["Status"] in ["Success", "Failed"]:
+                break
+        
+        if result["Status"] == "Success":
+            output = result["StandardOutputContent"].strip()
+            return output if output else None
+        
+        return None
+        
+    except Exception as e:
+        # logger.debug(f"Failed to get disk usage for {instance_id}: {e}") # Original code had this line commented out
+        return None
+
+
+def get_studio_disk_usage_via_ssm(instance_id: str, username: str) -> Optional[str]:
+    """Get disk usage for a studio via SSM.
+    
+    Returns:
+        String like "333/500 GB" or None if failed
+    """
+    try:
+        ssm = boto3.client("ssm", region_name="us-east-1")
+        
+        # Run df command to get studio disk usage
+        response = ssm.send_command(
+            InstanceIds=[instance_id],
+            DocumentName="AWS-RunShellScript",
+            Parameters={
+                "commands": [
+                    # Get studio filesystem usage in GB
+                    f"df -BG /studios/{username} 2>/dev/null | tail -1 | awk '{{gsub(/G/, \"\", $2); gsub(/G/, \"\", $3); print $3 \"/\" $2 \" GB\"}}'"
+                ],
+                "executionTimeout": ["10"],
+            },
+        )
+        
+        command_id = response["Command"]["CommandId"]
+        
+        # Wait for command to complete (with timeout)
+        for _ in range(5):  # 5 second timeout
+            time.sleep(1)
+            result = ssm.get_command_invocation(
+                CommandId=command_id,
+                InstanceId=instance_id,
+            )
+            if result["Status"] in ["Success", "Failed"]:
+                break
+        
+        if result["Status"] == "Success":
+            output = result["StandardOutputContent"].strip()
+            return output if output else None
+        
+        return None
+        
+    except Exception:
+        return None
+
+
 def parse_launch_time(launch_time_str: str) -> datetime:
     """Parse launch time from API response."""
     # Try different datetime formats
@@ -381,6 +471,7 @@ def list_engines(
         table.add_column("Type")
         table.add_column("User")
         table.add_column("Status")
+        table.add_column("Disk Usage")
         table.add_column("Uptime/Since")
         table.add_column("$/hour", justify="right")
         table.add_column("Cost Today", justify="right", style="yellow")
@@ -395,9 +486,12 @@ def list_engines(
                 daily_cost = hourly_cost * min(uptime.total_seconds() / 3600, 24)
                 total_cost += daily_cost
                 time_str = format_duration(uptime)
+                # Get disk usage for running engines
+                disk_usage = get_disk_usage_via_ssm(engine["instance_id"]) or "-"
             else:
                 daily_cost = 0
                 time_str = launch_time.strftime("%Y-%m-%d %H:%M")
+                disk_usage = "-"
 
             table.add_row(
                 engine["name"],
@@ -405,6 +499,7 @@ def list_engines(
                 engine["engine_type"],
                 engine["user"],
                 format_status(engine["state"], engine.get("ready")),
+                disk_usage,
                 time_str,
                 f"${hourly_cost:.2f}",
                 f"${daily_cost:.2f}" if daily_cost > 0 else "-",
@@ -776,8 +871,6 @@ def keep_awake(
         command_id = response["Command"]["CommandId"]
 
         # Wait for command to complete
-        import time
-
         for _ in range(10):
             time.sleep(1)
             result = ssm.get_command_invocation(
@@ -837,8 +930,6 @@ def cancel_keep_awake(
         command_id = response["Command"]["CommandId"]
 
         # Wait for command to complete
-        import time
-
         for _ in range(10):
             time.sleep(1)
             result = ssm.get_command_invocation(
@@ -861,6 +952,124 @@ def cancel_keep_awake(
         console.print(f"[red]❌ Failed to cancel keep-awake: {e}[/red]")
 
 
+@engine_app.command("resize")
+def resize_engine(
+    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+    size: int = typer.Option(..., "--size", "-s", help="New size in GB"),
+    online: bool = typer.Option(
+        False, "--online", help="Resize while running (requires manual filesystem expansion)"
+    ),
+):
+    """Resize an engine's boot disk."""
+    check_aws_sso()
+
+    # Get all engines to resolve name
+    response = make_api_request("GET", "/engines")
+    if response.status_code != 200:
+        console.print("[red]❌ Failed to fetch engines[/red]")
+        raise typer.Exit(1)
+
+    engines = response.json().get("engines", [])
+    engine = resolve_engine(name_or_id, engines)
+
+    # Get current volume info to validate size
+    ec2 = boto3.client("ec2", region_name="us-east-1")
+    
+    try:
+        # Get instance details to find root volume
+        instance_info = ec2.describe_instances(InstanceIds=[engine["instance_id"]])
+        instance = instance_info["Reservations"][0]["Instances"][0]
+        
+        # Find root volume
+        root_device = instance.get("RootDeviceName", "/dev/xvda")
+        root_volume_id = None
+        
+        for bdm in instance.get("BlockDeviceMappings", []):
+            if bdm["DeviceName"] == root_device:
+                root_volume_id = bdm["Ebs"]["VolumeId"]
+                break
+        
+        if not root_volume_id:
+            console.print("[red]❌ Could not find root volume[/red]")
+            raise typer.Exit(1)
+        
+        # Get current volume size
+        volumes = ec2.describe_volumes(VolumeIds=[root_volume_id])
+        current_size = volumes["Volumes"][0]["Size"]
+        
+        if size <= current_size:
+            console.print(f"[red]❌ New size ({size}GB) must be larger than current size ({current_size}GB)[/red]")
+            raise typer.Exit(1)
+        
+        console.print(f"[yellow]Resizing engine boot disk from {current_size}GB to {size}GB[/yellow]")
+        
+        # Check if we need to stop the instance
+        if not online and engine["state"].lower() == "running":
+            console.print("Stopping engine for offline resize...")
+            stop_response = make_api_request(
+                "POST", f"/engines/{engine['instance_id']}/stop", json_data={"detach_studios": False}
+            )
+            if stop_response.status_code != 200:
+                console.print("[red]❌ Failed to stop engine[/red]")
+                raise typer.Exit(1)
+            
+            # Wait for instance to stop
+            console.print("Waiting for engine to stop...")
+            waiter = ec2.get_waiter("instance_stopped")
+            waiter.wait(InstanceIds=[engine["instance_id"]])
+            console.print("[green]✓ Engine stopped[/green]")
+        
+        # Call the resize API
+        console.print("Resizing volume...")
+        resize_response = make_api_request(
+            "POST", 
+            f"/engines/{engine['instance_id']}/resize",
+            json_data={"size": size}
+        )
+        
+        if resize_response.status_code != 200:
+            error = resize_response.json().get("error", "Unknown error")
+            console.print(f"[red]❌ Failed to resize engine: {error}[/red]")
+            raise typer.Exit(1)
+        
+        # Wait for volume modification to complete
+        console.print("Waiting for volume modification to complete...")
+        while True:
+            mod_state = ec2.describe_volumes_modifications(VolumeIds=[root_volume_id])
+            if not mod_state["VolumesModifications"]:
+                break  # Modification complete
+            state = mod_state["VolumesModifications"][0]["ModificationState"]
+            if state == "completed":
+                break
+            elif state == "failed":
+                console.print("[red]❌ Volume modification failed[/red]")
+                raise typer.Exit(1)
+            time.sleep(5)
+        
+        console.print("[green]✓ Volume resized successfully[/green]")
+        
+        # If offline resize, start the instance back up
+        if not online and engine["state"].lower() == "running":
+            console.print("Starting engine back up...")
+            start_response = make_api_request("POST", f"/engines/{engine['instance_id']}/start")
+            if start_response.status_code != 200:
+                console.print("[yellow]⚠️  Failed to restart engine automatically[/yellow]")
+                console.print(f"Please start it manually: [cyan]dh engine start {engine['name']}[/cyan]")
+            else:
+                console.print("[green]✓ Engine started[/green]")
+                console.print("The filesystem will be automatically expanded on boot.")
+        
+        elif online and engine["state"].lower() == "running":
+            console.print("\n[yellow]⚠️  Online resize complete. You must now expand the filesystem:[/yellow]")
+            console.print(f"1. SSH into the engine: [cyan]ssh {engine['name']}[/cyan]")
+            console.print("2. Run: [cyan]sudo growpart /dev/nvme0n1 1[/cyan]")
+            console.print("3. Run: [cyan]sudo xfs_growfs /[/cyan]")
+        
+    except ClientError as e:
+        console.print(f"[red]❌ Failed to resize engine: {e}[/red]")
+        raise typer.Exit(1)
+
+
 @engine_app.command("create-ami")
 def create_ami(
     name_or_id: str = typer.Argument(
@@ -924,8 +1133,6 @@ def create_ami(
         )
 
         # Wait for cleanup to complete
-        import time
-
         command_id = cleanup_response["Command"]["CommandId"]
         for _ in range(10):
             time.sleep(1)
@@ -1098,14 +1305,26 @@ def create_studio(
 
 
 @studio_app.command("status")
-def studio_status():
+def studio_status(
+    user: Optional[str] = typer.Option(None, "--user", "-u", help="Check status for a different user (admin only)"),
+):
     """Show status of your studio."""
     username = check_aws_sso()
-
-    studio = get_user_studio(username)
+    
+    # Use specified user if provided, otherwise use current user
+    target_user = user if user else username
+    
+    # Add warning when checking another user's studio
+    if target_user != username:
+        console.print(f"[yellow]⚠️  Checking studio status for user: {target_user}[/yellow]")
+    
+    studio = get_user_studio(target_user)
     if not studio:
-        console.print("[yellow]You don't have a studio yet.[/yellow]")
-        console.print("Create one with: [cyan]dh studio create[/cyan]")
+        if target_user == username:
+            console.print("[yellow]You don't have a studio yet.[/yellow]")
+            console.print("Create one with: [cyan]dh studio create[/cyan]")
+        else:
+            console.print(f"[yellow]User {target_user} doesn't have a studio.[/yellow]")
         return
 
     # Create status panel
@@ -1153,28 +1372,43 @@ def studio_status():
 @studio_app.command("attach")
 def attach_studio(
     engine_name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+    user: Optional[str] = typer.Option(None, "--user", "-u", help="Attach a different user's studio (admin only)"),
 ):
     """Attach your studio to an engine."""
     username = check_aws_sso()
+    
+    # Use specified user if provided, otherwise use current user
+    target_user = user if user else username
+    
+    # Add confirmation when attaching another user's studio
+    if target_user != username:
+        console.print(f"[yellow]⚠️  Managing studio for user: {target_user}[/yellow]")
+        if not Confirm.ask(f"Are you sure you want to attach {target_user}'s studio?"):
+            console.print("Operation cancelled.")
+            return
 
     # Get user's studio
-    studio = get_user_studio(username)
+    studio = get_user_studio(target_user)
     if not studio:
-        console.print("[yellow]You don't have a studio yet.[/yellow]")
-        if Confirm.ask("Would you like to create one now?"):
-            size = IntPrompt.ask("Studio size (GB)", default=50)
-            response = make_api_request(
-                "POST",
-                "/studios",
-                json_data={"user": username, "size_gb": size},
-            )
-            if response.status_code != 201:
-                console.print("[red]❌ Failed to create studio[/red]")
-                raise typer.Exit(1)
-            studio = response.json()
-            studio["studio_id"] = studio["studio_id"]  # Normalize key
+        if target_user == username:
+            console.print("[yellow]You don't have a studio yet.[/yellow]")
+            if Confirm.ask("Would you like to create one now?"):
+                size = IntPrompt.ask("Studio size (GB)", default=50)
+                response = make_api_request(
+                    "POST",
+                    "/studios",
+                    json_data={"user": username, "size_gb": size},
+                )
+                if response.status_code != 201:
+                    console.print("[red]❌ Failed to create studio[/red]")
+                    raise typer.Exit(1)
+                studio = response.json()
+                studio["studio_id"] = studio["studio_id"]  # Normalize key
+            else:
+                raise typer.Exit(0)
         else:
-            raise typer.Exit(0)
+            console.print(f"[red]❌ User {target_user} doesn't have a studio.[/red]")
+            raise typer.Exit(1)
 
     # Check if already attached
     if studio.get("status") == "in-use":
@@ -1238,7 +1472,7 @@ def attach_studio(
             f"/studios/{studio['studio_id']}/attach",
             json_data={
                 "vm_id": engine["instance_id"],
-                "user": username,
+                "user": target_user,  # Use target_user instead of username
                 "public_key": public_key,
             },
         )
@@ -1248,28 +1482,46 @@ def attach_studio(
     if response.status_code == 200:
         console.print(f"[green]✓ Studio attached successfully![/green]")
 
-        # Update SSH config
-        update_ssh_config_entry(engine["name"], engine["instance_id"], username)
+        # Update SSH config - use target_user for the connection
+        update_ssh_config_entry(engine["name"], engine["instance_id"], target_user)
         console.print(f"[green]✓ SSH config updated[/green]")
         console.print(f"\nConnect with: [cyan]ssh {engine['name']}[/cyan]")
-        console.print(f"Your files are at: [cyan]/studios/{username}[/cyan]")
+        console.print(f"Files are at: [cyan]/studios/{target_user}[/cyan]")
     else:
         error = response.json().get("error", "Unknown error")
         console.print(f"[red]❌ Failed to attach studio: {error}[/red]")
 
 
 @studio_app.command("detach")
-def detach_studio():
+def detach_studio(
+    user: Optional[str] = typer.Option(None, "--user", "-u", help="Detach a different user's studio (admin only)"),
+):
     """Detach your studio from its current engine."""
     username = check_aws_sso()
+    
+    # Use specified user if provided, otherwise use current user
+    target_user = user if user else username
+    
+    # Add confirmation when detaching another user's studio
+    if target_user != username:
+        console.print(f"[yellow]⚠️  Managing studio for user: {target_user}[/yellow]")
+        if not Confirm.ask(f"Are you sure you want to detach {target_user}'s studio?"):
+            console.print("Operation cancelled.")
+            return
 
-    studio = get_user_studio(username)
+    studio = get_user_studio(target_user)
     if not studio:
-        console.print("[yellow]You don't have a studio.[/yellow]")
+        if target_user == username:
+            console.print("[yellow]You don't have a studio.[/yellow]")
+        else:
+            console.print(f"[yellow]User {target_user} doesn't have a studio.[/yellow]")
         return
 
     if studio.get("status") != "in-use":
-        console.print("[yellow]Your studio is not attached to any engine.[/yellow]")
+        if target_user == username:
+            console.print("[yellow]Your studio is not attached to any engine.[/yellow]")
+        else:
+            console.print(f"[yellow]{target_user}'s studio is not attached to any engine.[/yellow]")
         return
 
     console.print(f"Detaching studio from {studio.get('attached_vm_id')}...")
@@ -1284,23 +1536,36 @@ def detach_studio():
 
 
 @studio_app.command("delete")
-def delete_studio():
+def delete_studio(
+    user: Optional[str] = typer.Option(None, "--user", "-u", help="Delete a different user's studio (admin only)"),
+):
     """Delete your studio permanently."""
     username = check_aws_sso()
-
-    studio = get_user_studio(username)
+    
+    # Use specified user if provided, otherwise use current user
+    target_user = user if user else username
+    
+    # Extra warning when deleting another user's studio
+    if target_user != username:
+        console.print(f"[red]⚠️  ADMIN ACTION: Deleting studio for user: {target_user}[/red]")
+
+    studio = get_user_studio(target_user)
     if not studio:
-        console.print("[yellow]You don't have a studio to delete.[/yellow]")
+        if target_user == username:
+            console.print("[yellow]You don't have a studio to delete.[/yellow]")
+        else:
+            console.print(f"[yellow]User {target_user} doesn't have a studio to delete.[/yellow]")
         return
 
     console.print(
-        "[red]⚠️  WARNING: This will permanently delete your studio and all data![/red]"
+        "[red]⚠️  WARNING: This will permanently delete the studio and all data![/red]"
     )
     console.print(f"Studio ID: {studio['studio_id']}")
+    console.print(f"User: {target_user}")
     console.print(f"Size: {studio['size_gb']}GB")
 
     # Multiple confirmations
-    if not Confirm.ask("\nAre you sure you want to delete your studio?"):
+    if not Confirm.ask(f"\nAre you sure you want to delete {target_user}'s studio?" if target_user != username else "\nAre you sure you want to delete your studio?"):
         console.print("Deletion cancelled.")
         return
 
@@ -1353,8 +1618,8 @@ def list_studios(
         table.add_column("User")
         table.add_column("Status")
         table.add_column("Size", justify="right")
+        table.add_column("Disk Usage", justify="right")
         table.add_column("Attached To")
-        table.add_column("Created")
 
         for studio in studios:
             # Change status display
@@ -1367,29 +1632,25 @@ def list_studios(
 
             # Format attached engine info
             attached_to = "-"
+            disk_usage = "?/?"
             if studio.get("attached_vm_id"):
                 vm_id = studio["attached_vm_id"]
                 engine_name = engines.get(vm_id, "unknown")
                 attached_to = f"{engine_name} ({vm_id})"
-
-            # Format creation date (remove microseconds and timezone info)
-            created = studio["creation_date"]
-            try:
-                # Parse and reformat to just show date and time
-                if "T" in created:
-                    created_dt = datetime.fromisoformat(created.replace("Z", "+00:00"))
-                    created = created_dt.strftime("%Y-%m-%d %H:%M")
-            except:
-                # If parsing fails, just truncate
-                created = created.split("T")[0] if "T" in created else created[:16]
+                
+                # Try to get disk usage if attached
+                if studio["status"] == "in-use":
+                    usage = get_studio_disk_usage_via_ssm(vm_id, studio["user"])
+                    if usage:
+                        disk_usage = usage
 
             table.add_row(
                 studio["studio_id"],
                 studio["user"],
                 status_display,
                 f"{studio['size_gb']}GB",
+                disk_usage,
                 attached_to,
-                created,
             )
 
         console.print(table)
@@ -1399,16 +1660,28 @@ def list_studios(
 
 
 @studio_app.command("reset")
-def reset_studio():
+def reset_studio(
+    user: Optional[str] = typer.Option(None, "--user", "-u", help="Reset a different user's studio"),
+):
     """Reset a stuck studio (admin operation)."""
     username = check_aws_sso()
-
-    studio = get_user_studio(username)
+    
+    # Use specified user if provided, otherwise use current user
+    target_user = user if user else username
+    
+    # Add warning when resetting another user's studio
+    if target_user != username:
+        console.print(f"[yellow]⚠️  Resetting studio for user: {target_user}[/yellow]")
+
+    studio = get_user_studio(target_user)
     if not studio:
-        console.print("[yellow]You don't have a studio.[/yellow]")
+        if target_user == username:
+            console.print("[yellow]You don't have a studio.[/yellow]")
+        else:
+            console.print(f"[yellow]User {target_user} doesn't have a studio.[/yellow]")
         return
 
-    console.print(f"[yellow]⚠️  This will force-reset your studio state[/yellow]")
+    console.print(f"[yellow]⚠️  This will force-reset the studio state[/yellow]")
     console.print(f"Current status: {studio['status']}")
     if studio.get("attached_vm_id"):
         console.print(f"Listed as attached to: {studio['attached_vm_id']}")
@@ -1461,3 +1734,91 @@ def reset_studio():
 
     except ClientError as e:
         console.print(f"[red]❌ Failed to reset studio: {e}[/red]")
+
+
+@studio_app.command("resize")
+def resize_studio(
+    size: int = typer.Option(..., "--size", "-s", help="New size in GB"),
+    user: Optional[str] = typer.Option(None, "--user", "-u", help="Resize a different user's studio (admin only)"),
+):
+    """Resize your studio volume (requires detachment)."""
+    username = check_aws_sso()
+    
+    # Use specified user if provided, otherwise use current user
+    target_user = user if user else username
+    
+    # Add warning when resizing another user's studio
+    if target_user != username:
+        console.print(f"[yellow]⚠️  Resizing studio for user: {target_user}[/yellow]")
+
+    studio = get_user_studio(target_user)
+    if not studio:
+        if target_user == username:
+            console.print("[yellow]You don't have a studio yet.[/yellow]")
+        else:
+            console.print(f"[yellow]User {target_user} doesn't have a studio.[/yellow]")
+        return
+
+    current_size = studio["size_gb"]
+    
+    if size <= current_size:
+        console.print(f"[red]❌ New size ({size}GB) must be larger than current size ({current_size}GB)[/red]")
+        raise typer.Exit(1)
+
+    # Check if studio is attached
+    if studio["status"] == "in-use":
+        console.print("[yellow]⚠️  Studio must be detached before resizing[/yellow]")
+        console.print(f"Currently attached to: {studio.get('attached_vm_id')}")
+        
+        if not Confirm.ask("\nDetach studio and proceed with resize?"):
+            console.print("Resize cancelled.")
+            return
+        
+        # Detach the studio
+        console.print("Detaching studio...")
+        response = make_api_request("POST", f"/studios/{studio['studio_id']}/detach")
+        if response.status_code != 200:
+            console.print("[red]❌ Failed to detach studio[/red]")
+            raise typer.Exit(1)
+        
+        console.print("[green]✓ Studio detached[/green]")
+        
+        # Wait a moment for detachment to complete
+        time.sleep(5)
+
+    console.print(f"[yellow]Resizing studio from {current_size}GB to {size}GB[/yellow]")
+
+    # Call the resize API
+    resize_response = make_api_request(
+        "POST",
+        f"/studios/{studio['studio_id']}/resize",
+        json_data={"size": size}
+    )
+    
+    if resize_response.status_code != 200:
+        error = resize_response.json().get("error", "Unknown error")
+        console.print(f"[red]❌ Failed to resize studio: {error}[/red]")
+        raise typer.Exit(1)
+    
+    # Wait for volume modification to complete
+    ec2 = boto3.client("ec2", region_name="us-east-1")
+    console.print("Waiting for volume modification to complete...")
+    while True:
+        try:
+            mod_state = ec2.describe_volumes_modifications(VolumeIds=[studio["studio_id"]])
+            if not mod_state["VolumesModifications"]:
+                break  # Modification complete
+            state = mod_state["VolumesModifications"][0]["ModificationState"]
+            if state == "completed":
+                break
+            elif state == "failed":
+                console.print("[red]❌ Volume modification failed[/red]")
+                raise typer.Exit(1)
+            time.sleep(5)
+        except ClientError:
+            # Modification might be complete
+            break
+    
+    console.print(f"[green]✓ Studio resized successfully to {size}GB![/green]")
+    console.print("\n[dim]The filesystem will be automatically expanded when you next attach the studio.[/dim]")
+    console.print(f"To attach: [cyan]dh studio attach <engine-name>[/cyan]")

{dayhoff_tools-1.3.9 → dayhoff_tools-1.3.11}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "dayhoff-tools"
-version = "1.3.9"
+version = "1.3.11"
 description = "Common tools for all the repos at Dayhoff Labs"
 authors = [
     {name = "Daniel Martin-Alarcon", email = "dma@dayhofflabs.com"}
@@ -20,13 +20,13 @@ dependencies = [
     "toml>=0.10",
     "questionary>=2.0.1",
     "tzdata>=2025.2",
+    "boto3>=1.36.8",
 ]
 requires-python = ">=3.10,<4.0"
 
 [project.optional-dependencies]
 full = [
     "biopython>=1.84",
-    "boto3>=1.36.8",
     "docker>=7.1.0",
     "fair-esm>=2.0.0",
     "h5py>=3.11.0",