wafer-cli 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

wafer/workspaces.py

@@ -13,15 +13,7 @@ import httpx
 from .api_client import get_api_url
 from .auth import get_auth_headers
 
-
-@dataclass(frozen=True)
-class SSHCredentials:
-    """SSH credentials for workspace access."""
-
-    host: str
-    port: int
-    user: str
-    key_path: Path
+VALID_STATUSES = {"creating", "running"}
 
 
 def _get_client() -> tuple[str, dict[str, str]]:
@@ -72,10 +64,11 @@ def _friendly_error(status_code: int, response_text: str, workspace_id: str) ->
 
     # Parse common error details from response
     detail = ""
-    if "stopped" in response_text.lower():
+    if "not running" in response_text.lower() or "not found" in response_text.lower():
         return (
-            f"Workspace '{workspace_id}' is stopped.\n"
-            "  Attach to start it: wafer workspaces attach " + workspace_id
+            f"Workspace '{workspace_id}' not found or not running.\n"
+            "  Check status: wafer workspaces list\n"
+            "  Create new:   wafer workspaces create <name>"
         )
 
     if "timeout" in response_text.lower():
@@ -85,6 +78,12 @@ def _friendly_error(status_code: int, response_text: str, workspace_id: str) ->
             "  Or set default: wafer config set defaults.exec_timeout 600"
         )
 
+    if "creating" in response_text.lower():
+        return (
+            f"Workspace '{workspace_id}' is still creating.\n"
+            "  Check status: wafer workspaces list"
+        )
+
     # Generic error with response detail
     try:
         import json
@@ -114,6 +113,14 @@ def _list_workspaces_raw() -> list[dict]:
         raise RuntimeError(f"Could not reach API: {e}") from e
 
     assert isinstance(workspaces, list), "API must return a list of workspaces"
+    
+    for ws in workspaces:
+        status = ws.get("status", "unknown")
+        assert status in VALID_STATUSES or status == "unknown", (
+            f"Workspace {ws.get('id', 'unknown')} has invalid status '{status}'. "
+            f"Valid statuses: {VALID_STATUSES}"
+        )
+    
     return workspaces
 
 
@@ -186,9 +193,15 @@ def list_workspaces(json_output: bool = False) -> str:
     except httpx.RequestError as e:
         raise RuntimeError(f"Could not reach API: {e}") from e
 
-    # Validate API response shape
     assert isinstance(workspaces, list), "API must return a list of workspaces"
 
+    for ws in workspaces:
+        status = ws.get("status", "unknown")
+        assert status in VALID_STATUSES or status == "unknown", (
+            f"Workspace {ws.get('id', 'unknown')} has invalid status '{status}'. "
+            f"Valid statuses: {VALID_STATUSES}"
+        )
+
     if json_output:
         return json.dumps(workspaces, indent=2)
 
@@ -198,10 +211,14 @@ def list_workspaces(json_output: bool = False) -> str:
     lines = ["Workspaces:", ""]
     for ws in workspaces:
         status = ws.get("status", "unknown")
-        status_icon = {"running": "●", "stopped": "○", "queued": "◐"}.get(status, "?")
+        status_icon = {"running": "●", "creating": "◐"}.get(status, "?")
         lines.append(f"  {status_icon} {ws['name']} ({ws['id']})")
         lines.append(f"    GPU: {ws.get('gpu_type', 'N/A')} | Image: {ws.get('image', 'N/A')}")
         lines.append(f"    Status: {status} | Created: {ws.get('created_at', 'N/A')}")
+        if status == "running" and ws.get("ssh_host") and ws.get("ssh_port") and ws.get("ssh_user"):
+            lines.append(
+                f"    SSH: ssh -p {ws['ssh_port']} {ws['ssh_user']}@{ws['ssh_host']}"
+            )
         lines.append("")
 
     return "\n".join(lines)
@@ -211,6 +228,7 @@ def create_workspace(
     name: str,
     gpu_type: str = "B200",
     image: str | None = None,
+    wait: bool = False,
     json_output: bool = False,
 ) -> str:
     """Create a new workspace.
@@ -219,6 +237,7 @@ def create_workspace(
         name: Workspace name (must be unique)
         gpu_type: GPU type (default: B200)
         image: Docker image (optional, uses default if not specified)
+        wait: If True, stream provisioning progress and return SSH credentials
         json_output: If True, return raw JSON; otherwise return formatted text
 
     Returns:
@@ -276,190 +295,114 @@ def create_workspace(
     assert "id" in workspace, "API response must contain workspace id"
     assert "name" in workspace, "API response must contain workspace name"
 
+    if wait:
+        ssh_info = _wait_for_provisioning(workspace["id"])
+        if json_output:
+            payload = {
+                "workspace_id": workspace["id"],
+                "ssh_host": ssh_info["ssh_host"],
+                "ssh_port": ssh_info["ssh_port"],
+                "ssh_user": ssh_info["ssh_user"],
+            }
+            return json.dumps(payload, indent=2)
+        return (
+            f"Workspace ready: {workspace['name']} ({workspace['id']})\n"
+            f"SSH: ssh -p {ssh_info['ssh_port']} {ssh_info['ssh_user']}@{ssh_info['ssh_host']}"
+        )
+
     if json_output:
         return json.dumps(workspace, indent=2)
 
-    return f"Created workspace: {workspace['name']} ({workspace['id']})"
-
+    return (
+        f"Creating workspace: {workspace['name']} ({workspace['id']})\n"
+        "Check status with: wafer workspaces list\n"
+        "Estimated time: ~30 seconds"
+    )
 
-def delete_workspace(workspace_id: str, json_output: bool = False) -> str:
-    """Delete a workspace.
 
-    Args:
-        workspace_id: Workspace ID to delete
-        json_output: If True, return raw JSON; otherwise return formatted text
+def _wait_for_provisioning(workspace_id: str) -> dict[str, str | int]:
+    """Wait for workspace provisioning to complete via SSE."""
+    import sys
 
-    Returns:
-        Deletion status as string
-    """
     assert workspace_id, "Workspace ID must be non-empty"
-
     api_url, headers = _get_client()
 
     try:
-        with httpx.Client(timeout=30.0, headers=headers) as client:
-            response = client.delete(f"{api_url}/v1/workspaces/{workspace_id}")
-            response.raise_for_status()
-            result = response.json()
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 401:
-            raise RuntimeError("Not authenticated. Run: wafer login") from e
-        if e.response.status_code == 404:
-            raise RuntimeError(f"Workspace not found: {workspace_id}") from e
-        raise RuntimeError(f"API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.RequestError as e:
-        raise RuntimeError(f"Could not reach API: {e}") from e
+        with httpx.Client(timeout=None, headers=headers) as client:
+            with client.stream(
+                "POST",
+                f"{api_url}/v1/workspaces/{workspace_id}/provision-stream",
+            ) as response:
+                if response.status_code != 200:
+                    error_body = response.read().decode("utf-8", errors="replace")
+                    raise RuntimeError(
+                        _friendly_error(response.status_code, error_body, workspace_id)
+                    )
 
-    if json_output:
-        return json.dumps(result, indent=2)
+                ssh_info: dict[str, str | int] | None = None
+                for line in response.iter_lines():
+                    if not line or not line.startswith("data: "):
+                        continue
+                    content = line[6:]
+                    if content.startswith("[STATUS:"):
+                        status = content[8:-1]
+                        print(f"[wafer] {status.lower()}...", file=sys.stderr)
+                        if status == "ERROR":
+                            raise RuntimeError(
+                                "Workspace provisioning failed. Check status with: wafer workspaces list"
+                            )
+                    elif content.startswith("[SSH:"):
+                        parts = content[5:-1].split(":")
+                        if len(parts) != 3:
+                            raise RuntimeError("Malformed SSH info in provisioning stream")
+                        ssh_info = {
+                            "ssh_host": parts[0],
+                            "ssh_port": int(parts[1]),
+                            "ssh_user": parts[2],
+                        }
+                        break
 
-    return f"Deleted workspace: {workspace_id}"
+                if ssh_info is None:
+                    raise RuntimeError("Provisioning did not return SSH credentials")
+                return ssh_info
+    except httpx.RequestError as e:
+        raise RuntimeError(f"Could not reach API: {e}") from e
 
 
-def attach_workspace(workspace_id: str, json_output: bool = False) -> str:
-    """Attach to a workspace (get SSH credentials).
+def delete_workspace(workspace_id: str, json_output: bool = False) -> str:
+    """Delete a workspace.
 
     Args:
-        workspace_id: Workspace ID to attach to
+        workspace_id: Workspace ID to delete
         json_output: If True, return raw JSON; otherwise return formatted text
 
     Returns:
-        SSH connection info as string
+        Deletion status as string
     """
     assert workspace_id, "Workspace ID must be non-empty"
 
     api_url, headers = _get_client()
 
     try:
-        with httpx.Client(timeout=120.0, headers=headers) as client:
-            response = client.post(f"{api_url}/v1/workspaces/{workspace_id}/attach")
+        with httpx.Client(timeout=30.0, headers=headers) as client:
+            response = client.delete(f"{api_url}/v1/workspaces/{workspace_id}")
             response.raise_for_status()
-            attach_info = response.json()
+            result = response.json()
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 401:
             raise RuntimeError("Not authenticated. Run: wafer login") from e
         if e.response.status_code == 404:
             raise RuntimeError(f"Workspace not found: {workspace_id}") from e
-        if e.response.status_code == 503:
-            raise RuntimeError("No GPU available. Please try again later.") from e
         raise RuntimeError(f"API error: {e.response.status_code} - {e.response.text}") from e
     except httpx.RequestError as e:
         raise RuntimeError(f"Could not reach API: {e}") from e
 
-    # Validate API response has required SSH fields
-    assert "ssh_host" in attach_info, "API response must contain ssh_host"
-    assert "ssh_port" in attach_info, "API response must contain ssh_port"
-    assert "ssh_user" in attach_info, "API response must contain ssh_user"
-    assert "private_key_pem" in attach_info, "API response must contain private_key_pem"
-
     if json_output:
-        return json.dumps(attach_info, indent=2)
-
-    # Write private key to temp file and generate SSH config
-    ssh_host = attach_info["ssh_host"]
-    ssh_port = attach_info["ssh_port"]
-    ssh_user = attach_info["ssh_user"]
-    private_key = attach_info["private_key_pem"]
-
-    # Validate field values before using them
-    assert ssh_host, "ssh_host must be non-empty"
-    assert isinstance(ssh_port, int), "ssh_port must be an integer"
-    assert ssh_port > 0, "ssh_port must be positive"
-    assert ssh_user, "ssh_user must be non-empty"
-    assert private_key, "private_key_pem must be non-empty"
-
-    # Save private key
-    key_dir = Path.home() / ".wafer" / "keys"
-    key_dir.mkdir(parents=True, exist_ok=True)
-    key_path = key_dir / f"{workspace_id}.pem"
-    key_path.write_text(private_key)
-    key_path.chmod(0o600)
-
-    # Generate SSH config entry
-    config_entry = f"""
-# Wafer workspace: {workspace_id}
-Host wafer-{workspace_id}
-    HostName {ssh_host}
-    Port {ssh_port}
-    User {ssh_user}
-    IdentityFile {key_path}
-    StrictHostKeyChecking no
-    UserKnownHostsFile /dev/null
-"""
-
-    lines = [
-        f"Attached to workspace: {workspace_id}",
-        "",
-        "SSH Connection:",
-        f"  ssh -i {key_path} -p {ssh_port} {ssh_user}@{ssh_host}",
-        "",
-        "Or add to ~/.ssh/config:",
-        config_entry,
-        f"Then connect with: ssh wafer-{workspace_id}",
-    ]
-
-    return "\n".join(lines)
-
-
-def get_ssh_credentials(workspace_id: str) -> tuple[SSHCredentials, str]:
-    """Get SSH credentials for a workspace.
-
-    Calls attach API, saves key file, returns credentials for SSH.
+        return json.dumps(result, indent=2)
 
-    Args:
-        workspace_id: Workspace ID or name
+    return f"Deleted workspace: {workspace_id}"
 
-    Returns:
-        Tuple of (SSHCredentials, resolved_workspace_id)
 
-    Raises:
-        RuntimeError: If attach fails
-    """
-    assert workspace_id, "Workspace ID must be non-empty"
-
-    api_url, headers = _get_client()
-
-    try:
-        with httpx.Client(timeout=120.0, headers=headers) as client:
-            response = client.post(f"{api_url}/v1/workspaces/{workspace_id}/attach")
-            response.raise_for_status()
-            attach_info = response.json()
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 401:
-            raise RuntimeError("Not authenticated. Run: wafer login") from e
-        if e.response.status_code == 404:
-            raise RuntimeError(f"Workspace not found: {workspace_id}") from e
-        if e.response.status_code == 503:
-            raise RuntimeError("No GPU available. Please try again later.") from e
-        raise RuntimeError(f"API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.RequestError as e:
-        raise RuntimeError(f"Could not reach API: {e}") from e
-
-    # Validate and extract fields
-    resolved_id = attach_info.get("workspace_id", workspace_id)
-    ssh_host = attach_info.get("ssh_host")
-    ssh_port = attach_info.get("ssh_port")
-    ssh_user = attach_info.get("ssh_user")
-    private_key = attach_info.get("private_key_pem")
-
-    assert ssh_host, "API response must contain ssh_host"
-    assert isinstance(ssh_port, int) and ssh_port > 0, "ssh_port must be positive integer"
-    assert ssh_user, "API response must contain ssh_user"
-    assert private_key, "API response must contain private_key_pem"
-
-    # Save private key using resolved ID
-    key_dir = Path.home() / ".wafer" / "keys"
-    key_dir.mkdir(parents=True, exist_ok=True)
-    key_path = key_dir / f"{resolved_id}.pem"
-    key_path.write_text(private_key)
-    key_path.chmod(0o600)
-
-    return SSHCredentials(
-        host=ssh_host,
-        port=ssh_port,
-        user=ssh_user,
-        key_path=key_path,
-    ), resolved_id
 
 
 def sync_files(
@@ -492,9 +435,23 @@ def sync_files(
     assert workspace_id, "Workspace ID must be non-empty"
     assert local_path.exists(), f"Path not found: {local_path}"
 
-    # Get SSH credentials (also wakes up workspace if needed)
-    # resolved_id is the UUID, workspace_id might be a name
-    creds, resolved_id = get_ssh_credentials(workspace_id)
+    ws = get_workspace_raw(workspace_id)
+    resolved_id = ws["id"]
+    workspace_status = ws.get("status")
+    assert workspace_status in VALID_STATUSES, (
+        f"Workspace {workspace_id} has invalid status '{workspace_status}'. "
+        f"Valid statuses: {VALID_STATUSES}"
+    )
+    if workspace_status != "running":
+        raise RuntimeError(
+            f"Workspace is {workspace_status}. Wait for it to be running before syncing."
+        )
+    ssh_host = ws.get("ssh_host")
+    ssh_port = ws.get("ssh_port")
+    ssh_user = ws.get("ssh_user")
+    assert ssh_host, "Workspace missing ssh_host"
+    assert isinstance(ssh_port, int) and ssh_port > 0, "Workspace missing valid ssh_port"
+    assert ssh_user, "Workspace missing ssh_user"
 
     # Build rsync command
     # -a: archive mode (preserves permissions, etc.)
@@ -507,13 +464,17 @@ def sync_files(
         # Single file: sync the file itself
         source = str(local_path)
 
+    # Build SSH command for rsync
+    # If key_path is None (BYOK model), SSH will use default key from ~/.ssh/
+    ssh_opts = f"-p {ssh_port} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
+    
     rsync_cmd = [
         "rsync",
         "-avz",
         "-e",
-        f"ssh -i {creds.key_path} -p {creds.port} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null",
+        f"ssh {ssh_opts}",
         source,
-        f"{creds.user}@{creds.host}:/workspace/",
+        f"{ssh_user}@{ssh_host}:/workspace/",
     ]
 
     try:
@@ -589,16 +550,8 @@ def _init_sync_state(workspace_id: str) -> str | None:
         return None
 
 
-def get_workspace(workspace_id: str, json_output: bool = False) -> str:
-    """Get details of a specific workspace.
-
-    Args:
-        workspace_id: Workspace ID to get
-        json_output: If True, return raw JSON; otherwise return formatted text
-
-    Returns:
-        Workspace details as string
-    """
+def get_workspace_raw(workspace_id: str) -> dict:
+    """Get workspace details as raw JSON dict."""
     assert workspace_id, "Workspace ID must be non-empty"
 
     api_url, headers = _get_client()
@@ -617,9 +570,29 @@ def get_workspace(workspace_id: str, json_output: bool = False) -> str:
     except httpx.RequestError as e:
         raise RuntimeError(f"Could not reach API: {e}") from e
 
-    # Validate API response has required fields
     assert "id" in workspace, "API response must contain workspace id"
     assert "name" in workspace, "API response must contain workspace name"
+    
+    status = workspace.get("status", "unknown")
+    assert status in VALID_STATUSES or status == "unknown", (
+        f"Workspace {workspace['id']} has invalid status '{status}'. "
+        f"Valid statuses: {VALID_STATUSES}"
+    )
+    
+    return workspace
+
+
+def get_workspace(workspace_id: str, json_output: bool = False) -> str:
+    """Get details of a specific workspace.
+
+    Args:
+        workspace_id: Workspace ID to get
+        json_output: If True, return raw JSON; otherwise return formatted text
+
+    Returns:
+        Workspace details as string
+    """
+    workspace = get_workspace_raw(workspace_id)
 
     if json_output:
         return json.dumps(workspace, indent=2)
@@ -643,15 +616,39 @@ def get_workspace(workspace_id: str, json_output: bool = False) -> str:
             f"  Port: {workspace.get('ssh_port', 22)}",
             f"  User: {workspace.get('ssh_user', 'root')}",
         ])
-    elif status in ("stopped", "created"):
-        lines.extend([
-            "",
-            "SSH: Run 'wafer workspaces attach' to get SSH credentials",
-        ])
+    elif status == "creating":
+        lines.extend(["", "SSH: available once workspace is running"])
 
     return "\n".join(lines)
 
 
+def _handle_sync_event(sync_type: str) -> None:
+    """Handle sync events and print status to stderr.
+
+    Sync events:
+    - FORWARD:START - Starting workspace → GPU sync
+    - FORWARD:DONE:N - Synced N files to GPU
+    - FORWARD:WARN:msg - Warning during forward sync
+    - REVERSE:START - Starting GPU → workspace sync
+    - REVERSE:DONE:N - Synced N artifacts back
+    """
+    import sys
+
+    if sync_type == "FORWARD:START":
+        print("[sync] Syncing workspace → GPU...", end="", file=sys.stderr, flush=True)
+    elif sync_type.startswith("FORWARD:DONE:"):
+        count = sync_type.split(":")[-1]
+        print(f" done ({count} files)", file=sys.stderr)
+    elif sync_type.startswith("FORWARD:WARN:"):
+        msg = sync_type[13:]  # Remove "FORWARD:WARN:"
+        print(f" warning: {msg}", file=sys.stderr)
+    elif sync_type == "REVERSE:START":
+        print("[sync] Syncing artifacts back...", end="", file=sys.stderr, flush=True)
+    elif sync_type.startswith("REVERSE:DONE:"):
+        count = sync_type.split(":")[-1]
+        print(f" done ({count} files)", file=sys.stderr)
+
+
 @dataclass(frozen=True)
 class SSEEvent:
     """Parsed SSE event result."""
@@ -659,6 +656,7 @@ class SSEEvent:
     output: str | None  # Content to print (None = no output)
     exit_code: int | None  # Exit code if stream should end (None = continue)
     is_error: bool  # Whether output goes to stderr
+    sync_event: str | None = None  # Sync event type (e.g., "FORWARD:START")
 
 
 def _parse_sse_content(content: str) -> SSEEvent:
@@ -680,6 +678,16 @@ def _parse_sse_content(content: str) -> SSEEvent:
     if content.startswith("[ERROR]"):
         return SSEEvent(output=content[8:], exit_code=1, is_error=True)
 
+    # Sync events: [SYNC:FORWARD:START], [SYNC:FORWARD:DONE:5], etc.
+    if content.startswith("[SYNC:"):
+        # Extract sync type (e.g., "FORWARD:START" or "REVERSE:DONE:5")
+        sync_type = content[6:-1]  # Remove [SYNC: and ]
+        return SSEEvent(output=None, exit_code=None, is_error=False, sync_event=sync_type)
+
+    # Status events we can ignore (already handled elsewhere)
+    if content.startswith("[STATUS:") or content.startswith("[CONTEXT:"):
+        return SSEEvent(output=None, exit_code=None, is_error=False)
+
     # Regular output
     return SSEEvent(output=content, exit_code=None, is_error=False)
 
@@ -688,13 +696,16 @@ def exec_command(
     workspace_id: str,
     command: str,
     timeout_seconds: int | None = None,
+    routing: str | None = None,
+    pull_image: bool = False,
 ) -> int:
-    """Execute a command in workspace with GPU routing, streaming output.
+    """Execute a command in workspace, streaming output.
 
     Args:
         workspace_id: Workspace ID or name
         command: Command to execute
         timeout_seconds: Execution timeout (default: 300, from config)
+        routing: Routing hint - "auto", "gpu", "cpu", or "baremetal" (default: auto)
 
     Returns:
         Exit code (0 = success, non-zero = failure)
@@ -710,10 +721,14 @@ def exec_command(
     # Base64 encode command to avoid escaping issues
     command_b64 = base64.b64encode(command.encode("utf-8")).decode("utf-8")
 
-    request_body: dict = {"command_b64": command_b64}
+    request_body: dict = {"command_b64": command_b64, "pull_image": pull_image}
     if timeout_seconds:
         request_body["timeout_seconds"] = timeout_seconds
 
+    # Add routing hint if specified
+    if routing:
+        request_body["requirements"] = {"routing": routing}
+
     try:
         # Use streaming request for SSE output
         with httpx.Client(timeout=None, headers=headers) as client:
@@ -736,6 +751,11 @@ def exec_command(
 
                     event = _parse_sse_content(line[6:])
 
+                    # Handle sync events - display status to stderr
+                    if event.sync_event:
+                        _handle_sync_event(event.sync_event)
+                        continue
+
                     if event.output is not None:
                         print(event.output, file=sys.stderr if event.is_error else sys.stdout)
 
@@ -751,3 +771,83 @@ def exec_command(
         ) from e
     except httpx.RequestError as e:
         raise RuntimeError(f"Could not reach API: {e}") from e
+
+
+def exec_command_capture(
+    workspace_id: str,
+    command: str,
+    timeout_seconds: int | None = None,
+    routing: str | None = None,
+    pull_image: bool = False,
+) -> tuple[int, str]:
+    """Execute a command in workspace and capture output.
+
+    Similar to exec_command but returns output as string instead of printing.
+
+    Args:
+        workspace_id: Workspace ID or name
+        command: Command to execute
+        timeout_seconds: Execution timeout (default: 300)
+        routing: Routing hint - "auto", "gpu", "cpu", or "baremetal"
+
+    Returns:
+        Tuple of (exit_code, output_string)
+    """
+    import base64
+
+    assert workspace_id, "Workspace ID must be non-empty"
+    assert command, "Command must be non-empty"
+
+    api_url, headers = _get_client()
+
+    # Base64 encode command to avoid escaping issues
+    command_b64 = base64.b64encode(command.encode("utf-8")).decode("utf-8")
+
+    request_body: dict = {"command_b64": command_b64, "pull_image": pull_image}
+    if timeout_seconds:
+        request_body["timeout_seconds"] = timeout_seconds
+
+    if routing:
+        request_body["requirements"] = {"routing": routing}
+
+    output_lines: list[str] = []
+
+    try:
+        with httpx.Client(timeout=None, headers=headers) as client:
+            with client.stream(
+                "POST",
+                f"{api_url}/v1/workspaces/{workspace_id}/exec",
+                json=request_body,
+            ) as response:
+                if response.status_code != 200:
+                    error_body = response.read().decode("utf-8", errors="replace")
+                    raise RuntimeError(
+                        _friendly_error(response.status_code, error_body, workspace_id)
+                    )
+
+                exit_code = 0
+                for line in response.iter_lines():
+                    if not line or not line.startswith("data: "):
+                        continue
+
+                    event = _parse_sse_content(line[6:])
+
+                    # Skip sync events
+                    if event.sync_event:
+                        continue
+
+                    if event.output is not None:
+                        output_lines.append(event.output)
+
+                    if event.exit_code is not None:
+                        exit_code = event.exit_code
+                        break
+
+                return exit_code, "\n".join(output_lines)
+
+    except httpx.HTTPStatusError as e:
+        raise RuntimeError(
+            _friendly_error(e.response.status_code, e.response.text, workspace_id)
+        ) from e
+    except httpx.RequestError as e:
+        raise RuntimeError(f"Could not reach API: {e}") from e

{wafer_cli-0.2.8.dist-info → wafer_cli-0.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-cli
-Version: 0.2.8
+Version: 0.2.10
 Summary: CLI tool for running commands on remote GPUs and GPU kernel optimization agent
 Requires-Python: >=3.11
 Requires-Dist: typer>=0.12.0