cua-computer 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

computer/computer.py

@@ -38,7 +38,8 @@ class Computer:
         noVNC_port: Optional[int] = 8006,
         host: str = os.environ.get("PYLUME_HOST", "localhost"),
         storage: Optional[str] = None,
-        ephemeral: bool = False
+        ephemeral: bool = False,
+        api_key: Optional[str] = None
     ):
         """Initialize a new Computer instance.
 
@@ -77,6 +78,8 @@ class Computer:
         self.os_type = os_type
         self.provider_type = provider_type
         self.ephemeral = ephemeral
+        
+        self.api_key = api_key
 
         # The default is currently to use non-ephemeral storage
         if storage and ephemeral and storage != "ephemeral":
@@ -256,9 +259,7 @@ class Computer:
                             elif self.provider_type == VMProviderType.CLOUD:
                                 self.config.vm_provider = VMProviderFactory.create_provider(
                                     self.provider_type,
-                                    port=port,
-                                    host=host,
-                                    storage=storage,
+                                    api_key=self.api_key,
                                     verbose=verbose,
                                 )
                             else:
@@ -392,12 +393,25 @@ class Computer:
             self.logger.info(f"Initializing interface for {self.os_type} at {ip_address}")
             from .interface.base import BaseComputerInterface
 
-            self._interface = cast(
-                BaseComputerInterface,
-                InterfaceFactory.create_interface_for_os(
-                    os=self.os_type, ip_address=ip_address  # type: ignore[arg-type]
-                ),
-            )
+            # Pass authentication credentials if using cloud provider
+            if self.provider_type == VMProviderType.CLOUD and self.api_key and self.config.name:
+                self._interface = cast(
+                    BaseComputerInterface,
+                    InterfaceFactory.create_interface_for_os(
+                        os=self.os_type, 
+                        ip_address=ip_address,
+                        api_key=self.api_key,
+                        vm_name=self.config.name
+                    ),
+                )
+            else:
+                self._interface = cast(
+                    BaseComputerInterface,
+                    InterfaceFactory.create_interface_for_os(
+                        os=self.os_type, 
+                        ip_address=ip_address
+                    ),
+                )
 
             # Wait for the WebSocket interface to be ready
             self.logger.info("Connecting to WebSocket interface...")
@@ -492,6 +506,11 @@ class Computer:
         
         # Call the provider's get_ip method which will wait indefinitely
         storage_param = "ephemeral" if self.ephemeral else self.storage
+        
+        # Log the image being used
+        self.logger.info(f"Running VM using image: {self.image}")
+        
+        # Call provider.get_ip with explicit image parameter
         ip = await self.config.vm_provider.get_ip(
             name=self.config.name,
             storage=storage_param,

computer/interface/base.py

@@ -8,17 +8,21 @@ from ..logger import Logger, LogLevel
 class BaseComputerInterface(ABC):
     """Base class for computer control interfaces."""
 
-    def __init__(self, ip_address: str, username: str = "lume", password: str = "lume"):
+    def __init__(self, ip_address: str, username: str = "lume", password: str = "lume", api_key: Optional[str] = None, vm_name: Optional[str] = None):
         """Initialize interface.
 
         Args:
             ip_address: IP address of the computer to control
             username: Username for authentication
             password: Password for authentication
+            api_key: Optional API key for cloud authentication
+            vm_name: Optional VM name for cloud authentication
         """
         self.ip_address = ip_address
         self.username = username
         self.password = password
+        self.api_key = api_key
+        self.vm_name = vm_name
         self.logger = Logger("cua.interface", LogLevel.NORMAL)
 
     @abstractmethod

computer/interface/factory.py

@@ -1,6 +1,6 @@
 """Factory for creating computer interfaces."""
 
-from typing import Literal
+from typing import Literal, Optional
 from .base import BaseComputerInterface
 
 class InterfaceFactory:
@@ -9,13 +9,17 @@ class InterfaceFactory:
     @staticmethod
     def create_interface_for_os(
         os: Literal['macos', 'linux'],
-        ip_address: str
+        ip_address: str,
+        api_key: Optional[str] = None,
+        vm_name: Optional[str] = None
     ) -> BaseComputerInterface:
         """Create an interface for the specified OS.
         
         Args:
             os: Operating system type ('macos' or 'linux')
             ip_address: IP address of the computer to control
+            api_key: Optional API key for cloud authentication
+            vm_name: Optional VM name for cloud authentication
             
         Returns:
             BaseComputerInterface: The appropriate interface for the OS
@@ -28,8 +32,8 @@ class InterfaceFactory:
         from .linux import LinuxComputerInterface
         
         if os == 'macos':
-            return MacOSComputerInterface(ip_address)
+            return MacOSComputerInterface(ip_address, api_key=api_key, vm_name=vm_name)
         elif os == 'linux':
-            return LinuxComputerInterface(ip_address)
+            return LinuxComputerInterface(ip_address, api_key=api_key, vm_name=vm_name)
         else:
             raise ValueError(f"Unsupported OS type: {os}")

computer/interface/linux.py

@@ -15,8 +15,8 @@ from .models import Key, KeyType
 class LinuxComputerInterface(BaseComputerInterface):
     """Interface for Linux."""
 
-    def __init__(self, ip_address: str, username: str = "lume", password: str = "lume"):
-        super().__init__(ip_address, username, password)
+    def __init__(self, ip_address: str, username: str = "lume", password: str = "lume", api_key: Optional[str] = None, vm_name: Optional[str] = None):
+        super().__init__(ip_address, username, password, api_key, vm_name)
         self._ws = None
         self._reconnect_task = None
         self._closed = False
@@ -37,7 +37,9 @@ class LinuxComputerInterface(BaseComputerInterface):
         Returns:
             WebSocket URI for the Computer API Server
         """
-        return f"ws://{self.ip_address}:8000/ws"
+        protocol = "wss" if self.api_key else "ws"
+        port = "8443" if self.api_key else "8000"
+        return f"{protocol}://{self.ip_address}:{port}/ws" 
 
     async def _keep_alive(self):
         """Keep the WebSocket connection alive with automatic reconnection."""
@@ -86,6 +88,32 @@ class LinuxComputerInterface(BaseComputerInterface):
                             timeout=30,
                         )
                         self.logger.info("WebSocket connection established")
+                        
+                        # If api_key and vm_name are provided, perform authentication handshake
+                        if self.api_key and self.vm_name:
+                            self.logger.info("Performing authentication handshake...")
+                            auth_message = {
+                                "command": "authenticate",
+                                "params": {
+                                    "api_key": self.api_key,
+                                    "container_name": self.vm_name
+                                }
+                            }
+                            await self._ws.send(json.dumps(auth_message))
+                            
+                            # Wait for authentication response
+                            auth_response = await asyncio.wait_for(self._ws.recv(), timeout=10)
+                            auth_result = json.loads(auth_response)
+                            
+                            if not auth_result.get("success"):
+                                error_msg = auth_result.get("error", "Authentication failed")
+                                self.logger.error(f"Authentication failed: {error_msg}")
+                                await self._ws.close()
+                                self._ws = None
+                                raise ConnectionError(f"Authentication failed: {error_msg}")
+                            
+                            self.logger.info("Authentication successful")
+                        
                         self._reconnect_delay = 1  # Reset reconnect delay on successful connection
                         self._last_ping = time.time()
                         retry_count = 0  # Reset retry count on successful connection

computer/interface/macos.py

@@ -13,10 +13,10 @@ from .models import Key, KeyType
 
 
 class MacOSComputerInterface(BaseComputerInterface):
-    """Interface for MacOS."""
+    """Interface for macOS."""
 
-    def __init__(self, ip_address: str, username: str = "lume", password: str = "lume"):
-        super().__init__(ip_address, username, password)
+    def __init__(self, ip_address: str, username: str = "lume", password: str = "lume", api_key: Optional[str] = None, vm_name: Optional[str] = None):
+        super().__init__(ip_address, username, password, api_key, vm_name)
         self._ws = None
         self._reconnect_task = None
         self._closed = False
@@ -27,7 +27,7 @@ class MacOSComputerInterface(BaseComputerInterface):
         self._max_reconnect_delay = 30  # Maximum delay between reconnection attempts
         self._log_connection_attempts = True  # Flag to control connection attempt logging
 
-        # Set logger name for MacOS interface
+        # Set logger name for macOS interface
         self.logger = Logger("cua.interface.macos", LogLevel.NORMAL)
 
     @property
@@ -37,7 +37,9 @@ class MacOSComputerInterface(BaseComputerInterface):
         Returns:
             WebSocket URI for the Computer API Server
         """
-        return f"ws://{self.ip_address}:8000/ws"
+        protocol = "wss" if self.api_key else "ws"
+        port = "8443" if self.api_key else "8000"
+        return f"{protocol}://{self.ip_address}:{port}/ws" 
 
     async def _keep_alive(self):
         """Keep the WebSocket connection alive with automatic reconnection."""
@@ -86,6 +88,32 @@ class MacOSComputerInterface(BaseComputerInterface):
                             timeout=30,
                         )
                         self.logger.info("WebSocket connection established")
+                        
+                        # If api_key and vm_name are provided, perform authentication handshake
+                        if self.api_key and self.vm_name:
+                            self.logger.info("Performing authentication handshake...")
+                            auth_message = {
+                                "command": "authenticate",
+                                "params": {
+                                    "api_key": self.api_key,
+                                    "container_name": self.vm_name
+                                }
+                            }
+                            await self._ws.send(json.dumps(auth_message))
+                            
+                            # Wait for authentication response
+                            auth_response = await asyncio.wait_for(self._ws.recv(), timeout=10)
+                            auth_result = json.loads(auth_response)
+                            
+                            if not auth_result.get("success"):
+                                error_msg = auth_result.get("error", "Authentication failed")
+                                self.logger.error(f"Authentication failed: {error_msg}")
+                                await self._ws.close()
+                                self._ws = None
+                                raise ConnectionError(f"Authentication failed: {error_msg}")
+                            
+                            self.logger.info("Authentication successful")
+                        
                         self._reconnect_delay = 1  # Reset reconnect delay on successful connection
                         self._last_ping = time.time()
                         retry_count = 0  # Reset retry count on successful connection

computer/providers/cloud/provider.py

@@ -11,90 +11,65 @@ from ..base import BaseVMProvider, VMProviderType
 # Setup logging
 logger = logging.getLogger(__name__)
 
+import asyncio
+import aiohttp
+from urllib.parse import urlparse
+
 class CloudProvider(BaseVMProvider):
-    """Cloud VM Provider stub implementation.
-    
-    This is a placeholder for a future cloud VM provider implementation.
-    """
-    
+    """Cloud VM Provider implementation."""
     def __init__(
-        self, 
-        host: str = "localhost",
-        port: int = 7777,
-        storage: Optional[str] = None,
+        self,
+        api_key: str,
         verbose: bool = False,
+        **kwargs,
     ):
-        """Initialize the Cloud provider.
-        
+        """
         Args:
-            host: Host to use for API connections (default: localhost)
-            port: Port for the API server (default: 7777)
-            storage: Path to store VM data
+            api_key: API key for authentication
+            name: Name of the VM
             verbose: Enable verbose logging
         """
-        self.host = host
-        self.port = port
-        self.storage = storage
+        assert api_key, "api_key required for CloudProvider"
+        self.api_key = api_key
         self.verbose = verbose
-        
-        logger.warning("CloudProvider is not yet implemented")
-        
+
     @property
     def provider_type(self) -> VMProviderType:
-        """Get the provider type."""
         return VMProviderType.CLOUD
-        
+
     async def __aenter__(self):
-        """Enter async context manager."""
-        logger.debug("Entering CloudProvider context")
         return self
-        
+
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Exit async context manager."""
-        logger.debug("Exiting CloudProvider context")
-        
+        pass
+
     async def get_vm(self, name: str, storage: Optional[str] = None) -> Dict[str, Any]:
-        """Get VM information by name."""
-        logger.warning("CloudProvider.get_vm is not implemented")
-        return {
-            "name": name,
-            "status": "unavailable",
-            "message": "CloudProvider is not implemented"
-        }
-        
+        """Get VM VNC URL by name using the cloud API."""
+        return {"name": name, "hostname": f"{name}.containers.cloud.trycua.com"}
+
     async def list_vms(self) -> List[Dict[str, Any]]:
-        """List all available VMs."""
         logger.warning("CloudProvider.list_vms is not implemented")
         return []
-        
+
     async def run_vm(self, image: str, name: str, run_opts: Dict[str, Any], storage: Optional[str] = None) -> Dict[str, Any]:
-        """Run a VM with the given options."""
         logger.warning("CloudProvider.run_vm is not implemented")
-        return {
-            "name": name,
-            "status": "unavailable",
-            "message": "CloudProvider is not implemented"
-        }
-        
+        return {"name": name, "status": "unavailable", "message": "CloudProvider is not implemented"}
+
     async def stop_vm(self, name: str, storage: Optional[str] = None) -> Dict[str, Any]:
-        """Stop a running VM."""
         logger.warning("CloudProvider.stop_vm is not implemented")
-        return {
-            "name": name,
-            "status": "stopped",
-            "message": "CloudProvider is not implemented"
-        }
-        
+        return {"name": name, "status": "stopped", "message": "CloudProvider is not implemented"}
+
     async def update_vm(self, name: str, update_opts: Dict[str, Any], storage: Optional[str] = None) -> Dict[str, Any]:
-        """Update VM configuration."""
         logger.warning("CloudProvider.update_vm is not implemented")
-        return {
-            "name": name,
-            "status": "unchanged",
-            "message": "CloudProvider is not implemented"
-        }
-        
-    async def get_ip(self, name: str, storage: Optional[str] = None, retry_delay: int = 2) -> str:
-        """Get the IP address of a VM."""
-        logger.warning("CloudProvider.get_ip is not implemented")
-        raise NotImplementedError("CloudProvider.get_ip is not implemented")
+        return {"name": name, "status": "unchanged", "message": "CloudProvider is not implemented"}
+
+    async def get_ip(self, name: Optional[str] = None, storage: Optional[str] = None, retry_delay: int = 2) -> str:
+        """
+        Return the VM's IP address as '{container_name}.containers.cloud.trycua.com'.
+        Uses the provided 'name' argument (the VM name requested by the caller),
+        falling back to self.name only if 'name' is None.
+        Retries up to 3 times with retry_delay seconds if hostname is not available.
+        """
+        if name is None:
+            raise ValueError("VM name is required for CloudProvider.get_ip")
+        return f"{name}.containers.cloud.trycua.com"

computer/providers/factory.py

@@ -22,7 +22,8 @@ class VMProviderFactory:
         image: Optional[str] = None,
         verbose: bool = False,
         ephemeral: bool = False,
-        noVNC_port: Optional[int] = None
+        noVNC_port: Optional[int] = None,
+        **kwargs,
     ) -> BaseVMProvider:
         """Create a VM provider of the specified type.
         
@@ -101,12 +102,9 @@ class VMProviderFactory:
         elif provider_type == VMProviderType.CLOUD:
             try:
                 from .cloud import CloudProvider
-                # Return the stub implementation of CloudProvider
                 return CloudProvider(
-                    host=host,
-                    port=port,
-                    storage=storage,
-                    verbose=verbose
+                    verbose=verbose,
+                    **kwargs,
                 )
             except ImportError as e:
                 logger.error(f"Failed to import CloudProvider: {e}")

computer/providers/lumier/provider.py

@@ -344,9 +344,15 @@ class LumierProvider(BaseVMProvider):
             # Use the VM image passed from the Computer class
             print(f"Using VM image: {self.image}")
             
+            # If ghcr.io is in the image, use the full image name
+            if "ghcr.io" in self.image:
+                vm_image = self.image
+            else:
+                vm_image = f"ghcr.io/trycua/{self.image}"
+
             cmd.extend([
                 "-e", f"VM_NAME={self.container_name}",
-                "-e", f"VERSION=ghcr.io/trycua/{self.image}",
+                "-e", f"VERSION={vm_image}",
                 "-e", f"CPU_CORES={run_opts.get('cpu', '4')}",
                 "-e", f"RAM_SIZE={memory_mb}",
             ])

{cua_computer-0.2.2.dist-info → cua_computer-0.2.3.dist-info}/METADATA

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

{cua_computer-0.2.2.dist-info → cua_computer-0.2.3.dist-info}/RECORD

@@ -1,29 +1,29 @@
 computer/__init__.py,sha256=QOxNrrJAuLRnsUC2zIFgRfzVSuDSXiYHlEF-9vkhV0o,1241
-computer/computer.py,sha256=nv2ZYg00ayq6N2OVVouE3ZekByCoYQez6vmuntVvKLs,31470
+computer/computer.py,sha256=Rc32XFZdKr7XZKO0zhbEom-REvYYPPlvmvjDbw5gP9k,32218
 computer/interface/__init__.py,sha256=xQvYjq5PMn9ZJOmRR5mWtONTl_0HVd8ACvW6AQnzDdw,262
-computer/interface/base.py,sha256=uRF2AfF3dbpOmvzZ55JgODpNC6LiudfhK8KCf5v7uUw,5771
-computer/interface/factory.py,sha256=2zUgFTKbhGqDbFKAcpOu47sDYmi4qidHegSQbfEAg1A,1159
-computer/interface/linux.py,sha256=5CyC0o-XR-TcelB5MPdzL20qSrT0C8kFYJxDupY3MWI,25350
-computer/interface/macos.py,sha256=WiK8hkJJwb6E6hFOMO30HVs6S2qSsPMM6f47cFj19OQ,25350
+computer/interface/base.py,sha256=CD9WpDp-6qP-ID5MjhXA8qpYs0XhJ4TPkR917l2FFSo,6021
+computer/interface/factory.py,sha256=RjAZAB_jFuS8JierYjLbapRX6RqFE0qE3BiIyP5UDOE,1441
+computer/interface/linux.py,sha256=EIVxwD_q0OmZoaW0Tv8FvKTpja9kInIsKWI47gpn2Po,27077
+computer/interface/macos.py,sha256=_8R_IroxbcVmh1WagrjDQOitaT6tVkCHVzGgA_lwTrM,27077
 computer/interface/models.py,sha256=RZKVUdwKrKUoFqwlx2Dk8Egkmq_AInlIu_d0xg7SZzw,3238
 computer/logger.py,sha256=UVvnmZGOWVF9TCsixEbeQnDZ3wBPAJ2anW3Zp-MoJ8Y,2896
 computer/models.py,sha256=iFNM1QfZArD8uf66XJXb2EDIREsfrxqqA5_liLBMfrE,1188
 computer/providers/__init__.py,sha256=hS9lLxmmHa1u82XJJ_xuqSKipClsYUEPx-8OK9ogtVg,194
 computer/providers/base.py,sha256=pUrM5aVBSUQS2TbfoiyMkNz20dWN7-F_aEjSf8EiJRc,3623
 computer/providers/cloud/__init__.py,sha256=SDAcfhI2BlmVBrBZOHxQd3i1bJZjMIfl7QgmqjXa4z8,144
-computer/providers/cloud/provider.py,sha256=Cgjb7vFMk4OxG8TKOMYWO8v3v1s7WtWXppNwQRm97Cw,3523
-computer/providers/factory.py,sha256=FskJGkdhl_arlGr2wd_e4Adi_L14VTkvPTK2gTuUhT0,4731
+computer/providers/cloud/provider.py,sha256=gpBl_ZVbwk-0FhYycne-69KslnrAoDSZcyzetpLfiKE,2864
+computer/providers/factory.py,sha256=9qVdt-fIovSNOokGMZ_2B1VPCLSZeDky4edcXyelZy4,4616
 computer/providers/lume/__init__.py,sha256=E6hTbVQF5lLZD8JyG4rTwUnCBO4q9K8UkYNQ31R0h7c,193
 computer/providers/lume/provider.py,sha256=grLZeXd4Y8iYsNq2gfNGcQq1bnTcNYNepEv-mxmROG4,20562
 computer/providers/lume_api.py,sha256=qLYFYdWtWVxWjMq8baiqlIW2EUaen4Gl2Tc1Qr_QEig,20196
 computer/providers/lumier/__init__.py,sha256=qz8coMA2K5MVoqNC12SDXJe6lI7z2pn6RHssUOMY5Ug,212
-computer/providers/lumier/provider.py,sha256=qBhaI_AFeS2ksLp8gHpHyts_HHSG8TduT6dPfBQ29hA,46547
+computer/providers/lumier/provider.py,sha256=CXwAKwJfR9ALFGM5u7UIZ-YrFwPvew_01wTe7dVmVbQ,46751
 computer/telemetry.py,sha256=FvNFpxgeRuCMdNpREuSL7bOMZy9gSzY4J0rLeNDw0CU,3746
 computer/ui/__init__.py,sha256=pmo05ek9qiB_x7DPeE6Vf_8RsIOqTD0w1dBLMHfoOnY,45
 computer/ui/gradio/__init__.py,sha256=5_KimixM48-X74FCsLw7LbSt39MQfUMEL8-M9amK3Cw,117
 computer/ui/gradio/app.py,sha256=o31nphBcb6zM5OKPuODTjuOzSJ3lt61kQHpUeMBBs70,65077
 computer/utils.py,sha256=zY50NXB7r51GNLQ6l7lhG_qv0_ufpQ8n0-SDhCei8m4,2838
-cua_computer-0.2.2.dist-info/METADATA,sha256=_uIqSLZnFdrSRDunf0AGhE93Twq91QbGzlzh3wWgwDc,5844
-cua_computer-0.2.2.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-cua_computer-0.2.2.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-cua_computer-0.2.2.dist-info/RECORD,,
+cua_computer-0.2.3.dist-info/METADATA,sha256=zStwBXVos0iY6yfYVYeKg9ogTELmf3BW8_i_a1EYWg0,5844
+cua_computer-0.2.3.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+cua_computer-0.2.3.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+cua_computer-0.2.3.dist-info/RECORD,,