dayhoff-tools 1.8.0__tar.gz → 1.8.2__tar.gz

{dayhoff_tools-1.8.0 → dayhoff_tools-1.8.2}/PKG-INFO

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

{dayhoff_tools-1.8.0 → dayhoff_tools-1.8.2}/dayhoff_tools/cli/engine_commands.py

@@ -9,7 +9,7 @@ import sys
 import time
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import boto3
 import requests
@@ -647,7 +647,7 @@ def launch_engine(
     ) as progress:
         progress.add_task("Creating engine...", total=None)
 
-        request_data = {
+        request_data: Dict[str, Any] = {
             "name": name,
             "user": username,
             "engine_type": engine_type,
@@ -797,18 +797,50 @@ def engine_status(
 
     engine_details = response.json()
     engine = engine_details.get("engine", engine)  # Use detailed info if available
-    idle_detector = engine_details.get("idle_detector", {})
+    idle_detector = engine_details.get("idle_detector", {}) or {}
     attached_studios = engine_details.get("attached_studios", [])
 
     # Calculate costs
     launch_time = parse_launch_time(engine["launch_time"])
     uptime = datetime.now(timezone.utc) - launch_time
     hourly_cost = HOURLY_COSTS.get(engine["engine_type"], 0)
-    total_cost = hourly_cost * (uptime.total_seconds() / 3600)
+    # total_cost intentionally not shown in status view
 
     stages_map = _fetch_init_stages([engine["instance_id"]])
     stage_val = stages_map.get(engine["instance_id"], "-")
 
+    # Try to fetch actual boot time via SSM (best-effort)
+    boot_time_str: Optional[str] = None
+    try:
+        if engine["state"].lower() == "running":
+            ssm = boto3.client("ssm", region_name="us-east-1")
+            resp = ssm.send_command(
+                InstanceIds=[engine["instance_id"]],
+                DocumentName="AWS-RunShellScript",
+                Parameters={
+                    "commands": ["uptime -s || who -b | awk '{print $3\" \"$4}'"]
+                },
+            )
+            cid = resp["Command"]["CommandId"]
+            time.sleep(1)
+            inv = ssm.get_command_invocation(
+                CommandId=cid, InstanceId=engine["instance_id"]
+            )
+            if inv.get("Status") == "Success":
+                boot_time_str = (
+                    (inv.get("StandardOutputContent") or "").strip().splitlines()[0]
+                    if inv.get("StandardOutputContent")
+                    else None
+                )
+    except Exception:
+        boot_time_str = None
+
+    started_line = (
+        f"[bold]Started:[/bold]     {boot_time_str} ({format_duration(uptime)} ago)"
+        if boot_time_str
+        else f"[bold]Started:[/bold]     {launch_time.strftime('%Y-%m-%d %H:%M:%S')} ({format_duration(uptime)} ago)"
+    )
+
     status_lines = [
         f"[bold]Name:[/bold]        {engine['name']}",
         f"[bold]Instance:[/bold]    {engine['instance_id']}",
@@ -816,10 +848,15 @@ def engine_status(
         f"[bold]Status:[/bold]      {format_status(engine['state'], engine.get('ready'))}",
         f"[bold]User:[/bold]        {engine['user']}",
         f"[bold]IP:[/bold]          {engine.get('public_ip', 'N/A')}",
-        f"[bold]Launched:[/bold]    {launch_time.strftime('%Y-%m-%d %H:%M:%S')} ({format_duration(uptime)} ago)",
-        f"[bold]Cost:[/bold]        ${hourly_cost:.2f}/hour (${total_cost:.2f} total)",
+        started_line,
+        f"[bold]$/hour:[/bold]     ${hourly_cost:.2f}",
     ]
 
+    # Disk usage (like list --detailed)
+    if engine["state"].lower() == "running":
+        disk_usage = get_disk_usage_via_ssm(engine["instance_id"]) or "-"
+        status_lines.append(f"[bold]Disk:[/bold]       {disk_usage}")
+
     # Health report (only if bootstrap finished)
     if stage_val == "finished":
         try:
@@ -854,7 +891,80 @@ def engine_status(
         except Exception:
             pass
 
-    # Idle detector status (from new API endpoint)
+    # 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"]
+            time.sleep(1)
+            inv = ssm.get_command_invocation(CommandId=cid, InstanceId=instance_id)
+            if inv["Status"] != "Success":
+                return None
+            content = inv["StandardOutputContent"].strip()
+            if not content:
+                return None
+            data = json.loads(content)
+            # Convert last_state schema to idle_detector schema used by CLI output
+            idle_info: Dict[str, Any] = {"available": True}
+            idle_info["status"] = "active" if not data.get("idle", True) else "idle"
+            # thresholds if present
+            if isinstance(data.get("timeout_sec"), (int, float)):
+                idle_info["idle_threshold"] = int(data["timeout_sec"])  # seconds
+            # keep raw reasons for sensor display
+            if isinstance(data.get("reasons"), list):
+                idle_info["_reasons_raw"] = data["reasons"]
+            # derive details from sensors
+            for r in data.get("reasons", []):
+                if not r.get("active"):
+                    continue
+                sensor = (r.get("sensor") or "").lower()
+                forensic = r.get("forensic") or {}
+                if sensor == "ideconnectionsensor":
+                    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":
+                    # Provide a single summarized SSH session if available
+                    sess = {
+                        "tty": r.get("forensic", {}).get("tty", "pts/?"),
+                        "pid": r.get("forensic", {}).get("pid", "?"),
+                        "idle_time": r.get("forensic", {}).get("idle_sec", 0),
+                        "from_ip": r.get("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)
+
+    # Idle detector status (API and/or on-engine fallback)
     if idle_detector.get("available"):
         status_lines.append("")
         status_lines.append("[bold]Idle Detector:[/bold]")
@@ -882,8 +992,13 @@ def engine_status(
         if ssh_sessions:
             status_lines.append(f"  • [blue]SSH Sessions ({len(ssh_sessions)}):[/blue]")
             for session in ssh_sessions:
+                idle_time = session.get("idle_time")
+                if isinstance(idle_time, (int, float)):
+                    idle_disp = f"{int(idle_time)//60}m"
+                else:
+                    idle_disp = str(idle_time) if idle_time else "0m"
                 status_lines.append(
-                    f"    - {session['tty']} (pid {session['pid']}, idle {session['idle_time']}) from {session['from_ip']}"
+                    f"    - {session.get('tty', 'pts/?')} (pid {session.get('pid', '?')}, idle {idle_disp}) from {session.get('from_ip', 'unknown')}"
                 )
 
         # IDE connections
@@ -893,6 +1008,18 @@ def engine_status(
                 f"  • [magenta]🖥  IDE connected ({ide_conn['connection_count']} connections)[/magenta]"
             )
 
+        # Sensors contributing to ACTIVE
+        reasons_raw = idle_detector.get("_reasons_raw")
+        if isinstance(reasons_raw, list):
+            active_sensors = [r for r in reasons_raw if r.get("active")]
+            if active_sensors:
+                status_lines.append("")
+                status_lines.append("[bold]Active Sensors:[/bold]")
+                for r in active_sensors:
+                    sensor = r.get("sensor", "Sensor")
+                    reason = r.get("reason") or "active"
+                    status_lines.append(f"  • {sensor}: {reason}")
+
     # Audit one-liner (best-effort SSM fetch)
     try:
         last_audit = _fetch_last_audit_via_ssm(engine["instance_id"])

{dayhoff_tools-1.8.0 → dayhoff_tools-1.8.2}/pyproject.toml

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