dayhoff-tools 1.9.0__tar.gz → 1.9.2__tar.gz

{dayhoff_tools-1.9.0 → dayhoff_tools-1.9.2}/PKG-INFO

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

{dayhoff_tools-1.9.0 → dayhoff_tools-1.9.2}/dayhoff_tools/cli/engine_commands.py

@@ -319,88 +319,6 @@ def format_status(state: str, ready: Optional[bool]) -> str:
         return state
 
 
-# --------------------------------------------------------------------------------
-# Audit helpers (Phase 1 observability)
-# --------------------------------------------------------------------------------
-
-
-def _get_engine_audit_bucket() -> Optional[str]:
-    """Return the engine audit bucket name from SSM Parameter Store, if configured."""
-    try:
-        ssm = boto3.client("ssm", region_name="us-east-1")
-        resp = ssm.get_parameter(Name="/dev/studio-manager/engine-audit-bucket")
-        return resp["Parameter"]["Value"]
-    except ClientError:
-        return None
-
-
-def _fetch_last_audit_via_ssm(instance_id: str) -> Optional[Dict]:
-    """Fetch last shutdown attempt audit from the engine via SSM (fast best-effort)."""
-    try:
-        ssm = boto3.client("ssm", region_name="us-east-1")
-        resp = ssm.send_command(
-            InstanceIds=[instance_id],
-            DocumentName="AWS-RunShellScript",
-            Parameters={
-                "commands": [
-                    "cat /var/log/idle-detector/last_shutdown_attempt.json 2>/dev/null || true",
-                ],
-                "executionTimeout": ["3"],
-            },
-        )
-        cid = resp["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
-        return json.loads(content)
-    except Exception:
-        return None
-
-
-def _fetch_last_audit_via_s3(instance_id: str) -> Optional[Dict]:
-    """Fetch the newest audit object from S3 if available."""
-    bucket = _get_engine_audit_bucket()
-    if not bucket:
-        return None
-    try:
-        s3 = boto3.client("s3", region_name="us-east-1")
-        paginator = s3.get_paginator("list_objects_v2")
-        newest = None
-        for page in paginator.paginate(
-            Bucket=bucket, Prefix=f"{instance_id}/", MaxKeys=1000
-        ):
-            for obj in page.get("Contents", []):
-                lm = obj.get("LastModified")
-                if newest is None or (lm and lm > newest["LastModified"]):
-                    newest = obj
-        if not newest:
-            return None
-        obj = s3.get_object(Bucket=bucket, Key=newest["Key"])
-        data = obj["Body"].read().decode("utf-8")
-        return json.loads(data)
-    except Exception:
-        return None
-
-
-def _summarize_audit(audit: Dict) -> str:
-    """Return a compact one-line summary for status output."""
-    ts = audit.get("ts", "?")
-    shutdown = audit.get("shutdown", {})
-    result = shutdown.get("result", "?")
-    detach = audit.get("detach", {})
-    num_detached = sum(
-        1 for r in detach.get("results", []) if r.get("status") == "success"
-    )
-    idle = audit.get("idle", {})
-    elapsed = int(idle.get("elapsed_sec", 0))
-    threshold = int(idle.get("threshold_sec", 0))
-    return f"Last shutdown attempt: {ts} result={result} detach={num_detached} idle={elapsed//60}/{threshold//60}m"
-
-
 def resolve_engine(name_or_id: str, engines: List[Dict]) -> Dict:
     """Resolve engine by name or ID with interactive selection."""
     # Exact ID match
@@ -1006,23 +924,55 @@ def engine_status(
             if not content:
                 return None
             data = json.loads(content)
-            # Convert last_state schema to idle_detector schema used by CLI output
+            # Convert last_state schema (new or old) 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
+
+            # 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
-            # keep raw reasons for sensor display
+            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"]
-            # derive details from sensors
-            for r in data.get("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":
-                    cnt = forensic.get("matches")
+                    # 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:
@@ -1034,12 +984,11 @@ def engine_status(
                             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"),
+                        "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
@@ -1081,15 +1030,23 @@ def engine_status(
         status_lines.append(_sensor_line(" IDE   ", "IDEConnectionSensor", "🖥"))
         status_lines.append(_sensor_line("Docker", "DockerWorkloadSensor", "🐳"))
 
-    # Audit one-liner (best-effort SSM fetch)
-    try:
-        last_audit = _fetch_last_audit_via_ssm(engine["instance_id"])
-        if last_audit:
-            status_lines.append("")
-            status_lines.append("[bold]Shutdown Audit:[/bold]")
-            status_lines.append(f"  • {_summarize_audit(last_audit)}")
-    except Exception:
-        pass
+        # 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
 
     # Combine top summary and details
     all_lines = top_lines + status_lines
@@ -1128,67 +1085,6 @@ def engine_status(
             console.print(f"[red]❌ Error fetching log: {e}[/red]")
 
 
-@engine_app.command("why")
-def engine_why(
-    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
-    raw: bool = typer.Option(False, "--raw", help="Print raw audit JSON"),
-):
-    """Explain the last idle-detector shutdown attempt for an engine.
-
-    Tries SSM (on-instance file) first, then falls back to S3 audit bucket.
-    """
-    check_aws_sso()
-
-    # Resolve engine
-    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)
-
-    audit = _fetch_last_audit_via_ssm(
-        engine["instance_id"]
-    ) or _fetch_last_audit_via_s3(engine["instance_id"])
-    if not audit:
-        console.print("No audit found (engine may not have attempted shutdown yet).")
-        raise typer.Exit(0)
-
-    if raw:
-        console.print_json(data=audit)
-        return
-
-    # Pretty summary
-    status = _summarize_audit(audit)
-    panel_lines = [
-        f"[bold]{status}[/bold]",
-        "",
-        "[bold]Sensors:[/bold]",
-    ]
-    for r in audit.get("idle", {}).get("reason_snapshot", []):
-        active = "✓" if r.get("active") else "-"
-        reason = r.get("reason") or ""
-        sensor = r.get("sensor")
-        panel_lines.append(f"  {active} {sensor}: {reason}")
-    panel_lines.append("")
-    panel_lines.append("[bold]Detach results:[/bold]")
-    for res in audit.get("detach", {}).get("results", []):
-        panel_lines.append(
-            f"  - {res.get('studio_id')}: {res.get('status')} {res.get('error') or ''}"
-        )
-    s3_info = audit.get("s3", {})
-    if s3_info.get("uploaded"):
-        panel_lines.append("")
-        panel_lines.append(
-            f"[dim]S3: s3://{s3_info.get('bucket')}/{s3_info.get('key')}[/dim]"
-        )
-
-    console.print(
-        Panel("\n".join(panel_lines), title="Idle Shutdown Audit", border_style="blue")
-    )
-
-
 @engine_app.command("stop")
 def stop_engine(
     name_or_id: str = typer.Argument(help="Engine name or instance ID"),

{dayhoff_tools-1.9.0 → dayhoff_tools-1.9.2}/pyproject.toml

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