urun-cli 0.1.0__py3-none-any.whl

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/api.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any
+
+from . import __version__
+from .errors import ApiError, UrunError
+from .manifest import FileBlob, hash_file
+
+DEFAULT_API_URL = "https://api.urun.sh/v1"
+
+
+class ApiClient:
+    def __init__(self, base_url: str, api_key: str, timeout: float = 30.0, attempts: int = 3):
+        require_safe_url(base_url, "API URL")
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+        self.attempts = attempts
+
+    def register_manifest(self, manifest: dict[str, Any]) -> dict[str, Any]:
+        return self._json("POST", "/register-manifest", manifest)
+
+    def finalize(self, manifest_hash: str) -> dict[str, Any]:
+        return self._json("POST", f"/finalize/{manifest_hash}", None)
+
+    def deployment_status(self, manifest_hash: str) -> dict[str, Any]:
+        return self._json("GET", f"/deployment-status/{manifest_hash}", None)
+
+    def _json(self, method: str, path: str, body: dict[str, Any] | None) -> dict[str, Any]:
+        data = (
+            None
+            if body is None
+            else json.dumps(body, sort_keys=True, separators=(",", ":")).encode("utf-8")
+        )
+        payload = b""
+        for attempt in range(1, self.attempts + 1):
+            req = urllib.request.Request(
+                self.base_url + path,
+                data=data,
+                method=method,
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Accept": "application/json",
+                    "Content-Type": "application/json",
+                    "User-Agent": f"urun-cli/{__version__}",
+                },
+            )
+            try:
+                with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                    payload = resp.read()
+                    break
+            except urllib.error.HTTPError as exc:
+                payload = exc.read()
+                code = "http_error"
+                message = payload.decode("utf-8", "replace") or exc.reason
+                try:
+                    parsed = json.loads(payload.decode("utf-8"))
+                    err = parsed.get("error") or {}
+                    code = err.get("code") or code
+                    message = err.get("message") or message
+                except Exception:
+                    pass
+                if exc.code not in {429, 500, 502, 503, 504} or attempt == self.attempts:
+                    raise ApiError(exc.code, code, message) from exc
+            except (urllib.error.URLError, TimeoutError) as exc:
+                if attempt == self.attempts:
+                    reason = getattr(exc, "reason", exc)
+                    raise UrunError(f"network error: {reason}") from exc
+            time.sleep(0.25 * attempt)
+        if not payload:
+            return {}
+        try:
+            return json.loads(payload.decode("utf-8"))
+        except json.JSONDecodeError as exc:
+            raise UrunError("invalid JSON response from urun API") from exc
+
+
+def upload_missing_blobs(
+    missing_blobs: list[dict[str, Any]], by_sha: dict[str, FileBlob], concurrency: int = 8
+) -> None:
+    if not missing_blobs:
+        return
+    if concurrency < 1:
+        raise UrunError("upload concurrency must be at least 1")
+    with ThreadPoolExecutor(max_workers=concurrency) as executor:
+        futures = []
+        seen: set[str] = set()
+        for item in missing_blobs:
+            if not isinstance(item, dict):
+                raise UrunError("invalid missing_blobs item from server")
+            sha = item.get("sha256")
+            upload_url = item.get("upload_url")
+            if not isinstance(sha, str) or not isinstance(upload_url, str):
+                raise UrunError("invalid missing_blobs item from server")
+            if sha in seen:
+                continue
+            seen.add(sha)
+            if sha not in by_sha:
+                raise UrunError(f"server requested unknown blob: {sha}")
+            futures.append(executor.submit(upload_blob, upload_url, by_sha[sha]))
+        for fut in as_completed(futures):
+            fut.result()
+
+
+def upload_blob(upload_url: str, blob: FileBlob, attempts: int = 3) -> None:
+    require_safe_url(upload_url, "upload URL")
+    current_sha, current_size = hash_file(blob.source)
+    if current_sha != blob.sha256 or current_size != blob.size:
+        raise UrunError(f"file changed after manifest generation: {blob.path}")
+    last_error: Exception | None = None
+    for attempt in range(1, attempts + 1):
+        try:
+            with blob.source.open("rb") as f:
+                req = urllib.request.Request(
+                    upload_url,
+                    data=f,
+                    method="PUT",
+                    headers={
+                        "Content-Length": str(blob.size),
+                        "If-None-Match": "*",
+                    },
+                )
+                with urllib.request.urlopen(req, timeout=120) as resp:
+                    if resp.status >= 300:
+                        raise UrunError(f"upload failed for {blob.path}: HTTP {resp.status}")
+                    return
+        except urllib.error.HTTPError as exc:
+            if exc.code == 412:
+                # Another identical deploy may have won the content-addressed race.
+                return
+            if exc.code < 500 or attempt == attempts:
+                raise UrunError(
+                    f"upload failed for {blob.path}: HTTP {exc.code} {exc.reason}"
+                ) from exc
+            last_error = exc
+        except (urllib.error.URLError, TimeoutError) as exc:
+            if attempt == attempts:
+                reason = getattr(exc, "reason", exc)
+                raise UrunError(f"upload failed for {blob.path}: {reason}") from exc
+            last_error = exc
+        time.sleep(0.25 * attempt)
+    if last_error is not None:
+        raise UrunError(f"upload failed for {blob.path}: {last_error}") from last_error
+
+
+def require_safe_url(raw_url: str, label: str) -> None:
+    parsed = urllib.parse.urlparse(raw_url)
+    host = (parsed.hostname or "").lower()
+    if parsed.scheme == "https":
+        return
+    if parsed.scheme == "http" and host in {"127.0.0.1", "localhost", "::1"}:
+        return
+    raise UrunError(f"{label} must use HTTPS except for localhost development")
+
+
+def poll_until_done(
+    client: ApiClient,
+    manifest_hash: str,
+    interval: float = 2.0,
+    timeout: float = 1800.0,
+    not_found_grace: float = 30.0,
+) -> dict[str, Any]:
+    deadline = time.time() + timeout
+    not_found_deadline = time.time() + min(not_found_grace, timeout)
+    last_state = "unknown"
+    while True:
+        try:
+            status = client.deployment_status(manifest_hash)
+        except ApiError as exc:
+            if exc.status == 404 and time.time() < not_found_deadline:
+                last_state = "not_found"
+                time.sleep(interval)
+                continue
+            raise
+        state = status.get("status")
+        last_state = str(state)
+        if state in {"ready", "failed"}:
+            return status
+        if time.time() >= deadline:
+            raise UrunError(
+                f"timed out waiting for deployment {manifest_hash} (last status: {last_state})"
+            )
+        time.sleep(interval)

urun/cli.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import argparse
+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 .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 == "deploy":
+            return deploy(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")
+    deploy = sub.add_parser("deploy", help="Deploy a Python app to urun")
+    deploy.add_argument("entrypoint", nargs="?", help="Python app file, e.g. app.py")
+    deploy.add_argument("--name", help="App name (defaults from entrypoint file)")
+    deploy.add_argument(
+        "--api-url", default=os.getenv("URUN_API_URL", DEFAULT_API_URL), help="API base URL"
+    )
+    deploy.add_argument(
+        "--api-key", default=os.getenv("URUN_API_KEY"), help="API key (or URUN_API_KEY)"
+    )
+    deploy.add_argument(
+        "--no-wait", action="store_true", help="Finalize deployment but do not poll for readiness"
+    )
+    deploy.add_argument("--poll-interval", type=float, default=2.0)
+    deploy.add_argument("--timeout", type=float, default=1800.0)
+    return parser
+
+
+def deploy(args: argparse.Namespace) -> int:
+    if not args.api_key:
+        raise UrunError("missing API key; set URUN_API_KEY or pass --api-key")
+    if not API_KEY_RE.fullmatch(args.api_key):
+        raise UrunError("invalid API key format; expected urun_<32 lowercase hex chars>")
+    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(args.api_url, args.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 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/deps.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import re
+import tomllib
+from pathlib import Path
+from typing import Any
+
+from .errors import UrunError
+from .manifest import FileBlob, file_blob
+
+DEFAULT_PYTHON_VERSION = "3.12"
+CREDENTIAL_URL_RE = re.compile(r"https?://[^\s/@:]+:[^\s/@]+@", re.IGNORECASE)
+
+
+def resolve_deps(project_root: Path) -> tuple[dict[str, Any], FileBlob | None, str]:
+    python_version = DEFAULT_PYTHON_VERSION
+
+    pyproject = project_root / "pyproject.toml"
+    if pyproject.is_file():
+        ensure_under_root(pyproject, project_root, "pyproject.toml")
+        reject_embedded_dependency_credentials(pyproject)
+        blob = file_blob(pyproject, project_root)
+        try:
+            data = tomllib.loads(pyproject.read_text())
+        except tomllib.TOMLDecodeError as exc:
+            raise UrunError(f"Invalid TOML in pyproject.toml: {exc}") from exc
+        requires = (data.get("project") or {}).get("requires-python")
+        if isinstance(requires, str):
+            python_version = python_from_requires(requires) or python_version
+        return (
+            {
+                "kind": "pyproject_toml",
+                "blob_sha256": blob.sha256,
+                "python_version": python_version,
+            },
+            blob,
+            python_version,
+        )
+
+    req = project_root / "requirements.txt"
+    if req.is_file():
+        ensure_under_root(req, project_root, "requirements.txt")
+        reject_embedded_dependency_credentials(req)
+        blob = file_blob(req, project_root)
+        return (
+            {
+                "kind": "requirements_txt",
+                "blob_sha256": blob.sha256,
+                "python_version": python_version,
+            },
+            blob,
+            python_version,
+        )
+
+    return {"kind": "none", "python_version": python_version}, None, python_version
+
+
+def ensure_under_root(path: Path, project_root: Path, label: str) -> None:
+    try:
+        path.resolve().relative_to(project_root.resolve())
+    except ValueError as exc:
+        raise UrunError(f"{label} is outside the project root: {path}") from exc
+
+
+def reject_embedded_dependency_credentials(path: Path) -> None:
+    text = path.read_text(errors="ignore")
+    if CREDENTIAL_URL_RE.search(text):
+        raise UrunError(
+            f"dependency file contains an embedded credential URL: {path.name}; "
+            "use token-free package references before deploying"
+        )
+
+
+def python_from_requires(spec: str) -> str | None:
+    # Conservative extraction for common specs such as >=3.11 or ==3.12.*.
+    versions = re.findall(r"(\d+)\.(\d+)", spec)
+    if not versions:
+        return None
+    major, minor = versions[0]
+    return f"{major}.{minor}"

urun/discovery.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import ast
+import fnmatch
+from pathlib import Path
+
+from .errors import UrunError
+from .manifest import FileBlob, file_blob
+
+
+def derive_app_name(entrypoint: str | None) -> str:
+    if not entrypoint:
+        raise UrunError("missing entrypoint")
+    p = Path(entrypoint)
+    if p.name == "__main__.py" and p.parent.name:
+        return p.parent.name
+    if p.parent != Path("."):
+        return p.parent.name
+    return p.stem
+
+
+def load_urunignore(root: Path) -> list[str]:
+    ignore = root / ".urunignore"
+    if not ignore.exists():
+        return []
+    return [
+        line.strip()
+        for line in ignore.read_text().splitlines()
+        if line.strip() and not line.lstrip().startswith("#")
+    ]
+
+
+def is_ignored(path: Path, project_root: Path, patterns: list[str]) -> bool:
+    try:
+        rel = path.resolve().relative_to(project_root.resolve()).as_posix()
+    except ValueError as exc:
+        raise UrunError(f"path is outside the project root: {path}") from exc
+    parts = rel.split("/")
+    if any(part == "__pycache__" for part in parts):
+        return True
+    if any(part == ".git" for part in parts):
+        return True
+    if path.name.startswith(".") or any(part.startswith(".") for part in parts):
+        return True
+    if path.suffix == ".pyc":
+        return True
+    return any(
+        fnmatch.fnmatch(rel, pattern) or fnmatch.fnmatch(path.name, pattern) for pattern in patterns
+    )
+
+
+def auto_include(entrypoint: Path, project_root: Path) -> list[FileBlob]:
+    files = discover_local_python_files(entrypoint, project_root, load_urunignore(project_root))
+    blobs: list[FileBlob] = []
+    for p in sorted(files):
+        try:
+            blobs.append(file_blob(p, project_root))
+        except ValueError as exc:
+            raise UrunError(f"path is outside the project root: {p}") from exc
+    return blobs
+
+
+def discover_local_python_files(
+    entrypoint: Path, project_root: Path, patterns: list[str]
+) -> set[Path]:
+    if not entrypoint.exists() or not entrypoint.is_file():
+        raise UrunError(f"entrypoint not found: {entrypoint}")
+    if entrypoint.suffix != ".py":
+        raise UrunError("entrypoint must be a .py file")
+
+    root = project_root.resolve()
+    stack = [entrypoint.resolve()]
+    seen: set[Path] = set()
+
+    while stack:
+        current = stack.pop()
+        try:
+            current.relative_to(root)
+        except ValueError as exc:
+            raise UrunError(f"path is outside the project root: {current}") from exc
+        if current in seen:
+            continue
+        if is_ignored(current, project_root, patterns):
+            label = "entrypoint" if current == entrypoint.resolve() else "imported file"
+            raise UrunError(f"{label} is ignored by defaults or .urunignore: {current}")
+        seen.add(current)
+        stack.extend(p for p in referenced_local_files(current, project_root) if p not in seen)
+
+    return seen
+
+
+def referenced_local_files(source: Path, project_root: Path) -> set[Path]:
+    try:
+        tree = ast.parse(source.read_text(), filename=str(source))
+    except SyntaxError as exc:
+        raise UrunError(f"entrypoint has invalid Python syntax: {source}") from exc
+
+    candidates: set[Path] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                candidates.update(resolve_absolute_import(alias.name, project_root))
+        elif isinstance(node, ast.ImportFrom):
+            if node.level:
+                candidates.update(resolve_relative_import(node, source, project_root))
+            elif node.module:
+                candidates.update(resolve_absolute_import(node.module, project_root))
+                for alias in node.names:
+                    if alias.name != "*":
+                        candidates.update(
+                            resolve_absolute_import(f"{node.module}.{alias.name}", project_root)
+                        )
+    return candidates
+
+
+def resolve_absolute_import(name: str, project_root: Path) -> set[Path]:
+    parts = name.split(".")
+    return module_path_candidates(project_root, parts)
+
+
+def resolve_relative_import(node: ast.ImportFrom, source: Path, project_root: Path) -> set[Path]:
+    base = source.parent
+    for _ in range(max(node.level - 1, 0)):
+        base = base.parent
+    parts = node.module.split(".") if node.module else []
+    candidates = module_path_candidates(base, parts)
+    for alias in node.names:
+        if alias.name != "*":
+            candidates.update(module_path_candidates(base, [*parts, alias.name]))
+    return {p for p in candidates if is_under_project(p, project_root)}
+
+
+def module_path_candidates(base: Path, parts: list[str]) -> set[Path]:
+    if not parts:
+        return set()
+    path = base.joinpath(*parts)
+    candidates: set[Path] = set()
+    module_file = path.with_suffix(".py")
+    package_init = path / "__init__.py"
+    if module_file.is_file():
+        candidates.add(module_file.resolve())
+    if package_init.is_file():
+        candidates.add(package_init.resolve())
+    return candidates
+
+
+def is_under_project(path: Path, project_root: Path) -> bool:
+    try:
+        path.resolve().relative_to(project_root.resolve())
+    except ValueError:
+        return False
+    return True
+
+
+def discover_main_files(
+    entrypoint_arg: str | None, project_root: Path
+) -> tuple[str, list[FileBlob]]:
+    if not entrypoint_arg:
+        raise UrunError("provide an entrypoint file")
+    entrypoint_path = Path(entrypoint_arg)
+    if not entrypoint_path.is_absolute():
+        entrypoint_path = project_root / entrypoint_path
+    files = auto_include(entrypoint_path, project_root)
+    try:
+        manifest_entrypoint = (
+            entrypoint_path.resolve().relative_to(project_root.resolve()).as_posix()
+        )
+    except ValueError as exc:
+        raise UrunError(f"entrypoint is outside the project root: {entrypoint_path}") from exc
+    return manifest_entrypoint, files

urun/errors.py

@@ -0,0 +1,10 @@
+class UrunError(Exception):
+    """User-facing CLI error."""
+
+
+class ApiError(UrunError):
+    def __init__(self, status: int, code: str, message: str):
+        super().__init__(f"{status} {code}: {message}")
+        self.status = status
+        self.code = code
+        self.message = message

urun/manifest.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class FileBlob:
+    path: str
+    source: Path
+    sha256: str
+    size: int
+    mode: int
+
+    def manifest_entry(self) -> dict[str, Any]:
+        return {
+            "path": self.path,
+            "sha256": self.sha256,
+            "size": self.size,
+            "mode": self.mode,
+        }
+
+
+def posix_rel(path: Path, root: Path) -> str:
+    return path.resolve().relative_to(root.resolve()).as_posix()
+
+
+def normalized_mode(path: Path) -> int:
+    st_mode = path.stat().st_mode
+    return 0o100755 if (st_mode & 0o111) else 0o100644
+
+
+def hash_file(path: Path, chunk_size: int = 1024 * 1024) -> tuple[str, int]:
+    h = hashlib.sha256()
+    size = 0
+    with path.open("rb") as f:
+        while True:
+            chunk = f.read(chunk_size)
+            if not chunk:
+                break
+            size += len(chunk)
+            h.update(chunk)
+    return h.hexdigest(), size
+
+
+def file_blob(path: Path, root: Path, manifest_path: str | None = None) -> FileBlob:
+    sha, size = hash_file(path)
+    return FileBlob(
+        path=manifest_path or posix_rel(path, root),
+        source=path.resolve(),
+        sha256=sha,
+        size=size,
+        mode=normalized_mode(path),
+    )
+
+
+def canonical_json(data: dict[str, Any]) -> bytes:
+    """Canonical JSON: sorted keys, compact separators, UTF-8, no trailing whitespace."""
+    return json.dumps(data, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode(
+        "utf-8"
+    )
+
+
+def manifest_hash(manifest_without_hash: dict[str, Any]) -> str:
+    data = dict(manifest_without_hash)
+    data.pop("manifest_hash", None)
+    return hashlib.sha256(canonical_json(data)).hexdigest()
+
+
+def unique_blobs(files: Iterable[FileBlob]) -> dict[str, FileBlob]:
+    out: dict[str, FileBlob] = {}
+    for blob in files:
+        out.setdefault(blob.sha256, blob)
+    return out

urun_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: urun-cli
+Version: 0.1.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
+
+Set your API key:
+
+```bash
+export URUN_API_KEY=urun_<32hex>
+```
+
+Create `app.py`:
+
+```python
+print("hello from urun")
+```
+
+Deploy it:
+
+```bash
+urun deploy app.py
+```
+
+The API key identifies your account on the server side. There is no separate org
+ID, login step, or local project setup for the v1 CLI.
+
+## 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 |
+
+Dependency declarations are included when present. `pyproject.toml` is preferred;
+`requirements.txt` is used when no `pyproject.toml` exists.
+
+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
+
+| Option | Description |
+| --- | --- |
+| `--name` | Override the derived app name. |
+| `--api-url` | Override the API URL; defaults to `https://api.urun.sh/v1`. |
+| `--api-key` | API key; prefer `URUN_API_KEY` to avoid shell history leaks. |
+| `--no-wait` | Finalize but do not poll for readiness. |
+| `--poll-interval`, `--timeout` | Control readiness polling. |
+
+## Troubleshooting
+
+| Error | Fix |
+| --- | --- |
+| `missing API key` | 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.

urun_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+urun/__init__.py,sha256=wUUhbNiFISZ2cpU7w-Z1RiUjfPDNtEEUyechv55oYyY,718
+urun/api.py,sha256=NOti71DwAvV-SPvcDoQgt4Y0w4yIQX2QzYWjsRi3o4U,7468
+urun/cli.py,sha256=No847NdPfstW4SKmfMh4HtvIa--W1cCmCW3fzRfcoAY,4560
+urun/deps.py,sha256=Md4ndQgjVO0lOHK8Fw8h21KQXpn3MRggcPFWfrNVAHk,2716
+urun/discovery.py,sha256=gQevD-PSmdJwhT0essmITp-Mf0GSwG9ph-PZlQAdJZQ,5994
+urun/errors.py,sha256=xd1UrFrqn5rQXcUX02_vfzHwHgpDA0RbwrbM_pnhaZY,293
+urun/manifest.py,sha256=YLpryYCFSu-w8yONj3oohBHpLNP-dPRYAny1JAe9pfI,2043
+urun_cli-0.1.0.dist-info/METADATA,sha256=8pbYsDMLHIAQxZGHj8a3H4We4xKakJt4zvdEDJCMmWQ,3215
+urun_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+urun_cli-0.1.0.dist-info/entry_points.txt,sha256=Hm1XEwW2k-vTyABcFkd8FevCaQHPz9CTOHxvXkiMiOs,64
+urun_cli-0.1.0.dist-info/licenses/LICENSE,sha256=e54RugXp4xrrinIGvXfGB3UBq__CoP32EEGPaju_G8I,1061
+urun_cli-0.1.0.dist-info/RECORD,,

urun_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

urun_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+urun = urun.cli:main
+urun-cli = urun.cli:main

urun_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 urun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.