runtime-sdk 0.1.0__py3-none-any.whl

runtime_sdk/__init__.py

@@ -0,0 +1,3 @@
+from runtime_sdk.client import RuntimeAPIError, RuntimeClient
+
+__all__ = ["RuntimeAPIError", "RuntimeClient"]

runtime_sdk/cli.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from typing import Any
+
+from runtime_sdk.client import RuntimeAPIError, RuntimeClient
+from runtime_sdk.config import DEFAULT_BASE_URL, PendingSignup, RuntimeConfig, load_config, save_config
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="runtime")
+    parser.add_argument("--base-url", help="Runtime API base URL")
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    signup = subparsers.add_parser("signup")
+    signup.add_argument("email")
+    signup.add_argument("--name", required=True)
+
+    verify = subparsers.add_parser("verify")
+    verify.add_argument("code")
+    verify.add_argument("--flow-id", type=int)
+
+    login = subparsers.add_parser("login")
+    login.add_argument("api_key")
+
+    subparsers.add_parser("whoami")
+    subparsers.add_parser("logout")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        config = load_config()
+        base_url = args.base_url or os.environ.get("RUNTIME_BASE_URL") or config.base_url or DEFAULT_BASE_URL
+        config.base_url = base_url
+
+        if args.command == "signup":
+            return handle_signup(config, args.email, args.name)
+        if args.command == "verify":
+            return handle_verify(config, args.code, args.flow_id)
+        if args.command == "login":
+            return handle_login(config, args.api_key)
+        if args.command == "whoami":
+            return handle_whoami(config)
+        if args.command == "logout":
+            return handle_logout(config)
+    except RuntimeAPIError as exc:
+        return write_json({"success": False, "error": str(exc), "status_code": exc.status_code}, error=True)
+
+    return write_json({"success": False, "error": "unknown command"}, error=True)
+
+
+def handle_signup(config: RuntimeConfig, email: str, name: str) -> int:
+    client = RuntimeClient(base_url=config.base_url)
+    result = client.signup(email, name)
+    config.pending_signup = PendingSignup(
+        flow_id=int(result["flow_id"]),
+        email=email,
+        expires_at=result.get("expires_at"),
+    )
+    save_config(config)
+    return write_json({"success": True, **result})
+
+
+def handle_verify(config: RuntimeConfig, code: str, flow_id: int | None) -> int:
+    pending = config.pending_signup
+    resolved_flow_id = flow_id or (pending.flow_id if pending else None)
+    if not resolved_flow_id:
+        return write_json(
+            {"success": False, "error": "missing flow id; run signup first or pass --flow-id"},
+            error=True,
+        )
+
+    client = RuntimeClient(base_url=config.base_url)
+    result = client.verify(resolved_flow_id, code)
+    api_key = result.get("api_key")
+    if api_key:
+        config.api_key = api_key
+    config.pending_signup = None
+    save_config(config)
+    return write_json({"success": True, **result})
+
+
+def handle_login(config: RuntimeConfig, api_key: str) -> int:
+    config.api_key = api_key
+    save_config(config)
+    return write_json({"success": True, "message": "api key saved"})
+
+
+def handle_whoami(config: RuntimeConfig) -> int:
+    if not config.api_key:
+        return write_json({"success": False, "error": "missing api key; run verify or login first"}, error=True)
+
+    client = RuntimeClient(base_url=config.base_url, api_key=config.api_key)
+    result = client.whoami()
+    return write_json({"success": True, **result})
+
+
+def handle_logout(config: RuntimeConfig) -> int:
+    config.api_key = None
+    config.pending_signup = None
+    save_config(config)
+    return write_json({"success": True, "message": "logged out"})
+
+
+def write_json(payload: dict[str, Any], *, error: bool = False) -> int:
+    stream = sys.stderr if error else sys.stdout
+    stream.write(json.dumps(payload) + "\n")
+    return 1 if error else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

runtime_sdk/client.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+
+class RuntimeAPIError(RuntimeError):
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+@dataclass(slots=True)
+class RuntimeClient:
+    base_url: str
+    api_key: str | None = None
+    timeout: float = 10.0
+    transport: httpx.BaseTransport | None = None
+
+    def __post_init__(self) -> None:
+        self.base_url = self.base_url.rstrip("/")
+
+    def signup(self, email: str, name: str) -> dict[str, Any]:
+        return self._request("POST", "/api/auth/start", json={"email": email, "name": name})
+
+    def verify(self, flow_id: int, code: str) -> dict[str, Any]:
+        return self._request("POST", "/api/auth/verify", json={"flow_id": flow_id, "code": code})
+
+    def whoami(self) -> dict[str, Any]:
+        return self._request("GET", "/api/auth/whoami", auth_required=True)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        auth_required: bool = False,
+    ) -> dict[str, Any]:
+        headers: dict[str, str] = {}
+        if auth_required:
+            if not self.api_key:
+                raise RuntimeAPIError("missing api key")
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        try:
+            with httpx.Client(
+                base_url=self.base_url,
+                timeout=self.timeout,
+                transport=self.transport,
+            ) as client:
+                response = client.request(method, path, json=json, headers=headers)
+        except httpx.HTTPError as exc:
+            raise RuntimeAPIError(f"request failed: {exc}") from exc
+
+        payload = self._decode_response(response)
+        if response.is_success:
+            return payload
+
+        message = payload.get("error") or payload.get("message") or f"http {response.status_code}"
+        raise RuntimeAPIError(str(message), status_code=response.status_code)
+
+    @staticmethod
+    def _decode_response(response: httpx.Response) -> dict[str, Any]:
+        if not response.content:
+            return {}
+        try:
+            decoded = response.json()
+        except ValueError as exc:
+            raise RuntimeAPIError("server returned invalid JSON", status_code=response.status_code) from exc
+
+        if not isinstance(decoded, dict):
+            raise RuntimeAPIError("server returned non-object JSON", status_code=response.status_code)
+        return decoded

runtime_sdk/config.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+
+DEFAULT_BASE_URL = "http://127.0.0.1:8080"
+
+
+@dataclass(slots=True)
+class PendingSignup:
+    flow_id: int
+    email: str
+    expires_at: str | None = None
+
+
+@dataclass(slots=True)
+class RuntimeConfig:
+    base_url: str = DEFAULT_BASE_URL
+    api_key: str | None = None
+    pending_signup: PendingSignup | None = None
+
+
+def config_path() -> Path:
+    root = os.environ.get("XDG_CONFIG_HOME")
+    if root:
+        return Path(root) / "runtime" / "config.json"
+    return Path.home() / ".config" / "runtime" / "config.json"
+
+
+def load_config() -> RuntimeConfig:
+    path = config_path()
+    if not path.exists():
+        return RuntimeConfig(base_url=os.environ.get("RUNTIME_BASE_URL", DEFAULT_BASE_URL))
+
+    data = json.loads(path.read_text())
+    pending = data.get("pending_signup")
+    return RuntimeConfig(
+        base_url=data.get("base_url") or os.environ.get("RUNTIME_BASE_URL", DEFAULT_BASE_URL),
+        api_key=data.get("api_key"),
+        pending_signup=PendingSignup(**pending) if pending else None,
+    )
+
+
+def save_config(config: RuntimeConfig) -> None:
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    payload = asdict(config)
+    path.write_text(json.dumps(payload, indent=2) + "\n")
+    os.chmod(path, 0o600)

runtime_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: runtime-sdk
+Version: 0.1.0
+Summary: Runtime Python SDK and CLI
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.1
+
+# runtime-sdk
+
+Python SDK and CLI for Runtime.
+
+## Install
+
+```bash
+uv tool install runtime-sdk
+```
+
+## Configure
+
+The CLI talks to `http://127.0.0.1:8080` by default. Override it with:
+
+```bash
+export RUNTIME_BASE_URL=https://runruntime.dev
+```
+
+Or pass `--base-url` per command.
+
+## Usage
+
+```bash
+runtime signup you@example.com --name "Your Name"
+runtime verify 123456
+runtime whoami
+runtime logout
+```
+
+## Python
+
+```python
+from runtime_sdk import RuntimeClient
+
+client = RuntimeClient(base_url="https://runruntime.dev")
+result = client.signup("you@example.com", "Your Name")
+print(result["flow_id"])
+```

runtime_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+runtime_sdk/__init__.py,sha256=Chc9jwyjuIjLAO6LMosodvmyN-sOxhXlGCVaT-LfBto,110
+runtime_sdk/cli.py,sha256=I3I9QSvUE2-7PGGTQDT5Gezs0TtzSd3Ey1lvJ7tO7n4,3978
+runtime_sdk/client.py,sha256=uPOAt35L7miX0dqm2UKAM-uRcrugb6uDvtlGYeWNtyU,2577
+runtime_sdk/config.py,sha256=KTUFv1s4vi1KDogVEVzLaDgzasBk0Mhm_AWD4x3WDHs,1396
+runtime_sdk-0.1.0.dist-info/METADATA,sha256=xrubKwPysdsqMTg16jmnb73w-kbMva4bab0kxqr5Png,794
+runtime_sdk-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+runtime_sdk-0.1.0.dist-info/entry_points.txt,sha256=Hk_zo0mQTeqWOYb1oTxGnGN-b61_6uKYAt3THED8xeE,49
+runtime_sdk-0.1.0.dist-info/top_level.txt,sha256=RmTYN3o3Mn1j6OozW1LbYaYvy3FjQU3E118nfNv7Ye0,12
+runtime_sdk-0.1.0.dist-info/RECORD,,

runtime_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

runtime_sdk-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+runtime = runtime_sdk.cli:main

runtime_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+runtime_sdk