urun-cli 0.5.32__tar.gz → 0.6.1__tar.gz

{urun_cli-0.5.32 → urun_cli-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urun-cli
-Version: 0.5.32
+Version: 0.6.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
@@ -108,8 +108,8 @@ urun deploy prompt_canary/backend/app.py --name prompt-canary --timeout 900
 urun demo prompt-canary --examples-root ~/workspace/urun-examples
 ```
 
-The positional argument is the **deployed app slug** (as shown by `urun list
-apps`). Nothing is declared in a manifest — every value is discovered:
+The positional argument is the **deployed app slug** (as shown by `urun app
+list`). Nothing is declared in a manifest — every value is discovered:
 
 | value | where it comes from |
 | --- | --- |
@@ -193,7 +193,7 @@ row instead of rendering one.
 List every app deployed in your org and its current status:
 
 ```bash
-urun list apps
+urun app list
 ```
 
 Sample output:
@@ -226,21 +226,22 @@ endpoint, which is in development.
 
 ## View logs
 
-Use `urun logs` for build logs or runtime logs scoped to an app, a function
+Use `urun build logs`, `urun app logs`, `urun function logs`, `urun session logs`,
+or `urun log list` for build logs or runtime logs scoped to an app, a function
 within an app, or a session:
 
 ```bash
-urun list logs
-urun logs build <build-id>
-urun logs app <app>
-urun logs function <app> <function>
-urun logs session <session>
+urun log list
+urun build logs <build-id>
+urun app logs <app>
+urun function logs <app> <function>
+urun session logs <session>
 ```
 
 Runtime commands accept `--follow`/`-f` for live output and `--json` for JSON
-(one-shot) or NDJSON (followed) output. Use `urun list logs` without filters to
+(one-shot) or NDJSON (followed) output. Use `urun log list` without filters to
 list all accessible logs, or add the same app, function, session, level, text,
-and time filters. `urun tail logs` remains available for the legacy follow
+and time filters. `urun log tail` remains available for the legacy follow
 workflow. The current logs API does not filter by environment.
 
 ## Inspect sessions
@@ -249,10 +250,10 @@ List live and historical sessions in your org. Newest sessions appear at the
 **bottom** of the table so the command works well with `tail`:
 
 ```bash
-urun list sessions
-urun list sessions | tail -20
-urun list sessions --state failed
-urun list sessions --limit 500
+urun session list
+urun session list | tail -20
+urun session list --state failed
+urun session list --limit 500
 ```
 
 Sample output:
@@ -289,7 +290,7 @@ endpoint, which is in development.
 List the compute slices your org currently has provisioned:
 
 ```bash
-urun list compute
+urun compute list
 ```
 
 Sample output:
@@ -309,8 +310,8 @@ reporting.
 
 Slices with no provisioned capacity are omitted, so this command answers
 "what is running right now". For the full deployment catalogue
-(including paused / failed / unprovisioned apps) use `urun list apps`;
-for historical or in-flight sessions use `urun list sessions`.
+(including paused / failed / unprovisioned apps) use `urun app list`;
+for historical or in-flight sessions use `urun session list`.
 
 Pass `--limit` to control how many rows are fetched (default 100).
 
@@ -320,10 +321,10 @@ endpoint, which is in development.
 ## Manage apps
 
 Manage the lifecycle of a single deployed app. The app is addressed by its
-slug (the name shown under `APP` in `urun list apps`); every operation is
+slug (the name shown under `APP` in `urun app list`); every operation is
 org-scoped via your API key.
 
-Show detailed status for one app (the single-app complement to `list apps`):
+Show detailed status for one app (the single-app complement to `app list`):
 
 ```bash
 urun app status lingbot
@@ -370,10 +371,21 @@ Enable a disabled app and bring it back online:
 urun app enable lingbot-handle
 ```
 
+If `urun deploy` or `urun dev --attach` reports that a function was paused
+after repeated startup failures, inspect its runtime logs before overriding
+the safety pause. Then explicitly resume every paused function:
+
+```bash
+urun app enable rapid-clips --force
+```
+
+`--force` may restart a known-crashing function; it does not change the
+platform's automatic pause policy.
+
 Stop a queued, starting, or live session:
 
 ```bash
-urun stop session sess_123 --yes
+urun session stop sess_123 --yes
 ```
 
 All `app` subcommands accept `--environment` (default `prod`) and `--json`.

{urun_cli-0.5.32 → urun_cli-0.6.1}/README.md

@@ -86,8 +86,8 @@ urun deploy prompt_canary/backend/app.py --name prompt-canary --timeout 900
 urun demo prompt-canary --examples-root ~/workspace/urun-examples
 ```
 
-The positional argument is the **deployed app slug** (as shown by `urun list
-apps`). Nothing is declared in a manifest — every value is discovered:
+The positional argument is the **deployed app slug** (as shown by `urun app
+list`). Nothing is declared in a manifest — every value is discovered:
 
 | value | where it comes from |
 | --- | --- |
@@ -171,7 +171,7 @@ row instead of rendering one.
 List every app deployed in your org and its current status:
 
 ```bash
-urun list apps
+urun app list
 ```
 
 Sample output:
@@ -204,21 +204,22 @@ endpoint, which is in development.
 
 ## View logs
 
-Use `urun logs` for build logs or runtime logs scoped to an app, a function
+Use `urun build logs`, `urun app logs`, `urun function logs`, `urun session logs`,
+or `urun log list` for build logs or runtime logs scoped to an app, a function
 within an app, or a session:
 
 ```bash
-urun list logs
-urun logs build <build-id>
-urun logs app <app>
-urun logs function <app> <function>
-urun logs session <session>
+urun log list
+urun build logs <build-id>
+urun app logs <app>
+urun function logs <app> <function>
+urun session logs <session>
 ```
 
 Runtime commands accept `--follow`/`-f` for live output and `--json` for JSON
-(one-shot) or NDJSON (followed) output. Use `urun list logs` without filters to
+(one-shot) or NDJSON (followed) output. Use `urun log list` without filters to
 list all accessible logs, or add the same app, function, session, level, text,
-and time filters. `urun tail logs` remains available for the legacy follow
+and time filters. `urun log tail` remains available for the legacy follow
 workflow. The current logs API does not filter by environment.
 
 ## Inspect sessions
@@ -227,10 +228,10 @@ List live and historical sessions in your org. Newest sessions appear at the
 **bottom** of the table so the command works well with `tail`:
 
 ```bash
-urun list sessions
-urun list sessions | tail -20
-urun list sessions --state failed
-urun list sessions --limit 500
+urun session list
+urun session list | tail -20
+urun session list --state failed
+urun session list --limit 500
 ```
 
 Sample output:
@@ -267,7 +268,7 @@ endpoint, which is in development.
 List the compute slices your org currently has provisioned:
 
 ```bash
-urun list compute
+urun compute list
 ```
 
 Sample output:
@@ -287,8 +288,8 @@ reporting.
 
 Slices with no provisioned capacity are omitted, so this command answers
 "what is running right now". For the full deployment catalogue
-(including paused / failed / unprovisioned apps) use `urun list apps`;
-for historical or in-flight sessions use `urun list sessions`.
+(including paused / failed / unprovisioned apps) use `urun app list`;
+for historical or in-flight sessions use `urun session list`.
 
 Pass `--limit` to control how many rows are fetched (default 100).
 
@@ -298,10 +299,10 @@ endpoint, which is in development.
 ## Manage apps
 
 Manage the lifecycle of a single deployed app. The app is addressed by its
-slug (the name shown under `APP` in `urun list apps`); every operation is
+slug (the name shown under `APP` in `urun app list`); every operation is
 org-scoped via your API key.
 
-Show detailed status for one app (the single-app complement to `list apps`):
+Show detailed status for one app (the single-app complement to `app list`):
 
 ```bash
 urun app status lingbot
@@ -348,10 +349,21 @@ Enable a disabled app and bring it back online:
 urun app enable lingbot-handle
 ```
 
+If `urun deploy` or `urun dev --attach` reports that a function was paused
+after repeated startup failures, inspect its runtime logs before overriding
+the safety pause. Then explicitly resume every paused function:
+
+```bash
+urun app enable rapid-clips --force
+```
+
+`--force` may restart a known-crashing function; it does not change the
+platform's automatic pause policy.
+
 Stop a queued, starting, or live session:
 
 ```bash
-urun stop session sess_123 --yes
+urun session stop sess_123 --yes
 ```
 
 All `app` subcommands accept `--environment` (default `prod`) and `--json`.

urun_cli-0.6.1/hatch_build.py

@@ -0,0 +1,145 @@
+"""Hatch build hook: platform-tag wheels that carry the vendored urun-openai binary.
+
+The `urun compat` proxy binary (see ``src/urun/_bin/README.md``) is a native
+executable, so a wheel that ships it must NOT claim ``py3-none-any`` — pip
+would happily install a mac binary on linux. This hook makes the wheel tag
+tell the truth, both ways:
+
+- binary PRESENT at ``src/urun/_bin/urun-openai`` → ``pure_python = False``
+  and an explicit ``py3-none-<platform>`` tag. NOT ``infer_tag`` — that would
+  stamp ``cp3XX-cp3XX-<platform>`` and needlessly bind the (pure-Python) code
+  to the building interpreter's minor version; the only platform-specific
+  content is the data binary. A present-but-non-executable binary fails the
+  build loudly — shipping it would only fail later on user machines.
+- binary ABSENT → nothing changes: the wheel stays pure ``py3-none-any`` and
+  ships without the binary (`urun compat` then resolves via its override/PATH
+  lanes or fails loud at runtime).
+
+The platform component is derived explicitly, never a bare ``linux_<arch>``:
+
+- Linux → ``manylinux_<major>_<minor>_<arch>`` from the GLIBC symbol versions
+  the VENDORED BINARY ITSELF actually references (``objdump -T``), never from
+  ``platform.libc_ver()`` (the build machine's installed glibc). PyPI rejects
+  bare ``linux_*`` uploads outright, and in the isolated build env
+  ``packaging.tags.platform_tags()`` can yield bare ``linux_x86_64`` first —
+  so the tag is constructed, not inferred.
+
+  INCIDENT (2026-08-25): tagging by the build machine's installed glibc
+  (``platform.libc_ver()`` on the ``ubuntu-24.04`` release runner → glibc
+  2.39) produced wheels tagged ``manylinux_2_39_x86_64`` even though the
+  actual bun-compiled binary's highest referenced symbol is ``GLIBC_2.17``
+  (confirmed via ``objdump -T``) — a decade-wide, entirely incidental gap
+  between "what the build runner happened to have installed" and "what the
+  binary actually needs". ``manylinux_2_39`` is only installable on glibc
+  ≥2.39 (Ubuntu 24.04+, roughly 2024 onward), so pip/uv silently rejected the
+  platform wheel on every older-but-still-current distro (Ubuntu 20.04/22.04,
+  Debian 11/12, RHEL 8/9, ...) and fell back to the binary-less
+  ``py3-none-any`` wheel with ZERO signal at install time — `uv tool install
+  urun-cli` "succeeded" and `urun compat` failed at runtime claiming the
+  binary "is not installed". Reading the binary's OWN symbol requirements is
+  the only floor that isn't a lie in either direction.
+- everything else (macOS) → the most specific ``packaging.tags`` platform tag
+  (e.g. ``macosx_15_0_arm64``).
+
+The release workflow builds one wheel per platform with the binary vendored
+(``scripts/vendor_openai_proxy.py --from-npm``) plus one pure wheel + sdist
+without it, and verifies each with ``scripts/verify_wheel.py`` — a
+``py3-none-any`` wheel containing the binary fails the release.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import sysconfig
+from pathlib import Path
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+_GLIBC_VERSION_RE = re.compile(r"\bGLIBC_(\d+)\.(\d+)(?:\.\d+)?\b")
+
+
+def parse_required_glibc_versions(objdump_dynsym_output: str) -> set[tuple[int, int]]:
+    """``{(major, minor), ...}`` GLIBC symbol versions referenced in ``objdump
+    -T`` text — pure string parsing, no filesystem/subprocess access."""
+    return {
+        (int(m.group(1)), int(m.group(2)))
+        for m in _GLIBC_VERSION_RE.finditer(objdump_dynsym_output)
+    }
+
+
+def required_glibc_symbol_versions(binary: Path) -> set[tuple[int, int]]:
+    """The GLIBC_x.y versions ``binary``'s own dynamic symbols reference.
+
+    Reads the binary directly instead of trusting the BUILD machine's
+    installed glibc (``platform.libc_ver()``) — a build machine can have a
+    far newer glibc than anything the compiled binary actually links
+    against, and tagging by the build machine rather than the binary's real
+    floor silently locks the platform wheel out of most real-world Linux
+    installs (see the module docstring's INCIDENT)."""
+    try:
+        result = subprocess.run(
+            ["objdump", "-T", str(binary)], capture_output=True, text=True, check=False
+        )
+    except FileNotFoundError as exc:
+        raise RuntimeError(
+            "objdump (binutils) is not on PATH — required to read the vendored "
+            "binary's real glibc floor; refusing to guess one"
+        ) from exc
+    if result.returncode != 0:
+        raise RuntimeError(
+            f"objdump -T {binary} failed (rc={result.returncode}): {result.stderr.strip()!r} — "
+            "cannot verify the binary's real glibc floor; refusing to guess one"
+        )
+    return parse_required_glibc_versions(result.stdout)
+
+
+def manylinux_tag(normalized_platform: str, glibc_versions: set[tuple[int, int]]) -> str:
+    """``manylinux_<major>_<minor>_<arch>`` from the binary's OWN required
+    GLIBC_x.y symbol versions — loud when none were found (statically linked
+    or unparseable; mislabeling in either direction would be a lie)."""
+    if not glibc_versions:
+        raise RuntimeError(
+            "the vendored binary declares no GLIBC_x.y symbol version requirements "
+            "(statically linked, or objdump output did not parse) — refusing to guess "
+            "a manylinux floor"
+        )
+    major, minor = max(glibc_versions)
+    arch = normalized_platform.removeprefix("linux_")
+    if not arch:
+        raise RuntimeError(
+            f"cannot derive a manylinux tag: no architecture in platform {normalized_platform!r}"
+        )
+    return f"manylinux_{major}_{minor}_{arch}"
+
+
+def wheel_platform_tag(binary: Path) -> str:
+    """The platform component for a wheel carrying ``binary`` on THIS machine."""
+    normalized = sysconfig.get_platform().replace("-", "_").replace(".", "_")
+    if normalized.startswith("linux_"):
+        return manylinux_tag(normalized, required_glibc_symbol_versions(binary))
+    # macOS (and anything else): packaging's most specific tag, e.g.
+    # macosx_15_0_arm64. packaging is a hatchling dependency, always present.
+    from packaging.tags import platform_tags
+
+    tag = next(iter(platform_tags()))
+    if tag.startswith("linux_"):  # belt & braces: never a bare linux tag
+        raise RuntimeError(f"refusing bare {tag!r} — PyPI rejects it")
+    return tag
+
+
+class VendoredBinaryBuildHook(BuildHookInterface):
+    PLUGIN_NAME = "custom"
+
+    def initialize(self, version: str, build_data: dict) -> None:
+        binary = os.path.join(self.root, "src", "urun", "_bin", "urun-openai")
+        if not os.path.isfile(binary):
+            return  # pure wheel, no binary — the honest py3-none-any case
+        if not os.access(binary, os.X_OK):
+            raise RuntimeError(
+                f"vendored binary {binary} exists but is not executable — "
+                "re-run scripts/vendor_openai_proxy.py instead of shipping a broken wheel"
+            )
+        build_data["pure_python"] = False
+        build_data["tag"] = f"py3-none-{wheel_platform_tag(Path(binary))}"

{urun_cli-0.5.32 → urun_cli-0.6.1}/pyproject.toml

@@ -10,7 +10,17 @@ build-backend = "hatchling.build"
 
 [project]
 name = "urun-cli"
-version = "0.5.32"
+# Cut the paused-function recovery fixes merged after v0.6.0.
+#
+# WHY THIS IS EDITED BY HAND. [tool.semantic_release] below is fully
+# configured -- conventional commit parser, version_toml pointing here, tag
+# format, changelog templates -- but NOTHING invokes it: `grep -rn
+# semantic.release .github/workflows/` matches nothing. release.yaml only
+# READS this value and skips publishing when the matching tag already exists,
+# 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 for the three post-v0.6.0 fixes.
+version = "0.6.1"
 description = "End-user CLI for deploying apps to urun"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -28,6 +38,7 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Topic :: Software Development :: Build Tools",
 ]
+dependencies = []
 
 [project.urls]
 Homepage = "https://urun.sh"

{urun_cli-0.5.32 → urun_cli-0.6.1}/src/urun/api.py

@@ -191,7 +191,7 @@ class ApiClient:
 
         The server filters out slices with no provisioned GPU units, so the
         listing reflects what is actively running for the org rather than
-        the full deployment catalogue (which is ``urun list apps``).
+        the full deployment catalogue (which is ``urun app list``).
 
         ``limit`` is passed through as a query param; this method does not
         impose a client-side maximum.
@@ -517,12 +517,6 @@ class ApiClient:
     def list_git_installations(self) -> dict[str, Any]:
         return self._get("/cli/git-installations")
 
-    def list_marketplace_apps(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
-        return self._get("/cli/marketplace-apps", params)
-
-    def get_marketplace_app(self, slug: str) -> dict[str, Any]:
-        return self._get(f"/cli/marketplace-apps/{urllib.parse.quote(slug, safe='')}")
-
     def app_status(self, app: str, environment: str | None = None) -> dict[str, Any]:
         """Fetch the detailed lifecycle status for a single app.
 
@@ -613,8 +607,25 @@ class ApiClient:
         body: dict[str, Any] | None = {"environment": environment} if environment else None
         return self._json("POST", f"/app/{urllib.parse.quote(app, safe='')}/activate", body)
 
+    def set_function_paused(
+        self,
+        app: str,
+        function_name: str,
+        paused: bool,
+        environment: str | None = None,
+    ) -> dict[str, Any]:
+        """Pause or resume one function of an app.
+
+        Hits ``POST /app/<slug>/pause`` with the function name and explicit
+        pause state. The org is derived from the API key.
+        """
+        body: dict[str, Any] = {"paused": paused, "function_name": function_name}
+        if environment:
+            body["environment"] = environment
+        return self._json("POST", f"/app/{urllib.parse.quote(app, safe='')}/pause", body)
+
     def retire_app(self, app: str, environment: str | None = None) -> dict[str, Any]:
-        """Retire an app through the CLI edge route (backs ``urun delete app``).
+        """Retire an app through the CLI edge route (backs ``urun app delete``).
 
         Hits ``DELETE /cli/apps/<slug>`` which calls the org-scoped
         ``urun_stage2_retire_app`` lifecycle RPC: the deployment is driven to
@@ -1106,7 +1117,7 @@ def poll_until_done(
                 "The control plane kept answering, so this is not a poll failure: it "
                 f"reported '{last_state}' for the whole {timeout:.0f}s budget. If the app "
                 "is in fact already serving, the build-status document is wedged "
-                "server-side — check `urun logs build` for the real build outcome."
+                "server-side — check `urun build logs` for the real build outcome."
             )
         time.sleep(_poll_sleep_interval(time.time() - poll_started, interval))
 
@@ -1143,7 +1154,7 @@ def _poll_streak_error(
         f"GET /deployment-status/{manifest_hash}: {describe_error(exc)}. "
         f"Failing now rather than re-polling a broken endpoint for the rest of the "
         f"wait budget; {staleness}. The build itself may still be running "
-        f"server-side — check `urun logs build` for the real outcome."
+        f"server-side — check `urun build logs` for the real outcome."
     )