r2flow-cloud-cli 0.1.0__tar.gz

r2flow_cloud_cli-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.coverage
+*.egg-info/
+dist/
+node_modules/
+designer-web/dist/
+frontend/dist/
+.env
+flow.json
+flows/
+*.log
+.vscode/
+.idea/
+.DS_Store

r2flow_cloud_cli-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.5
+Name: r2flow-cloud-cli
+Version: 0.1.0
+Summary: CLI for deploying and managing R2Flow Cloud processes
+Requires-Python: >=3.11
+Requires-Dist: click
+Requires-Dist: httpx
+Requires-Dist: rich

r2flow_cloud_cli-0.1.0/README.md

@@ -0,0 +1,55 @@
+# r2flow-cloud-cli
+
+CLI for deploying and managing processes on the R2Flow Cloud orchestrator.
+
+## Install
+
+```bash
+cd cli
+pip install -e .
+```
+
+## Configuration
+
+Set the orchestrator URL via the `--orchestrator` flag or the `R2FLOW_CLOUD_URL` environment variable (default: `http://localhost:8000`).
+
+## Usage
+
+### Deploy a project
+
+Pack a local directory and upload it as a new process:
+
+```bash
+r2flow-cloud deploy ./my-process --name "Data Pipeline" --description "Nightly ETL" --entry main.py
+```
+
+### List processes
+
+```bash
+r2flow-cloud processes
+```
+
+### List agents
+
+```bash
+r2flow-cloud agents
+```
+
+### Run a process on an agent
+
+```bash
+r2flow-cloud run <process_id> <agent_id>
+```
+
+### Custom orchestrator URL
+
+```bash
+r2flow-cloud --orchestrator http://remote-host:8000 deploy ./my-process --name "Pipeline"
+```
+
+Or via environment variable:
+
+```bash
+export R2FLOW_CLOUD_URL=http://remote-host:8000
+r2flow-cloud deploy ./my-process --name "Pipeline"
+```

r2flow_cloud_cli-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "r2flow-cloud-cli"
+version = "0.1.0"
+description = "CLI for deploying and managing R2Flow Cloud processes"
+requires-python = ">=3.11"
+dependencies = [
+    "httpx",
+    "rich",
+    "click",
+]
+
+[project.scripts]
+r2flow-cloud = "r2flow_cloud_cli.main:cli"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/r2flow_cloud_cli"]

r2flow_cloud_cli-0.1.0/src/r2flow_cloud_cli/__init__.py

@@ -0,0 +1,5 @@
+"""R2Flow Cloud CLI — deploy and manage processes on the orchestrator."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"

r2flow_cloud_cli-0.1.0/src/r2flow_cloud_cli/client.py

@@ -0,0 +1,223 @@
+"""Async HTTP client for the R2Flow orchestrator API."""
+
+from __future__ import annotations
+
+import json
+from contextlib import suppress
+from pathlib import Path
+from typing import Any, cast
+
+import httpx
+
+
+def _credentials_path() -> Path:
+    """Location of the CLI token store (``~/.r2flow/credentials.json``)."""
+    return Path.home() / ".r2flow" / "credentials.json"
+
+
+def _load_tokens(base_url: str) -> dict[str, str]:
+    try:
+        data = json.loads(_credentials_path().read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    entry = data.get(base_url) if isinstance(data, dict) else None
+    return entry if isinstance(entry, dict) else {}
+
+
+def _save_tokens(base_url: str, tokens: dict[str, str] | None) -> None:
+    import os
+    from contextlib import suppress
+
+    path = _credentials_path()
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        data = {}
+    if not isinstance(data, dict):
+        data = {}
+    if tokens is None:
+        data.pop(base_url, None)
+    else:
+        data[base_url] = tokens
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    with suppress(OSError):
+        os.chmod(path, 0o600)
+
+
+class OrchestratorClient:
+    """Thin wrapper around :mod:`httpx` for the orchestrator REST API.
+
+    Bearer tokens saved by ``r2flow-cloud login`` are loaded automatically
+    and refreshed transparently when the server answers 401.
+    """
+
+    def __init__(self, base_url: str = "http://localhost:8000") -> None:
+        self._base = base_url.rstrip("/")
+        self._http = httpx.AsyncClient(base_url=self._base, timeout=30)
+        tokens = _load_tokens(self._base)
+        self._access_token: str | None = tokens.get("access_token")
+        self._refresh_token: str | None = tokens.get("refresh_token")
+
+    # -- context-manager support ------------------------------------------------
+
+    async def __aenter__(self) -> OrchestratorClient:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: object,
+    ) -> None:
+        await self._http.aclose()
+
+    @property
+    def logged_in(self) -> bool:
+        """Whether stored user credentials are available."""
+        return self._access_token is not None
+
+    # -- auth -----------------------------------------------------------------
+
+    async def login(self, email: str, password: str) -> dict[str, Any]:
+        """Authenticate via ``POST /api/auth/login`` and persist the token pair."""
+        resp = await self._http.post(
+            "/api/auth/login", data={"username": email, "password": password}
+        )
+        resp.raise_for_status()
+        body = cast(dict[str, Any], resp.json())
+        self._store_tokens(str(body["access_token"]), str(body["refresh_token"]))
+        return await self.me()
+
+    async def logout(self) -> None:
+        """Revoke the refresh token server-side and drop local credentials."""
+        if self._refresh_token:
+            with suppress(httpx.HTTPError):
+                await self._http.post(
+                    "/api/auth/logout", json={"refresh_token": self._refresh_token}
+                )
+        self._access_token = None
+        self._refresh_token = None
+        _save_tokens(self._base, None)
+
+    async def me(self) -> dict[str, Any]:
+        """Return the current user via ``GET /api/auth/me``."""
+        resp = await self._send("GET", "/api/auth/me")
+        resp.raise_for_status()
+        return cast(dict[str, Any], resp.json())
+
+    # -- transport --------------------------------------------------------------
+
+    def _store_tokens(self, access_token: str, refresh_token: str) -> None:
+        self._access_token = access_token
+        self._refresh_token = refresh_token
+        _save_tokens(
+            self._base,
+            {"access_token": access_token, "refresh_token": refresh_token},
+        )
+
+    async def _refresh_access(self) -> bool:
+        """Rotate the token pair. Returns True when new tokens were stored."""
+        if not self._refresh_token:
+            return False
+        try:
+            resp = await self._http.post(
+                "/api/auth/refresh", json={"refresh_token": self._refresh_token}
+            )
+        except httpx.HTTPError:
+            return False
+        if resp.status_code != 200:
+            self._access_token = None
+            self._refresh_token = None
+            _save_tokens(self._base, None)
+            return False
+        body = cast(dict[str, Any], resp.json())
+        self._store_tokens(str(body["access_token"]), str(body["refresh_token"]))
+        return True
+
+    async def _send(self, method: str, url: str, **kwargs: Any) -> httpx.Response:
+        """Send a request with Bearer auth, refreshing once on 401."""
+        if self._access_token:
+            headers = dict(kwargs.pop("headers", {}) or {})
+            headers.setdefault("Authorization", f"Bearer {self._access_token}")
+            kwargs["headers"] = headers
+        resp = await self._http.request(method, url, **kwargs)
+        if (
+            resp.status_code == 401
+            and self._refresh_token
+            and await self._refresh_access()
+            and self._access_token
+        ):
+            headers = dict(kwargs.pop("headers", {}) or {})
+            headers["Authorization"] = f"Bearer {self._access_token}"
+            kwargs["headers"] = headers
+            resp = await self._http.request(method, url, **kwargs)
+        return resp
+
+    # -- processes --------------------------------------------------------------
+
+    async def create_process(
+        self,
+        *,
+        name: str,
+        description: str = "",
+        entry_point: str = "main.py",
+        files: dict[str, str],
+        requirements: list[str] | None = None,
+    ) -> dict[str, Any]:
+        """Create a new process via ``POST /api/processes``."""
+        resp = await self._send(
+            "POST",
+            "/api/processes",
+            json={
+                "name": name,
+                "description": description,
+                "entry_point": entry_point,
+                "files": files,
+                "requirements": requirements or [],
+            },
+        )
+        resp.raise_for_status()
+        return cast(dict[str, Any], resp.json())
+
+    async def update_process(self, process_id: str, **kwargs: object) -> dict[str, Any]:
+        """Update an existing process via ``PUT /api/processes/{id}``."""
+        resp = await self._send("PUT", f"/api/processes/{process_id}", json=kwargs)
+        resp.raise_for_status()
+        return cast(dict[str, Any], resp.json())
+
+    async def list_processes(self) -> list[dict[str, Any]]:
+        """Return all processes via ``GET /api/processes``."""
+        resp = await self._send("GET", "/api/processes")
+        resp.raise_for_status()
+        return cast(list[dict[str, Any]], resp.json())
+
+    # -- agents ----------------------------------------------------------------
+
+    async def list_agents(self) -> list[dict[str, Any]]:
+        """Return all registered agents via ``GET /api/agents``."""
+        resp = await self._send("GET", "/api/agents")
+        resp.raise_for_status()
+        return cast(list[dict[str, Any]], resp.json())
+
+    # -- deployment / execution ------------------------------------------------
+
+    async def deploy(self, process_id: str, agent_id: str) -> dict[str, Any]:
+        """Deploy a process to an agent via ``POST /api/processes/{id}/deploy``."""
+        resp = await self._send(
+            "POST",
+            f"/api/processes/{process_id}/deploy",
+            json={"agent_id": agent_id},
+        )
+        resp.raise_for_status()
+        return cast(dict[str, Any], resp.json())
+
+    async def run(self, process_id: str, agent_id: str) -> dict[str, Any]:
+        """Run a process on an agent via ``POST /api/processes/{id}/run``."""
+        resp = await self._send(
+            "POST",
+            f"/api/processes/{process_id}/run",
+            json={"agent_id": agent_id},
+        )
+        resp.raise_for_status()
+        return cast(dict[str, Any], resp.json())

r2flow_cloud_cli-0.1.0/src/r2flow_cloud_cli/main.py

@@ -0,0 +1,315 @@
+"""CLI entry-point — ``r2flow-cloud`` command."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from r2flow_cloud_cli.client import OrchestratorClient
+from r2flow_cloud_cli.packager import read_directory, read_requirements
+
+console = Console()
+
+
+# ---------------------------------------------------------------------------
+# Helper: resolve orchestrator URL from option / env-var / default
+# ---------------------------------------------------------------------------
+
+
+def _client_ctx(ctx: click.Context) -> OrchestratorClient:
+    return OrchestratorClient(base_url=ctx.obj["orchestrator"])
+
+
+# ---------------------------------------------------------------------------
+# Root group
+# ---------------------------------------------------------------------------
+
+
+@click.group()
+@click.option(
+    "--orchestrator",
+    envvar="R2FLOW_CLOUD_URL",
+    default="http://localhost:8000",
+    show_default=True,
+    help="URL of the orchestrator service.",
+)
+@click.pass_context
+def cli(ctx: click.Context, orchestrator: str) -> None:
+    """R2Flow Cloud CLI — deploy and run processes on remote agents."""
+    ctx.ensure_object(dict)
+    ctx.obj["orchestrator"] = orchestrator
+
+
+# ---------------------------------------------------------------------------
+# deploy
+# ---------------------------------------------------------------------------
+
+
+@cli.command()
+@click.argument("path", type=click.Path(exists=True, file_okay=False))
+@click.option("--name", required=True, help="Process name.")
+@click.option("--description", default="", help="Human-readable description.")
+@click.option(
+    "--entry",
+    "entry_point",
+    default="main.py",
+    show_default=True,
+    help="Entry-point filename.",
+)
+@click.pass_context
+def deploy(ctx: click.Context, path: str, name: str, description: str, entry_point: str) -> None:
+    """Pack a directory and upload it as a new process."""
+    console.print(f"[bold]Packing[/bold] {path} …")
+    files = read_directory(path)
+    if not files:
+        console.print("[red]No files found in the given directory.[/red]")
+        raise SystemExit(1)
+
+    requirements = read_requirements(path)
+    console.print(f"  {len(files)} file(s), {len(requirements)} requirement(s)")
+
+    async def _create() -> dict[str, Any]:
+        async with _client_ctx(ctx) as client:
+            return await client.create_process(
+                name=name,
+                description=description,
+                entry_point=entry_point,
+                files=files,
+                requirements=requirements,
+            )
+
+    result = asyncio.run(_create())
+    pid = result.get("id") or result.get("process_id") or "?"
+    console.print(f"[green]✓ Process created[/green]  id={pid}")
+
+
+# ---------------------------------------------------------------------------
+# update
+# ---------------------------------------------------------------------------
+
+
+@cli.command()
+@click.argument("process_id")
+@click.argument("path", type=click.Path(exists=True, file_okay=False))
+@click.option(
+    "--entry",
+    "entry_point",
+    default="main.py",
+    show_default=True,
+    help="Entry-point filename.",
+)
+@click.option(
+    "--agent",
+    "agent_ref",
+    default=None,
+    help="Agent name or ID to deploy to (implies --deploy).",
+)
+@click.option(
+    "--deploy/--no-deploy",
+    default=False,
+    show_default=True,
+    help="Deploy the updated bundle to the agent given via --agent.",
+)
+@click.pass_context
+def update(
+    ctx: click.Context,
+    process_id: str,
+    path: str,
+    entry_point: str,
+    agent_ref: str | None,
+    deploy: bool,
+) -> None:
+    """Re-pack a directory and update an existing process in place."""
+    if deploy and not agent_ref:
+        console.print("[red]--deploy requires --agent <name|id>.[/red]")
+        raise SystemExit(2)
+
+    console.print(f"[bold]Packing[/bold] {path} …")
+    files = read_directory(path)
+    if not files:
+        console.print("[red]No files found in the given directory.[/red]")
+        raise SystemExit(1)
+
+    requirements = read_requirements(path)
+    console.print(f"  {len(files)} file(s), {len(requirements)} requirement(s)")
+
+    async def _update() -> dict[str, Any]:
+        async with _client_ctx(ctx) as client:
+            return await client.update_process(
+                process_id,
+                files=files,
+                requirements=requirements,
+                entry_point=entry_point,
+            )
+
+    try:
+        asyncio.run(_update())
+    except Exception as err:
+        console.print(f"[red]Update failed:[/red] {err}")
+        raise SystemExit(1) from err
+    console.print(f"[green]✓ Process updated[/green]  id={process_id}")
+
+    if not agent_ref:
+        return
+
+    async def _deploy() -> tuple[str, dict[str, Any]]:
+        async with _client_ctx(ctx) as client:
+            agents = await client.list_agents()
+            match = next(
+                (
+                    a
+                    for a in agents
+                    if a.get("id") == agent_ref or a.get("name") == agent_ref
+                ),
+                None,
+            )
+            if match is None:
+                raise LookupError(f"no agent matching {agent_ref!r}")
+            agent_id = str(match["id"])
+            return agent_id, await client.deploy(process_id, agent_id)
+
+    try:
+        agent_id, _ = asyncio.run(_deploy())
+    except LookupError as err:
+        console.print(f"[red]Deploy failed:[/red] {err}")
+        raise SystemExit(1) from err
+    except Exception as err:
+        console.print(f"[red]Deploy failed:[/red] {err}")
+        raise SystemExit(1) from err
+    console.print(f"[green]✓ Deploy triggered[/green]  agent={agent_id}")
+
+
+# ---------------------------------------------------------------------------
+# processes
+# ---------------------------------------------------------------------------
+
+
+@cli.command()
+@click.pass_context
+def processes(ctx: click.Context) -> None:
+    """List all processes."""
+
+    async def _list() -> list[dict[str, Any]]:
+        async with _client_ctx(ctx) as client:
+            return await client.list_processes()
+
+    items = asyncio.run(_list())
+
+    table = Table(title="Processes")
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Name", style="green")
+    table.add_column("Entry Point")
+    table.add_column("Description")
+
+    for p in items:
+        table.add_row(
+            str(p.get("id", "")),
+            p.get("name", ""),
+            p.get("entry_point", ""),
+            p.get("description", ""),
+        )
+
+    console.print(table)
+
+
+# ---------------------------------------------------------------------------
+# agents
+# ---------------------------------------------------------------------------
+
+
+@cli.command()
+@click.pass_context
+def agents(ctx: click.Context) -> None:
+    """List all registered agents."""
+
+    async def _list() -> list[dict[str, Any]]:
+        async with _client_ctx(ctx) as client:
+            return await client.list_agents()
+
+    items = asyncio.run(_list())
+
+    table = Table(title="Agents")
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Name", style="green")
+    table.add_column("Status")
+
+    for a in items:
+        table.add_row(
+            str(a.get("id", "")),
+            a.get("name", ""),
+            a.get("status", ""),
+        )
+
+    console.print(table)
+
+
+# ---------------------------------------------------------------------------
+# login / logout
+# ---------------------------------------------------------------------------
+
+
+@cli.command()
+@click.option("--email", prompt=True, help="Account email.")
+@click.option(
+    "--password",
+    prompt=True,
+    hide_input=True,
+    help="Account password.",
+)
+@click.pass_context
+def login(ctx: click.Context, email: str, password: str) -> None:
+    """Authenticate against the orchestrator and store tokens locally."""
+
+    async def _login() -> dict[str, Any]:
+        async with _client_ctx(ctx) as client:
+            return await client.login(email, password)
+
+    try:
+        user = asyncio.run(_login())
+    except Exception as err:
+        console.print(f"[red]Login failed:[/red] {err}")
+        raise SystemExit(1) from err
+    console.print(
+        f"[green]✓ Logged in[/green]  {user.get('email')} (role={user.get('role')})"
+    )
+
+
+@cli.command()
+@click.pass_context
+def logout(ctx: click.Context) -> None:
+    """Revoke the stored session and drop local credentials."""
+
+    async def _logout() -> None:
+        async with _client_ctx(ctx) as client:
+            await client.logout()
+
+    asyncio.run(_logout())
+    console.print("[green]✓ Logged out[/green]")
+
+
+# ---------------------------------------------------------------------------
+# run
+# ---------------------------------------------------------------------------
+
+
+@cli.command()
+@click.argument("process_id")
+@click.argument("agent_id")
+@click.pass_context
+def run(ctx: click.Context, process_id: str, agent_id: str) -> None:
+    """Trigger a process run on an agent."""
+
+    async def _run() -> dict[str, Any]:
+        async with _client_ctx(ctx) as client:
+            return await client.run(process_id, agent_id)
+
+    result = asyncio.run(_run())
+    console.print(f"[green]✓ Run triggered[/green]  {result}")
+
+
+if __name__ == "__main__":
+    cli()

r2flow_cloud_cli-0.1.0/src/r2flow_cloud_cli/packager.py

@@ -0,0 +1,71 @@
+"""Read a project directory into a JSON-serialisable files dict and requirements."""
+
+from __future__ import annotations
+
+import fnmatch
+from pathlib import Path
+
+_EXCLUDE_DIRS: set[str] = {
+    ".git",
+    ".venv",
+    "__pycache__",
+    "node_modules",
+    ".ruff_cache",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".gigacode",
+}
+_EXCLUDE_GLOBS: set[str] = {"*.pyc", "*.pyo", ".env"}
+
+
+def read_directory(path: str | Path) -> dict[str, str]:
+    """Walk *path* recursively and return ``{relative_path: content}`` dicts.
+
+    Skips directories and files in ``_EXCLUDE_DIRS`` / ``_EXCLUDE_GLOBS``.
+    Binary files (those that raise :class:`UnicodeDecodeError`) are silently
+    skipped.
+    """
+    root = Path(path).resolve()
+    files: dict[str, str] = {}
+
+    for entry in sorted(root.rglob("*")):
+        if not entry.is_file():
+            continue
+
+        # Directory name check (walks through each parent too).
+        if any(part in _EXCLUDE_DIRS for part in entry.relative_to(root).parts):
+            continue
+
+        name = entry.name
+        if any(fnmatch.fnmatch(name, pat) for pat in _EXCLUDE_GLOBS):
+            continue
+
+        rel = entry.relative_to(root).as_posix()
+        try:
+            files[rel] = entry.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue  # binary file — skip
+
+    return files
+
+
+def read_requirements(path: str | Path | None = None) -> list[str]:
+    """Return requirements lines from *requirements.txt* if it exists.
+
+    Parameters
+    ----------
+    path:
+        Directory that may contain ``requirements.txt``.  Defaults to cwd.
+    """
+    req_file = Path(path) if path else Path.cwd()
+    req_file = req_file / "requirements.txt"
+
+    if not req_file.is_file():
+        return []
+
+    lines = [
+        line.strip()
+        for line in req_file.read_text(encoding="utf-8").splitlines()
+        if line.strip() and not line.strip().startswith("#")
+    ]
+    return lines