urun-cli 0.3.1__tar.gz → 0.4.0__tar.gz

{urun_cli-0.3.1 → urun_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urun-cli
-Version: 0.3.1
+Version: 0.4.0
 Summary: End-user CLI for deploying apps to urun
 Project-URL: Homepage, https://urun.sh
 Project-URL: Repository, https://github.com/urun-sh/urun-cli

{urun_cli-0.3.1 → urun_cli-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "urun-cli"
-version = "0.3.1"
+version = "0.4.0"
 description = "End-user CLI for deploying apps to urun"
 readme = "README.md"
 requires-python = ">=3.11"

{urun_cli-0.3.1 → urun_cli-0.4.0}/src/urun/api.py

@@ -5,6 +5,7 @@ import time
 import urllib.error
 import urllib.parse
 import urllib.request
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Any
 
@@ -171,13 +172,36 @@ def require_safe_url(raw_url: str, label: str) -> None:
     raise UrunError(f"{label} must use HTTPS except for localhost development")
 
 
+# Terminal build states reported by the control plane's deployment-status document.
+# The build worker transitions a deployment queued -> building -> ready|failed and
+# records the actual build stderr/reason in the `error` field on failure.
+TERMINAL_STATES = {"ready", "failed"}
+
+# Human-readable progress lines for non-terminal states, so the CLI streams what the
+# builder is doing instead of blocking silently until ready/failed.
+_STATE_PROGRESS = {
+    "queued": "queued (waiting for a build slot)",
+    "building": "building (installing deps + materializing app)",
+    "not_found": "waiting for the control plane to register the build",
+}
+
+
 def poll_until_done(
     client: ApiClient,
     manifest_hash: str,
     interval: float = 2.0,
     timeout: float = 1800.0,
     not_found_grace: float = 30.0,
+    on_state: Callable[[str], None] | None = None,
 ) -> dict[str, Any]:
+    """Poll the control plane for the real build outcome of a deployment.
+
+    Streams each new build state via ``on_state`` (so callers can show
+    queued -> building -> ... progress) and returns the terminal status
+    document (status ``ready`` or ``failed``). The ``failed`` document carries
+    the actual build error under ``error`` for the caller to surface. Raises
+    ``UrunError`` on timeout.
+    """
     deadline = time.time() + timeout
     not_found_deadline = time.time() + min(not_found_grace, timeout)
     last_state = "unknown"
@@ -186,16 +210,25 @@ def poll_until_done(
             status = client.deployment_status(manifest_hash)
         except ApiError as exc:
             if exc.status == 404 and time.time() < not_found_deadline:
+                if last_state != "not_found" and on_state is not None:
+                    on_state("not_found")
                 last_state = "not_found"
                 time.sleep(interval)
                 continue
             raise
-        state = status.get("status")
-        last_state = str(state)
-        if state in {"ready", "failed"}:
+        state = str(status.get("status"))
+        if state != last_state and on_state is not None:
+            on_state(state)
+        last_state = state
+        if state in TERMINAL_STATES:
             return status
         if time.time() >= deadline:
             raise UrunError(
                 f"timed out waiting for deployment {manifest_hash} (last status: {last_state})"
             )
         time.sleep(interval)
+
+
+def progress_line(state: str) -> str:
+    """Render a human-readable progress line for a build state."""
+    return _STATE_PROGRESS.get(state, state)

{urun_cli-0.3.1 → urun_cli-0.4.0}/src/urun/cli.py

@@ -11,7 +11,13 @@ from pathlib import Path
 from typing import Any
 
 from . import __version__
-from .api import DEFAULT_API_URL, ApiClient, poll_until_done, upload_missing_blobs
+from .api import (
+    DEFAULT_API_URL,
+    ApiClient,
+    poll_until_done,
+    progress_line,
+    upload_missing_blobs,
+)
 from .config import load_credentials, save_credentials
 from .deps import resolve_deps
 from .discovery import derive_app_name, discover_main_files
@@ -326,17 +332,43 @@ def deploy(args: argparse.Namespace) -> int:
             print(f"Status: {status_url}")
         return 0
 
-    status = poll_until_done(client, mh, args.poll_interval, args.timeout)
+    print("Waiting for build to complete (--no-wait to skip)")
+    status = poll_until_done(
+        client,
+        mh,
+        args.poll_interval,
+        args.timeout,
+        on_state=lambda state: print(f"  build: {progress_line(state)}"),
+    )
     if status.get("status") == "failed":
-        err = status.get("error") or {}
-        code = err.get("code")
-        message = err.get("message")
-        detail = f"{code}: {message}" if code and message else (message or code or "unknown error")
-        raise UrunError(f"deployment failed: {detail}")
+        print_build_failure(status)
+        return 1
     print_ready(status)
     return 0
 
 
+def print_build_failure(status: dict[str, Any]) -> None:
+    """Surface the REAL build failure (e.g. the uv/git/torch error) to stderr.
+
+    The control plane records the build worker's terminal error under
+    ``error`` as ``{code, message}`` where ``message`` is the actual build
+    stderr/reason. We print the full message verbatim so callers no longer have
+    to kubectl into the cluster to learn why a build failed.
+    """
+    err = status.get("error") or {}
+    code = string_value(err.get("code"))
+    message = string_value(err.get("message"))
+    print("Deployment failed: build did not succeed", file=sys.stderr)
+    if code:
+        print(f"  reason: {code}", file=sys.stderr)
+    if message:
+        print("  build error:", file=sys.stderr)
+        for line in message.rstrip().splitlines() or [message]:
+            print(f"    {line}", file=sys.stderr)
+    if not code and not message:
+        print("  (no error detail recorded by the build worker)", file=sys.stderr)
+
+
 def resolve_api_credentials(args: argparse.Namespace) -> tuple[str, str]:
     api_key = args.api_key or os.getenv("URUN_API_KEY")
     api_url = args.api_url or os.getenv("URUN_API_URL")