cua-computer 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

computer/computer.py

@@ -753,7 +753,7 @@ class Computer:
 
 
     # Add virtual environment management functions to computer interface
-    async def venv_install(self, venv_name: str, requirements: list[str]) -> tuple[str, str]:
+    async def venv_install(self, venv_name: str, requirements: list[str]):
         """Install packages in a virtual environment.
         
         Args:
@@ -771,14 +771,14 @@ class Computer:
         
         # Check if venv exists, if not create it
         check_cmd = f"test -d {venv_path} || ({create_cmd})"
-        _, _ = await self.interface.run_command(check_cmd)
+        _ = await self.interface.run_command(check_cmd)
         
         # Install packages
         requirements_str = " ".join(requirements)
         install_cmd = f". {venv_path}/bin/activate && pip install {requirements_str}"
         return await self.interface.run_command(install_cmd)
     
-    async def venv_cmd(self, venv_name: str, command: str) -> tuple[str, str]:
+    async def venv_cmd(self, venv_name: str, command: str):
         """Execute a shell command in a virtual environment.
         
         Args:
@@ -792,9 +792,9 @@ class Computer:
         
         # Check if virtual environment exists
         check_cmd = f"test -d {venv_path}"
-        stdout, stderr = await self.interface.run_command(check_cmd)
+        result = await self.interface.run_command(check_cmd)
         
-        if stderr or "test:" in stdout:  # venv doesn't exist
+        if result.stderr or "test:" in result.stdout:  # venv doesn't exist
             return "", f"Virtual environment '{venv_name}' does not exist. Create it first using venv_install."
         
         # Activate virtual environment and run command
@@ -890,21 +890,21 @@ print(f"<<<VENV_EXEC_START>>>{{output_json}}<<<VENV_EXEC_END>>>")
         
         # Execute the Python code in the virtual environment
         python_command = f"python -c \"import base64; exec(base64.b64decode('{encoded_code}').decode('utf-8'))\""
-        stdout, stderr = await self.venv_cmd(venv_name, python_command)
+        result = await self.venv_cmd(venv_name, python_command)
         
         # Parse the output to extract the payload
         start_marker = "<<<VENV_EXEC_START>>>"
         end_marker = "<<<VENV_EXEC_END>>>"
 
         # Print original stdout
-        print(stdout[:stdout.find(start_marker)])
+        print(result.stdout[:result.stdout.find(start_marker)])
         
-        if start_marker in stdout and end_marker in stdout:
-            start_idx = stdout.find(start_marker) + len(start_marker)
-            end_idx = stdout.find(end_marker)
+        if start_marker in result.stdout and end_marker in result.stdout:
+            start_idx = result.stdout.find(start_marker) + len(start_marker)
+            end_idx = result.stdout.find(end_marker)
             
             if start_idx < end_idx:
-                output_json = stdout[start_idx:end_idx]
+                output_json = result.stdout[start_idx:end_idx]
 
                 try:
                     # Decode and deserialize the output payload from JSON
@@ -923,4 +923,4 @@ print(f"<<<VENV_EXEC_START>>>{{output_json}}<<<VENV_EXEC_END>>>")
                 raise Exception("Invalid output format: markers found but no content between them")
         else:
             # Fallback: return stdout/stderr if no payload markers found
-            raise Exception(f"No output payload found. stdout: {stdout}, stderr: {stderr}")
+            raise Exception(f"No output payload found. stdout: {result.stdout}, stderr: {result.stderr}")

computer/interface/generic.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional, Tuple
 from PIL import Image
 
 import websockets
+import aiohttp
 
 from ..logger import Logger, LogLevel
 from .base import BaseComputerInterface
@@ -57,6 +58,17 @@ class GenericComputerInterface(BaseComputerInterface):
         protocol = "wss" if self.api_key else "ws"
         port = "8443" if self.api_key else "8000"
         return f"{protocol}://{self.ip_address}:{port}/ws"
+    
+    @property
+    def rest_uri(self) -> str:
+        """Get the REST URI using the current IP address.
+        
+        Returns:
+            REST URI for the Computer API Server
+        """
+        protocol = "https" if self.api_key else "http"
+        port = "8443" if self.api_key else "8000"
+        return f"{protocol}://{self.ip_address}:{port}/cmd"
 
     # Mouse actions
     async def mouse_down(self, x: Optional[int] = None, y: Optional[int] = None, button: str = "left", delay: Optional[float] = None) -> None:
@@ -677,7 +689,7 @@ class GenericComputerInterface(BaseComputerInterface):
 
         raise ConnectionError("Failed to establish WebSocket connection after multiple retries")
 
-    async def _send_command(self, command: str, params: Optional[Dict] = None) -> Dict[str, Any]:
+    async def _send_command_ws(self, command: str, params: Optional[Dict] = None) -> Dict[str, Any]:
         """Send command through WebSocket."""
         max_retries = 3
         retry_count = 0
@@ -717,7 +729,151 @@ class GenericComputerInterface(BaseComputerInterface):
 
             raise last_error if last_error else RuntimeError("Failed to send command")
 
+    async def _send_command_rest(self, command: str, params: Optional[Dict] = None) -> Dict[str, Any]:
+        """Send command through REST API without retries or connection management."""
+        try:
+            # Prepare the request payload
+            payload = {"command": command, "params": params or {}}
+            
+            # Prepare headers
+            headers = {"Content-Type": "application/json"}
+            if self.api_key:
+                headers["X-API-Key"] = self.api_key
+            if self.vm_name:
+                headers["X-Container-Name"] = self.vm_name
+            
+            # Send the request
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    self.rest_uri,
+                    json=payload,
+                    headers=headers
+                ) as response:
+                    # Get the response text
+                    response_text = await response.text()
+                    
+                    # Trim whitespace
+                    response_text = response_text.strip()
+                    
+                    # Check if it starts with "data: "
+                    if response_text.startswith("data: "):
+                        # Extract everything after "data: "
+                        json_str = response_text[6:]  # Remove "data: " prefix
+                        try:
+                            return json.loads(json_str)
+                        except json.JSONDecodeError:
+                            return {
+                                "success": False,
+                                "error": "Server returned malformed response",
+                                "message": response_text
+                            }
+                    else:
+                        # Return error response
+                        return {
+                            "success": False,
+                            "error": "Server returned malformed response",
+                            "message": response_text
+                        }
+                        
+        except Exception as e:
+            return {
+                "success": False,
+                "error": "Request failed",
+                "message": str(e)
+            }
+
+    async def _send_command(self, command: str, params: Optional[Dict] = None) -> Dict[str, Any]:
+        """Send command using REST API with WebSocket fallback."""
+        # Try REST API first
+        result = await self._send_command_rest(command, params)
+        
+        # If REST failed with "Request failed", try WebSocket as fallback
+        if not result.get("success", True) and (result.get("error") == "Request failed" or result.get("error") == "Server returned malformed response"):
+            self.logger.debug(f"REST API failed for command '{command}', trying WebSocket fallback")
+            try:
+                return await self._send_command_ws(command, params)
+            except Exception as e:
+                self.logger.debug(f"WebSocket fallback also failed: {e}")
+                # Return the original REST error
+                return result
+        
+        return result
+
     async def wait_for_ready(self, timeout: int = 60, interval: float = 1.0):
+        """Wait for Computer API Server to be ready by testing version command."""
+
+        # Check if REST API is available
+        try:
+            result = await self._send_command_rest("version", {})
+            assert result.get("success", True)
+        except Exception as e:
+            self.logger.debug(f"REST API failed for command 'version', trying WebSocket fallback: {e}")
+            try:
+                await self._wait_for_ready_ws(timeout, interval)
+                return
+            except Exception as e:
+                self.logger.debug(f"WebSocket fallback also failed: {e}")
+                raise e
+
+        start_time = time.time()
+        last_error = None
+        attempt_count = 0
+        progress_interval = 10  # Log progress every 10 seconds
+        last_progress_time = start_time
+
+        try:
+            self.logger.info(
+                f"Waiting for Computer API Server to be ready (timeout: {timeout}s)..."
+            )
+
+            # Wait for the server to respond to get_screen_size command
+            while time.time() - start_time < timeout:
+                try:
+                    attempt_count += 1
+                    current_time = time.time()
+
+                    # Log progress periodically without flooding logs
+                    if current_time - last_progress_time >= progress_interval:
+                        elapsed = current_time - start_time
+                        self.logger.info(
+                            f"Still waiting for Computer API Server... (elapsed: {elapsed:.1f}s, attempts: {attempt_count})"
+                        )
+                        last_progress_time = current_time
+
+                    # Test the server with a simple get_screen_size command
+                    result = await self._send_command("get_screen_size")
+                    if result.get("success", False):
+                        elapsed = time.time() - start_time
+                        self.logger.info(
+                            f"Computer API Server is ready (after {elapsed:.1f}s, {attempt_count} attempts)"
+                        )
+                        return  # Server is ready
+                    else:
+                        last_error = result.get("error", "Unknown error")
+                        self.logger.debug(f"Initial connection command failed: {last_error}")
+
+                except Exception as e:
+                    last_error = e
+                    self.logger.debug(f"Connection attempt {attempt_count} failed: {e}")
+
+                # Wait before trying again
+                await asyncio.sleep(interval)
+
+            # If we get here, we've timed out
+            error_msg = f"Could not connect to {self.ip_address} after {timeout} seconds"
+            if last_error:
+                error_msg += f": {str(last_error)}"
+            self.logger.error(error_msg)
+            raise TimeoutError(error_msg)
+
+        except Exception as e:
+            if isinstance(e, TimeoutError):
+                raise
+            error_msg = f"Error while waiting for server: {str(e)}"
+            self.logger.error(error_msg)
+            raise RuntimeError(error_msg)
+
+    async def _wait_for_ready_ws(self, timeout: int = 60, interval: float = 1.0):
         """Wait for WebSocket connection to become available."""
         start_time = time.time()
         last_error = None
@@ -755,7 +911,7 @@ class GenericComputerInterface(BaseComputerInterface):
                     if self._ws and self._ws.state == websockets.protocol.State.OPEN:
                         # Test the connection with a simple command
                         try:
-                            await self._send_command("get_screen_size")
+                            await self._send_command_ws("get_screen_size")
                             elapsed = time.time() - start_time
                             self.logger.info(
                                 f"Computer API Server is ready (after {elapsed:.1f}s, {attempt_count} attempts)"

{cua_computer-0.3.4.dist-info → cua_computer-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cua-computer
-Version: 0.3.4
+Version: 0.3.5
 Summary: Computer-Use Interface (CUI) framework powering Cua
 Author-Email: TryCua <gh@trycua.com>
 Requires-Python: >=3.11

{cua_computer-0.3.4.dist-info → cua_computer-0.3.5.dist-info}/RECORD

@@ -1,11 +1,11 @@
 computer/__init__.py,sha256=44ZBq815dMihgAHmBKn1S_GFNbElCXyZInh3hle1k9Y,1237
-computer/computer.py,sha256=bHo7pdJoz8p3YSERYvdY7aLYdqYdiXbPVQydirlhwkM,41390
+computer/computer.py,sha256=uwbV0yZHhs5VUuMTGJvEaN8f7Xcr_msSQpufjdpZ2B4,41410
 computer/diorama_computer.py,sha256=jOP7_eXxxU6SMIoE25ni0YXPK0E7p5sZeLKmkYLh6G8,3871
 computer/helpers.py,sha256=iHkO2WhuCLc15g67kfMnpQWxfNRlz2YeJNEvYaL9jlM,1826
 computer/interface/__init__.py,sha256=xQvYjq5PMn9ZJOmRR5mWtONTl_0HVd8ACvW6AQnzDdw,262
 computer/interface/base.py,sha256=1beR4T0z5anb9NaNgKJrMJTF0BFIKyiHlokMLesOV5Q,15131
 computer/interface/factory.py,sha256=Eas5u9sOZ8FegwX51dP9M37oZBjy2EiVcmhTPc98L3Y,1639
-computer/interface/generic.py,sha256=EH9OCSU2PDG-9GAzIZdmzFfCgSAkPs1Pc8xfAQSnFAQ,36296
+computer/interface/generic.py,sha256=LwesmF0NyZ9RWaDKZsXLt7UokQmbTK8sSGLhQ1yfLQU,43056
 computer/interface/linux.py,sha256=fDm2OwqfeeO72HwctboPEE5AwPTo2XBRDyYkwQxMyt0,417
 computer/interface/macos.py,sha256=m1aRn3BCbA95gPoO-WSP9NPwruT4BT5DZzxY10UuBI0,675
 computer/interface/models.py,sha256=kPpmoO-TSxSr95f5ELuTpobY-SckG1Sn9pE8zz1t008,3605
@@ -31,7 +31,7 @@ computer/ui/__main__.py,sha256=Jwy2oC_mGZLN0fX7WLqpjaQkbXMeM3ISrUc8WSRUG0c,284
 computer/ui/gradio/__init__.py,sha256=5_KimixM48-X74FCsLw7LbSt39MQfUMEL8-M9amK3Cw,117
 computer/ui/gradio/app.py,sha256=5_AG2dQR9RtFrGQNonScAw64rlswclKW26tYlFBdXtM,70396
 computer/utils.py,sha256=zY50NXB7r51GNLQ6l7lhG_qv0_ufpQ8n0-SDhCei8m4,2838
-cua_computer-0.3.4.dist-info/METADATA,sha256=QsaQuhlPQwQfEyofCsYtz_otdH0cjJrfmtxF5mlRTsE,5802
-cua_computer-0.3.4.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-cua_computer-0.3.4.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-cua_computer-0.3.4.dist-info/RECORD,,
+cua_computer-0.3.5.dist-info/METADATA,sha256=YXTgZWO99OCJTusRXd8R-UFpJjoFVgEB-eskOasojvM,5802
+cua_computer-0.3.5.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+cua_computer-0.3.5.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+cua_computer-0.3.5.dist-info/RECORD,,