orpheus-cli 0.1.0__py3-none-any.whl

orpheus/__init__.py

@@ -0,0 +1 @@
+"""Orpheus CLI."""

orpheus/auth.py

@@ -0,0 +1,94 @@
+"""GitHub device flow authentication."""
+
+import time
+
+import httpx
+from pydantic import BaseModel, HttpUrl
+
+from orpheus.config import get_config
+
+
+class AuthError(Exception):
+    """Authentication failed."""
+
+    pass
+
+
+class DeviceCodeResponse(BaseModel):
+    device_code: str
+    user_code: str
+    verification_uri: HttpUrl
+    expires_in: int
+    interval: int
+
+
+class AccessTokenResponse(BaseModel):
+    access_token: str
+    token_type: str
+    scope: str
+
+
+class ErrorResponse(BaseModel):
+    error: str
+    error_description: str | None = None
+    interval: int | None = None
+
+    def check(self) -> int:
+        """Return interval for retryable errors, raise AuthError for fatal."""
+        match self.error:
+            case "authorization_pending":
+                return self.interval or 5
+            case "slow_down":
+                return self.interval or 10
+            case "expired_token":
+                raise AuthError("Device code expired. Please try again.")
+            case "access_denied":
+                raise AuthError("Authorization denied by user.")
+            case _:
+                raise AuthError(f"Unexpected error: {self.error}")
+
+
+TokenResponse = AccessTokenResponse | ErrorResponse
+
+
+def parse_token_response(data: dict) -> TokenResponse:
+    """Parse GitHub's token endpoint response."""
+    if "access_token" in data:
+        return AccessTokenResponse.model_validate(data)
+    return ErrorResponse.model_validate(data)
+
+
+def request_device_code() -> DeviceCodeResponse:
+    """Request a device code from GitHub."""
+    config = get_config()
+    response = httpx.post(
+        "https://github.com/login/device/code",
+        data={"client_id": config.github_client_id},
+        headers={"Accept": "application/json"},
+    )
+    response.raise_for_status()
+    return DeviceCodeResponse.model_validate(response.json())
+
+
+def poll_for_user_access_token(device_code: str, interval: int) -> str:
+    """Poll GitHub until user authorizes, then return user access token."""
+    config = get_config()
+
+    while True:
+        response = httpx.post(
+            "https://github.com/login/oauth/access_token",
+            data={
+                "client_id": config.github_client_id,
+                "device_code": device_code,
+                "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+            },
+            headers={"Accept": "application/json"},
+        )
+        response.raise_for_status()
+
+        match parse_token_response(response.json()):
+            case AccessTokenResponse(access_token=token):
+                return token
+            case ErrorResponse() as error:
+                interval = error.check()
+                time.sleep(interval)

orpheus/client.py

@@ -0,0 +1,208 @@
+"""HTTP client for Orpheus server API."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import httpx
+from pydantic import HttpUrl
+
+from orpheus.config import load_config
+
+
+if TYPE_CHECKING:
+    from orpheus.config import Config
+
+
+class NotFoundError(Exception):
+    """Raised when a resource is not found."""
+
+    def __init__(self, resource_type: str, identifier: str):
+        self.resource_type = resource_type
+        self.identifier = identifier
+        super().__init__(f"{resource_type} '{identifier}' not found")
+
+
+class APIError(Exception):
+    """Raised when an API request fails."""
+
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class OrpheusClient:
+    """Orpheus API client."""
+
+    def __init__(self, config: Config | None = None):
+        self.config = config or load_config()
+        self._client = httpx.Client(base_url=str(self.base_url), timeout=300)
+
+    @property
+    def base_url(self) -> HttpUrl:
+        """Base URL for the Orpheus API."""
+        return self.config.base_url
+
+    @property
+    def user_access_token(self) -> str | None:
+        """User access token for the Orpheus API."""
+        return self.config.user_access_token
+
+    @property
+    def _headers(self) -> dict[str, str]:
+        """Headers for API requests."""
+        headers = {}
+        if self.user_access_token:
+            headers["Authorization"] = f"Bearer {self.user_access_token}"
+        return headers
+
+    def create_task(
+        self,
+        spec: str,
+        repo_full_name: str,
+        snapshot_id: str | None = None,
+        programs: list[str] | None = None,
+        git_branch: str | None = None,
+    ) -> dict[str, Any]:
+        """Create a new task."""
+        body: dict[str, Any] = {"spec": spec, "repo_full_name": repo_full_name}
+        if snapshot_id:
+            body["snapshot_id"] = snapshot_id
+        if programs:
+            body["programs"] = programs
+        if git_branch:
+            body["git_branch"] = git_branch
+        response = self._client.post("/tasks", json=body, headers=self._headers)
+        if response.status_code != 200:
+            raise APIError(response.text)
+        return response.json()
+
+    def get_task(self, task_slug: str) -> dict[str, Any]:
+        """Get task details by slug."""
+        response = self._client.get(f"/tasks/{task_slug}", headers=self._headers)
+        if response.status_code == 404:
+            raise NotFoundError("Task", task_slug)
+        if response.status_code != 200:
+            raise APIError(response.text)
+        return response.json()
+
+    def stop_task(self, task_slug: str) -> dict[str, Any]:
+        """Stop a task by slug."""
+        response = self._client.delete(f"/tasks/{task_slug}", headers=self._headers)
+        if response.status_code == 404:
+            raise NotFoundError("Task", task_slug)
+        if response.status_code != 200:
+            raise APIError(response.text)
+        return response.json()
+
+    def list_tasks(self, active_only: bool = True) -> list[dict[str, Any]]:
+        """List tasks."""
+        params = {} if active_only else {"active_only": "false"}
+        response = self._client.get("/tasks", headers=self._headers, params=params)
+        if response.status_code != 200:
+            raise APIError(response.text)
+        return response.json()["tasks"]
+
+    def get_execution_diff(self, execution_slug: str) -> str:
+        """Get diff for an execution by slug."""
+        response = self._client.get(f"/executions/{execution_slug}/diff", headers=self._headers)
+        if response.status_code == 404:
+            raise NotFoundError("Execution", execution_slug)
+        if response.status_code != 200:
+            raise APIError(response.text)
+        return response.json()["diff"]
+
+    def list_programs(self) -> list[str]:
+        """List available programs."""
+        response = self._client.get("/available-programs", headers=self._headers)
+        if response.status_code != 200:
+            raise APIError(response.text)
+        return response.json()["programs"]
+
+    def list_repos(self) -> list[dict[str, Any]]:
+        """List accessible repositories."""
+        response = self._client.get("/repos", headers=self._headers)
+        if response.status_code != 200:
+            raise APIError(response.text)
+        return response.json()["repos"]
+
+    def start_setup(self, repo_full_name: str, private: bool) -> dict[str, Any]:
+        """Start devbox setup for a repository."""
+        response = self._client.post(
+            "/setup/start",
+            json={"repo_full_name": repo_full_name, "private": private},
+            headers=self._headers,
+        )
+        if response.status_code != 200:
+            raise APIError(response.text)
+        return response.json()
+
+    def save_setup(self, repo_full_name: str) -> dict[str, Any]:
+        """Save devbox state by creating a snapshot."""
+        response = self._client.post(
+            "/setup/save",
+            json={"repo_full_name": repo_full_name},
+            headers=self._headers,
+        )
+        if response.status_code != 200:
+            raise APIError(response.text)
+        return response.json()
+
+    def download_file(
+        self,
+        path: str,
+        repo: str | None = None,
+        execution_slug: str | None = None,
+        agent_name: str | None = None,
+    ) -> httpx.Response:
+        """Download a file from a VM. Returns the raw response for streaming."""
+        params: dict[str, str] = {"path": path}
+        if repo:
+            params["repo"] = repo
+        if execution_slug:
+            params["execution_slug"] = execution_slug
+        if agent_name:
+            params["agent_name"] = agent_name
+        response = self._client.get("/files/download", params=params, headers=self._headers)
+        if response.status_code == 404:
+            raise NotFoundError("File", path)
+        if response.status_code != 200:
+            raise APIError(response.text)
+        return response
+
+    def upload_file(
+        self,
+        local_path: Path | None,
+        remote_path: str,
+        content: bytes | None = None,
+        repo: str | None = None,
+        execution_slug: str | None = None,
+        agent_name: str | None = None,
+    ) -> dict[str, Any]:
+        """Upload a file to a VM."""
+        params: dict[str, str] = {"path": remote_path}
+        if repo:
+            params["repo"] = repo
+        if execution_slug:
+            params["execution_slug"] = execution_slug
+        if agent_name:
+            params["agent_name"] = agent_name
+
+        if content is not None:
+            file_data = content
+            filename = Path(remote_path).name
+        elif local_path:
+            file_data = local_path.read_bytes()
+            filename = local_path.name
+        else:
+            raise ValueError("Either local_path or content must be provided")
+
+        response = self._client.post(
+            "/files/upload",
+            params=params,
+            files={"file": (filename, file_data)},
+            headers=self._headers,
+        )
+        if response.status_code != 200:
+            raise APIError(response.text)
+        return response.json()

orpheus/commands/auth.py

@@ -0,0 +1,85 @@
+"""Authentication commands."""
+
+import webbrowser
+
+import typer
+from orpheus.auth import AuthError, poll_for_user_access_token, request_device_code
+from orpheus.config import load_config, save_config
+from orpheus.display import console, print_error, print_success
+
+
+auth = typer.Typer(help="Manage authentication.", no_args_is_help=True)
+
+
+def has_browser() -> bool:
+    """Check if a browser is available."""
+    try:
+        webbrowser.get()
+        return True
+    except webbrowser.Error:
+        return False
+
+
+def _prompt_app_installation(app_slug: str) -> None:
+    """Print the installation link so the user can add the app to their repos."""
+    install_url = f"https://github.com/apps/{app_slug}/installations/new"
+    console.print()
+    console.print("Install the Orpheus GitHub App on any repos you want agents to work on:")
+    console.print(f"  {install_url}")
+    console.print()
+
+
+@auth.command()
+def login():
+    """Authenticate with Orpheus via GitHub."""
+    config = load_config()
+
+    # Request device code
+    response = request_device_code()
+
+    # Prompt user
+    console.print(f"Your one-time code is [bold green]{response.user_code}[/bold green]")
+    console.print()
+
+    if has_browser():
+        console.print("Press Enter to open `github.com` in your browser...")
+        input()
+        webbrowser.open(str(response.verification_uri))
+    else:
+        console.print(f"Open this URL in a browser: [bold blue]{response.verification_uri}[/bold blue]")
+        console.print("Enter the code above, then authorize the application.")
+        console.print()
+
+    # Poll for token
+    console.print("Waiting for authorization...")
+    try:
+        user_access_token = poll_for_user_access_token(response.device_code, response.interval)
+    except AuthError as error:
+        print_error(str(error))
+        raise typer.Exit(1)
+
+    # Save
+    config.user_access_token = user_access_token
+    save_config(config)
+    print_success("Authenticated successfully.")
+
+    _prompt_app_installation(config.github_app_slug)
+
+
+@auth.command()
+def logout():
+    """Clear stored credentials."""
+    config = load_config()
+    config.user_access_token = None
+    save_config(config)
+    print_success("Logged out.")
+
+
+@auth.command()
+def status():
+    """Show current authentication status."""
+    config = load_config()
+    if config.user_access_token:
+        print_success("Authenticated.")
+    else:
+        print_error("Not authenticated. Run `orpheus auth login`.")

orpheus/commands/setup.py

@@ -0,0 +1,132 @@
+"""Setup commands for devbox configuration."""
+
+from pathlib import Path
+
+import questionary
+import typer
+from orpheus.client import APIError, OrpheusClient
+from orpheus.config import get_config
+from orpheus.display import console, print_error, print_success, print_warning
+from orpheus.git import get_repo_from_cwd
+
+
+setup = typer.Typer(help="Manage devbox setup.", no_args_is_help=True)
+
+
+def get_keys_dir() -> Path:
+    """Get the directory for SSH keys."""
+    keys_dir = Path.home() / ".orpheus" / "keys"
+    keys_dir.mkdir(parents=True, exist_ok=True)
+    return keys_dir
+
+
+@setup.command()
+def start():
+    """Start devbox setup by selecting a repository."""
+    config = get_config()
+
+    if not config.user_access_token:
+        print_error("Not authenticated. Run 'orpheus auth login' first.")
+        raise typer.Exit(1)
+
+    client = OrpheusClient(config)
+
+    console.print("Fetching your repositories...")
+    try:
+        repos = client.list_repos()
+    except APIError as e:
+        print_error(f"Failed to fetch repos: {e}")
+        raise typer.Exit(1)
+
+    if not repos:
+        print_error("No repositories found.")
+        raise typer.Exit(1)
+
+    # Try to auto-detect repo from cwd
+    detected_repo = get_repo_from_cwd()
+    selected = None
+
+    if detected_repo:
+        selected = next((r for r in repos if r["full_name"] == detected_repo), None)
+        if selected:
+            console.print(f"Detected repository: [bold]{detected_repo}[/bold]")
+        else:
+            print_error(f"Detected repo '{detected_repo}' not in your accessible repos.")
+            raise typer.Exit(1)
+
+    if not selected:
+        choices = [questionary.Choice(title=r["full_name"], value=r) for r in repos]
+        selected = questionary.select(
+            "Select a repository:",
+            choices=choices,
+            use_shortcuts=False,
+            use_arrow_keys=True,
+            use_jk_keys=False,
+            use_search_filter=True,
+        ).ask()
+
+    if selected is None:
+        raise typer.Exit(1)
+
+    repo_full_name = selected["full_name"]
+    is_private = selected["private"]
+
+    console.print()
+    console.print(f"Provisioning devbox for [bold]{repo_full_name}[/bold]...")
+
+    try:
+        data = client.start_setup(repo_full_name, is_private)
+    except APIError as e:
+        print_error(f"Failed to start setup: {e}")
+        raise typer.Exit(1)
+
+    # Save SSH key
+    keys_dir = get_keys_dir()
+    key_path = keys_dir / data["instance_id"]
+    key_path.write_text(data["ssh_private_key"])
+    key_path.chmod(0o600)
+
+    # Display SSH info
+    console.print()
+    print_success("Your devbox is ready!")
+    console.print()
+    console.print("[bold]SSH command:[/bold]")
+    console.print(f"  ssh -i {key_path} {data['ssh_user']}@{data['ssh_host']}")
+    console.print()
+    console.print("[bold]Or use password:[/bold]")
+    console.print(f"  {data['ssh_password']}")
+    console.print()
+    print_warning("When you're done configuring, run:")
+    console.print("  [bold]orpheus setup save[/bold]")
+
+
+@setup.command()
+def save():
+    """Save devbox state by creating a snapshot."""
+    config = get_config()
+
+    if not config.user_access_token:
+        print_error("Not authenticated. Run 'orpheus auth login' first.")
+        raise typer.Exit(1)
+
+    # Detect repo from cwd
+    repo_full_name = get_repo_from_cwd()
+    if not repo_full_name:
+        print_error("Not in a git repository with a GitHub remote.")
+        print_error("Run this command from within your cloned repo directory.")
+        raise typer.Exit(1)
+
+    client = OrpheusClient(config)
+
+    console.print(f"Saving devbox snapshot for [bold]{repo_full_name}[/bold]...")
+
+    try:
+        data = client.save_setup(repo_full_name)
+    except APIError as e:
+        print_error(f"Failed to save devbox: {e}")
+        raise typer.Exit(1)
+
+    print_success(f"Snapshot saved: {data['snapshot_id']}")
+    console.print()
+    console.print("You can now run tasks with:")
+    console.print("  [bold]orpheus exec spec.txt[/bold]")

orpheus/config.py

@@ -0,0 +1,47 @@
+"""Configuration management for `~/.orpheus/config.json`."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from pydantic import HttpUrl
+from pydantic_settings import BaseSettings
+
+
+_config: Config | None = None
+
+
+class Config(BaseSettings):
+    """Orpheus CLI configuration."""
+
+    base_url: HttpUrl = "https://api.orpheus.dev"
+    github_client_id: str = "Iv23liwHHi6oub0QWFau"
+    github_app_slug: str = "orpheus-by-fulcrum"
+    user_access_token: str | None = None
+
+
+def get_config() -> Config:
+    """Get the configuration."""
+    global _config
+    if _config is None:
+        _config = load_config()
+    return _config
+
+
+def load_config() -> Config:
+    """Load config from `~/.orpheus/config.json`."""
+    home = Path.home()
+    config_path = home / ".orpheus" / "config.json"
+    if config_path.exists():
+        data = json.loads(config_path.read_text())
+        return Config(**data)
+    return Config()
+
+
+def save_config(config: Config) -> None:
+    """Save config to `~/.orpheus/config.json`."""
+    home = Path.home()
+    config_path = home / ".orpheus" / "config.json"
+    config_path.parent.mkdir(exist_ok=True)
+    config_path.write_text(config.model_dump_json(indent=2))

orpheus/display.py

@@ -0,0 +1,21 @@
+"""Display helpers using Rich."""
+
+from rich.console import Console
+
+
+console = Console()
+
+
+def print_success(message: str) -> None:
+    """Print a success message."""
+    console.print(f"[green]✓[/green] {message}")
+
+
+def print_error(message: str) -> None:
+    """Print an error message."""
+    console.print(f"[red]✗[/red] {message}")
+
+
+def print_warning(message: str) -> None:
+    """Print a warning message."""
+    console.print(f"[yellow]![/yellow] {message}")

orpheus/git.py

@@ -0,0 +1,39 @@
+"""Git helpers for the Orpheus CLI."""
+
+import re
+import subprocess
+
+
+def get_repo_from_cwd() -> str | None:
+    """Get GitHub repo (user/repo) from current directory's git remote.
+
+    Returns None if not in a git repo or origin remote is not GitHub.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        url = result.stdout.strip()
+    except subprocess.CalledProcessError:
+        return None
+
+    # Parse GitHub URLs:
+    # - https://github.com/user/repo.git
+    # - https://github.com/user/repo
+    # - git@github.com:user/repo.git
+    # - git@github.com:user/repo
+
+    # HTTPS pattern
+    https_match = re.match(r"https://github\.com/([^/]+)/([^/]+?)(?:\.git)?$", url)
+    if https_match:
+        return f"{https_match.group(1)}/{https_match.group(2)}"
+
+    # SSH pattern
+    ssh_match = re.match(r"git@github\.com:([^/]+)/([^/]+?)(?:\.git)?$", url)
+    if ssh_match:
+        return f"{ssh_match.group(1)}/{ssh_match.group(2)}"
+
+    return None

orpheus/main.py

@@ -0,0 +1,319 @@
+"""Orpheus CLI entry point."""
+
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+
+from orpheus.client import APIError, NotFoundError, OrpheusClient
+from orpheus.commands.auth import auth
+from orpheus.commands.setup import setup
+from orpheus.config import get_config
+from orpheus.display import console, print_error, print_success
+from orpheus.git import get_repo_from_cwd
+
+
+app = typer.Typer(name="orpheus", help="A command-line interface for orchestrating AI agents.", no_args_is_help=True)
+app.add_typer(auth, name="auth")
+app.add_typer(setup, name="setup")
+
+
+def get_authenticated_client() -> OrpheusClient:
+    """Get an authenticated client or exit with error."""
+    config = get_config()
+    if not config.user_access_token:
+        print_error("Not authenticated. Run 'orpheus auth login' first.")
+        raise typer.Exit(1)
+    return OrpheusClient(config)
+
+
+@app.command()
+def exec(
+    spec_file: Path = typer.Argument(..., help="Path to spec file"),
+    snapshot: str | None = typer.Option(None, "--snapshot", "-s", help="Base snapshot ID"),
+    repo: str | None = typer.Option(None, "--repo", "-r", help="GitHub repo (owner/repo)"),
+    branch: str | None = typer.Option(None, "--branch", "-b", help="Git branch to checkout"),
+    program: list[str] | None = typer.Option(
+        None, "--program", "-p", help="Program to run. Repeatable. Default: orchestrator_with_review."
+    ),
+    all_programs: bool = typer.Option(False, "--all", help="Run all available programs in parallel"),
+):
+    """Run a SWE agent to implement the given spec."""
+    client = get_authenticated_client()
+
+    if not spec_file.exists():
+        print_error(f"Spec file not found: {spec_file}")
+        raise typer.Exit(1)
+
+    repo_full_name = repo or get_repo_from_cwd()
+    if not repo_full_name:
+        print_error("Could not detect repo. Run from inside a git repo or use --repo flag.")
+        raise typer.Exit(1)
+
+    spec_content = spec_file.read_text()
+
+    # --all sends no filter (server runs every discovered program).
+    # --program sends an explicit list. Default is orchestrator_with_review.
+    if all_programs:
+        selected = None
+    elif program:
+        selected = program
+    else:
+        selected = ["orchestrator_with_review"]
+
+    programs_label = ", ".join(selected) if selected else "all"
+    typer.echo(f"Starting task for: {spec_file.name} (repo: {repo_full_name}, programs: {programs_label})")
+
+    try:
+        data = client.create_task(spec_content, repo_full_name, snapshot, programs=selected, git_branch=branch)
+    except APIError as e:
+        print_error(f"Error: {e}")
+        raise typer.Exit(1)
+
+    task_slug = data["task_slug"]
+    print_success(f"Task created: [bold]{task_slug}[/bold]")
+    console.print(f"  Executions: {', '.join(data['execution_slugs'])}")
+    console.print(f"  Run 'orpheus status {task_slug}' to check progress.")
+
+
+@app.command()
+def programs():
+    """List available programs."""
+    config = get_config()
+
+    if not config.user_access_token:
+        print_error("Not authenticated. Run 'orpheus auth login' first.")
+        raise typer.Exit(1)
+
+    client = OrpheusClient(config)
+
+    try:
+        program_list = client.list_programs()
+    except APIError as e:
+        print_error(f"Error: {e}")
+        raise typer.Exit(1)
+
+    typer.echo("Available programs:")
+    for p in program_list:
+        typer.echo(f"  {p}")
+
+
+@app.command()
+def status(
+    task_slug: str = typer.Argument(..., help="Task slug"),
+):
+    """Check status of a task."""
+    client = get_authenticated_client()
+
+    try:
+        data = client.get_task(task_slug)
+    except NotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+    except APIError as e:
+        print_error(f"Error: {e}")
+        raise typer.Exit(1)
+
+    console.print(f"[bold]Task:[/bold] {data['task_slug']}")
+    console.print(f"[bold]Status:[/bold] {'active' if data['is_active'] else 'stopped'}")
+
+    if data.get("executions"):
+        console.print("[bold]Executions:[/bold]")
+        for ex in data["executions"]:
+            status_color = "green" if ex["status"] == "running" else "yellow" if ex["status"] == "completed" else "red"
+            console.print(f"  [{status_color}]{ex['slug']}[/{status_color}] ({ex['program_name']}) - {ex['status']}")
+            if ex.get("pr_url"):
+                console.print(f"    PR: {ex['pr_url']}")
+            for svc in ex.get("exposed_services", []):
+                console.print(f"    {svc['service_name']} -> {svc['url']}")
+
+
+@app.command()
+def stop(
+    task_slug: str = typer.Argument(..., help="Task slug"),
+):
+    """Stop a task."""
+    client = get_authenticated_client()
+
+    try:
+        data = client.stop_task(task_slug)
+    except NotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+    except APIError as e:
+        print_error(f"Error: {e}")
+        raise typer.Exit(1)
+
+    print_success(f"Task {data['task_slug']} stopped")
+
+
+@app.command()
+def tasks(
+    all_tasks: bool = typer.Option(False, "--all", "-a", help="Include stopped/inactive tasks"),
+):
+    """List all tasks and their executions."""
+    client = get_authenticated_client()
+
+    try:
+        task_list = client.list_tasks(active_only=not all_tasks)
+    except APIError as e:
+        print_error(f"Error: {e}")
+        raise typer.Exit(1)
+
+    if not task_list:
+        typer.echo("No tasks found")
+        return
+
+    for task in task_list:
+        status = "[green]active[/green]" if task["is_active"] else "[dim]stopped[/dim]"
+        console.print(f"\n{status} [bold]{task['slug']}[/bold]")
+        console.print(f"  Created: {task['created_at']}")
+        if task.get("executions"):
+            for ex in task["executions"]:
+                instance = ex.get("root_instance_id") or "no instance"
+                pr = f" → {ex['pr_url']}" if ex.get("pr_url") else ""
+                console.print(f"    [dim]{ex['slug']}[/dim] ({ex['program_name']}) [{ex['status']}] {instance}{pr}")
+
+
+@app.command()
+def apply(
+    execution_slug: str = typer.Argument(..., help="Execution slug"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing files"),
+):
+    """Apply diff from an execution's VM to local repo."""
+    client = get_authenticated_client()
+
+    try:
+        diff = client.get_execution_diff(execution_slug)
+    except NotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+    except APIError as e:
+        print_error(f"Error: {e}")
+        raise typer.Exit(1)
+
+    if not diff.strip():
+        typer.echo("No changes to apply")
+        raise typer.Exit(0)
+
+    typer.echo(diff)
+    typer.echo()
+
+    # Find repo root
+    repo_root_result = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        capture_output=True,
+        text=True,
+    )
+    if repo_root_result.returncode != 0:
+        print_error("Not in a git repository")
+        raise typer.Exit(1)
+    repo_root = repo_root_result.stdout.strip()
+
+    apply_args = ["git", "apply", "-v"]
+    if force:
+        apply_args.append("--reject")
+
+    if not force:
+        result = subprocess.run(
+            ["git", "apply", "--check"],
+            input=diff,
+            text=True,
+            capture_output=True,
+            cwd=repo_root,
+        )
+        if result.returncode != 0:
+            print_error(f"Diff cannot be applied cleanly:\n{result.stderr}")
+            print_error("Use --force to apply anyway")
+            raise typer.Exit(1)
+
+    result = subprocess.run(
+        apply_args,
+        input=diff,
+        text=True,
+        capture_output=True,
+        cwd=repo_root,
+    )
+
+    if result.returncode != 0:
+        print_error(f"Failed to apply diff:\n{result.stderr}")
+        raise typer.Exit(1)
+
+    if result.stderr:
+        typer.echo(result.stderr)
+    print_success("Changes applied")
+
+
+@app.command()
+def download(
+    remote_path: str = typer.Argument(..., help="Remote file path on the VM"),
+    repo: str | None = typer.Option(None, "--repo", "-r", help="Repo full name (devbox target)"),
+    exec_slug: str | None = typer.Option(None, "--exec", "-e", help="Execution slug"),
+    agent: str | None = typer.Option(None, "--agent", "-a", help="Agent name"),
+):
+    """Download a file from a VM to stdout."""
+    client = get_authenticated_client()
+
+    # Auto-detect repo from cwd if no explicit target
+    target_repo = repo
+    if not exec_slug and not target_repo:
+        target_repo = get_repo_from_cwd()
+    if not target_repo and not exec_slug:
+        print_error("Could not detect repo. Use --repo or --exec/--agent.")
+        raise typer.Exit(1)
+
+    try:
+        response = client.download_file(remote_path, repo=target_repo, execution_slug=exec_slug, agent_name=agent)
+    except NotFoundError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+    except APIError as e:
+        print_error(f"Error: {e}")
+        raise typer.Exit(1)
+
+    sys.stdout.buffer.write(response.content)
+
+
+@app.command()
+def upload(
+    local_path: str = typer.Argument(..., help="Local file path (use '-' for stdin)"),
+    remote_path: str = typer.Argument(..., help="Remote file path on the VM"),
+    repo: str | None = typer.Option(None, "--repo", "-r", help="Repo full name (devbox target)"),
+    exec_slug: str | None = typer.Option(None, "--exec", "-e", help="Execution slug"),
+    agent: str | None = typer.Option(None, "--agent", "-a", help="Agent name"),
+):
+    """Upload a file to a VM."""
+    client = get_authenticated_client()
+
+    # Auto-detect repo from cwd if no explicit target
+    target_repo = repo
+    if not exec_slug and not target_repo:
+        target_repo = get_repo_from_cwd()
+    if not target_repo and not exec_slug:
+        print_error("Could not detect repo. Use --repo or --exec/--agent.")
+        raise typer.Exit(1)
+
+    if local_path == "-":
+        content = sys.stdin.buffer.read()
+        file_path = None
+    else:
+        file_path = Path(local_path)
+        if not file_path.exists():
+            print_error(f"File not found: {local_path}")
+            raise typer.Exit(1)
+        content = None
+
+    try:
+        client.upload_file(
+            file_path, remote_path, content=content, repo=target_repo, execution_slug=exec_slug, agent_name=agent
+        )
+    except APIError as e:
+        print_error(f"Error: {e}")
+        raise typer.Exit(1)
+
+    print_success(f"Uploaded to {remote_path}")
+
+
+if __name__ == "__main__":
+    app()

orpheus_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: orpheus-cli
+Version: 0.1.0
+Summary: A command-line interface for orchestrating AI agents
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic-settings>=2.12.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: questionary>=2.1.0
+Requires-Dist: rich>=14.3.2
+Requires-Dist: typer>=0.21.1
+Description-Content-Type: text/markdown
+
+# Orpheus CLI
+
+Command-line interface for Orpheus by [Fulcrum](https://fulcrum.inc/).

orpheus_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+orpheus/__init__.py,sha256=6gffQg-yymrWVJGzkeudaP8-x1FfXcuzwDMRlkND7n4,19
+orpheus/auth.py,sha256=XOVxxHeiIKw-rWmqY5UHn4vVLo7oI5jEAa8_wcpvXzM,2716
+orpheus/client.py,sha256=LUq-4SzBZZoYpmRkb9OpEU0bnZ_jaQa924oHMU665pw,7204
+orpheus/config.py,sha256=3emCR7vcQL86UG5N65glI7R4PL40muJTtbYCCIn3q18,1218
+orpheus/display.py,sha256=02yEQDtgYeMj6ubsLlaeHXEkhd9rdYOX-U9xs5jPgYY,470
+orpheus/git.py,sha256=UspJpa6D-NPymFM5n084csWfidGhUgVeYkDvTimj8XA,1097
+orpheus/main.py,sha256=TYDrTuEbpN8H7VP38BKXMa3vrQ9t1xtTvW2n2QjADpg,10452
+orpheus/commands/auth.py,sha256=aB4BzLSWjkzI41eyhHUw8SnJ-nw-t8hpIzE8Lqp8AyI,2485
+orpheus/commands/setup.py,sha256=0ezDZSjIsZxAc9rfmkmtAE1AG_e-DugOKDleAMjAuj4,4027
+orpheus_cli-0.1.0.dist-info/METADATA,sha256=1XMMhMnRDz13tMg485fbuyQlLnEq29xUY9u8qcbMtyw,461
+orpheus_cli-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+orpheus_cli-0.1.0.dist-info/entry_points.txt,sha256=AJja123jnod7B9XzdO1OM29vTC04ljDJapq1SG_f1r4,45
+orpheus_cli-0.1.0.dist-info/RECORD,,

orpheus_cli-0.1.0.dist-info/WHEEL

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

orpheus_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+orpheus = orpheus.main:app