urun-cli 0.7.0__tar.gz → 0.7.1__tar.gz

{urun_cli-0.7.0 → urun_cli-0.7.1}/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.7.1
+
+- `urun serve --warm N` — an idle replica floor on a serve deploy (the
+  catalog's `warm` marker for platform-operated shared endpoints; absent =
+  the unchanged scale-to-zero default). Pins `URUN_SERVE_WARM` into the
+  generated shim so the bundled app's `@app.function(warm=...)` reads it.
+- `urun serve --exo-class / --exo-image` — pin a deploy's provider on the EXO rail.
+- Deploy Python and Rust functions in one app release.
+- Compat: bundle the proxy with the queued session identity; stop reporting
+  an unconverged roll as ready and stop dropping the server's error message.
+
 ## 0.6.3
 
 - Bump the vendored `urun-openai` binary pin to `@urun-sh/openai@0.5.0` — the

{urun_cli-0.7.0 → urun_cli-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urun-cli
-Version: 0.7.0
+Version: 0.7.1
 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.7.0 → urun_cli-0.7.1}/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.0"
+version = "0.7.1"
 description = "End-user CLI for deploying apps to urun"
 readme = "README.md"
 requires-python = ">=3.11"

{urun_cli-0.7.0 → urun_cli-0.7.1}/src/urun/cli.py

@@ -2675,7 +2675,7 @@ def deploy_once(args: argparse.Namespace) -> DeployOutcome:
         # showing" and hides a broken build-log path (owner, 2026-07-17).
         if not tailer.emitted_any:
             print(f"{BUILD_LOG_PREFIX}{NO_BUILD_LOGS_NOTE}")
-        watch_rollout(
+        rollout = watch_rollout(
             client,
             app=app_name,
             manifest_hash=mh,
@@ -2683,6 +2683,27 @@ def deploy_once(args: argparse.Namespace) -> DeployOutcome:
             on_phase=lambda phase: print(f"  rollout: {phase}"),
         )
         mark_phase("roll-wait")
+        # A ROLL THAT DID NOT CONVERGE IS NOT A READY DEPLOYMENT. watch_rollout's
+        # verdict used to be discarded, so a `timeout` printed its own honest
+        # "still not converged" line and was then immediately contradicted by
+        # "Deployment ready" and exit 0 -- the one signal automation reads.
+        # Live receipt, dev-usw2 2026-09-09 `urun serve qwen3.6-27b:bf16`:
+        # `rollout: still not converged after 300s` followed by
+        # `Deployment ready`, exit 0, while the app sat at
+        # `no_ready_gpu_units`. A CI job gating on the exit code called that a
+        # successful deploy. `skipped` (no presence signal for this app at all)
+        # stays exit 0: nothing was observed, so nothing is contradicted.
+        if rollout == "timeout":
+            print(format_phase_timing(phases))
+            print(
+                "Deployment NOT confirmed ready: the build succeeded and the "
+                "roll continues server-side, but this command did not observe "
+                "the new release serving before its deadline. Re-check with "
+                "`urun app status`, or pass --no-wait to finalize without "
+                "waiting.",
+                file=sys.stderr,
+            )
+            return DeployOutcome(exit_code=1, manifest_hash=mh, deps=deps, status=status)
     print(format_phase_timing(phases))
     print_ready(status)
     return DeployOutcome(exit_code=0, manifest_hash=mh, deps=deps, status=status)

{urun_cli-0.7.0 → urun_cli-0.7.1}/src/urun/errors.py

@@ -31,6 +31,55 @@ MAX_ERROR_BODY_CHARS = 500
 ENDPOINT_HINT = "the endpoint may not be deployed on this server yet"
 
 
+# ── credential redaction ──────────────────────────────────────────────────────
+#
+# Server-supplied error text is echoed to terminals and CI logs (the exception
+# string itself, and urun.retry.describe_error's retry line). A PROXIED upstream
+# error can carry credential material verbatim -- a signed URL's query token, an
+# echoed Authorization header, a JWT. Whitespace normalisation and truncation do
+# not prevent it reaching a log, so redact before any of it is rendered.
+#
+# Patterns are TARGETED, never "anything long and hex": a build id is 64 hex
+# chars and is exactly the value an operator needs to keep reading. Redacting it
+# would trade a credential leak for an unusable diagnostic.
+_REDACTIONS: tuple[tuple[re.Pattern[str], str], ...] = (
+    # urun API keys, both shapes (cli.API_KEY_RE).
+    (re.compile(r"\burun_(?:[0-9a-f]{32}|sk_[A-Za-z0-9_-]{43})\b"), "urun_[redacted]"),
+    # Authorization headers echoed back by a proxy.
+    (
+        re.compile(r"\b(bearer|basic)\s+[A-Za-z0-9._~+/=-]{8,}", re.IGNORECASE),
+        r"\1 [redacted]",
+    ),
+    # JWTs (three base64url segments), wherever they appear.
+    (
+        re.compile(r"\beyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}"),
+        "[redacted-jwt]",
+    ),
+    # Signed-URL and query-string secrets: ?token=, &sig=, &X-Amz-Signature=, ...
+    (
+        re.compile(
+            r"([?&](?:[A-Za-z0-9_-]*(?:token|signature|sig|secret|password|api[_-]?key|"
+            r"access[_-]?key|credential)[A-Za-z0-9_-]*)=)[^&\s\"']+",
+            re.IGNORECASE,
+        ),
+        r"\1[redacted]",
+    ),
+)
+
+
+def redact_credentials(text: str) -> str:
+    """Strip credential material from server-supplied text before it is logged.
+
+    Applied at :class:`ApiError` construction so EVERY render of a server
+    message -- the exception string, ``describe_error``'s retry line, anything
+    downstream -- is safe by construction rather than by each caller
+    remembering.
+    """
+    for pattern, replacement in _REDACTIONS:
+        text = pattern.sub(replacement, text)
+    return text
+
+
 def sanitize_error_text(text: str, limit: int = MAX_ERROR_BODY_CHARS) -> str:
     """Make server-supplied text safe to print: no ANSI/control chars, bounded.
 
@@ -74,6 +123,11 @@ class ApiError(UrunError):
         method: str | None = None,
         url: str | None = None,
     ):
+        # Redact FIRST: `message` (and a signed `url`) are server-supplied and
+        # end up in this exception's string, in retry lines, and in CI logs.
+        message = redact_credentials(message)
+        if url:
+            url = redact_credentials(url)
         detail = f"{status} {code}: {message}"
         if method and url:
             detail += f" ({method} {url})"

{urun_cli-0.7.0 → urun_cli-0.7.1}/src/urun/retry.py

@@ -157,9 +157,27 @@ def retry_call(
             sleep(wait)
 
 
+#: Cap for the server message echoed by :func:`describe_error`. Long enough for
+#: a real upstream diagnosis ("cube load failed: upstream status 503"), short
+#: enough that a retry line stays one line.
+_DESCRIBE_DETAIL_MAX = 160
+
+
 def describe_error(exc: BaseException) -> str:
     """Short, honest one-line description of a transient failure for logging."""
     if isinstance(exc, ApiError):
+        # The server's MESSAGE is the diagnosis; the code alone is only a label.
+        # Dropping it turned a 30-second read into an investigation: a `urun
+        # serve` on dev-usw2 2026-09-09 retried the build-log fetch 7 times
+        # showing `HTTP 502 logs_upstream_error` and gave up, while the very
+        # same response body said `cube load failed: upstream status 503` --
+        # i.e. the log backend had no healthy upstream at all. Bounded so a
+        # verbose server message cannot turn a retry line into a paragraph.
+        detail = " ".join((exc.message or "").split())
+        if detail:
+            if len(detail) > _DESCRIBE_DETAIL_MAX:
+                detail = detail[: _DESCRIBE_DETAIL_MAX - 1].rstrip() + "\u2026"
+            return f"HTTP {exc.status} {exc.code}: {detail}"
         return f"HTTP {exc.status} {exc.code}"
     if isinstance(exc, urllib.error.HTTPError):
         return f"HTTP {exc.code} {exc.reason}"

{urun_cli-0.7.0 → urun_cli-0.7.1}/src/urun/rust.py

@@ -909,11 +909,15 @@ def _resolve_symlink(logical: Path, ws_root: Path, rel: str) -> Path:
 def _dir_ignored(rel: str, name: str, patterns: list[str]) -> bool:
     if rel in _BUILTIN_EXCLUDED_DIRS or name in _BUILTIN_EXCLUDED_DIRS:
         return True
-    # gitignore-style directory patterns ("docs/") match the directory itself.
+    # gitignore-style directory patterns ("docs/") match the directory itself;
+    # a descendant pattern ("cache/**", "cache/*") ignores every entry under
+    # the directory, so the directory is skipped as a whole.
     for pat in patterns:
         base = pat.rstrip("/")
         if fnmatch.fnmatch(rel, base) or fnmatch.fnmatch(name, base):
             return True
+        if fnmatch.fnmatch(rel + "/", pat):
+            return True
     return False
 
 
@@ -938,6 +942,8 @@ def _collect_files(ws_root: Path, patterns: list[str]) -> dict[str, Path]:
                     f"{rel}: '.urun' is generated exclusively by the builder; "
                     "remove it from the project before deploying"
                 )
+            if _dir_ignored(rel, d, patterns):
+                continue  # an ignored tree never ships, symlinked or not
             if logical.is_symlink():
                 target = _resolve_symlink(logical, ws_root, rel)
                 raise UrunError(
@@ -945,8 +951,6 @@ def _collect_files(ws_root: Path, patterns: list[str]) -> dict[str, Path]:
                     f"(only file symlinks inside the workspace ship; {rel} resolves "
                     f"to {target})"
                 )
-            if _dir_ignored(rel, d, patterns):
-                continue
             keep.append(d)
         dirnames[:] = keep
         for f in sorted(filenames):

{urun_cli-0.7.0 → urun_cli-0.7.1}/src/urun/serve.py

@@ -120,6 +120,19 @@ def _add_serve_model_args(parser: argparse.ArgumentParser) -> None:
             "own this flag pins nothing and is refused)."
         ),
     )
+    parser.add_argument(
+        "--warm",
+        dest="warm",
+        type=int,
+        default=None,
+        metavar="N",
+        help=(
+            "Idle replica floor (app_functions.warm_replicas) for THIS deploy: "
+            "N idle replicas stay resident at zero live sessions. Omit = legacy "
+            "always-on (NULL). 0 = scale to zero when idle. Shared-endpoint "
+            "deploys pass the catalog row's warm (default 0)."
+        ),
+    )
     parser.add_argument(
         "--entrypoint",
         help=(
@@ -314,14 +327,30 @@ def _build_deploy_args(args: argparse.Namespace, row: CatalogRow) -> argparse.Na
     The shim does NOT bake the catalog row — it sets ``URUN_SERVE_MODEL`` (the
     ``<id:variant>`` string), ``URUN_SERVE_GPUS`` (the resolved gpu spec), and
     ``URUN_SERVE_ENGINE`` (the row's engine) in its own module body and re-exports
-    ``urun.serve.app:app``. Those land scoped to THIS deploy artifact (NOT a shared
-    ``URUN_SERVE_CONFIG`` materializer env, the retired coupling bug). The bundled
-    app resolves engine ARGS by-string at boot; the engine NAME is pinned here only
-    to select the build-time dependency group (vllm / llama-cpp-python / ...) so the
-    deps venv carries the engine the adapter imports at load.
+    ``urun.serve.app:app``. When ``--warm`` is given, the idle replica floor rides
+    the same channel (``URUN_SERVE_WARM``, JSON int) so the bundled app's
+    ``@app.function(warm=...)`` declares it at import; an omitted ``--warm``
+    renders nothing (byte-identical shim, legacy always-on NULL). Those land
+    scoped to THIS deploy artifact (NOT a shared ``URUN_SERVE_CONFIG``
+    materializer env, the retired coupling bug). The bundled app resolves engine
+    ARGS by-string at boot; the engine NAME is pinned here only to select the
+    build-time dependency group (vllm / llama-cpp-python / ...) so the deps venv
+    carries the engine the adapter imports at load.
     """
     name = getattr(args, "name", None) or _default_app_name(row)
     exo_class, exo_image = _validated_exo_pin(args)
+    # --warm re-validation (argparse guarantees the int): a negative floor is a
+    # config contradiction the deployer must see here, never at app import in
+    # a build pod minutes later. Warm rides the shim env, so --entrypoint (the
+    # user's own app) + --warm cannot combine — validate against entrypoint too.
+    warm = getattr(args, "warm", None)
+    if warm is not None and warm < 0:
+        raise UrunError(f"--warm must be a non-negative integer, got {warm}")
+    if warm is not None and getattr(args, "entrypoint", None):
+        raise UrunError(
+            "--warm only applies to the bundled serve app (it is pinned in the "
+            "generated shim); it cannot be combined with --entrypoint."
+        )
 
     entrypoint = getattr(args, "entrypoint", None)
     if entrypoint:
@@ -334,7 +363,7 @@ def _build_deploy_args(args: argparse.Namespace, row: CatalogRow) -> argparse.Na
         shim_root = None
     else:
         project_root, rel_entrypoint = _write_serve_shim(
-            row, exo_class=exo_class, exo_image=exo_image
+            row, exo_class=exo_class, exo_image=exo_image, warm=warm
         )
         # PLATFORM RELEASE SCOPE (catalog prebuilt instant serve). The shim is
         # deterministic given the resolved row + gpu, so its manifest hash is an
@@ -399,13 +428,14 @@ def _write_serve_shim(
     *,
     exo_class: str | None = None,
     exo_image: str | None = None,
+    warm: int | None = None,
 ) -> tuple[Path, str]:
     """Write the bundled-app shim ``app.py`` pinned to ``row`` into a temp root."""
     project_root = Path(tempfile.mkdtemp(prefix="urun-serve-"))
     try:
         app_path = project_root / "app.py"
         app_path.write_text(
-            render_serve_shim_py(row, exo_class=exo_class, exo_image=exo_image),
+            render_serve_shim_py(row, exo_class=exo_class, exo_image=exo_image, warm=warm),
             encoding="utf-8",
         )
         # Function-engine map for the launcher's PRE-IMPORT topology decision
@@ -523,6 +553,7 @@ def render_serve_shim_py(
     *,
     exo_class: str | None = None,
     exo_image: str | None = None,
+    warm: int | None = None,
 ) -> str:
     """Render the tiny shim that deploys the BUNDLED urun-python serve app.
 
@@ -540,6 +571,10 @@ def render_serve_shim_py(
         ``deps=_deploy_deps()`` selects this engine's dependency group — the build
         installs vllm / llama-cpp-python / ... into the per-serve deps venv (the
         engine the adapter lazily imports at load).
+      * When ``warm`` is not None, ``URUN_SERVE_WARM`` is set before the import so
+        the bundled app's ``@app.function(warm=...)`` declares the idle replica
+        floor (app_functions.warm_replicas) at import. Unset renders NOTHING —
+        byte-identical shim, legacy always-on.
 
     Values are embedded as JSON (NOT interpolated Python) so a weird model string,
     gpu spec, or engine name can never break the module. The catalog row's
@@ -605,6 +640,7 @@ os.environ["URUN_SERVE_MODEL"] = %(model)s
 os.environ["URUN_SERVE_GPUS"] = %(gpus)s
 os.environ["URUN_SERVE_ENGINE"] = %(engine)s
 %(exo_env)s
+%(warm_env)s
 %(serve_deps_env)s
 
 from urun.serve.app import app  # noqa: E402  (bundled urun-python serve app)
@@ -626,6 +662,11 @@ if False:  # AST-visible deps declaration; never runs.
 __all__ = ["app"]
 '''
     exo_env = render_exo_pin_env(exo_class, exo_image)
+    warm_env = (
+        'os.environ["URUN_SERVE_WARM"] = ' + json.dumps(int(warm)) + "\n"
+        if warm is not None
+        else ""
+    )
     return template % {
         "entrypoint": BUNDLED_SERVE_ENTRYPOINT,
         "model": model,
@@ -634,6 +675,7 @@ __all__ = ["app"]
         "deps_literal": deps_literal,
         "serve_deps_env": serve_deps_env,
         "exo_env": exo_env,
+        "warm_env": warm_env,
     }