dayhoff-tools 1.9.5__tar.gz → 1.9.7__tar.gz

{dayhoff_tools-1.9.5 → dayhoff_tools-1.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dayhoff-tools
-Version: 1.9.5
+Version: 1.9.7
 Summary: Common tools for all the repos at Dayhoff Labs
 Author: Daniel Martin-Alarcon
 Author-email: dma@dayhofflabs.com

{dayhoff_tools-1.9.5 → dayhoff_tools-1.9.7}/dayhoff_tools/cli/engine_commands.py

@@ -693,9 +693,10 @@ def list_engines(
 @engine_app.command("status")
 def engine_status(
     name_or_id: str = typer.Argument(help="Engine name or instance ID"),
-    show_log: bool = typer.Option(False, "--show-log", help="Show bootstrap log"),
+    detailed: bool = typer.Option(False, "--detailed", "-d", help="Show detailed status (slower)"),
+    show_log: bool = typer.Option(False, "--show-log", help="Show bootstrap log (requires --detailed)"),
 ):
-    """Show detailed engine status and information."""
+    """Show engine status and information."""
     check_aws_sso()
 
     # Get all engines to resolve name
@@ -706,8 +707,122 @@ def engine_status(
 
     engines = response.json().get("engines", [])
     engine = resolve_engine(name_or_id, engines)
+    
+    # Fast status display (default)
+    if not detailed:
+        # Skip the API call for studios - use basic info we already have
+        attached_studios = []
+        studio_user = engine.get("user")  # Use the engine's user as studio owner
+        
+        # Fetch idle status via SSM with longer timeout
+        ssm = boto3.client("ssm", region_name="us-east-1")
+        idle_data = None  # Use None to indicate no data received
+        
+        if engine["state"].lower() == "running":
+            try:
+                resp = ssm.send_command(
+                    InstanceIds=[engine["instance_id"]],
+                    DocumentName="AWS-RunShellScript",
+                    Parameters={
+                        "commands": [
+                            "cat /var/run/idle-detector/last_state.json 2>/dev/null || echo '{}'"
+                        ],
+                        "executionTimeout": ["10"],
+                    },
+                )
+                cid = resp["Command"]["CommandId"]
+                
+                # Wait up to 3 seconds for result
+                for _ in range(6):  # 6 * 0.5 = 3 seconds
+                    time.sleep(0.5)
+                    inv = ssm.get_command_invocation(
+                        CommandId=cid, InstanceId=engine["instance_id"]
+                    )
+                    if inv["Status"] in ["Success", "Failed"]:
+                        break
+                
+                if inv["Status"] == "Success":
+                    content = inv["StandardOutputContent"].strip()
+                    if content and content != "{}":
+                        idle_data = json.loads(content)
+                    else:
+                        idle_data = {}  # Empty response but SSM worked
+            except Exception:
+                idle_data = None  # SSM failed
+        
+        # Determine running state display
+        running_state = engine["state"].lower()
+        if running_state == "running":
+            run_disp = "[green]Running[/green]"
+        elif running_state == "pending":
+            run_disp = "[yellow]Starting...[/yellow]"
+        elif running_state == "stopping":
+            run_disp = "[yellow]Stopping...[/yellow]"
+        elif running_state == "stopped":
+            run_disp = "[dim]Stopped[/dim]"
+        else:
+            run_disp = engine["state"].capitalize()
+        
+        # Determine idle/active status
+        idle_disp = ""
+        if running_state == "running":
+            if idle_data is None:
+                # SSM failed - we don't know the status
+                idle_disp = "  [dim]N/A[/dim]"
+            elif not idle_data:
+                # Empty data - likely very early in boot
+                idle_disp = "  [dim]N/A[/dim]"
+            else:
+                # We have data
+                is_idle = idle_data.get("idle", False)
+                timeout_sec = idle_data.get("timeout_sec")
+                idle_seconds = idle_data.get("idle_seconds", 0) if is_idle else 0
+                
+                if is_idle:
+                    if isinstance(timeout_sec, int) and isinstance(idle_seconds, int):
+                        remaining = max(0, timeout_sec - idle_seconds)
+                        idle_disp = f"  [yellow]Idle {idle_seconds//60}m/{timeout_sec//60}m: [red]{remaining//60}m {remaining%60}s[/red] left[/yellow]"
+                    else:
+                        idle_disp = "  [yellow]Idle ?/?[/yellow]"
+                else:
+                    # Actively not idle
+                    idle_disp = "  [green]Active[/green]"
+        
+        # Build status lines - minimal info for fast view
+        status_lines = [
+            f"[blue]{engine['name']}[/blue]  {run_disp}{idle_disp}\n",
+        ]
+        
+        # Add studio owner if known
+        if studio_user:
+            status_lines.append(f"Studio: [magenta]{studio_user}[/magenta]")
+        
+        # Add activity sensors if we have idle data
+        if idle_data and idle_data.get("reasons"):
+            status_lines.append("")
+            status_lines.append("[bold]Activity:[/bold]")
+            
+            sensor_map = {
+                "CoffeeLockSensor": ("☕", "Coffee"),
+                "ActiveLoginSensor": ("🐚", "SSH"),
+                "IDEConnectionSensor": ("🖥 ", "IDE"),
+                "DockerWorkloadSensor": ("🐳", "Docker"),
+            }
+            
+            for r in idle_data.get("reasons", []):
+                sensor = r.get("sensor", "Unknown")
+                active = r.get("active", False)
+                icon, label = sensor_map.get(sensor, ("?", sensor))
+                status_str = "[green]YES[/green]" if active else "[dim]nope[/dim]"
+                status_lines.append(f"  {icon} {label:6} {status_str}")
+        
+        # Display in a nice panel
+        console.print(
+            Panel("\n".join(status_lines), title="Engine Status", border_style="blue")
+        )
+        return  # Exit early for fast status
 
-    # Get detailed engine status including idle detector info
+    # Get detailed engine status including idle detector info (for --detailed mode)
     response = make_api_request("GET", f"/engines/{engine['instance_id']}")
     if response.status_code != 200:
         console.print("[red]❌ Failed to fetch engine details[/red]")
@@ -783,12 +898,13 @@ def engine_status(
         if not idle_info.get("available"):
             return "[dim]N/A[/dim]"
             
-        # If idle, show time/threshold if available, otherwise show uncertainty
+        # If idle, show time/threshold with time remaining if available
         if idle_info.get("status") == "idle":
             idle_seconds_v = idle_info.get("idle_seconds")
             thresh_v = idle_info.get("idle_threshold")
             if isinstance(idle_seconds_v, (int, float)) and isinstance(thresh_v, (int, float)):
-                return f"[yellow]Idle {int(idle_seconds_v)//60}m/{int(thresh_v)//60}m[/yellow]"
+                remaining = max(0, int(thresh_v) - int(idle_seconds_v))
+                return f"[yellow]Idle {int(idle_seconds_v)//60}m/{int(thresh_v)//60}m: [red]{remaining//60}m {remaining%60}s[/red] left[/yellow]"
             elif isinstance(thresh_v, (int, float)):
                 return f"[yellow]Idle ?/{int(thresh_v)//60}m[/yellow]"
             else:
@@ -1062,6 +1178,9 @@ def engine_status(
     )
 
     if show_log:
+        if not detailed:
+            console.print("[yellow]Note: --show-log requires --detailed flag[/yellow]")
+            return
         console.print("\n[bold]Bootstrap Log:[/bold]")
         try:
             ssm = boto3.client("ssm", region_name="us-east-1")
@@ -2631,9 +2750,7 @@ def idle_timeout_cmd(
     set: Optional[str] = typer.Option(
         None, "--set", "-s", help="New timeout (e.g., 2h30m, 45m)"
     ),
-    status: bool = typer.Option(
-        False, "--status", help="Show detailed idle status (faster than full engine status)"
-    ),
+
 ):
     """Show or set the engine idle-detector timeout."""
     check_aws_sso()
@@ -2648,87 +2765,6 @@ def idle_timeout_cmd(
     engine = resolve_engine(name_or_id, engines)
 
     ssm = boto3.client("ssm", region_name="us-east-1")
-    
-    # Handle --status flag for quick idle status check
-    if status:
-        console.print(f"[bold]Idle Status for {engine['name']}:[/bold]")
-        
-        # Fetch state file with longer timeout for reliability
-        try:
-            resp = ssm.send_command(
-                InstanceIds=[engine["instance_id"]],
-                DocumentName="AWS-RunShellScript",
-                Parameters={
-                    "commands": [
-                        "cat /var/run/idle-detector/last_state.json 2>/dev/null || echo '{}'"
-                    ],
-                    "executionTimeout": ["10"],
-                },
-            )
-            cid = resp["Command"]["CommandId"]
-            
-            # Wait up to 3 seconds for result
-            for _ in range(6):  # 6 * 0.5 = 3 seconds
-                time.sleep(0.5)
-                inv = ssm.get_command_invocation(
-                    CommandId=cid, InstanceId=engine["instance_id"]
-                )
-                if inv["Status"] in ["Success", "Failed"]:
-                    break
-            
-            if inv["Status"] == "Success":
-                import json
-                content = inv["StandardOutputContent"].strip()
-                if content and content != "{}":
-                    data = json.loads(content)
-                    
-                    # Extract key values
-                    is_idle = data.get("idle", False)
-                    timeout_sec = data.get("timeout_sec", "?")
-                    idle_seconds = data.get("idle_seconds", 0) if is_idle else 0
-                    
-                    # Display status
-                    if is_idle:
-                        if isinstance(timeout_sec, int) and isinstance(idle_seconds, int):
-                            console.print(f"  Status: [yellow]Idle {idle_seconds//60}m/{timeout_sec//60}m[/yellow]")
-                            remaining = max(0, timeout_sec - idle_seconds)
-                            console.print(f"  Time until shutdown: [red]{remaining//60}m {remaining%60}s[/red]")
-                        else:
-                            console.print(f"  Status: [yellow]Idle (timing unavailable)[/yellow]")
-                    else:
-                        console.print(f"  Status: [green]Active[/green]")
-                        if isinstance(timeout_sec, int):
-                            console.print(f"  Timeout: {timeout_sec//60}m ({timeout_sec}s)")
-                    
-                    # Show activity sensors
-                    console.print("\n[bold]Activity Sensors:[/bold]")
-                    reasons = data.get("reasons", [])
-                    for r in reasons:
-                        sensor = r.get("sensor", "Unknown")
-                        active = r.get("active", False)
-                        reason = r.get("reason", "")
-                        
-                        # Map sensor names to icons and labels
-                        sensor_map = {
-                            "CoffeeLockSensor": ("☕", "Coffee"),
-                            "ActiveLoginSensor": ("🐚", "SSH"),
-                            "IDEConnectionSensor": ("🖥", "IDE"),
-                            "DockerWorkloadSensor": ("🐳", "Docker"),
-                        }
-                        
-                        icon, label = sensor_map.get(sensor, ("?", sensor))
-                        status_str = "[green]YES[/green]" if active else "[dim]no[/dim]"
-                        console.print(f"  {icon} {label:8} {status_str}  {reason if active else ''}")
-                    
-                else:
-                    console.print("[yellow]⚠️  Could not read idle detector state[/yellow]")
-            else:
-                console.print(f"[red]❌ Failed to get status: {inv.get('StandardErrorContent', 'Unknown error')}[/red]")
-                
-        except Exception as e:
-            console.print(f"[red]❌ Error fetching idle status: {e}[/red]")
-        
-        return
 
     if set is None:
         # Show current timeout setting

{dayhoff_tools-1.9.5 → dayhoff_tools-1.9.7}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "dayhoff-tools"
-version = "1.9.5"
+version = "1.9.7"
 description = "Common tools for all the repos at Dayhoff Labs"
 authors = [
     {name = "Daniel Martin-Alarcon", email = "dma@dayhofflabs.com"}