dayhoff-tools 1.9.26__py3-none-any.whl → 1.10.1__py3-none-any.whl

dayhoff_tools/cli/engine/__init__.py

@@ -1,323 +1 @@
-"""Engine and Studio management commands for DHT CLI."""
-
-from typing import Optional
-
-import typer
-
-# Initialize Typer apps
-engine_app = typer.Typer(help="Manage compute engines for development.")
-studio_app = typer.Typer(help="Manage persistent development studios.")
-
-# 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: Optional[str] = typer.Option(
-        None, "--set", "-s", help="New timeout (e.g., 2h30m, 45m)"
-    ),
-    slack: Optional[str] = typer.Option(
-        None, "--slack", help="Set Slack notifications: none, default, all"
-    ),
-):
-    """Show or set engine idle-detector settings."""
-    from .engine_maintenance import idle_timeout_cmd
-
-    return idle_timeout_cmd(name_or_id=name_or_id, set=set, slack=slack)
-
-
-@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)
+"""Engine management commands."""

dayhoff_tools/cli/engine/coffee.py

@@ -0,0 +1,110 @@
+"""Engine coffee command."""
+
+import re
+import time
+
+import boto3
+import typer
+from botocore.exceptions import ClientError
+
+from ..engine_studio_utils.api_utils import make_api_request
+from ..engine_studio_utils.aws_utils import check_aws_sso
+from ..engine_studio_utils.constants import console
+from ..engine_studio_utils.formatting import resolve_engine
+
+
+def coffee(
+    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)."""
+    username = check_aws_sso()
+
+    # Parse duration
+    if not cancel:
+        match = re.match(r"(?:(\d+)h)?(?:(\d+)m)?", duration)
+        if not match or (not match.group(1) and not match.group(2)):
+            console.print(f"[red]❌ Invalid duration format: {duration}[/red]")
+            console.print("Use format like: 4h, 30m, 2h30m")
+            raise typer.Exit(1)
+
+        hours = int(match.group(1) or 0)
+        minutes = int(match.group(2) or 0)
+        seconds_total = (hours * 60 + minutes) * 60
+        if seconds_total == 0:
+            console.print("[red]❌ Duration must be greater than zero[/red]")
+            raise typer.Exit(1)
+
+    # Get all engines to resolve name
+    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)
+
+    if engine["state"].lower() != "running":
+        console.print(f"[red]❌ Engine is not running (state: {engine['state']})[/red]")
+        raise typer.Exit(1)
+
+    if cancel:
+        console.print(f"Cancelling coffee for [cyan]{engine['name']}[/cyan]…")
+    else:
+        console.print(
+            f"Pouring coffee for [cyan]{engine['name']}[/cyan] for {duration}…"
+        )
+
+    # Use SSM to run the engine coffee command
+    ssm = boto3.client("ssm", region_name="us-east-1")
+    try:
+        response = ssm.send_command(
+            InstanceIds=[engine["instance_id"]],
+            DocumentName="AWS-RunShellScript",
+            Parameters={
+                "commands": [
+                    (
+                        "/usr/local/bin/engine-coffee --cancel"
+                        if cancel
+                        else f"/usr/local/bin/engine-coffee {seconds_total}"
+                    )
+                ],
+                "executionTimeout": ["60"],
+            },
+        )
+
+        command_id = response["Command"]["CommandId"]
+
+        # Wait for command to complete
+        for _ in range(10):
+            time.sleep(1)
+            result = ssm.get_command_invocation(
+                CommandId=command_id,
+                InstanceId=engine["instance_id"],
+            )
+            if result["Status"] in ["Success", "Failed"]:
+                break
+
+        if result["Status"] == "Success":
+            if cancel:
+                console.print(
+                    "[green]✓ Coffee cancelled – auto-shutdown re-enabled[/green]"
+                )
+            else:
+                console.print(f"[green]✓ Coffee poured for {duration}[/green]")
+            console.print(
+                "\n[dim]Note: Detached Docker containers (except dev containers) will also keep the engine awake.[/dim]"
+            )
+            console.print(
+                "[dim]Use coffee for nohup operations or other background tasks.[/dim]"
+            )
+        else:
+            console.print(
+                f"[red]❌ Failed to manage coffee: {result.get('StatusDetails', 'Unknown error')}[/red]"
+            )
+
+    except ClientError as e:
+        console.print(f"[red]❌ Failed to manage coffee: {e}[/red]")

dayhoff_tools/cli/engine/config_ssh.py

@@ -0,0 +1,113 @@
+"""Engine config-ssh command."""
+
+from pathlib import Path
+
+import typer
+
+from ..engine_studio_utils.api_utils import make_api_request
+from ..engine_studio_utils.aws_utils import check_aws_sso
+from ..engine_studio_utils.constants import SSH_MANAGED_COMMENT, console
+from ..engine_studio_utils.ssh_utils import check_session_manager_plugin
+
+
+def config_ssh(
+    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."""
+    username = check_aws_sso()
+
+    # Only check for Session Manager Plugin if we're not just cleaning
+    if not clean and not check_session_manager_plugin():
+        raise typer.Exit(1)
+
+    if clean:
+        console.print("Removing all managed SSH entries...")
+    else:
+        if all_engines:
+            console.print("Updating SSH config with all running engines...")
+        else:
+            console.print(
+                f"Updating SSH config with running engines for [cyan]{username}[/cyan] and [cyan]shared[/cyan]..."
+            )
+
+    # Get all engines
+    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", [])
+    running_engines = [e for e in engines if e["state"].lower() == "running"]
+
+    # Filter engines based on options
+    if not all_engines:
+        # Show only current user's engines and shared engines
+        running_engines = [
+            e for e in running_engines if e["user"] == username or e["user"] == "shared"
+        ]
+
+    # Read existing config
+    config_path = Path.home() / ".ssh" / "config"
+    config_path.parent.mkdir(mode=0o700, exist_ok=True)
+
+    if config_path.exists():
+        content = config_path.read_text()
+        lines = content.splitlines()
+    else:
+        content = ""
+        lines = []
+
+    # Remove old managed entries
+    new_lines = []
+    skip_until_next_host = False
+    for line in lines:
+        if SSH_MANAGED_COMMENT in line:
+            skip_until_next_host = True
+        elif line.strip().startswith("Host ") and skip_until_next_host:
+            skip_until_next_host = False
+            # Check if this is a managed host
+            if SSH_MANAGED_COMMENT not in line:
+                new_lines.append(line)
+        elif not skip_until_next_host:
+            new_lines.append(line)
+
+    # Add new entries if not cleaning
+    if not clean:
+        for engine in running_engines:
+            # Determine ssh user based on --admin flag
+            ssh_user = "ec2-user" if admin else username
+            new_lines.extend(
+                [
+                    "",
+                    f"Host {engine['name']} {SSH_MANAGED_COMMENT}",
+                    f"    HostName {engine['instance_id']}",
+                    f"    User {ssh_user}",
+                    f"    ProxyCommand sh -c \"AWS_SSM_IDLE_TIMEOUT=600 aws ssm start-session --target %h --document-name AWS-StartSSHSession --parameters 'portNumber=%p'\"",
+                ]
+            )
+
+    # Write back
+    config_path.write_text("\n".join(new_lines))
+    config_path.chmod(0o600)
+
+    if clean:
+        console.print("[green]✓ Removed all managed SSH entries[/green]")
+    else:
+        console.print(
+            f"[green]✓ Updated SSH config with {len(running_engines)} engines[/green]"
+        )
+        for engine in running_engines:
+            user_display = (
+                f"[dim]({engine['user']})[/dim]" if engine["user"] != username else ""
+            )
+            console.print(
+                f"  • {engine['name']} → {engine['instance_id']} {user_display}"
+            )

dayhoff_tools/cli/engine/debug.py

@@ -0,0 +1,79 @@
+"""Engine debug command."""
+
+import time
+
+import boto3
+import typer
+
+from ..engine_studio_utils.api_utils import make_api_request
+from ..engine_studio_utils.aws_utils import check_aws_sso
+from ..engine_studio_utils.constants import console
+from ..engine_studio_utils.formatting import resolve_engine
+
+
+def debug_engine(
+    name_or_id: str = typer.Argument(help="Engine name or instance ID"),
+):
+    """Debug engine bootstrap status and files."""
+    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)
+
+    console.print(f"[bold]Debug info for {engine['name']}:[/bold]\n")
+
+    ssm = boto3.client("ssm", region_name="us-east-1")
+
+    # Check multiple files and systemd status
+    checks = [
+        (
+            "Stage file",
+            "cat /opt/dayhoff/state/engine-init.stage 2>/dev/null || cat /var/run/engine-init.stage 2>/dev/null || echo 'MISSING'",
+        ),
+        (
+            "Health file",
+            "cat /opt/dayhoff/state/engine-health.json 2>/dev/null || cat /var/run/engine-health.json 2>/dev/null || echo 'MISSING'",
+        ),
+        (
+            "Sentinel file",
+            "ls -la /opt/dayhoff/first_boot_complete.sentinel 2>/dev/null || echo 'MISSING'",
+        ),
+        (
+            "Setup service",
+            "systemctl status setup-aws-vm.service --no-pager || echo 'Service not found'",
+        ),
+        (
+            "Bootstrap log tail",
+            "tail -20 /var/log/engine-setup.log 2>/dev/null || echo 'No log'",
+        ),
+        ("Environment file", "cat /etc/engine.env 2>/dev/null || echo 'MISSING'"),
+    ]
+
+    for name, cmd in checks:
+        try:
+            resp = ssm.send_command(
+                InstanceIds=[engine["instance_id"]],
+                DocumentName="AWS-RunShellScript",
+                Parameters={"commands": [cmd], "executionTimeout": ["10"]},
+            )
+            cid = resp["Command"]["CommandId"]
+            time.sleep(1)
+            inv = ssm.get_command_invocation(
+                CommandId=cid, InstanceId=engine["instance_id"]
+            )
+
+            if inv["Status"] == "Success":
+                output = inv["StandardOutputContent"].strip()
+                console.print(f"[cyan]{name}:[/cyan]")
+                console.print(f"[dim]{output}[/dim]\n")
+            else:
+                console.print(f"[cyan]{name}:[/cyan] [red]FAILED[/red]\n")
+
+        except Exception as e:
+            console.print(f"[cyan]{name}:[/cyan] [red]ERROR: {e}[/red]\n")