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

{urun_cli-0.1.2 → 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.1.2 → urun_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urun-cli
-Version: 0.1.2
+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
@@ -51,34 +51,47 @@ uvx urun-cli --version
 
 ## Quick start
 
-Set your API key:
+Today, an operator manually vends an org-scoped deploy API key. Save it locally
+with `urun login`:
 
 ```bash
-export URUN_API_KEY=urun_<32hex>
+urun login --api-key urun_<32hex>
 ```
 
-Create a small Python app:
+`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
-cat > app.py <<'PY'
-print("hello from urun")
-PY
+export URUN_API_KEY=urun_<32hex>
 ```
 
-Deploy it:
+Create `app.py`:
 
-```bash
-urun deploy 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)}
 ```
 
-You can also deploy a Python module:
+Run it:
 
 ```bash
-urun deploy -m my_package.main
+urun run 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.
+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
 
@@ -86,11 +99,11 @@ ID, login step, or local project setup for the v1 CLI.
 
 | Entrypoint | Included source |
 | --- | --- |
-| `urun deploy app.py` | `app.py` only |
-| `urun deploy -m my_package.main` | Python files in the containing package |
+| `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.
+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.
@@ -100,12 +113,13 @@ auto-included yet.
 
 ## Common options
 
+Shared by `run` and `deploy`:
+
 | Option | Description |
 | --- | --- |
-| `-m, --module` | Deploy a Python module entrypoint, e.g. `my_package.main`. |
 | `--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. |
+| `--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. |
 
@@ -113,11 +127,11 @@ auto-included yet.
 
 | Error | Fix |
 | --- | --- |
-| `missing API key` | Set `URUN_API_KEY` or pass `--api-key`. |
+| `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 | Use a module entrypoint for packages; non-Python assets are not auto-included yet. |
+| Expected files are missing | Import local Python files from `app.py`; non-Python assets are not auto-included yet. |
 
 ## Development
 
@@ -126,3 +140,15 @@ 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.2 → urun_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "urun-cli"
-version = "0.1.2"
+version = "0.2.0"
 description = "End-user CLI for deploying apps to urun"
 readme = "README.md"
 requires-python = ">=3.11"

{urun_cli-0.1.2 → 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

urun_cli-0.2.0/src/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_cli-0.1.2/CHANGELOG.md

@@ -1,18 +0,0 @@
-# Changelog
-
-## 0.1.2
-
-- Clean the public CLI and docs for the config-free v1 surface.
-- Remove legacy spec/config artifacts from the repository and package surface.
-- Harden release packaging checks and publish only fresh `urun-cli` artifacts.
-
-## 0.1.1
-
-- Publish the CLI under the `urun-cli` PyPI distribution name.
-- Keep both `urun` and `urun-cli` command entrypoints available.
-
-## 0.1.0
-
-- Initial end-user `urun deploy` CLI.
-- Source manifest generation, Python file discovery, dependency declaration upload, and API deploy flow.
-- Test coverage for local manifest generation, API flow, and presigned upload behavior.

urun_cli-0.1.2/README.md

@@ -1,106 +0,0 @@
-# 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 a small Python app:
-
-```bash
-cat > app.py <<'PY'
-print("hello from urun")
-PY
-```
-
-Deploy it:
-
-```bash
-urun deploy app.py
-```
-
-You can also deploy a Python module:
-
-```bash
-urun deploy -m my_package.main
-```
-
-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` only |
-| `urun deploy -m my_package.main` | Python files in the containing package |
-
-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 |
-| --- | --- |
-| `-m, --module` | Deploy a Python module entrypoint, e.g. `my_package.main`. |
-| `--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 | Use a module entrypoint for packages; 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.2/src/urun/cli.py

@@ -1,126 +0,0 @@
-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")
-    target = deploy.add_mutually_exclusive_group()
-    target.add_argument("entrypoint", nargs="?", help="Python file entrypoint, e.g. app.py")
-    target.add_argument("-m", "--module", help="Python module entrypoint, e.g. myapp.main")
-    deploy.add_argument("--name", help="App name (defaults from entrypoint/module)")
-    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, args.module, project_root)
-    deps, deps_blob, python_version = resolve_deps(project_root)
-
-    app_name = args.name or derive_app_name(args.entrypoint, args.module)
-    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_cli-0.1.2/src/urun/deps.py

@@ -1,80 +0,0 @@
-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_cli-0.1.2/src/urun/discovery.py

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-import fnmatch
-import importlib.util
-import sys
-from pathlib import Path
-
-from .errors import UrunError
-from .manifest import FileBlob, file_blob
-
-MAX_AUTO_INCLUDE_BYTES = 50 * 1024 * 1024
-
-
-def derive_app_name(entrypoint: str | None, module: str | None) -> str:
-    if module:
-        return module.split(".")[0]
-    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 package_root_for(entrypoint: Path) -> Path | None:
-    current = entrypoint.resolve().parent
-    if not (current / "__init__.py").exists():
-        return None
-    root = current
-    while (root.parent / "__init__.py").exists():
-        root = root.parent
-    return root
-
-
-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]:
-    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")
-    patterns = load_urunignore(project_root)
-    pkg = package_root_for(entrypoint)
-    files: list[Path]
-    if pkg:
-        files = sorted(
-            p
-            for p in pkg.rglob("*.py")
-            if p.is_file() and not is_ignored(p, project_root, patterns)
-        )
-        total = sum(p.stat().st_size for p in files)
-        if total > MAX_AUTO_INCLUDE_BYTES:
-            raise UrunError(
-                f"auto-included package {pkg} is {total} bytes, above 50 MB; "
-                "add exclusions with .urunignore"
-            )
-    else:
-        if is_ignored(entrypoint, project_root, patterns):
-            raise UrunError(f"entrypoint is ignored by defaults or .urunignore: {entrypoint}")
-        files = [entrypoint]
-    blobs: list[FileBlob] = []
-    for p in 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_main_files(
-    entrypoint_arg: str | None, module_arg: str | None, project_root: Path
-) -> tuple[str, list[FileBlob]]:
-    ensure_project_on_path(project_root)
-    if module_arg:
-        spec = importlib.util.find_spec(module_arg)
-        if spec is None or spec.origin is None:
-            raise UrunError(f"module not found: {module_arg}")
-        entrypoint_path = ensure_under_root(Path(spec.origin), project_root, "module")
-    elif entrypoint_arg:
-        entrypoint_path = Path(entrypoint_arg)
-    else:
-        raise UrunError("provide an entrypoint or -m module")
-    if not entrypoint_path.is_absolute():
-        entrypoint_path = project_root / entrypoint_path
-    files = auto_include(entrypoint_path, project_root)
-    try:
-        manifest_entrypoint = (
-            module_arg
-            if module_arg
-            else 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
-
-
-def ensure_project_on_path(project_root: Path) -> None:
-    candidates = [project_root.resolve()]
-    src = project_root / "src"
-    if src.is_dir():
-        candidates.append(src.resolve())
-    for candidate in reversed(candidates):
-        path = str(candidate)
-        if path not in sys.path:
-            sys.path.insert(0, path)
-
-
-def ensure_under_root(path: Path, project_root: Path, label: str = "path") -> Path:
-    resolved = path.resolve()
-    try:
-        resolved.relative_to(project_root.resolve())
-    except ValueError as exc:
-        raise UrunError(f"{label} is outside the project root: {path}") from exc
-    return resolved