urun-cli 0.1.1__tar.gz → 0.2.0__tar.gz

{urun_cli-0.1.1 → urun_cli-0.2.0}/.gitignore

@@ -12,3 +12,7 @@ htmlcov/
 dist/
 build/
 *.egg-info/
+
+# Local development environment
+.devcontainer.env
+.cache/

urun_cli-0.2.0/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 0.2.0
+
+- Bumped past 0.1.1/0.1.2 because both filenames were occupied by previously-deleted PyPI artifacts.
+- Drop the org-id requirement from `urun deploy`; authentication now relies solely on the API key.
+- Add `urun login`, `urun run`, and `urun org`/`urun auth` subcommands.
+
+## 0.1.0
+
+- Initial public `urun deploy` CLI.
+- Deploy from a Python app file with local Python imports included automatically.
+- Source manifest generation, dependency declaration upload, and API deploy flow.
+- Public docs for the config-free v1 CLI surface.

urun_cli-0.2.0/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: urun-cli
+Version: 0.2.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
+Project-URL: Issues, https://github.com/urun-sh/urun-cli/issues
+Author: urun
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,deploy,urun
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# urun CLI
+
+Deploy Python apps to urun from your terminal.
+
+[![PyPI](https://img.shields.io/pypi/v/urun-cli.svg)](https://pypi.org/project/urun-cli/)
+[![Python](https://img.shields.io/pypi/pyversions/urun-cli.svg)](https://pypi.org/project/urun-cli/)
+
+## Install
+
+```bash
+uv tool install urun-cli
+# or
+pip install urun-cli
+```
+
+The package installs the `urun` command:
+
+```bash
+urun --version
+```
+
+For one-off `uvx` usage:
+
+```bash
+uvx --from urun-cli urun --version
+# or the package-matching command alias
+uvx urun-cli --version
+```
+
+## Quick start
+
+Today, an operator manually vends an org-scoped deploy API key. Save it locally
+with `urun login`:
+
+```bash
+urun login --api-key urun_<32hex>
+```
+
+`urun login` verifies the key with the urun API and stores credentials for later
+commands. The future browser-based login flow is not available in this CLI
+release.
+
+For CI or one-off commands, you can still use the environment variable:
+
+```bash
+export URUN_API_KEY=urun_<32hex>
+```
+
+Create `app.py`:
+
+```python
+import urun
+from urun import App
+
+app = App("hello-h100")
+
+
+@app.function(gpus="h100:1")
+def hello(ctx: urun.Context):
+    print(f"running on {ctx.device}")
+    return {"device": str(ctx.device)}
+```
+
+Run it:
+
+```bash
+urun run app.py
+```
+
+In this release, `urun run` uses the same deploy pipeline as `urun deploy`.
+`deploy` remains available as the lower-level command while the full
+deploy/run/monitor workflow is being built.
+
+## What gets deployed
+
+`urun deploy` creates a source manifest from your Python entrypoint:
+
+| Entrypoint | Included source |
+| --- | --- |
+| `urun deploy app.py` | `app.py` and local Python files it imports |
+
+Dependencies are declared in your urun app code. Project-level files such as
+`pyproject.toml` and `requirements.txt` are not uploaded as dependency
+declarations by the CLI.
+
+Generated/cache content such as `.git`, dotfiles, `__pycache__`, and `.pyc`
+files is excluded. Add `.urunignore` to exclude additional paths.
+
+Non-Python assets such as templates, static files, and data files are not
+auto-included yet.
+
+## Common options
+
+Shared by `run` and `deploy`:
+
+| Option | Description |
+| --- | --- |
+| `--name` | Override the derived app name. |
+| `--api-url` | Override the API URL; defaults to `URUN_API_URL`, saved login credentials, or `https://api.urun.sh/v1`. |
+| `--api-key` | Deploy API key; defaults to `URUN_API_KEY` or saved login credentials. |
+| `--no-wait` | Finalize but do not poll for readiness. |
+| `--poll-interval`, `--timeout` | Control readiness polling. |
+
+## Troubleshooting
+
+| Error | Fix |
+| --- | --- |
+| `missing API key` | Run `urun login`, set `URUN_API_KEY`, or pass `--api-key`. |
+| `invalid API key format` | Use `urun_<32 lowercase hex chars>`. |
+| `entrypoint not found` | Run from the project root or pass the entrypoint path. |
+| `path is outside the project root` | Move the file under the project before deploying. |
+| Expected files are missing | Import local Python files from `app.py`; non-Python assets are not auto-included yet. |
+
+## Development
+
+Contributing and test instructions are in [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+MIT.
+
+## Development environment
+
+This repo has a Nix/direnv/devcontainer baseline:
+
+```bash
+direnv allow
+just sync
+just check
+```
+
+Use VS Code Dev Containers to open the repository with the same toolchain in a container. Copy `devcontainer.env.example` to `.devcontainer.env` if you need to pass local git identity or other non-secret development settings into the container.

urun_cli-0.2.0/README.md

@@ -0,0 +1,132 @@
+# urun CLI
+
+Deploy Python apps to urun from your terminal.
+
+[![PyPI](https://img.shields.io/pypi/v/urun-cli.svg)](https://pypi.org/project/urun-cli/)
+[![Python](https://img.shields.io/pypi/pyversions/urun-cli.svg)](https://pypi.org/project/urun-cli/)
+
+## Install
+
+```bash
+uv tool install urun-cli
+# or
+pip install urun-cli
+```
+
+The package installs the `urun` command:
+
+```bash
+urun --version
+```
+
+For one-off `uvx` usage:
+
+```bash
+uvx --from urun-cli urun --version
+# or the package-matching command alias
+uvx urun-cli --version
+```
+
+## Quick start
+
+Today, an operator manually vends an org-scoped deploy API key. Save it locally
+with `urun login`:
+
+```bash
+urun login --api-key urun_<32hex>
+```
+
+`urun login` verifies the key with the urun API and stores credentials for later
+commands. The future browser-based login flow is not available in this CLI
+release.
+
+For CI or one-off commands, you can still use the environment variable:
+
+```bash
+export URUN_API_KEY=urun_<32hex>
+```
+
+Create `app.py`:
+
+```python
+import urun
+from urun import App
+
+app = App("hello-h100")
+
+
+@app.function(gpus="h100:1")
+def hello(ctx: urun.Context):
+    print(f"running on {ctx.device}")
+    return {"device": str(ctx.device)}
+```
+
+Run it:
+
+```bash
+urun run app.py
+```
+
+In this release, `urun run` uses the same deploy pipeline as `urun deploy`.
+`deploy` remains available as the lower-level command while the full
+deploy/run/monitor workflow is being built.
+
+## What gets deployed
+
+`urun deploy` creates a source manifest from your Python entrypoint:
+
+| Entrypoint | Included source |
+| --- | --- |
+| `urun deploy app.py` | `app.py` and local Python files it imports |
+
+Dependencies are declared in your urun app code. Project-level files such as
+`pyproject.toml` and `requirements.txt` are not uploaded as dependency
+declarations by the CLI.
+
+Generated/cache content such as `.git`, dotfiles, `__pycache__`, and `.pyc`
+files is excluded. Add `.urunignore` to exclude additional paths.
+
+Non-Python assets such as templates, static files, and data files are not
+auto-included yet.
+
+## Common options
+
+Shared by `run` and `deploy`:
+
+| Option | Description |
+| --- | --- |
+| `--name` | Override the derived app name. |
+| `--api-url` | Override the API URL; defaults to `URUN_API_URL`, saved login credentials, or `https://api.urun.sh/v1`. |
+| `--api-key` | Deploy API key; defaults to `URUN_API_KEY` or saved login credentials. |
+| `--no-wait` | Finalize but do not poll for readiness. |
+| `--poll-interval`, `--timeout` | Control readiness polling. |
+
+## Troubleshooting
+
+| Error | Fix |
+| --- | --- |
+| `missing API key` | Run `urun login`, set `URUN_API_KEY`, or pass `--api-key`. |
+| `invalid API key format` | Use `urun_<32 lowercase hex chars>`. |
+| `entrypoint not found` | Run from the project root or pass the entrypoint path. |
+| `path is outside the project root` | Move the file under the project before deploying. |
+| Expected files are missing | Import local Python files from `app.py`; non-Python assets are not auto-included yet. |
+
+## Development
+
+Contributing and test instructions are in [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+MIT.
+
+## Development environment
+
+This repo has a Nix/direnv/devcontainer baseline:
+
+```bash
+direnv allow
+just sync
+just check
+```
+
+Use VS Code Dev Containers to open the repository with the same toolchain in a container. Copy `devcontainer.env.example` to `.devcontainer.env` if you need to pass local git identity or other non-secret development settings into the container.

{urun_cli-0.1.1 → urun_cli-0.2.0}/SECURITY.md

@@ -12,10 +12,6 @@ Please report suspected vulnerabilities privately to the urun maintainers. Do no
 
 ## Source upload behavior
 
-`urun deploy` uploads selected source files and dependency declaration files to urun via presigned object-store URLs. Review `.urunignore` and `urun.toml` before deploying sensitive repositories.
+`urun deploy` uploads selected source files and dependency declaration files to urun via presigned object-store URLs. Review `.urunignore` before deploying sensitive repositories.
 
-The CLI enforces project-root containment for entrypoints, explicit mounts, and dependency files. Symlinks are resolved before that containment check.
-
-## Local MinIO
-
-MinIO is optional for local S3-compatible integration tests. The documented `minioadmin` credentials are development-only and must not be used for production services.
+The CLI enforces project-root containment for entrypoints and dependency files. Symlinks are resolved before that containment check.

{urun_cli-0.1.1 → urun_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "urun-cli"
-version = "0.1.1"
+version = "0.2.0"
 description = "End-user CLI for deploying apps to urun"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -74,9 +74,19 @@ type = "github"
 ignore_token_for_push = false
 
 [tool.semantic_release.publish]
-dist_glob_patterns = ["dist/*"]
+dist_glob_patterns = ["dist/urun_cli-*"]
 upload_to_vcs_release = true
 
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src",
+  "/README.md",
+  "/LICENSE",
+  "/SECURITY.md",
+  "/CHANGELOG.md",
+  "/pyproject.toml",
+]
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/urun"]
 

urun_cli-0.2.0/src/urun/__init__.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import tomllib
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+
+def _source_tree_version() -> str:
+    for parent in Path(__file__).resolve().parents:
+        pyproject = parent / "pyproject.toml"
+        if pyproject.is_file():
+            data = tomllib.loads(pyproject.read_text())
+            project_version = (data.get("project") or {}).get("version")
+            if isinstance(project_version, str) and project_version:
+                return project_version
+    return "0.0.0"
+
+
+try:
+    __version__ = version("urun-cli")
+except PackageNotFoundError:  # pragma: no cover - source tree fallback
+    __version__ = _source_tree_version()

{urun_cli-0.1.1 → urun_cli-0.2.0}/src/urun/api.py

@@ -32,6 +32,9 @@ class ApiClient:
     def deployment_status(self, manifest_hash: str) -> dict[str, Any]:
         return self._json("GET", f"/deployment-status/{manifest_hash}", None)
 
+    def org_config(self) -> dict[str, Any]:
+        return self._json("GET", "/org-config", None)
+
     def _json(self, method: str, path: str, body: dict[str, Any] | None) -> dict[str, Any]:
         data = (
             None

urun_cli-0.2.0/src/urun/cli.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import argparse
+import getpass
+import os
+import re
+import sys
+from datetime import UTC, datetime
+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 .config import load_credentials, save_credentials
+from .deps import resolve_deps
+from .discovery import derive_app_name, discover_main_files
+from .errors import UrunError
+from .manifest import manifest_hash, unique_blobs
+
+API_KEY_RE = re.compile(r"^urun_[0-9a-f]{32}$")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        if args.command in {"deploy", "run"}:
+            return deploy(args)
+        if args.command == "login":
+            return login(args)
+        parser.print_help()
+        return 2
+    except UrunError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print("aborted", file=sys.stderr)
+        return 130
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="urun")
+    parser.add_argument("--version", action="version", version=f"urun {__version__}")
+    sub = parser.add_subparsers(dest="command")
+
+    login_parser = sub.add_parser(
+        "login",
+        help="Save manually vended deploy credentials",
+        description=(
+            "Save a manually vended URUN deploy API key. "
+            "Browser-based login is planned but not available in this CLI release."
+        ),
+    )
+    add_login_args(login_parser)
+
+    deploy = sub.add_parser("deploy", help="Deploy a Python app to urun")
+    add_deploy_args(deploy)
+
+    run = sub.add_parser(
+        "run",
+        help="Run a Python app on urun",
+        description=(
+            "Run a Python app on urun. In this release, run uses the deploy pipeline "
+            "while the full deploy/run/monitor workflow is still being built."
+        ),
+    )
+    add_deploy_args(run)
+    return parser
+
+
+def add_login_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--api-url",
+        help=f"API base URL; defaults to URUN_API_URL or {DEFAULT_API_URL}",
+    )
+    parser.add_argument(
+        "--api-key",
+        help="Deploy API key; defaults to URUN_API_KEY, otherwise prompts interactively",
+    )
+
+
+def add_api_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--api-url",
+        help=(
+            f"API base URL; defaults to URUN_API_URL, saved login credentials, or {DEFAULT_API_URL}"
+        ),
+    )
+    parser.add_argument(
+        "--api-key",
+        help="Deploy API key; defaults to URUN_API_KEY or saved login credentials",
+    )
+
+
+def add_deploy_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("entrypoint", nargs="?", help="Python app file, e.g. app.py")
+    parser.add_argument("--name", help="App name (defaults from entrypoint file)")
+    add_api_args(parser)
+    parser.add_argument(
+        "--no-wait", action="store_true", help="Finalize deployment but do not poll for readiness"
+    )
+    parser.add_argument("--poll-interval", type=float, default=2.0)
+    parser.add_argument("--timeout", type=float, default=1800.0)
+
+
+def login(args: argparse.Namespace) -> int:
+    api_url = args.api_url or os.getenv("URUN_API_URL") or DEFAULT_API_URL
+    api_key = args.api_key or os.getenv("URUN_API_KEY")
+    if not api_key:
+        if not sys.stdin.isatty():
+            raise UrunError("missing API key; pass --api-key or set URUN_API_KEY")
+        api_key = getpass.getpass("URUN API key: ").strip()
+
+    validate_api_key(api_key)
+    config = ApiClient(api_url, api_key).org_config()
+    org_id = config_value(config, "org_id")
+    key_id = config_value(config, "key_id")
+    path = save_credentials(
+        {
+            "api_url": api_url,
+            "api_key": api_key,
+            "org_id": org_id,
+            "key_id": key_id,
+        }
+    )
+
+    print("Authenticated successfully. Credentials saved.")
+    print("Login currently uses a manually vended deploy API key.")
+    print(f"Org: {org_id}")
+    print(f"Key ID: {key_id}")
+    print(f"Credentials: {path}")
+    return 0
+
+
+def deploy(args: argparse.Namespace) -> int:
+    api_url, api_key = resolve_api_credentials(args)
+    if args.poll_interval <= 0:
+        raise UrunError("--poll-interval must be greater than 0")
+    if args.timeout <= 0:
+        raise UrunError("--timeout must be greater than 0")
+
+    project_root = Path.cwd()
+    entrypoint, files = discover_main_files(args.entrypoint, project_root)
+    deps, deps_blob, python_version = resolve_deps(project_root)
+
+    app_name = args.name or derive_app_name(args.entrypoint)
+    all_blobs = files + ([deps_blob] if deps_blob is not None else [])
+    manifest = {
+        "version": 1,
+        "app_name": app_name,
+        "entrypoint": entrypoint,
+        "python_version": python_version,
+        "files": [b.manifest_entry() for b in sorted(files, key=lambda b: b.path)],
+        "deps": deps,
+        "created_at": datetime.now(UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z"),
+        "client_version": f"urun-cli/{__version__}",
+    }
+    mh = manifest_hash(manifest)
+
+    print(f"Deploying {app_name} ({mh[:12]})")
+    print(f"Files: {len(files)} app, deps: {deps['kind']}")
+
+    client = ApiClient(api_url, api_key)
+    register = client.register_manifest(manifest)
+    server_hash = register.get("manifest_hash")
+    if server_hash and server_hash != mh:
+        raise UrunError(f"server manifest hash mismatch: local {mh}, server {server_hash}")
+    missing = register.get("missing_blobs", [])
+    print(f"Uploading {len(missing)} missing blob(s)")
+    upload_missing_blobs(missing, unique_blobs(all_blobs))
+
+    final = client.finalize(mh)
+    print(f"Deployment {final.get('status', 'queued')}: {mh}")
+    if args.no_wait:
+        status_url = register.get("status_url")
+        if status_url:
+            print(f"Status: {status_url}")
+        return 0
+
+    status = poll_until_done(client, mh, args.poll_interval, args.timeout)
+    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_ready(status)
+    return 0
+
+
+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")
+    if not api_key or not api_url:
+        saved = load_credentials()
+        api_key = api_key or string_value(saved.get("api_key"))
+        api_url = api_url or string_value(saved.get("api_url"))
+
+    api_url = api_url or DEFAULT_API_URL
+    if not api_key:
+        raise UrunError("missing API key; run `urun login`, set URUN_API_KEY, or pass --api-key")
+    validate_api_key(api_key)
+    return api_url, api_key
+
+
+def validate_api_key(api_key: str) -> None:
+    if not API_KEY_RE.fullmatch(api_key):
+        raise UrunError("invalid API key format; expected urun_<32 lowercase hex chars>")
+
+
+def config_value(config: dict[str, Any], key: str) -> str:
+    value = string_value(config.get(key))
+    if not value:
+        raise UrunError(f"org-config response did not include {key}")
+    return value
+
+
+def string_value(value: Any) -> str | None:
+    return value if isinstance(value, str) and value else None
+
+
+def print_ready(status: dict[str, Any]) -> None:
+    print("Deployment ready")
+    if status.get("url"):
+        print(f"URL: {status['url']}")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

urun_cli-0.2.0/src/urun/config.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import json
+import os
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from .errors import UrunError
+
+
+def config_dir() -> Path:
+    override = os.getenv("URUN_CONFIG_HOME")
+    if override:
+        return Path(override).expanduser()
+
+    xdg = os.getenv("XDG_CONFIG_HOME")
+    if xdg:
+        return Path(xdg).expanduser() / "urun"
+
+    return Path.home() / ".config" / "urun"
+
+
+def credentials_path() -> Path:
+    return config_dir() / "credentials.json"
+
+
+def load_credentials() -> dict[str, Any]:
+    path = credentials_path()
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise UrunError(f"could not read credentials file: {path}") from exc
+    except json.JSONDecodeError as exc:
+        raise UrunError(f"credentials file is not valid JSON: {path}") from exc
+    if not isinstance(data, dict):
+        raise UrunError(f"credentials file must contain a JSON object: {path}")
+    return data
+
+
+def save_credentials(credentials: dict[str, Any]) -> Path:
+    path = credentials_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        **credentials,
+        "updated_at": datetime.now(UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z"),
+    }
+    tmp = path.with_suffix(".json.tmp")
+    try:
+        tmp.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+        tmp.chmod(0o600)
+        tmp.replace(path)
+        path.chmod(0o600)
+    except OSError as exc:
+        raise UrunError(f"could not write credentials file: {path}") from exc
+    return path

urun_cli-0.2.0/src/urun/deps.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+DEFAULT_PYTHON_VERSION = "3.12"
+
+
+def resolve_deps(_project_root: Path) -> tuple[dict[str, Any], None, str]:
+    # Dependencies are declared by the urun app in app.py, not by project-level
+    # pyproject.toml or requirements.txt files.
+    python_version = DEFAULT_PYTHON_VERSION
+    return {"kind": "app", "python_version": python_version}, None, python_version