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

dayhoff_tools/__init__.py

@@ -0,0 +1,10 @@
+import importlib.metadata
+
+try:
+    # The package name here should match the 'name' field in your pyproject.toml
+    __version__ = importlib.metadata.version("dayhoff-tools")
+except importlib.metadata.PackageNotFoundError:
+    # This is a fallback for when the package might not be installed (e.g., running from source
+    # without installation, or during development). You can set it to None, "unknown",
+    # or handle it as you see fit.
+    __version__ = "unknown"

dayhoff_tools/cli/cloud_commands.py

@@ -256,6 +256,32 @@ def _get_adc_status() -> str:
     return "Not configured"
 
 
+def _is_adc_authenticated() -> bool:
+    """Check if Application Default Credentials (ADC) are valid.
+
+    Returns:
+        True if `gcloud auth application-default print-access-token --quiet` succeeds,
+        False otherwise.
+    """
+    try:
+        gcloud_path = _find_executable("gcloud")
+        returncode, _, _ = _run_command(
+            [
+                gcloud_path,
+                "auth",
+                "application-default",
+                "print-access-token",
+                "--quiet",
+            ],
+            capture=True,
+            check=False,
+            suppress_output=True,
+        )
+        return returncode == 0
+    except FileNotFoundError:
+        return False
+
+
 def _is_gcp_user_authenticated() -> bool:
     """Check if the current gcloud user authentication is valid and non-interactive.
 
@@ -347,7 +373,7 @@ def _run_gcloud_login() -> None:
 
 
 def _test_gcp_credentials(user: str, impersonation_sa: str) -> None:
-    """Test GCP credentials. Only prints output on failure (to stderr)."""
+    """Test GCP credentials. Prints output on failure (to stderr) and success (to stdout)."""
     gcloud_path = _find_executable("gcloud")
     user_short = _get_short_name(user)
     impersonation_short = _get_short_name(impersonation_sa)
@@ -363,64 +389,73 @@ def _test_gcp_credentials(user: str, impersonation_sa: str) -> None:
         ]
 
         if impersonation_sa != "None":
+            # Test 1: Access as the user directly (temporarily disable impersonation)
+            print(f"  Testing direct access as user ({user_short})...")
             orig_sa = impersonation_sa
             unset_rc, _, unset_err = _gcloud_unset_config(
                 "auth/impersonate_service_account"
             )
             if unset_rc != 0:
-                # Failure to unset is an error state
                 print(
-                    f"{RED}✗ Test Error: Failed to temporarily disable impersonation: {unset_err}{NC}",
+                    f"    {RED}✗ Test Error: Failed to temporarily disable impersonation: {unset_err}{NC}",
                     file=sys.stderr,
                 )
-
-            user_returncode, _, _ = _run_command(cmd, suppress_output=True, check=False)
-            if user_returncode != 0:
-                # Failure to access as user
-                print(
-                    f"{RED}✗ Test Failure: Cannot access resources directly as user '{user_short}'. Check roles/project.{NC}",
-                    file=sys.stderr,
+                # Even if unsetting fails, attempt to restore and continue with impersonation test
+            else:
+                user_returncode, _, _ = _run_command(
+                    cmd, suppress_output=True, check=False
                 )
+                if user_returncode != 0:
+                    print(
+                        f"    {RED}✗ User Test Failure: Cannot access resources directly as user '{user_short}'. Check roles/project.{NC}",
+                        file=sys.stderr,
+                    )
+                else:
+                    print(
+                        f"    {GREEN}✓ User Test ({user_short}): Direct access OK{NC}"
+                    )
 
+            # Restore impersonation setting
             set_rc, _, set_err = _gcloud_set_config(
                 "auth/impersonate_service_account", orig_sa
             )
             if set_rc != 0:
-                # Failure to restore is an error state
                 print(
-                    f"{RED}✗ Test Error: Failed to restore impersonation config for {impersonation_short}: {set_err}{NC}",
+                    f"    {RED}✗ Test Error: Failed to restore impersonation config for {impersonation_short}: {set_err}{NC}",
                     file=sys.stderr,
                 )
+                # If restoring fails, it's a significant issue for the next test
 
+            # Test 2: Access while impersonating the SA
+            print(f"  Testing access while impersonating SA ({impersonation_short})...")
             impersonation_returncode, _, _ = _run_command(
                 cmd, suppress_output=True, check=False
             )
             if impersonation_returncode != 0:
-                # Failure to access while impersonating
                 print(
-                    f"{RED}✗ Test Failure: Cannot access resources impersonating '{impersonation_short}'. Check permissions/config.{NC}",
+                    f"    {RED}✗ Impersonation Test Failure: Cannot access resources impersonating '{impersonation_short}'. Check permissions/config.{NC}",
                     file=sys.stderr,
                 )
+            else:
+                print(
+                    f"    {GREEN}✓ Impersonation Test ({impersonation_short}): Access OK{NC}"
+                )
 
         else:
             # Test user account directly (no impersonation config)
+            print(f"  Testing direct access as user ({user_short})...")
             returncode, _, _ = _run_command(cmd, suppress_output=True, check=False)
             if returncode != 0:
-                # Failure to access as user
                 print(
-                    f"{RED}✗ Test Failure: Cannot access resources directly as user '{user_short}'. Check roles/project.{NC}",
+                    f"    {RED}✗ User Test Failure: Cannot access resources directly as user '{user_short}'. Check roles/project.{NC}",
                     file=sys.stderr,
                 )
-            # Success: No output
-            # else:
-            #    print(f"{GREEN}✓ Direct access as user {user_short}: OK{NC}")
-            # Correctly indented pass statement if no action needed on success
-            pass
+            else:
+                print(f"    {GREEN}✓ User Test ({user_short}): Direct access OK{NC}")
     else:
-        # If user isn't authenticated at all, maybe print a warning?
-        # print(f"{YELLOW}User not authenticated, skipping credential test.{NC}")
-        # Decided against this to keep output minimal unless actual test fails.
-        pass  # Explicit pass for the outer else
+        print(
+            f"  {YELLOW}User not authenticated, skipping credential access tests.{NC}"
+        )
 
 
 # --- AWS Functions ---
@@ -450,10 +485,14 @@ def _get_current_aws_profile() -> str:
         cmd = [aws_path, "configure", "list", "--no-cli-pager"]
         _, stdout, _ = _run_command(cmd, capture=True, check=False)
 
-        # Extract profile from output
-        profile_match = re.search(r"profile\s+(\S+)", stdout)
-        if profile_match and profile_match.group(1) not in ("<not", "not"):
-            return profile_match.group(1)
+        # Extract profile from output (format: "profile    : <value>    : <type>    : <location>")
+        # Match the line starting with "profile" and capture the value after the first colon
+        profile_match = re.search(r"^profile\s+:\s+(\S+)", stdout, re.MULTILINE)
+        if profile_match:
+            profile_value = profile_match.group(1)
+            # Check if the profile is actually set (not "<not" or "not")
+            if profile_value not in ("<not", "not"):
+                return profile_value
     except:
         pass
 
@@ -516,30 +555,54 @@ aws_app = typer.Typer(help="Manage AWS SSO authentication using RC files.")
 # --- GCP Commands ---
 @gcp_app.command("status")
 def gcp_status():
-    """Show active GCP credentials for CLI and Libraries/ADC."""
+    """Show active GCP credentials for CLI and Libraries/ADC, including staleness."""
     cli_user = _get_current_gcp_user()
     cli_impersonation = _get_current_gcp_impersonation()
-    adc_principal = _get_adc_status()
+    adc_principal_raw = _get_adc_status()  # Raw status string, potentially complex
+
+    user_auth_valid = _is_gcp_user_authenticated()
+    adc_auth_valid = _is_adc_authenticated()
 
     # Determine active principal for CLI
     if cli_impersonation != "None":
         cli_active_short = _get_short_name(cli_impersonation)
+        cli_is_impersonating = True
     else:
         cli_active_short = _get_short_name(cli_user)
+        cli_is_impersonating = False
 
-    # Get short name for ADC principal
-    adc_active_short = _get_short_name(adc_principal)
+    adc_active_short = _get_short_name(adc_principal_raw)
 
-    # Define a fixed width for the principal name field
-    name_width = 10
+    print(f"{BLUE}--- GCP CLI Credentials ---{NC}")
+    print(f"  Effective Principal: {GREEN}{cli_active_short}{NC}")
+    print(f"  User Account ({_get_short_name(cli_user)}):")
+    if user_auth_valid:
+        print(f"    └─ Authentication: {GREEN}VALID{NC}")
+    else:
+        print(
+            f"    └─ Authentication: {RED}STALE/EXPIRED{NC} (Hint: run 'dh gcp login')"
+        )
 
-    print(
-        f"Using {GREEN}{cli_active_short:<{name_width}}{NC} for {BLUE}gcloud CLI{NC} (gcloud, gsutil)"
-    )
-    print(
-        f"Using {GREEN}{adc_active_short:<{name_width}}{NC} for {BLUE}Libraries/Tools{NC} (warehouse, Terraform, Python clients)\n"
-    )
+    if cli_is_impersonating:
+        print(
+            f"  Impersonation ({_get_short_name(cli_impersonation)}): {GREEN}Active{NC}"
+        )
+        print(f"    └─ Access Test: (see results below)")
+    else:
+        print(f"  Impersonation: {YELLOW}Not Active{NC}")
+
+    print(f"\n{BLUE}--- GCP Library/ADC Credentials ---{NC}")
+    print(f"  Effective Principal: {GREEN}{adc_active_short}{NC}")
+    if adc_principal_raw in ["Not configured", "Error reading", "Invalid format"]:
+        print(f"    └─ Status: {RED}{adc_principal_raw}{NC}")
+    elif adc_auth_valid:
+        print(f"    └─ Authentication: {GREEN}VALID{NC}")
+    else:
+        print(
+            f"    └─ Authentication: {RED}STALE/EXPIRED{NC} (Hint: run 'dh gcp use-...-adc' or 'gcloud auth application-default login ...')"
+        )
 
+    print(f"\n{BLUE}--- GCP Access Tests (for CLI configuration) ---{NC}")
     # Run tests silently, they will print to stderr only on failure
     _test_gcp_credentials(cli_user, cli_impersonation)
 
@@ -843,6 +906,72 @@ def gcp_use_devcon_adc():
         sys.exit(1)
 
 
+@gcp_app.command("logout")
+def gcp_logout():
+    """Clear all GCP credentials for testing or role switching purposes.
+
+    This removes the active user's gcloud login, disables impersonation,
+    and invalidates Application Default Credentials (ADC).
+    """
+    print(f"{BLUE}Clearing all GCP credentials...{NC}")
+
+    try:
+        gcloud_path = _find_executable("gcloud")
+        errors = []
+
+        # 1. Revoke user-level credentials
+        print(f"{BLUE}Revoking active gcloud credentials...{NC}")
+        revoke_cmd = [gcloud_path, "auth", "revoke", "--all", "--quiet"]
+        revoke_code, _, revoke_err = _run_command(revoke_cmd, capture=True, check=False)
+        if revoke_code != 0 and revoke_err:
+            errors.append(f"Failed to revoke credentials: {revoke_err}")
+
+        # 2. Unset impersonation config
+        print(f"{BLUE}Disabling service account impersonation...{NC}")
+        unset_code, _, unset_err = _gcloud_unset_config(
+            "auth/impersonate_service_account"
+        )
+        if unset_code != 0 and unset_err:
+            errors.append(f"Failed to unset impersonation: {unset_err}")
+
+        # 3. Revoke ADC
+        print(f"{BLUE}Revoking Application Default Credentials (ADC)...{NC}")
+        adc_cmd = [gcloud_path, "auth", "application-default", "revoke", "--quiet"]
+        adc_code, _, adc_err = _run_command(adc_cmd, capture=True, check=False)
+
+        # 4. Additionally remove ADC file if it exists (belt-and-suspenders approach)
+        adc_file = (
+            Path.home() / ".config" / "gcloud" / "application_default_credentials.json"
+        )
+        if adc_file.exists():
+            try:
+                adc_file.unlink()
+                print(f"{BLUE}Removed ADC file: {adc_file}{NC}")
+            except Exception as e:
+                errors.append(f"Failed to delete ADC file: {e}")
+
+        if errors:
+            print(f"{YELLOW}Logged out with some warnings:{NC}")
+            for err in errors:
+                print(f"{YELLOW}  - {err}{NC}")
+        else:
+            print(f"{GREEN}Successfully logged out from GCP.{NC}")
+
+        # Always show how to log back in
+        print(f"\n{BLUE}To log back in:{NC}")
+        print(f"  {YELLOW}dh gcp login{NC}")
+
+        # Show current (now-cleared) status
+        print(f"\n{BLUE}Current status:{NC}")
+        gcp_status()
+
+    except Exception as e:
+        print(f"{RED}Error during logout: {e}{NC}", file=sys.stderr)
+        print(f"{YELLOW}You may need to manually run:{NC}")
+        print(f"  {YELLOW}gcloud auth revoke --all{NC}")
+        print(f"  {YELLOW}gcloud auth application-default revoke{NC}")
+
+
 # === End NEW ADC Commands ===
 
 
@@ -862,12 +991,19 @@ def aws_status(
         # Get detailed identity information
         aws_path = _find_executable("aws")
         _run_command(
-            [aws_path, "sts", "get-caller-identity", "--profile", target_profile]
+            [
+                aws_path,
+                "sts",
+                "get-caller-identity",
+                "--profile",
+                target_profile,
+                "--no-cli-pager",
+            ]
         )
     else:
         print(f"Credential status: {RED}not authenticated{NC}")
         print(f"\nTo authenticate, run:")
-        print(f"  {YELLOW}dh aws login --profile {target_profile}{NC}")
+        print(f"  {YELLOW}dh aws login{NC}")
 
 
 @aws_app.command("login")

dayhoff_tools/cli/engine1/__init__.py

@@ -0,0 +1,323 @@
+"""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)