cua-computer 0.2.2__tar.gz → 0.2.4__tar.gz

{cua_computer-0.2.2 → cua_computer-0.2.4}/PKG-INFO

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

{cua_computer-0.2.2 → cua_computer-0.2.4}/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,

{cua_computer-0.2.2 → cua_computer-0.2.4}/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

{cua_computer-0.2.2 → cua_computer-0.2.4}/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}")

{cua_computer-0.2.2 → cua_computer-0.2.4}/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

{cua_computer-0.2.2 → cua_computer-0.2.4}/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

cua_computer-0.2.4/computer/providers/cloud/provider.py

@@ -0,0 +1,75 @@
+"""Cloud VM provider implementation.
+
+This module contains a stub implementation for a future cloud VM provider.
+"""
+
+import logging
+from typing import Dict, List, Optional, Any
+
+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 implementation."""
+    def __init__(
+        self,
+        api_key: str,
+        verbose: bool = False,
+        **kwargs,
+    ):
+        """
+        Args:
+            api_key: API key for authentication
+            name: Name of the VM
+            verbose: Enable verbose logging
+        """
+        assert api_key, "api_key required for CloudProvider"
+        self.api_key = api_key
+        self.verbose = verbose
+
+    @property
+    def provider_type(self) -> VMProviderType:
+        return VMProviderType.CLOUD
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    async def get_vm(self, name: str, storage: Optional[str] = None) -> Dict[str, Any]:
+        """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]]:
+        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]:
+        logger.warning("CloudProvider.run_vm 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]:
+        logger.warning("CloudProvider.stop_vm 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]:
+        logger.warning("CloudProvider.update_vm 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"

{cua_computer-0.2.2 → cua_computer-0.2.4}/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}")

{cua_computer-0.2.2 → cua_computer-0.2.4}/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 → cua_computer-0.2.4}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "cua-computer"
-version = "0.2.2"
+version = "0.2.4"
 description = "Computer-Use Interface (CUI) framework powering Cua"
 readme = "README.md"
 authors = [
@@ -57,7 +57,7 @@ target-version = [
 
 [tool.ruff]
 line-length = 100
-target-version = "0.2.2"
+target-version = "0.2.4"
 select = [
     "E",
     "F",
@@ -71,7 +71,7 @@ docstring-code-format = true
 
 [tool.mypy]
 strict = true
-python_version = "0.2.2"
+python_version = "0.2.4"
 ignore_missing_imports = true
 disallow_untyped_defs = true
 check_untyped_defs = true

cua_computer-0.2.2/computer/providers/cloud/provider.py

@@ -1,100 +0,0 @@
-"""Cloud VM provider implementation.
-
-This module contains a stub implementation for a future cloud VM provider.
-"""
-
-import logging
-from typing import Dict, List, Optional, Any
-
-from ..base import BaseVMProvider, VMProviderType
-
-# Setup logging
-logger = logging.getLogger(__name__)
-
-class CloudProvider(BaseVMProvider):
-    """Cloud VM Provider stub implementation.
-    
-    This is a placeholder for a future cloud VM provider implementation.
-    """
-    
-    def __init__(
-        self, 
-        host: str = "localhost",
-        port: int = 7777,
-        storage: Optional[str] = None,
-        verbose: bool = False,
-    ):
-        """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
-            verbose: Enable verbose logging
-        """
-        self.host = host
-        self.port = port
-        self.storage = storage
-        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")
-        
-    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"
-        }
-        
-    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"
-        }
-        
-    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"
-        }
-        
-    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")