dayhoff-tools 1.9.10__py3-none-any.whl → 1.9.12__py3-none-any.whl

dayhoff_tools/cli/engine/__init__.py

@@ -6,44 +6,286 @@ import typer
 engine_app = typer.Typer(help="Manage compute engines for development.")
 studio_app = typer.Typer(help="Manage persistent development studios.")
 
-# Import all command functions
-from .engine_core import engine_status, launch_engine, list_engines
-from .engine_lifecycle import start_engine, stop_engine, terminate_engine
-from .engine_maintenance import coffee, debug_engine, idle_timeout_cmd, repair_engine
-from .engine_management import config_ssh, create_ami, resize_engine, ssh_engine
-from .studio_commands import (
-    attach_studio,
-    create_studio,
-    delete_studio,
-    detach_studio,
-    list_studios,
-    reset_studio,
-    resize_studio,
-    studio_status,
-)
-
-# Register engine commands
-engine_app.command("launch")(launch_engine)
-engine_app.command("list")(list_engines)
-engine_app.command("status")(engine_status)
-engine_app.command("start")(start_engine)
-engine_app.command("stop")(stop_engine)
-engine_app.command("terminate")(terminate_engine)
-engine_app.command("ssh")(ssh_engine)
-engine_app.command("config-ssh")(config_ssh)
-engine_app.command("resize")(resize_engine)
-engine_app.command("gami")(create_ami)
-engine_app.command("coffee")(coffee)
-engine_app.command("idle")(idle_timeout_cmd)
-engine_app.command("debug")(debug_engine)
-engine_app.command("repair")(repair_engine)
-
-# Register studio commands
-studio_app.command("create")(create_studio)
-studio_app.command("status")(studio_status)
-studio_app.command("attach")(attach_studio)
-studio_app.command("detach")(detach_studio)
-studio_app.command("delete")(delete_studio)
-studio_app.command("list")(list_studios)
-studio_app.command("reset")(reset_studio)
-studio_app.command("resize")(resize_studio)
+# Use lazy loading pattern similar to main.py swarm commands
+# Import functions only when commands are actually called
+
+# Engine commands
+@engine_app.command("launch")
+def launch_engine_cmd(
+    name: str = typer.Argument(help="Name for the new engine"),
+    engine_type: str = typer.Option(
+        "cpu",
+        "--type",
+        "-t",
+        help="Engine type: cpu, cpumax, t4, a10g, a100, 4_t4, 8_t4, 4_a10g, 8_a10g",
+    ),
+    user: str = typer.Option(None, "--user", "-u", help="Override username"),
+    boot_disk_size: int = typer.Option(
+        None,
+        "--size",
+        "-s",
+        help="Boot disk size in GB (default: 50GB, min: 20GB, max: 1000GB)",
+    ),
+    availability_zone: str = typer.Option(
+        None,
+        "--az",
+        help="Prefer a specific Availability Zone (e.g., us-east-1b). If omitted the service will try all public subnets.",
+    ),
+):
+    """Launch a new engine instance."""
+    from .engine_core import launch_engine
+    return launch_engine(name, engine_type, user, boot_disk_size, availability_zone)
+
+
+@engine_app.command("list")
+def list_engines_cmd(
+    user: str = typer.Option(None, "--user", "-u", help="Filter by user"),
+    running_only: bool = typer.Option(
+        False, "--running", help="Show only running engines"
+    ),
+    stopped_only: bool = typer.Option(
+        False, "--stopped", help="Show only stopped engines"
+    ),
+    detailed: bool = typer.Option(
+        False, "--detailed", "-d", help="Show detailed status (slower)"
+    ),
+):
+    """List engines (shows all engines by default)."""
+    from .engine_core import list_engines
+    return list_engines(user, running_only, stopped_only, detailed)
+
+
+@engine_app.command("status")
+def engine_status_cmd(
+    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+    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 engine status and information."""
+    from .engine_core import engine_status
+    return engine_status(name_or_id, detailed, show_log)
+
+
+@engine_app.command("start")
+def start_engine_cmd(
+    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+):
+    """Start a stopped engine."""
+    from .engine_lifecycle import start_engine
+    return start_engine(name_or_id)
+
+
+@engine_app.command("stop")
+def stop_engine_cmd(
+    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Force stop and detach all studios"
+    ),
+):
+    """Stop an engine."""
+    from .engine_lifecycle import stop_engine
+    return stop_engine(name_or_id, force)
+
+
+@engine_app.command("terminate")
+def terminate_engine_cmd(
+    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+):
+    """Permanently terminate an engine."""
+    from .engine_lifecycle import terminate_engine
+    return terminate_engine(name_or_id)
+
+
+@engine_app.command("ssh")
+def ssh_engine_cmd(
+    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+    admin: bool = typer.Option(
+        False, "--admin", help="Connect as ec2-user instead of the engine owner user"
+    ),
+    idle_timeout: int = typer.Option(
+        600,
+        "--idle-timeout",
+        help="Idle timeout (seconds) for the SSM port-forward (0 = disable)",
+    ),
+):
+    """Connect to an engine via SSH."""
+    from .engine_management import ssh_engine
+    return ssh_engine(name_or_id, admin, idle_timeout)
+
+
+@engine_app.command("config-ssh")
+def config_ssh_cmd(
+    clean: bool = typer.Option(False, "--clean", help="Remove all managed entries"),
+    all_engines: bool = typer.Option(
+        False, "--all", "-a", help="Include all engines from all users"
+    ),
+    admin: bool = typer.Option(
+        False,
+        "--admin",
+        help="Generate entries that use ec2-user instead of per-engine owner user",
+    ),
+):
+    """Update SSH config with available engines."""
+    from .engine_management import config_ssh
+    return config_ssh(clean, all_engines, admin)
+
+
+@engine_app.command("resize")
+def resize_engine_cmd(
+    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)",
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Force resize and detach all studios"
+    ),
+):
+    """Resize an engine's boot disk."""
+    from .engine_management import resize_engine
+    return resize_engine(name_or_id, size, online, force)
+
+
+@engine_app.command("gami")
+def create_ami_cmd(
+    name_or_id: str = typer.Argument(
+        help="Engine name or instance ID to create AMI from"
+    ),
+):
+    """Create a 'Golden AMI' from a running engine."""
+    from .engine_management import create_ami
+    return create_ami(name_or_id)
+
+
+@engine_app.command("coffee")
+def coffee_cmd(
+    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+    duration: str = typer.Argument("4h", help="Duration (e.g., 2h, 30m, 2h30m)"),
+    cancel: bool = typer.Option(
+        False, "--cancel", help="Cancel existing coffee lock instead of extending"
+    ),
+):
+    """Pour ☕ for an engine: keeps it awake for the given duration (or cancel)."""
+    from .engine_maintenance import coffee
+    return coffee(name_or_id, duration, cancel)
+
+
+@engine_app.command("idle")
+def idle_timeout_cmd_wrapper(
+    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+    set: str = typer.Option(
+        None, "--set", "-s", help="New timeout (e.g., 2h30m, 45m)"
+    ),
+):
+    """Show or set the engine idle-detector timeout."""
+    from .engine_maintenance import idle_timeout_cmd
+    return idle_timeout_cmd(name_or_id, set)
+
+
+@engine_app.command("debug")
+def debug_engine_cmd(
+    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+):
+    """Debug engine bootstrap status and files."""
+    from .engine_maintenance import debug_engine
+    return debug_engine(name_or_id)
+
+
+@engine_app.command("repair")
+def repair_engine_cmd(
+    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+):
+    """Repair an engine that's stuck in a bad state (e.g., after GAMI creation)."""
+    from .engine_maintenance import repair_engine
+    return repair_engine(name_or_id)
+
+
+# Studio commands
+@studio_app.command("create")
+def create_studio_cmd(
+    size_gb: int = typer.Option(50, "--size", "-s", help="Studio size in GB"),
+):
+    """Create a new studio for the current user."""
+    from .studio_commands import create_studio
+    return create_studio(size_gb)
+
+
+@studio_app.command("status")
+def studio_status_cmd(
+    user: str = typer.Option(
+        None, "--user", "-u", help="Check status for a different user (admin only)"
+    ),
+):
+    """Show status of your studio."""
+    from .studio_commands import studio_status
+    return studio_status(user)
+
+
+@studio_app.command("attach")
+def attach_studio_cmd(
+    engine_name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+    user: str = typer.Option(
+        None, "--user", "-u", help="Attach a different user's studio (admin only)"
+    ),
+):
+    """Attach your studio to an engine."""
+    from .studio_commands import attach_studio
+    return attach_studio(engine_name_or_id, user)
+
+
+@studio_app.command("detach")
+def detach_studio_cmd(
+    user: str = typer.Option(
+        None, "--user", "-u", help="Detach a different user's studio (admin only)"
+    ),
+):
+    """Detach your studio from its current engine."""
+    from .studio_commands import detach_studio
+    return detach_studio(user)
+
+
+@studio_app.command("delete")
+def delete_studio_cmd(
+    user: str = typer.Option(
+        None, "--user", "-u", help="Delete a different user's studio (admin only)"
+    ),
+):
+    """Delete your studio permanently."""
+    from .studio_commands import delete_studio
+    return delete_studio(user)
+
+
+@studio_app.command("list")
+def list_studios_cmd(
+    all_users: bool = typer.Option(
+        False, "--all", "-a", help="Show all users' studios"
+    ),
+):
+    """List studios."""
+    from .studio_commands import list_studios
+    return list_studios(all_users)
+
+
+@studio_app.command("reset")
+def reset_studio_cmd(
+    user: str = typer.Option(
+        None, "--user", "-u", help="Reset a different user's studio"
+    ),
+):
+    """Reset a stuck studio (admin operation)."""
+    from .studio_commands import reset_studio
+    return reset_studio(user)
+
+
+@studio_app.command("resize")
+def resize_studio_cmd(
+    size: int = typer.Option(..., "--size", "-s", help="New size in GB"),
+    user: str = typer.Option(
+        None, "--user", "-u", help="Resize a different user's studio (admin only)"
+    ),
+):
+    """Resize your studio volume (requires detachment)."""
+    from .studio_commands import resize_studio
+    return resize_studio(size, user)

dayhoff_tools/cli/engine/engine_core.py

@@ -231,45 +231,12 @@ def engine_status(
 
     engines = response.json().get("engines", [])
     engine = resolve_engine(name_or_id, engines)
-    
+
+    # Always try to fetch live idle data from the engine for both views
+    live_idle_data = _fetch_live_idle_data(engine["instance_id"])
+
     # Fast status display (default)
-    if not detailed:       
-        # 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
-        
+    if not detailed:
         # Determine running state display
         running_state = engine["state"].lower()
         if running_state == "running":
@@ -282,59 +249,33 @@ def engine_status(
             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)
-                        remaining_mins = remaining // 60
-                        if remaining_mins == 0:
-                            idle_disp = f"  [yellow]Idle {idle_seconds//60}m/{timeout_sec//60}m: [red]<1m[/red] left[/yellow]"
-                        else:
-                            idle_disp = f"  [yellow]Idle {idle_seconds//60}m/{timeout_sec//60}m: [red]{remaining_mins}m[/red] left[/yellow]"
-                    else:
-                        idle_disp = "  [yellow]Idle ?/?[/yellow]"
-                else:
-                    # Actively not idle
-                    idle_disp = "  [green]Active[/green]"
-        
+
+        # Format idle display using the unified function
+        idle_disp = "  " + _format_idle_status_display(live_idle_data, running_state)
+
         # Build status lines - minimal info for fast view
         status_lines = [
             f"[blue]{engine['name']}[/blue]  {run_disp}{idle_disp}",
         ]
-        
-        # Add activity sensors if we have idle data
-        if idle_data and idle_data.get("reasons"):
+
+        # Add activity sensors if we have live data
+        if live_idle_data and live_idle_data.get("_reasons_raw"):
             status_lines.append("")  # blank line before sensors
-            
+
             sensor_map = {
                 "CoffeeLockSensor": ("☕", "Coffee"),
                 "ActiveLoginSensor": ("🐚", "SSH"),
                 "IDEConnectionSensor": ("🖥 ", "IDE"),
                 "DockerWorkloadSensor": ("🐳", "Docker"),
             }
-            
-            for r in idle_data.get("reasons", []):
+
+            for r in live_idle_data.get("_reasons_raw", []):
                 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")
@@ -352,6 +293,18 @@ def engine_status(
     idle_detector = engine_details.get("idle_detector", {}) or {}
     attached_studios = engine_details.get("attached_studios", [])
 
+    # Overlay stale API data with fresh data from the engine
+    if live_idle_data:
+        # If API didn't indicate availability, replace entirely; otherwise, update.
+        if not idle_detector.get("available"):
+            idle_detector = live_idle_data
+        else:
+            idle_detector.update(live_idle_data)
+    else:
+        # SSM failed - mark as unavailable if we don't have good data from API
+        if not idle_detector.get("available"):
+            idle_detector = {"available": False}  # Mark as unavailable
+
     # Calculate costs
     launch_time = parse_launch_time(engine["launch_time"])
     uptime = datetime.now(timezone.utc) - launch_time
@@ -406,37 +359,8 @@ def engine_status(
     else:
         run_disp = engine["state"].capitalize()
 
-    # Compose Active/Idle header with extra detail when idle
-    def _compute_active_disp(idle_info: Dict[str, Any]) -> str:
-        # If we don't have idle info or it's explicitly unavailable, show N/A
-        if not idle_info or idle_info.get("available") == False:
-            return "[dim]N/A[/dim]"
-            
-        if idle_info.get("status") == "active":
-            return "[green]Active[/green]"
-        if running_state in ("stopped", "stopping"):
-            return "[dim]N/A[/dim]"
-            
-        # 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)):
-                remaining = max(0, int(thresh_v) - int(idle_seconds_v))
-                remaining_mins = remaining // 60
-                if remaining_mins == 0:
-                    return f"[yellow]Idle {int(idle_seconds_v)//60}m/{int(thresh_v)//60}m: [red]<1m[/red] left[/yellow]"
-                else:
-                    return f"[yellow]Idle {int(idle_seconds_v)//60}m/{int(thresh_v)//60}m: [red]{remaining_mins}m[/red] left[/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)
+    # Recompute header display with latest data
+    active_disp = _format_idle_status_display(idle_detector, running_state)
 
     top_lines = [
         f"[blue]{engine['name']}[/blue]  {run_disp}  {active_disp}\n",
@@ -553,122 +477,6 @@ def engine_status(
         except Exception:
             pass
 
-    # Try to enrich/fallback idle-detector details from on-engine summary file via SSM
-    def _fetch_idle_summary_via_ssm(instance_id: str) -> Optional[Dict]:
-        try:
-            ssm = boto3.client("ssm", region_name="us-east-1")
-            res = ssm.send_command(
-                InstanceIds=[instance_id],
-                DocumentName="AWS-RunShellScript",
-                Parameters={
-                    "commands": [
-                        "cat /var/run/idle-detector/last_state.json 2>/dev/null || true",
-                    ],
-                    "executionTimeout": ["5"],
-                },
-            )
-            cid = res["Command"]["CommandId"]
-            # 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()
-            if not content:
-                return None
-            data = json.loads(content)
-            # Convert last_state schema (new or old) to idle_detector schema used by CLI output
-            idle_info: Dict[str, Any] = {"available": True}
-
-            # Active/idle
-            idle_flag = bool(data.get("idle", False))
-            idle_info["status"] = "idle" if idle_flag else "active"
-
-            # Threshold and elapsed
-            if isinstance(data.get("timeout_sec"), (int, float)):
-                idle_info["idle_threshold"] = int(data["timeout_sec"])  # seconds
-            if isinstance(data.get("idle_seconds"), (int, float)):
-                idle_info["idle_seconds"] = int(data["idle_seconds"])
-
-            # Keep raw reasons for sensor display when available (new schema)
-            if isinstance(data.get("reasons"), list):
-                idle_info["_reasons_raw"] = data["reasons"]
-            else:
-                # Fallback: synthesize reasons from the old forensics layout
-                f_all = data.get("forensics", {}) or {}
-                synthesized = []
-
-                def _mk(sensor_name: str, key: str):
-                    entry = f_all.get(key, {}) or {}
-                    synthesized.append(
-                        {
-                            "sensor": sensor_name,
-                            "active": bool(entry.get("active", False)),
-                            "reason": entry.get("reason", ""),
-                            "forensic": entry.get("forensic", {}),
-                        }
-                    )
-
-                _mk("CoffeeLockSensor", "coffee")
-                _mk("ActiveLoginSensor", "ssh")
-                _mk("IDEConnectionSensor", "ide")
-                _mk("DockerWorkloadSensor", "docker")
-                idle_info["_reasons_raw"] = synthesized
-
-            # Derive details from sensors
-            for r in idle_info.get("_reasons_raw", []):
-                if not r.get("active"):
-                    continue
-                sensor = (r.get("sensor") or "").lower()
-                forensic = r.get("forensic") or {}
-                if sensor == "ideconnectionsensor":
-                    # Prefer unique_pid_count written by new detector
-                    cnt = forensic.get("unique_pid_count")
-                    if not isinstance(cnt, int):
-                        cnt = forensic.get("matches")
-                    if isinstance(cnt, int):
-                        idle_info["ide_connections"] = {"connection_count": cnt}
-                    else:
-                        idle_info["ide_connections"] = {"connection_count": 1}
-                elif sensor == "coffeelocksensor":
-                    rem = forensic.get("remaining_sec")
-                    if isinstance(rem, (int, float)) and rem > 0:
-                        idle_info["coffee_lock"] = format_duration(
-                            timedelta(seconds=int(rem))
-                        )
-                elif sensor == "activeloginsensor":
-                    sess = {
-                        "tty": forensic.get("tty", "pts/?"),
-                        "pid": forensic.get("pid", "?"),
-                        "idle_time": forensic.get("idle_sec", 0),
-                        "from_ip": forensic.get("remote_addr", "unknown"),
-                    }
-                    idle_info.setdefault("ssh_sessions", []).append(sess)
-            return idle_info
-        except Exception:
-            return None
-
-    # Always try to enrich from on-engine summary (fast, best-effort)
-    overlay = _fetch_idle_summary_via_ssm(engine["instance_id"])
-    if overlay:
-        # If API didn't indicate availability, replace entirely; otherwise fill gaps
-        if not idle_detector.get("available"):
-            idle_detector = overlay
-        else:
-            for k, v in overlay.items():
-                idle_detector.setdefault(k, v)
-    else:
-        # SSM failed - mark as unavailable if we don't have good data
-        if not idle_detector.get("available"):
-            idle_detector = {"available": False}  # Mark as unavailable
-
-    # Recompute header display with latest data
-    active_disp = _compute_active_disp(idle_detector)
-    top_lines[0] = f"[blue]{engine['name']}[/blue]  {run_disp}  {active_disp}\n"
-
     # Activity Sensors (show all with YES/no)
     if idle_detector.get("available"):
         status_lines.append("")
@@ -694,11 +502,6 @@ def engine_status(
         status_lines.append(_sensor_line(" IDE   ", "IDEConnectionSensor", "🖥"))
         status_lines.append(_sensor_line("Docker", "DockerWorkloadSensor", "🐳"))
 
-        # 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
     console.print(
@@ -737,3 +540,114 @@ def engine_status(
                 console.print("[red]❌ Could not retrieve bootstrap log[/red]")
         except Exception as e:
             console.print(f"[red]❌ Error fetching log: {e}[/red]")
+
+
+def _format_idle_status_display(
+    idle_info: Optional[Dict[str, Any]], running_state: str
+) -> str:
+    """Computes the rich string for active/idle status display."""
+    # If we don't have idle info or it's explicitly unavailable, show N/A
+    if not idle_info or idle_info.get("available") is False:
+        return "[dim]N/A[/dim]"
+
+    if idle_info.get("status") == "active":
+        return "[green]Active[/green]"
+    if running_state in ("stopped", "stopping"):
+        return "[dim]N/A[/dim]"
+
+    # 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)
+        ):
+            remaining = max(0, int(thresh_v) - int(idle_seconds_v))
+            remaining_mins = remaining // 60
+            if remaining_mins == 0:
+                return f"[yellow]Idle {int(idle_seconds_v)//60}m/{int(thresh_v)//60}m: [red]<1m[/red] left[/yellow]"
+            else:
+                return f"[yellow]Idle {int(idle_seconds_v)//60}m/{int(thresh_v)//60}m: [red]{remaining_mins}m[/red] left[/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]"
+
+
+def _fetch_live_idle_data(instance_id: str) -> Optional[Dict]:
+    """
+    Fetch and parse the live idle detector state from an engine via SSM.
+
+    This is the single source of truth for on-engine idle status. It fetches
+    the `last_state.json` file, parses it, and transforms it into the schema
+    used by the CLI for display logic.
+    """
+    try:
+        ssm = boto3.client("ssm", region_name="us-east-1")
+        res = ssm.send_command(
+            InstanceIds=[instance_id],
+            DocumentName="AWS-RunShellScript",
+            Parameters={
+                "commands": [
+                    "cat /var/run/idle-detector/last_state.json 2>/dev/null || true",
+                ],
+                "executionTimeout": ["5"],
+            },
+        )
+        cid = res["Command"]["CommandId"]
+        # Wait up to 3 seconds for SSM command to complete
+        for _ in range(6):  # 6 * 0.5 = 3 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()
+        if not content:
+            return None
+        data = json.loads(content)
+        # Convert last_state schema (new or old) to idle_detector schema used by CLI output
+        idle_info: Dict[str, Any] = {"available": True}
+
+        # Active/idle
+        idle_flag = bool(data.get("idle", False))
+        idle_info["status"] = "idle" if idle_flag else "active"
+
+        # Threshold and elapsed
+        if isinstance(data.get("timeout_sec"), (int, float)):
+            idle_info["idle_threshold"] = int(data["timeout_sec"])  # seconds
+        if isinstance(data.get("idle_seconds"), (int, float)):
+            idle_info["idle_seconds"] = int(data["idle_seconds"])
+
+        # Keep raw reasons for sensor display when available (new schema)
+        if isinstance(data.get("reasons"), list):
+            idle_info["_reasons_raw"] = data["reasons"]
+        else:
+            # Fallback: synthesize reasons from the old forensics layout
+            f_all = data.get("forensics", {}) or {}
+            synthesized = []
+
+            def _mk(sensor_name: str, key: str):
+                entry = f_all.get(key, {}) or {}
+                synthesized.append(
+                    {
+                        "sensor": sensor_name,
+                        "active": bool(entry.get("active", False)),
+                        "reason": entry.get("reason", ""),
+                        "forensic": entry.get("forensic", {}),
+                    }
+                )
+
+            _mk("CoffeeLockSensor", "coffee")
+            _mk("ActiveLoginSensor", "ssh")
+            _mk("IDEConnectionSensor", "ide")
+            _mk("DockerWorkloadSensor", "docker")
+            idle_info["_reasons_raw"] = synthesized
+
+        return idle_info
+    except Exception:
+        return None

{dayhoff_tools-1.9.10.dist-info → dayhoff_tools-1.9.12.dist-info}/METADATA

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

{dayhoff_tools-1.9.10.dist-info → dayhoff_tools-1.9.12.dist-info}/RECORD

@@ -3,8 +3,8 @@ dayhoff_tools/chemistry/standardizer.py,sha256=uMn7VwHnx02nc404eO6fRuS4rsl4dvSPf
 dayhoff_tools/chemistry/utils.py,sha256=jt-7JgF-GeeVC421acX-bobKbLU_X94KNOW24p_P-_M,2257
 dayhoff_tools/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dayhoff_tools/cli/cloud_commands.py,sha256=33qcWLmq-FwEXMdL3F0OHm-5Stlh2r65CldyEZgQ1no,40904
-dayhoff_tools/cli/engine/__init__.py,sha256=KZwnbUcyZvoZp8CI0znszyt3B61BvEytCJlGQ8CEgiM,1763
-dayhoff_tools/cli/engine/engine_core.py,sha256=p0YQgKJ0Ow_MRXpzU3zZlgq29fIxsNCaZxeNhTIIkL8,30074
+dayhoff_tools/cli/engine/__init__.py,sha256=CGJ2blhWIIEsVb8HoLibZjSlMFRTSYZOO4zDQTtY3SY,9300
+dayhoff_tools/cli/engine/engine_core.py,sha256=IEU2m93qArFx-EdVHnepWKvLwlNUAcT7ytIAqeOY6a0,25147
 dayhoff_tools/cli/engine/engine_lifecycle.py,sha256=_Dk-EZs_qbm8APdOuGOuxhlbK6RgkkoLk2nrwKoo1-A,4519
 dayhoff_tools/cli/engine/engine_maintenance.py,sha256=Vz4FpbM0eyfl9tTM6Q8z0ZzS2Ug5gAE-uKVbqBHkznU,13761
 dayhoff_tools/cli/engine/engine_management.py,sha256=s_H3FtMlKsdfzR8pwV-j2W2QX-Fypkqj2kPC0aTqC1A,19072
@@ -33,7 +33,7 @@ dayhoff_tools/intake/uniprot.py,sha256=BZYJQF63OtPcBBnQ7_P9gulxzJtqyorgyuDiPeOJq
 dayhoff_tools/logs.py,sha256=DKdeP0k0kliRcilwvX0mUB2eipO5BdWUeHwh-VnsICs,838
 dayhoff_tools/sqlite.py,sha256=jV55ikF8VpTfeQqqlHSbY8OgfyfHj8zgHNpZjBLos_E,18672
 dayhoff_tools/warehouse.py,sha256=UETBtZD3r7WgvURqfGbyHlT7cxoiVq8isjzMuerKw8I,24475
-dayhoff_tools-1.9.10.dist-info/METADATA,sha256=w4OvewsdP4h4a4pHt1DysDq6pKxABi1LrE5Dke97gTE,2915
-dayhoff_tools-1.9.10.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-dayhoff_tools-1.9.10.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
-dayhoff_tools-1.9.10.dist-info/RECORD,,
+dayhoff_tools-1.9.12.dist-info/METADATA,sha256=EkiO1dejnv9KxAs8X7ycLdfGUlph70tyIeNPWQc-12U,2915
+dayhoff_tools-1.9.12.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+dayhoff_tools-1.9.12.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
+dayhoff_tools-1.9.12.dist-info/RECORD,,