dh-cli 0.4.1__tar.gz → 0.4.3__tar.gz

{dh_cli-0.4.1 → dh_cli-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dh-cli
-Version: 0.4.1
+Version: 0.4.3
 Summary: Dayhoff Labs developer CLI
 Author-email: Dayhoff Labs <dev@dayhofflabs.com>
 License: # PolyForm Noncommercial License 1.0.0

{dh_cli-0.4.1 → dh_cli-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dh-cli"
-version = "0.4.1"
+version = "0.4.3"
 description = "Dayhoff Labs developer CLI"
 requires-python = ">=3.11"
 readme = "README.md"

{dh_cli-0.4.1 → dh_cli-0.4.3}/src/dh_cli/hz/__init__.py

@@ -10,6 +10,48 @@ hz_app = typer.Typer(
     context_settings={"help_option_names": ["-h", "--help"]},
 )
 
+API_URLS = {
+    "prod": "https://api.horizyn.dayhofflabs.com",
+    "dev": "https://horizyn-api-dev.dayhofflabs.com",
+}
+
+
+@hz_app.command()
+def health(
+    detailed: bool = typer.Option(False, "-d", "--detailed", help="Include GPU and EFS details."),
+):
+    """Check API health for both prod and dev environments."""
+    import json
+    from concurrent.futures import ThreadPoolExecutor
+    from urllib.request import urlopen
+    from urllib.error import URLError
+
+    path = "/healthz/detailed" if detailed else "/healthz"
+
+    def _fetch(env: str) -> tuple[str, dict | str]:
+        try:
+            with urlopen(f"{API_URLS[env]}{path}", timeout=10) as resp:
+                return env, json.loads(resp.read())
+        except (URLError, OSError) as exc:
+            return env, f"unreachable ({exc})"
+        except json.JSONDecodeError:
+            return env, "invalid response"
+
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        results = dict(pool.map(_fetch, API_URLS))
+
+    for env in ("prod", "dev"):
+        label = f"[{env}] {API_URLS[env]}"
+        data = results[env]
+        if isinstance(data, str):
+            typer.secho(f"{label}  ✗ {data}", fg=typer.colors.RED)
+        else:
+            status = data.get("status", "unknown")
+            version = data.get("version", "?")
+            color = typer.colors.GREEN if status == "healthy" else typer.colors.YELLOW
+            typer.secho(f"{label}  v{version}  {status}", fg=color)
+            typer.echo(json.dumps(data, indent=2))
+
 
 def _find_workspace_root() -> Path:
     root = os.environ.get("WORKSPACE_ROOT")

{dh_cli-0.4.1 → dh_cli-0.4.3}/src/dh_cli/hz/users.py

@@ -40,9 +40,26 @@ def _format_csv(emails: set[str]) -> str:
     return ",".join(sorted(emails))
 
 
+def compute_user_tiers(
+    allowed_emails: set[str],
+    alpha_emails: set[str],
+    admin_emails: set[str],
+) -> tuple[set[str], set[str], set[str]]:
+    """Derive beta set and find orphaned emails not on the allowed list.
+
+    Returns (beta_emails, alpha_only, orphaned_emails) where orphaned
+    means present in alpha or admin but missing from allowed_emails.
+    """
+    orphaned = (alpha_emails | admin_emails) - allowed_emails
+    alpha_only = alpha_emails - admin_emails - orphaned
+    beta_emails = allowed_emails - alpha_emails - admin_emails
+    return beta_emails, alpha_only, orphaned
+
+
 @users_app.command("list")
 def list_users(
     env: str = typer.Option("prod", "--env", "-e", help="Environment: prod or dev."),
+    detailed: bool = typer.Option(False, "-d", "--detailed", help="Show raw SSM parameter lists."),
 ):
     """Show all authorized users and their tiers."""
     ssm = _ssm_client()
@@ -53,7 +70,7 @@ def list_users(
     allowed_domains = _parse_csv(_get_param(ssm, SSM_PARAMS["allowed_domains"].format(env=env)))
     allowed_emails = _parse_csv(_get_param(ssm, SSM_PARAMS["allowed_emails"].format(env=env)))
 
-    typer.echo(f"\n  Horizyn users ({env})\n")
+    env_colored = typer.style(env, fg=typer.colors.BRIGHT_GREEN, bold=True)
 
     def _print_section(label: str, items: set[str]) -> None:
         typer.echo(f"  {label}:")
@@ -62,13 +79,36 @@ def list_users(
         else:
             for item in sorted(items):
                 typer.echo(f"    {item}")
+        typer.echo()
+
+    if detailed:
+        typer.echo(f"\n  Horizyn users ({env_colored}) — detailed")
+        typer.echo()
+        typer.echo("  Access requires allowed_emails or allowed_domains match.")
+        typer.echo("  Allowed users default to beta tier unless listed in alpha or admin.")
+        typer.echo()
+        _print_section("Admin domains", admin_domains)
+        _print_section("Admin emails", admin_emails)
+        _print_section("Alpha emails", alpha_emails)
+        _print_section("Allowed domains", allowed_domains)
+        _print_section("Allowed emails", allowed_emails)
+    else:
+        beta, alpha_only, orphaned = compute_user_tiers(
+            allowed_emails, alpha_emails, admin_emails,
+        )
 
-    _print_section("Admin domains", admin_domains)
-    _print_section("Admin emails", admin_emails)
-    _print_section("Alpha emails", alpha_emails)
-    _print_section("Allowed domains", allowed_domains)
-    _print_section("Allowed emails", allowed_emails)
-    typer.echo()
+        typer.echo(f"\n  Horizyn users ({env_colored})")
+        typer.echo()
+        _print_section("Alpha", alpha_only)
+        _print_section("Beta", beta)
+
+        if orphaned:
+            for email in sorted(orphaned):
+                typer.secho(
+                    f"  ⚠ {email} is in alpha/admin but NOT in allowed_emails",
+                    fg=typer.colors.RED,
+                )
+            typer.echo()
 
 
 @users_app.command("add")
@@ -169,11 +209,12 @@ def find_user(
                 if email in values:
                     matches.append(param_key)
 
+        env_colored = typer.style(env, fg=typer.colors.BRIGHT_GREEN, bold=True)
         if matches:
-            typer.echo(f"  {env}: found")
+            typer.echo(f"  {env_colored}: found")
             for m in matches:
                 typer.echo(f"    - {m}")
         else:
-            typer.echo(f"  {env}: not found")
+            typer.echo(f"  {env_colored}: not found")
 
     typer.echo()

{dh_cli-0.4.1 → dh_cli-0.4.3}/tests/hz/test_users.py

@@ -5,7 +5,7 @@ from unittest.mock import MagicMock, patch
 import pytest
 from click.exceptions import Exit
 
-from dh_cli.hz.users import _format_csv, _parse_csv
+from dh_cli.hz.users import _format_csv, _parse_csv, compute_user_tiers
 
 
 class TestParseCSV:
@@ -206,3 +206,50 @@ class TestPromoteUser:
             from dh_cli.hz.users import promote_user
 
             promote_user("alice@x.com", tier="superadmin", env="prod")
+
+
+class TestComputeUserTiers:
+    def test_beta_is_allowed_minus_alpha_minus_admin(self):
+        beta, alpha_only, orphaned = compute_user_tiers(
+            allowed_emails={"a@x.com", "b@x.com", "c@x.com"},
+            alpha_emails={"b@x.com"},
+            admin_emails=set(),
+        )
+        assert beta == {"a@x.com", "c@x.com"}
+        assert alpha_only == {"b@x.com"}
+        assert orphaned == set()
+
+    def test_admin_emails_excluded_from_alpha_and_beta(self):
+        beta, alpha_only, orphaned = compute_user_tiers(
+            allowed_emails={"a@x.com", "b@x.com", "c@x.com"},
+            alpha_emails={"b@x.com", "c@x.com"},
+            admin_emails={"c@x.com"},
+        )
+        assert beta == {"a@x.com"}
+        assert alpha_only == {"b@x.com"}
+        assert orphaned == set()
+
+    def test_orphaned_alpha_not_in_allowed(self):
+        beta, alpha_only, orphaned = compute_user_tiers(
+            allowed_emails={"a@x.com"},
+            alpha_emails={"ghost@x.com"},
+            admin_emails=set(),
+        )
+        assert beta == {"a@x.com"}
+        assert alpha_only == set()
+        assert orphaned == {"ghost@x.com"}
+
+    def test_orphaned_admin_not_in_allowed(self):
+        beta, alpha_only, orphaned = compute_user_tiers(
+            allowed_emails={"a@x.com"},
+            alpha_emails=set(),
+            admin_emails={"ghost@x.com"},
+        )
+        assert beta == {"a@x.com"}
+        assert orphaned == {"ghost@x.com"}
+
+    def test_all_empty(self):
+        beta, alpha_only, orphaned = compute_user_tiers(set(), set(), set())
+        assert beta == set()
+        assert alpha_only == set()
+        assert orphaned == set()