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

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

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

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

@@ -778,15 +778,24 @@ def engine_status(
             return "[green]Active[/green]"
         if running_state in ("stopped", "stopping"):
             return "[dim]N/A[/dim]"
-        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]"
-            )
-        return "[yellow]Idle[/yellow]"
+        
+        # If we don't have idle info at all, show N/A
+        if not idle_info.get("available"):
+            return "[dim]N/A[/dim]"
+            
+        # If idle, show time/threshold if available, otherwise show uncertainty
+        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]"
+            elif isinstance(thresh_v, (int, float)):
+                return f"[yellow]Idle ?/{int(thresh_v)//60}m[/yellow]"
+            else:
+                return "[yellow]Idle ?/?[/yellow]"
+        
+        # Default to N/A if we can't determine status
+        return "[dim]N/A[/dim]"
 
     active_disp = _compute_active_disp(idle_detector)
 
@@ -894,9 +903,10 @@ def engine_status(
                 status_lines.append(
                     f"  • GPU Drivers: {'OK' if health.get('drivers_ok') else 'MISSING'}"
                 )
-                status_lines.append(
-                    f"  • Idle Detector: {health.get('idle_detector_timer', 'unknown')}"
+                idle_stat = health.get("idle_detector_service") or health.get(
+                    "idle_detector_timer", "unknown"
                 )
+                status_lines.append(f"  • Idle Detector: {idle_stat}")
         except Exception:
             pass
 
@@ -915,8 +925,12 @@ def engine_status(
                 },
             )
             cid = res["Command"]["CommandId"]
-            time.sleep(1)
-            inv = ssm.get_command_invocation(CommandId=cid, InstanceId=instance_id)
+            # Wait up to 2 seconds for SSM command to complete (was 1 second)
+            for _ in range(4):  # 4 * 0.5 = 2 seconds
+                time.sleep(0.5)
+                inv = ssm.get_command_invocation(CommandId=cid, InstanceId=instance_id)
+                if inv["Status"] in ["Success", "Failed"]:
+                    break
             if inv["Status"] != "Success":
                 return None
             content = inv["StandardOutputContent"].strip()
@@ -1036,23 +1050,10 @@ def engine_status(
         status_lines.append(_sensor_line(" IDE   ", "IDEConnectionSensor", "🖥"))
         status_lines.append(_sensor_line("Docker", "DockerWorkloadSensor", "🐳"))
 
-        # If we have elapsed idle seconds and threshold, reflect that in the header
-        try:
-            if idle_detector.get("status") == "idle":
-                idle_secs = int(idle_detector.get("idle_seconds", 0))
-                thresh_secs = int(idle_detector.get("idle_threshold", 0))
-                if thresh_secs > 0:
-                    active_disp = (
-                        f"[yellow]Idle {idle_secs//60}m/{thresh_secs//60}m[/yellow]"
-                    )
-                    # Rewrite top header line (index 0) to include updated display
-                    all_header = top_lines[0]
-                    # Replace the portion after two spaces (name and running state fixed)
-                    top_lines[0] = (
-                        f"[blue]{engine['name']}[/blue]  {run_disp}  {active_disp}\n"
-                    )
-        except Exception:
-            pass
+        # Recompute display with latest idle detector data
+        active_disp = _compute_active_disp(idle_detector)
+        # Rewrite top header line (index 0) to include updated display
+        top_lines[0] = f"[blue]{engine['name']}[/blue]  {run_disp}  {active_disp}\n"
 
     # Combine top summary and details
     all_lines = top_lines + status_lines
@@ -2630,6 +2631,9 @@ 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()
@@ -2644,9 +2648,90 @@ 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
+        # Show current timeout setting
         resp = ssm.send_command(
             InstanceIds=[engine["instance_id"]],
             DocumentName="AWS-RunShellScript",
@@ -2687,7 +2772,7 @@ def idle_timeout_cmd(
     cmd = (
         "sudo sed -i '/^IDLE_TIMEOUT_SECONDS=/d' /etc/engine.env && "
         f"echo 'IDLE_TIMEOUT_SECONDS={seconds}' | sudo tee -a /etc/engine.env >/dev/null && "
-        "sudo systemctl restart engine-idle-detector.timer"
+        "sudo systemctl restart engine-idle-detector.service"
     )
 
     resp = ssm.send_command(
@@ -2826,8 +2911,7 @@ def repair_engine(
         "echo 'finished' | sudo tee /opt/dayhoff/state/engine-init.stage > /dev/null",
         # Ensure SSM agent is running
         "sudo systemctl restart amazon-ssm-agent 2>/dev/null || true",
-        # Restart idle detector
-        "sudo systemctl restart engine-idle-detector.timer 2>/dev/null || true",
+        # Restart idle detector (service only)
         "sudo systemctl restart engine-idle-detector.service 2>/dev/null || true",
         # Report status
         "echo '=== Repair Complete ===' && echo 'Sentinel: ' && ls -la /opt/dayhoff/first_boot_complete.sentinel",

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

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