urun-cli 0.7.7__tar.gz → 0.7.8__tar.gz

{urun_cli-0.7.7 → urun_cli-0.7.8}/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## Unreleased
 
+- `urun release promote <release_id> [--environment main]` — make an existing
+  release current again (clean rollback, no marker commits). Server side it
+  takes the same path as a same-content `urun deploy`: the control plane
+  re-registers the release and republishes the release pointer.
+- Deploy deps collector: `@app.function(deps=...)` may now reference a
+  module-level `Dependencies(...)` constant imported from a file shipped with
+  the app (`from sense_deploy import SENSE_DEPS`) — resolved statically by the
+  same side-effect-free evaluator, including re-export chains and the
+  `import mod` + `mod.SYM` attribute form. An attached `deps=` that cannot be
+  statically resolved now FAILS THE DEPLOY LOUDLY naming `file:line`, the
+  import it came through, and the fix — previously it silently shipped an
+  EMPTY manifest (no python pins, no files) and the app's boot self-test died
+  with `No module named ...` after fleet rollout (sense, 2026-10-27/28).
+- `kubectl urun` — a kubectl plugin (`kubectl-urun`, installed alongside
+  `urun`) with four verbs over the `gpu.urun.sh/v1alpha1` GPUWorker surface:
+  `logs` (the `logs.urun.sh/v1` log subresource, with `-f` follow
+  passthrough, `--since`, `--tail`, `-s <service>`), `cordon`/`uncordon`
+  (`spec.unschedulable`), `drain` (cordon, then wait for the `Draining`
+  condition to reach `False`/`Drained`, nonzero on `--timeout`), and
+  `describe` (node block, services, conditions, events, liveness lease,
+  claim summary). Claim-owned workers are cordoned through their OWNING
+  GPUWorkerClaim (resolved via `spec.claimRef`) because the claim
+  reconciler re-renders the worker's spec; the patched object is printed.
+  All verbs ride a bounded `kubectl proxy --port=0` child, so
+  `--kubeconfig`/`--context`/`-n` resolve exactly as kubectl resolves them.
 - Security (ENG-570 / pentest urun-cli-01, mirrored in urun-python
   `urun/core/store/repo.py`): `store.repo(...)` specs parsed from untrusted
   app source are validated before any git call. The `@<ref>` pin must be a

{urun_cli-0.7.7 → urun_cli-0.7.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urun-cli
-Version: 0.7.7
+Version: 0.7.8
 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
@@ -534,6 +534,33 @@ What it does:
   sooner. `--no-logs` skips streaming the occupant's log after creation
   (Ctrl-C also detaches without tearing the occupant down).
 
+## Operator: GPUWorker nodes (`kubectl urun`)
+
+Installing `urun-cli` also installs the `kubectl-urun` binary; with it on
+`PATH`, kubectl dispatches `kubectl urun` to it as a standard kubectl plugin.
+These verbs are the operator surface over the `gpu.urun.sh/v1alpha1`
+GPUWorker custom resources (the cluster must have the urun controller
+installed); they resolve kubeconfig/context through kubectl itself, so
+`--kubeconfig`, `--context`, and `-n` behave like any other kubectl command:
+
+```bash
+kubectl urun logs <worker> -n urun                       # one-shot aggregated log
+kubectl urun logs <worker> -n urun -s vineyard --tail 200 --since 30m
+kubectl urun logs <worker> -n urun -f                    # follow; Ctrl-C detaches
+kubectl urun cordon <worker> -n urun                     # mark unschedulable
+kubectl urun uncordon <worker> -n urun
+kubectl urun drain <worker> -n urun --timeout 300        # cordon + wait for Drained
+kubectl urun describe <worker> -n urun                   # node/services/conditions/events/lease
+```
+
+`cordon` sets `spec.unschedulable`. Claim-owned workers (workers with a
+`spec.claimRef`) are re-rendered from their claim by the claim reconciler, so
+`cordon`/`uncordon`/`drain` patch the OWNING CLAIM's `spec.unschedulable`
+instead and print which object they patched; workers without a claim are
+patched directly. `drain` cordons and then watches the worker's `Draining`
+condition until it flips to `False`/`Drained` (no sessions left), exiting
+nonzero on `--timeout` (default 300s).
+
 ## What gets deployed
 
 `urun deploy` creates a source manifest from your Python entrypoint:
@@ -579,6 +606,11 @@ def superres(): ...
 - `files=` is **purely additive**. With no `files=`, collection is exactly what
   it was before.
 - Entries are **individual files**, not directories or globs. List each file.
+- `deps=` may be a module-level `Dependencies(...)` constant imported from a
+  file shipped with the app (`from deps_mod import APP_DEPS`) — the deploy
+  collector resolves it statically. Anything it cannot resolve (an import
+  outside the app directory, a non-literal) **fails the deploy loudly**, naming
+  `file:line` and the fix — it never ships an empty manifest.
 - A declared path that does not exist, escapes the app directory (`..`, a
   symlink pointing outside), or is absolute **fails the deploy immediately**,
   naming the path and the directory it was looked up under. A declared file is

{urun_cli-0.7.7 → urun_cli-0.7.8}/README.md

@@ -509,6 +509,33 @@ What it does:
   sooner. `--no-logs` skips streaming the occupant's log after creation
   (Ctrl-C also detaches without tearing the occupant down).
 
+## Operator: GPUWorker nodes (`kubectl urun`)
+
+Installing `urun-cli` also installs the `kubectl-urun` binary; with it on
+`PATH`, kubectl dispatches `kubectl urun` to it as a standard kubectl plugin.
+These verbs are the operator surface over the `gpu.urun.sh/v1alpha1`
+GPUWorker custom resources (the cluster must have the urun controller
+installed); they resolve kubeconfig/context through kubectl itself, so
+`--kubeconfig`, `--context`, and `-n` behave like any other kubectl command:
+
+```bash
+kubectl urun logs <worker> -n urun                       # one-shot aggregated log
+kubectl urun logs <worker> -n urun -s vineyard --tail 200 --since 30m
+kubectl urun logs <worker> -n urun -f                    # follow; Ctrl-C detaches
+kubectl urun cordon <worker> -n urun                     # mark unschedulable
+kubectl urun uncordon <worker> -n urun
+kubectl urun drain <worker> -n urun --timeout 300        # cordon + wait for Drained
+kubectl urun describe <worker> -n urun                   # node/services/conditions/events/lease
+```
+
+`cordon` sets `spec.unschedulable`. Claim-owned workers (workers with a
+`spec.claimRef`) are re-rendered from their claim by the claim reconciler, so
+`cordon`/`uncordon`/`drain` patch the OWNING CLAIM's `spec.unschedulable`
+instead and print which object they patched; workers without a claim are
+patched directly. `drain` cordons and then watches the worker's `Draining`
+condition until it flips to `False`/`Drained` (no sessions left), exiting
+nonzero on `--timeout` (default 300s).
+
 ## What gets deployed
 
 `urun deploy` creates a source manifest from your Python entrypoint:
@@ -554,6 +581,11 @@ def superres(): ...
 - `files=` is **purely additive**. With no `files=`, collection is exactly what
   it was before.
 - Entries are **individual files**, not directories or globs. List each file.
+- `deps=` may be a module-level `Dependencies(...)` constant imported from a
+  file shipped with the app (`from deps_mod import APP_DEPS`) — the deploy
+  collector resolves it statically. Anything it cannot resolve (an import
+  outside the app directory, a non-literal) **fails the deploy loudly**, naming
+  `file:line` and the fix — it never ships an empty manifest.
 - A declared path that does not exist, escapes the app directory (`..`, a
   symlink pointing outside), or is absolute **fails the deploy immediately**,
   naming the path and the directory it was looked up under. A declared file is

{urun_cli-0.7.7 → urun_cli-0.7.8}/pyproject.toml

@@ -20,7 +20,7 @@ name = "urun-cli"
 # so every merge remains on the already-published version until this value is
 # advanced. Wiring semantic-release into CI remains separate work; this patch
 # bump is the minimal release unblock (post-v0.6.3 fixes + the Rust feature minor).
-version = "0.7.7"
+version = "0.7.8"
 description = "End-user CLI for deploying apps to urun"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -48,6 +48,7 @@ Issues = "https://github.com/urun-sh/urun-cli/issues"
 [project.scripts]
 urun = "urun.cli:main"
 urun-cli = "urun.cli:main"
+kubectl-urun = "urun.kubectl_plugin:main"
 
 [project.optional-dependencies]
 # Rust app discovery (urun/rust.py) parses with the pinned native

{urun_cli-0.7.7 → urun_cli-0.7.8}/src/urun/api.py

@@ -461,6 +461,18 @@ class ApiClient:
     def get_release(self, release_id: str) -> dict[str, Any]:
         return self._get(f"/cli/releases/{urllib.parse.quote(release_id, safe='')}")
 
+    def promote_release(self, release_id: str, environment: str) -> dict[str, Any]:
+        """Make an EXISTING release current for ``environment`` (rollback).
+
+        ``POST /cli/releases/<id>/promote`` re-fires the release's deploy event —
+        the same path a same-content ``urun deploy`` takes — so the control plane
+        re-registers it and republishes the release pointer.
+        """
+        return self._post(
+            f"/cli/releases/{urllib.parse.quote(release_id, safe='')}/promote",
+            {"environment": environment},
+        )
+
     def query_logs(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
         return self._get("/cli/logs", params)
 

{urun_cli-0.7.7 → urun_cli-0.7.8}/src/urun/catalog.py

@@ -120,7 +120,7 @@ ENGINE_DEPS: dict[str, list[str]] = {
         "nvidia-cuda-crt==13.0.88",
         "nvidia-cuda-cccl==13.0.85",
         "nvidia-nvvm==13.0.88",
-        "nvidia-cuda-runtime==13.0.96",
+        "nvidia-cuda-runtime==13.0.*",
         "numpy<2",
         "pillow>=10.0.0",
         "orjson",
@@ -162,7 +162,7 @@ ENGINE_DEPS: dict[str, list[str]] = {
         "nvidia-cuda-crt==13.0.88",
         "nvidia-cuda-cccl==13.0.85",
         "nvidia-nvvm==13.0.88",
-        "nvidia-cuda-runtime==13.0.96",
+        "nvidia-cuda-runtime==13.0.*",
         "numpy<2",
         "pillow>=10.0.0",
         "orjson",
@@ -368,7 +368,7 @@ ENGINE_DEPS: dict[str, list[str]] = {
         "nvidia-cuda-crt==13.0.88",
         "nvidia-cuda-cccl==13.0.85",
         "nvidia-nvvm==13.0.88",
-        "nvidia-cuda-runtime==13.0.96",
+        "nvidia-cuda-runtime==13.0.*",
         "numpy<2",
         "pillow>=10.0.0",
         "orjson",
@@ -446,7 +446,7 @@ ENGINE_DEPS: dict[str, list[str]] = {
         "nvidia-cuda-crt==13.0.88",
         "nvidia-cuda-cccl==13.0.85",
         "nvidia-nvvm==13.0.88",
-        "nvidia-cuda-runtime==13.0.96",
+        "nvidia-cuda-runtime==13.0.*",
         "ninja",
         "pip",
         "nvidia-cutlass-dsl>=4.6.0.dev0,<5",

{urun_cli-0.7.7 → urun_cli-0.7.8}/src/urun/cli.py

@@ -744,6 +744,14 @@ def add_session_parsers(sub: argparse._SubParsersAction) -> None:
 
 def add_secret_parsers(sub: argparse._SubParsersAction) -> None:
     parser = sub.add_parser("secret", help="Manage secrets (list, get, set, delete)")
+    parser.add_argument(
+        "--hub-url",
+        help=(
+            "Regional hub base URL; manage the hub's per-org sealed secret "
+            "store instead of the legacy control plane. Defaults to "
+            "URUN_HUB_URL; unset = the legacy path."
+        ),
+    )
     secret_sub = parser.add_subparsers(dest="secret_command")
 
     list_p = secret_sub.add_parser("list", help="List secret metadata")
@@ -802,7 +810,7 @@ def add_capacity_parsers(sub: argparse._SubParsersAction) -> None:
 
 
 def add_release_parsers(sub: argparse._SubParsersAction) -> None:
-    parser = sub.add_parser("release", help="Manage releases (list, get)")
+    parser = sub.add_parser("release", help="Manage releases (list, get, promote)")
     release_sub = parser.add_subparsers(dest="release_command")
 
     list_p = release_sub.add_parser("list", help="List releases")
@@ -814,6 +822,13 @@ def add_release_parsers(sub: argparse._SubParsersAction) -> None:
     get_p.add_argument("target")
     add_json_api(get_p)
 
+    promote_p = release_sub.add_parser(
+        "promote", help="Make an existing release current (rollback / re-promote)"
+    )
+    promote_p.add_argument("target", help="Release id (see `urun release list`)")
+    add_environment_arg(promote_p, "Environment to promote into (default: configured, else main)")
+    add_json_api(promote_p)
+
 
 def add_environment_parsers(sub: argparse._SubParsersAction) -> None:
     parser = sub.add_parser("environment", help="Manage environments (list, get, create)")
@@ -2234,13 +2249,25 @@ def _hub_client_for_deploy(
     of the login, not an engineer-only flag). Unset = the legacy
     control-plane path, byte-for-byte unchanged.
     """
+    hub_url = _hub_url_selected(args)
+    if not hub_url:
+        return None
+    return HubBuildClient(hub_url, api_key, on_retry=on_retry)
+
+
+def _hub_url_selected(args: argparse.Namespace) -> str | None:
+    """The hub URL when hub mode is selected, else None.
+
+    Precedence: ``--hub-url`` flag > ``URUN_HUB_URL`` env > the SAVED LOGIN's
+    ``hub_url`` (written by ``urun login --hub-url``). The ONE copy of this
+    order — every hub-mode client resolution (deploy, secrets) goes through
+    here so none of them can drift onto a different surface.
+    """
     hub_url = getattr(args, "hub_url", None) or os.getenv("URUN_HUB_URL")
     if not hub_url:
         saved = load_credentials().get("hub_url")
         hub_url = saved if isinstance(saved, str) and saved else None
-    if not hub_url:
-        return None
-    return HubBuildClient(hub_url, api_key, on_retry=on_retry)
+    return hub_url
 
 
 def hub_deployment_doc(
@@ -2495,27 +2522,29 @@ def deploy_once(args: argparse.Namespace) -> DeployOutcome:
     creds_to_push: dict[str, str] = {}
     creds_from_store: list[str] = []
     declared_credential_names: list[str] = []
-    secret_client: ApiClient | None = None
-    if (required_env or optional_env) and hub is not None:
-        # HUB ISOLATION (owner ruling 2026-10-27): a hub deploy must never touch
-        # the legacy control plane — silently reading or pushing secrets to
-        # api_url is exactly the bug that created prod rows from hub-mode
-        # deploys. The hub has no secret surface yet, so fail loud; declaring
-        # creds on a hub deploy needs that surface first.
-        raise UrunError(
-            "deploy --hub-url cannot deliver declared Credentials(...) yet: the "
-            "hub has no secret surface, and pushing them to the legacy control "
-            "plane would silently touch prod. Remove the Credentials(...) "
-            "declaration, or deploy without --hub-url."
-        )
+    secret_client: ApiClient | HubBuildClient | None = None
     if required_env or optional_env:
-        secret_client = ApiClient(api_url, api_key)
-        # Org-level secrets (``app_id`` null) plus this app's app-level secrets —
-        # the precise set the runtime injects (see control-plane urun_org_secret_env).
-        all_secrets = secret_client.list_secrets(None).get("secrets", [])
-        store_names = {s["name"] for s in all_secrets if not s.get("app_id")}
-        app_secrets = secret_client.list_secrets(app_name).get("secrets", [])
-        store_names |= {s["name"] for s in app_secrets}
+        if hub is not None:
+            # HUB SECRETS CONTRACT: the hub keeps a per-org sealed secret store
+            # (GET/PUT/DELETE /v1/secrets on the org API key); values are
+            # delivered to nodes only at claim time over the worker channel
+            # (POST /v1/worker/secrets, claim-fenced). The legacy control plane
+            # is never contacted in hub mode — not even constructed.
+            secret_client = hub
+            all_secrets = secret_client.list_secrets().get("secrets", [])
+            # Same two-set union as the legacy path: org-level (``app_id`` null)
+            # plus this app's app-level secrets — the precise set the runtime
+            # injects (see control-plane urun_org_secret_env).
+            store_names = {s["name"] for s in all_secrets if not s.get("app_id")}
+            store_names |= {s["name"] for s in all_secrets if s.get("app_id") == app_name}
+        else:
+            secret_client = ApiClient(api_url, api_key)
+            # Org-level secrets (``app_id`` null) plus this app's app-level secrets —
+            # the precise set the runtime injects (see control-plane urun_org_secret_env).
+            all_secrets = secret_client.list_secrets(None).get("secrets", [])
+            store_names = {s["name"] for s in all_secrets if not s.get("app_id")}
+            app_secrets = secret_client.list_secrets(app_name).get("secrets", [])
+            store_names |= {s["name"] for s in app_secrets}
         creds_to_push, _missing_required, creds_from_store = resolve_declared_credentials(
             required_env, optional_env, store_names
         )
@@ -3503,6 +3532,19 @@ def _client(args: argparse.Namespace) -> ApiClient:
     return ApiClient(api_url, api_key)
 
 
+def _secrets_client(args: argparse.Namespace) -> ApiClient | HubBuildClient:
+    """The secret-store client: the hub when hub mode is selected, else legacy.
+
+    A `--hub-url` on a secret command must never dial the legacy control
+    plane behind it — same precedence as :func:`_hub_client_for_deploy`.
+    """
+    api_url, api_key = resolve_api_credentials(args)
+    hub_url = _hub_url_selected(args)
+    if hub_url:
+        return HubBuildClient(hub_url, api_key)
+    return ApiClient(api_url, api_key)
+
+
 def _print_json(payload: Any) -> None:
     print(json.dumps(payload, indent=2, sort_keys=True))
 
@@ -3528,8 +3570,9 @@ def _filter_params(args: argparse.Namespace) -> dict[str, Any]:
     return {k: v for k, v in params.items() if v is not None and v is not False}
 
 
-def generic_list(args: argparse.Namespace, target: str) -> int:
-    client = _client(args)
+def generic_list(args: argparse.Namespace, target: str, client: Any = None) -> int:
+    if client is None:
+        client = _client(args)
     params = _filter_params(args)
     fetchers: dict[str, Callable[[], dict[str, Any]]] = {
         "shapes": lambda: client.list_shapes(params),
@@ -3574,7 +3617,7 @@ def _mcp_only_failure(command: str, mcp_tool: str) -> int:
 
 def _get_secret_metadata(args: argparse.Namespace) -> dict[str, Any]:
     """Metadata-only: the store NEVER returns secret values."""
-    client = _client(args)
+    client = _secrets_client(args)
     secrets = client.list_secrets(getattr(args, "app", None)).get("secrets", [])
     matches = [s for s in secrets if s.get("name") == args.target]
     if not matches:
@@ -3614,7 +3657,7 @@ def _session_stop_command(args: argparse.Namespace) -> int:
 def secret_command(args: argparse.Namespace) -> int:
     command = getattr(args, "secret_command", None)
     if command == "list":
-        return generic_list(args, "secrets")
+        return generic_list(args, "secrets", client=_secrets_client(args))
     if command == "get":
         response = _get_secret_metadata(args)
         return print_or_table(response, args, "secret")
@@ -3637,7 +3680,7 @@ def _secret_set_command(args: argparse.Namespace) -> int:
         value = getpass.getpass(f"Value for secret {args.name}: ")
         if value == "":
             raise UrunError("empty secret value from prompt; aborting")
-    response = _client(args).set_secret(args.name, {"value": value, "app": args.app})
+    response = _secrets_client(args).set_secret(args.name, {"value": value, "app": args.app})
     return print_or_table(response, args, "secret")
 
 
@@ -3645,7 +3688,7 @@ def _secret_delete_command(args: argparse.Namespace) -> int:
     if not getattr(args, "yes", False) and not _confirm_action(f"Delete secret {args.target}?"):
         print("Aborted.")
         return 1
-    response = _client(args).delete_secret(args.target, app=getattr(args, "app", None))
+    response = _secrets_client(args).delete_secret(args.target, app=getattr(args, "app", None))
     return print_or_table(response, args, "secret")
 
 
@@ -3678,7 +3721,10 @@ def release_command(args: argparse.Namespace) -> int:
     if command == "get":
         response = _client(args).get_release(args.target)
         return print_or_table(response, args, "release")
-    print("usage: urun release {list,get} [options]", file=sys.stderr)
+    if command == "promote":
+        response = _client(args).promote_release(args.target, resolve_environment(args))
+        return print_or_table(response, args, "release")
+    print("usage: urun release {list,get,promote} [options]", file=sys.stderr)
     return 2