dayhoff-tools 1.9.11__py3-none-any.whl → 1.9.13__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

@@ -217,8 +217,12 @@ def list_engines(
 
 def engine_status(
     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)"),
+    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."""
     check_aws_sso()
@@ -477,6 +481,47 @@ def engine_status(
         except Exception:
             pass
 
+    # Slack notifications status (detailed view only)
+    try:
+        ssm = boto3.client("ssm", region_name="us-east-1")
+        resp = ssm.send_command(
+            InstanceIds=[engine["instance_id"]],
+            DocumentName="AWS-RunShellScript",
+            Parameters={
+                "commands": ["grep '^SLACK_NOTIFY_' /etc/engine.env || true"],
+                "executionTimeout": ["10"],
+            },
+        )
+        cid = resp["Command"]["CommandId"]
+        time.sleep(1)
+        inv = ssm.get_command_invocation(
+            CommandId=cid, InstanceId=engine["instance_id"]
+        )
+        if inv["Status"] == "Success":
+            settings_raw = inv["StandardOutputContent"].strip()
+            settings = {}
+            for line in settings_raw.splitlines():
+                if "=" in line:
+                    key, value = line.split("=", 1)
+                    settings[key.strip()] = value.strip().lower()
+
+            status_lines.append("")
+            status_lines.append("[bold]Slack Notifications:[/bold]")
+
+            def _setting_line(label: str, key: str) -> str:
+                val = settings.get(key, "false")  # Default to false if not set
+                status = "[green]on[/green]" if val == "true" else "[dim]off[/dim]"
+                return f"  - {label:15} {status}"
+
+            status_lines.append(_setting_line("Idle Start", "SLACK_NOTIFY_IDLE_START"))
+            status_lines.append(
+                _setting_line("IDE Disconnect", "SLACK_NOTIFY_IDE_DISCONNECT")
+            )
+            status_lines.append(_setting_line("Warnings", "SLACK_NOTIFY_WARNINGS"))
+            status_lines.append(_setting_line("Shutdown", "SLACK_NOTIFY_SHUTDOWN"))
+    except Exception:
+        pass
+
     # Activity Sensors (show all with YES/no)
     if idle_detector.get("available"):
         status_lines.append("")
@@ -564,10 +609,14 @@ def _format_idle_status_display(
         ):
             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]"
+            remaining_secs = remaining % 60
+
+            if remaining < 60:
+                time_left_str = f"[red]{remaining}s[/red] left"
             else:
-                return f"[yellow]Idle {int(idle_seconds_v)//60}m/{int(thresh_v)//60}m: [red]{remaining_mins}m[/red] left[/yellow]"
+                time_left_str = f"[red]{remaining_mins}m {remaining_secs}s[/red] left"
+
+            return f"[yellow]Idle {int(idle_seconds_v)//60}m/{int(thresh_v)//60}m: {time_left_str}[/yellow]"
         elif isinstance(thresh_v, (int, float)):
             return f"[yellow]Idle ?/{int(thresh_v)//60}m[/yellow]"
         else:

dayhoff_tools/cli/engine/engine_maintenance.py

@@ -11,12 +11,7 @@ from botocore.exceptions import ClientError
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Confirm
 
-from .shared import (
-    check_aws_sso,
-    console,
-    make_api_request,
-    resolve_engine,
-)
+from .shared import check_aws_sso, console, make_api_request, resolve_engine
 
 
 def coffee(
@@ -123,9 +118,11 @@ def idle_timeout_cmd(
     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 the engine idle-detector timeout."""
+    """Show or set engine idle-detector settings."""
     check_aws_sso()
 
     # Resolve engine
@@ -139,7 +136,56 @@ def idle_timeout_cmd(
 
     ssm = boto3.client("ssm", region_name="us-east-1")
 
-    if set is None:
+    # Handle slack notifications change
+    if slack:
+        slack = slack.lower()
+        if slack not in ["none", "default", "all"]:
+            console.print("[red]❌ Invalid slack option. Use: none, default, all[/red]")
+            raise typer.Exit(1)
+
+        console.print(f"Setting Slack notifications to [bold]{slack}[/bold]...")
+
+        if slack == "none":
+            settings = {
+                "SLACK_NOTIFY_WARNINGS": "false",
+                "SLACK_NOTIFY_IDLE_START": "false",
+                "SLACK_NOTIFY_IDE_DISCONNECT": "false",
+                "SLACK_NOTIFY_SHUTDOWN": "false",
+            }
+        elif slack == "default":
+            settings = {
+                "SLACK_NOTIFY_WARNINGS": "true",
+                "SLACK_NOTIFY_IDLE_START": "false",
+                "SLACK_NOTIFY_IDE_DISCONNECT": "false",
+                "SLACK_NOTIFY_SHUTDOWN": "true",
+            }
+        else:  # all
+            settings = {
+                "SLACK_NOTIFY_WARNINGS": "true",
+                "SLACK_NOTIFY_IDLE_START": "true",
+                "SLACK_NOTIFY_IDE_DISCONNECT": "true",
+                "SLACK_NOTIFY_SHUTDOWN": "true",
+            }
+
+        commands = []
+        for key, value in settings.items():
+            # Use a robust sed command that adds the line if it doesn't exist
+            commands.append(
+                f"grep -q '^{key}=' /etc/engine.env && sudo sed -i 's|^{key}=.*|{key}={value}|' /etc/engine.env || echo '{key}={value}' | sudo tee -a /etc/engine.env > /dev/null"
+            )
+
+        commands.append("sudo systemctl restart engine-idle-detector.service")
+
+        resp = ssm.send_command(
+            InstanceIds=[engine["instance_id"]],
+            DocumentName="AWS-RunShellScript",
+            Parameters={"commands": commands, "executionTimeout": ["60"]},
+        )
+        cid = resp["Command"]["CommandId"]
+        time.sleep(2)  # Give it a moment to process
+        console.print(f"[green]✓ Slack notifications updated to '{slack}'[/green]")
+
+    if set is None and not slack:
         # Show current timeout setting
         resp = ssm.send_command(
             InstanceIds=[engine["instance_id"]],
@@ -164,7 +210,7 @@ def idle_timeout_cmd(
             console.print("[red]❌ Could not retrieve idle timeout[/red]")
         return
 
-    # ----- set new value -----
+    # ----- set new value for timeout -----
     m = re.match(r"^(?:(\d+)h)?(?:(\d+)m)?$", set)
     if not m:
         console.print("[red]❌ Invalid duration format. Use e.g. 2h, 45m, 1h30m[/red]")

{dayhoff_tools-1.9.11.dist-info → dayhoff_tools-1.9.13.dist-info}/METADATA

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

{dayhoff_tools-1.9.11.dist-info → dayhoff_tools-1.9.13.dist-info}/RECORD

@@ -3,10 +3,10 @@ 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=IEU2m93qArFx-EdVHnepWKvLwlNUAcT7ytIAqeOY6a0,25147
+dayhoff_tools/cli/engine/__init__.py,sha256=CGJ2blhWIIEsVb8HoLibZjSlMFRTSYZOO4zDQTtY3SY,9300
+dayhoff_tools/cli/engine/engine_core.py,sha256=ItfqW3ZWoHEWLOgtWPYT-SO1idxk5RBBCIe8w9xxf3w,26959
 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_maintenance.py,sha256=xZgEgpjwTDI2RpoN7P6E7MEGiIA8RJpb0MkCT9u2R14,15889
 dayhoff_tools/cli/engine/engine_management.py,sha256=s_H3FtMlKsdfzR8pwV-j2W2QX-Fypkqj2kPC0aTqC1A,19072
 dayhoff_tools/cli/engine/shared.py,sha256=Ecx6I1jtzmxQDn3BezKpgpQ4SJeZf4SZjUCLg-67p80,16844
 dayhoff_tools/cli/engine/studio_commands.py,sha256=VwTQujz32-uMcYusDRE73SdzRpgvIkv7ZAF4zRv6AzA,30266
@@ -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.11.dist-info/METADATA,sha256=BDXSvhTBdCaaxl_2i2kZ6m7ce7C81j6QFDdoLimM2ek,2915
-dayhoff_tools-1.9.11.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-dayhoff_tools-1.9.11.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
-dayhoff_tools-1.9.11.dist-info/RECORD,,
+dayhoff_tools-1.9.13.dist-info/METADATA,sha256=Sf1ILU9mg5Cvs7NepbxAB0NJSuKM_gMqrKopTykTqDM,2915
+dayhoff_tools-1.9.13.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+dayhoff_tools-1.9.13.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
+dayhoff_tools-1.9.13.dist-info/RECORD,,