dayhoff-tools 1.1.10__py3-none-any.whl → 1.13.12__py3-none-any.whl

dayhoff_tools/cli/engines_studios/progress.py

@@ -0,0 +1,260 @@
+"""Progress display utilities for async operations."""
+
+import time
+from typing import Any, Callable, Dict, Optional
+
+import click
+
+
+def wait_with_progress(
+    status_func: Callable[[], Dict[str, Any]],
+    is_complete_func: Callable[[Dict[str, Any]], bool],
+    label: str = "Progress",
+    timeout_seconds: int = 300,
+    poll_interval: float = 2.0,
+    show_stages: bool = True,
+) -> Dict[str, Any]:
+    """Wait for an async operation with progress display.
+
+    Args:
+        status_func: Function that returns current status dict
+        is_complete_func: Function that checks if operation is complete
+        label: Label for progress bar
+        timeout_seconds: Maximum time to wait
+        poll_interval: Seconds between status checks
+        show_stages: Whether to show stage/step updates
+
+    Returns:
+        Final status dict
+
+    Raises:
+        TimeoutError: If operation exceeds timeout
+    """
+
+    stages_shown = set()
+    start_time = time.time()
+
+    with click.progressbar(length=100, label=label) as bar:
+        while True:
+            # Check timeout
+            if time.time() - start_time > timeout_seconds:
+                raise TimeoutError(f"Operation exceeded {timeout_seconds}s timeout")
+
+            # Get current status
+            try:
+                status = status_func()
+            except Exception as e:
+                click.echo(f"\nError fetching status: {e}", err=True)
+                time.sleep(poll_interval)
+                continue
+
+            # Update progress bar
+            progress = status.get("progress_percent", 0)
+            if progress > bar.pos:
+                bar.update(progress - bar.pos)
+
+            # Show stage/step updates
+            if show_stages:
+                current_stage = status.get("current_stage") or status.get(
+                    "current_step"
+                )
+                if current_stage and current_stage not in stages_shown:
+                    stages_shown.add(current_stage)
+                    elapsed = int(time.time() - start_time)
+                    display_name = current_stage.replace("_", " ").title()
+                    click.echo(f"  [{elapsed}s] {display_name}")
+
+            # Check completion
+            if is_complete_func(status):
+                bar.update(100 - bar.pos)
+                return status
+
+            # Check for failure
+            status_value = status.get("status", "").lower()
+            if status_value == "failed" or status_value == "error":
+                error = status.get("error", "Unknown error")
+                raise Exception(f"Operation failed: {error}")
+
+            time.sleep(poll_interval)
+
+
+def format_sensor_status(sensor_data: Dict[str, Any]) -> str:
+    """Format sensor status for display.
+
+    Args:
+        sensor_data: Sensor data dict
+
+    Returns:
+        Formatted string
+    """
+    active = sensor_data.get("active", False)
+    reason = sensor_data.get("reason", "No reason provided")
+
+    if active:
+        return f"🟢\n  {reason}"
+    else:
+        return "⚪"
+
+
+def format_idle_state(
+    idle_state: Dict[str, Any],
+    detailed: bool = False,
+    attached_studios: Optional[list] = None,
+) -> str:
+    """Format idle state for display.
+
+    Args:
+        idle_state: Idle state dict
+        detailed: Whether to show detailed sensor information
+        attached_studios: Optional list of attached studio dicts
+
+    Returns:
+        Formatted string
+    """
+    is_idle = idle_state.get("is_idle", False)
+
+    lines = []
+
+    # Status line
+    icon = "🟡 IDLE" if is_idle else "🟢 ACTIVE"
+    lines.append(f"Idle Status: {icon}")
+
+    # Timing information
+    if idle_state.get("idle_seconds"):
+        timeout = idle_state.get("timeout_seconds", 1800)
+        elapsed = idle_state["idle_seconds"]
+        remaining = max(0, timeout - elapsed)
+        lines.append(f"Idle Time: {elapsed}s / {timeout}s")
+        if remaining > 0:
+            minutes = remaining // 60
+            # Yellow text using ANSI escape codes
+            lines.append(f"\033[33mWill shutdown in: {remaining}s ({minutes}m)\033[0m")
+
+    # Attached studios (show before sensors)
+    if attached_studios:
+        # Purple text for studio names
+        studio_names = ", ".join(
+            [
+                f"\033[35m{s.get('user', s.get('studio_id', 'unknown'))}\033[0m"
+                for s in attached_studios
+            ]
+        )
+        lines.append(f"\nAttached Studios: {studio_names}")
+    else:
+        # Normal text for "None"
+        lines.append(f"\nAttached Studios: None")
+
+    # Detailed sensor information with colorful emojis
+    if detailed and idle_state.get("sensors"):
+        lines.append(f"\n{'═'*60}")
+        lines.append("🔍 Activity Sensors:")
+        lines.append(f"{'═'*60}")
+
+        # Sensor emoji mapping
+        sensor_emojis = {
+            "coffee": "☕",
+            "ssh": "🐚",
+            "ide": "💻",
+            "docker": "🐳",
+        }
+
+        for sensor_name, sensor_data in idle_state["sensors"].items():
+            emoji = sensor_emojis.get(sensor_name.lower(), "📊")
+            active = sensor_data.get("active", False)
+
+            # Special formatting for coffee sensor
+            if sensor_name.lower() == "coffee" and active:
+                # Extract minutes from details for cleaner display
+                details = sensor_data.get("details", {})
+                remaining_seconds = int(details.get("remaining_seconds", 0))
+                remaining_minutes = remaining_seconds // 60
+                lines.append(f"\n{emoji} {sensor_name.upper()} 🟢")
+                lines.append(f"  Caffeinated for another {remaining_minutes}m")
+            else:
+                status_icon = format_sensor_status(sensor_data)
+                # Format: emoji NAME status_icon (on same line for inactive, split for active)
+                if active:
+                    lines.append(
+                        f"\n{emoji} {sensor_name.upper()} {status_icon.split(chr(10))[0]}"
+                    )
+                    # Add reason on next line
+                    reason_line = (
+                        status_icon.split("\n")[1] if "\n" in status_icon else ""
+                    )
+                    if reason_line:
+                        lines.append(reason_line)
+                else:
+                    lines.append(f"\n{emoji} {sensor_name.upper()} {status_icon}")
+
+            # Show details if available (skip for active coffee sensor with special formatting)
+            if sensor_name.lower() == "coffee" and active:
+                continue  # Already showed coffee details in special format above
+
+            details = sensor_data.get("details", {})
+            if details:
+                for key, value in details.items():
+                    # Skip internal bookkeeping fields and redundant info
+                    if key in [
+                        "unique_flavor_count",
+                        "unique_pid_count",
+                        "expires_at",
+                        "flavors",
+                        "remaining_seconds",  # Redundant with time shown in reason
+                        "pid_count",  # Redundant with connections list
+                        "connections",  # Redundant, connections shown in sessions/containers
+                    ]:
+                        continue
+
+                    if isinstance(value, list):
+                        if value:  # Only show non-empty lists
+                            # Show workload containers with clear header
+                            if key == "containers":
+                                # Show actual workload container names that are keeping engine active
+                                for item in value[:5]:
+                                    lines.append(f"    • {item}")
+                            elif key in ["connections", "sessions"]:
+                                # Just show the items with bullets, no header
+                                for item in value[:5]:
+                                    lines.append(f"    • {item}")
+                            elif key == "ignored":
+                                # Ignored list at same indentation level, with header
+                                lines.append(f"  {key}:")
+                                for item in value[:5]:
+                                    lines.append(f"    • {item}")
+                            else:
+                                # Other lists get shown with bullets only
+                                for item in value[:5]:
+                                    lines.append(f"    • {item}")
+                    elif not isinstance(value, (dict, list)):
+                        lines.append(f"  ℹ️  {key}: {value}")
+
+    return "\n".join(lines)
+
+
+def format_time_ago(timestamp: str) -> str:
+    """Format timestamp as time ago.
+
+    Args:
+        timestamp: ISO format timestamp
+
+    Returns:
+        Human readable time ago string
+    """
+    from datetime import datetime
+
+    try:
+        dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+        now = datetime.now(dt.tzinfo)
+        delta = now - dt
+
+        seconds = int(delta.total_seconds())
+        if seconds < 60:
+            return f"{seconds}s ago"
+        elif seconds < 3600:
+            return f"{seconds // 60}m ago"
+        elif seconds < 86400:
+            return f"{seconds // 3600}h ago"
+        else:
+            return f"{seconds // 86400}d ago"
+    except:
+        return timestamp

dayhoff_tools/cli/engines_studios/simulators/cli-simulators.md

@@ -0,0 +1,151 @@
+# CLI Output Simulators
+
+This directory contains simulators for iterating on CLI output design without needing AWS access. They're useful for:
+
+- Rapid UI iteration during development
+- Visualizing edge cases and different states
+- Testing output formatting without live infrastructure
+- Documentation and examples
+
+## Available Simulators
+
+### 1. Engine List Simulator
+
+Simulates `dh engine2 list` output with different configurations.
+
+**Usage:**
+```bash
+# Show all scenarios
+python dayhoff_tools/cli/engines_studios/simulators/engine_list_simulator.py
+
+# Show specific scenario
+python dayhoff_tools/cli/engines_studios/simulators/engine_list_simulator.py --scenario few
+
+# Override environment
+python dayhoff_tools/cli/engines_studios/simulators/engine_list_simulator.py --scenario many --env prod
+```
+
+**Scenarios:**
+- `single` - Single running engine
+- `few` - Few engines with mixed states (running, stopped, starting)
+- `many` - Many engines (production-like)
+- `empty` - No engines
+- `transitions` - All transitional states (starting, stopping, pending)
+- `all` - Show all scenarios
+
+### 2. Engine Status Simulator
+
+Simulates `dh engine2 status` output for different engine states.
+
+**Usage:**
+```bash
+# Show all scenarios
+python dayhoff_tools/cli/engines_studios/simulators/engine_status_simulator.py
+
+# Show specific scenario
+python dayhoff_tools/cli/engines_studios/simulators/engine_status_simulator.py --scenario running_active
+
+# Override environment
+python dayhoff_tools/cli/engines_studios/simulators/engine_status_simulator.py --scenario stopped --env sand
+```
+
+**Scenarios:**
+- `running_idle` - Running engine with all sensors idle
+- `running_active` - Running engine with SSH, IDE, and coffee active
+- `stopped` - Stopped engine (no idle detection)
+- `starting` - Engine in starting state
+- `stopping` - Engine in stopping state
+- `running_docker` - Running engine with Docker containers
+- `all` - Show all scenarios
+
+### 3. Studio Status Simulator
+
+Simulates `dh studio2 status` output for different studio states.
+
+**Usage:**
+```bash
+# Show all scenarios
+python dayhoff_tools/cli/engines_studios/simulators/studio_status_simulator.py
+
+# Show specific scenario
+python dayhoff_tools/cli/engines_studios/simulators/studio_status_simulator.py --scenario attached
+
+# Override environment
+python dayhoff_tools/cli/engines_studios/simulators/studio_status_simulator.py --scenario large --env prod
+```
+
+**Scenarios:**
+- `available` - Available studio (not attached)
+- `attached` - Studio attached to an engine
+- `large` - Large production studio
+- `new` - Newly created studio
+- `modifying` - Studio being modified
+- `all` - Show all scenarios
+
+### 4. Idle Status Simulator
+
+Simulates detailed idle detection output with various sensor configurations.
+
+**Usage:**
+```bash
+# Show all scenarios
+python dayhoff_tools/cli/engines_studios/simulators/idle_status_simulator.py
+
+# Show specific scenario
+python dayhoff_tools/cli/engines_studios/simulators/idle_status_simulator.py --scenario coffee_lock
+
+# Use more emojis
+python dayhoff_tools/cli/engines_studios/simulators/idle_status_simulator.py --colorful
+```
+
+**Scenarios:**
+- `idle` - Completely idle engine (all sensors inactive)
+- `active_ssh_docker` - Active SSH sessions and Docker containers
+- `active_ide` - Active IDE connection (Cursor)
+- `coffee_lock` - Coffee lock active (prevents shutdown)
+- `near_timeout` - Engine near idle timeout
+- `initializing` - Engine just started (initializing state)
+- `stopped` - Stopped engine (no idle detection)
+- `all` - Show all scenarios
+
+## Implementation Notes
+
+### Standalone Design
+
+The simulators are completely standalone and don't require:
+- AWS credentials
+- Network access
+- Installed Python packages (beyond stdlib)
+
+They use `simulator_utils.py` which contains formatting functions copied from the main codebase but with no external dependencies.
+
+### Synchronization
+
+When modifying formatting in the actual CLI code (`engine_commands.py`, `studio_commands.py`, `progress.py`), update the corresponding simulators to match:
+
+1. **Output changes** → Update simulator `format_*_output()` functions
+2. **New scenarios** → Add scenarios to `generate_scenarios()`
+3. **New formatters** → Copy to `simulator_utils.py` (without dependencies)
+
+### Color Codes
+
+The simulators use ANSI escape codes for colors:
+- `\033[32m` - Green (running states, active)
+- `\033[31m` - Red (stopped/terminated)
+- `\033[33m` - Yellow (transitional states, warnings)
+- `\033[34m` - Blue (names, environments)
+- `\033[35m` - Purple (studios)
+- `\033[0m` - Reset
+
+## Development Workflow
+
+When designing new CLI output:
+
+1. **Add scenarios** to the appropriate simulator
+2. **Iterate quickly** by running the simulator
+3. **Review output** for readability and information density
+4. **Implement** in actual CLI code
+5. **Update simulator** to match final implementation
+
+This is much faster than deploying infrastructure changes and running real CLI commands for every tweak.
+

dayhoff_tools/cli/engines_studios/simulators/demo.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# Demo script to showcase all CLI output simulators
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+echo "╔════════════════════════════════════════════════════════════════════════════╗"
+echo "║                  CLI Output Simulators Demo                                ║"
+echo "╚════════════════════════════════════════════════════════════════════════════╝"
+echo ""
+echo "These simulators let you iterate on CLI design without AWS access."
+echo ""
+
+read -p "Press Enter to start the demo..."
+
+# Engine List Simulator
+echo ""
+echo "┌────────────────────────────────────────────────────────────────────────────┐"
+echo "│ 1. ENGINE LIST - Few engines in different states                          │"
+echo "└────────────────────────────────────────────────────────────────────────────┘"
+echo ""
+python engine_list_simulator.py --scenario few
+read -p "Press Enter to continue..."
+
+# Engine Status - Running with activity
+echo ""
+echo "┌────────────────────────────────────────────────────────────────────────────┐"
+echo "│ 2. ENGINE STATUS - Running engine with SSH, IDE, and Coffee active        │"
+echo "└────────────────────────────────────────────────────────────────────────────┘"
+echo ""
+python engine_status_simulator.py --scenario running_active
+read -p "Press Enter to continue..."
+
+# Engine Status - Stopped
+echo ""
+echo "┌────────────────────────────────────────────────────────────────────────────┐"
+echo "│ 3. ENGINE STATUS - Stopped engine (no idle detection)                     │"
+echo "└────────────────────────────────────────────────────────────────────────────┘"
+echo ""
+python engine_status_simulator.py --scenario stopped
+read -p "Press Enter to continue..."
+
+# Studio Status - Attached
+echo ""
+echo "┌────────────────────────────────────────────────────────────────────────────┐"
+echo "│ 4. STUDIO STATUS - Studio attached to engine                              │"
+echo "└────────────────────────────────────────────────────────────────────────────┘"
+echo ""
+python studio_status_simulator.py --scenario attached
+read -p "Press Enter to continue..."
+
+# Idle Status - Coffee lock
+echo ""
+echo "┌────────────────────────────────────────────────────────────────────────────┐"
+echo "│ 5. IDLE STATUS - Engine with coffee lock active                           │"
+echo "└────────────────────────────────────────────────────────────────────────────┘"
+echo ""
+python idle_status_simulator.py --scenario coffee_lock
+read -p "Press Enter to continue..."
+
+echo ""
+echo "╔════════════════════════════════════════════════════════════════════════════╗"
+echo "║                           Demo Complete!                                   ║"
+echo "╚════════════════════════════════════════════════════════════════════════════╝"
+echo ""
+echo "Try running simulators with different scenarios:"
+echo "  • python engine_list_simulator.py --scenario many"
+echo "  • python engine_status_simulator.py --scenario running_docker"
+echo "  • python studio_status_simulator.py --scenario all"
+echo "  • python idle_status_simulator.py --scenario all"
+echo ""
+echo "See README.md for full documentation."
+