cua-computer 0.2.1__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,12 +78,14 @@ class Computer:
         self.os_type = os_type
         self.provider_type = provider_type
         self.ephemeral = ephemeral
+        
+        self.api_key = api_key
 
-        if ephemeral:
-            self.storage = "ephemeral"
-        else:
-            self.storage = storage
-            
+        # The default is currently to use non-ephemeral storage
+        if storage and ephemeral and storage != "ephemeral":
+            raise ValueError("Storage path and ephemeral flag cannot be used together")
+        self.storage = "ephemeral" if ephemeral else storage
+        
         # For Lumier provider, store the first shared directory path to use
         # for VM file sharing
         self.shared_path = None
@@ -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:
@@ -279,12 +280,14 @@ class Computer:
                         raise RuntimeError(f"Failed to initialize VM provider: {e}")
 
                 # Check if VM exists or create it
+                is_running = False
                 try:
                     if self.config.vm_provider is None:
                         raise RuntimeError(f"VM provider not initialized for {self.config.name}")
                         
                     vm = await self.config.vm_provider.get_vm(self.config.name)
                     self.logger.verbose(f"Found existing VM: {self.config.name}")
+                    is_running = vm.get("status") == "running"
                 except Exception as e:
                     self.logger.error(f"VM not found: {self.config.name}")
                     self.logger.error(f"Error: {e}")
@@ -292,63 +295,67 @@ class Computer:
                         f"VM {self.config.name} could not be found or created."
                     )
 
-                # Convert paths to dictionary format for shared directories
-                shared_dirs = []
-                for path in self.shared_directories:
-                    self.logger.verbose(f"Adding shared directory: {path}")
-                    path = os.path.abspath(os.path.expanduser(path))
-                    if os.path.exists(path):
-                        # Add path in format expected by Lume API
-                        shared_dirs.append({
-                            "hostPath": path,
-                            "readOnly": False
-                        })
-                    else:
-                        self.logger.warning(f"Shared directory does not exist: {path}")
+                # Start the VM if it's not running
+                if not is_running:
+                    self.logger.info(f"VM {self.config.name} is not running, starting it...")
+
+                    # Convert paths to dictionary format for shared directories
+                    shared_dirs = []
+                    for path in self.shared_directories:
+                        self.logger.verbose(f"Adding shared directory: {path}")
+                        path = os.path.abspath(os.path.expanduser(path))
+                        if os.path.exists(path):
+                            # Add path in format expected by Lume API
+                            shared_dirs.append({
+                                "hostPath": path,
+                                "readOnly": False
+                            })
+                        else:
+                            self.logger.warning(f"Shared directory does not exist: {path}")
+                            
+                    # Prepare run options to pass to the provider
+                    run_opts = {}
+
+                    # Add display information if available
+                    if self.config.display is not None:
+                        display_info = {
+                            "width": self.config.display.width,
+                            "height": self.config.display.height,
+                        }
                         
-                # Prepare run options to pass to the provider
-                run_opts = {}
-
-                # Add display information if available
-                if self.config.display is not None:
-                    display_info = {
-                        "width": self.config.display.width,
-                        "height": self.config.display.height,
-                    }
-                    
-                    # Check if scale_factor exists before adding it
-                    if hasattr(self.config.display, "scale_factor"):
-                        display_info["scale_factor"] = self.config.display.scale_factor
-                    
-                    run_opts["display"] = display_info
+                        # Check if scale_factor exists before adding it
+                        if hasattr(self.config.display, "scale_factor"):
+                            display_info["scale_factor"] = self.config.display.scale_factor
+                        
+                        run_opts["display"] = display_info
 
-                # Add shared directories if available
-                if self.shared_directories:
-                    run_opts["shared_directories"] = shared_dirs.copy()
+                    # Add shared directories if available
+                    if self.shared_directories:
+                        run_opts["shared_directories"] = shared_dirs.copy()
 
-                # Run the VM with the provider
-                try:
-                    if self.config.vm_provider is None:
-                        raise RuntimeError(f"VM provider not initialized for {self.config.name}")
+                    # Run the VM with the provider
+                    try:
+                        if self.config.vm_provider is None:
+                            raise RuntimeError(f"VM provider not initialized for {self.config.name}")
+                            
+                        # Use the complete run_opts we prepared earlier
+                        # Handle ephemeral storage for run_vm method too
+                        storage_param = "ephemeral" if self.ephemeral else self.storage
                         
-                    # Use the complete run_opts we prepared earlier
-                    # Handle ephemeral storage for run_vm method too
-                    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.run_vm with explicit image parameter
-                    response = await self.config.vm_provider.run_vm(
-                        image=self.image,
-                        name=self.config.name,
-                        run_opts=run_opts,
-                        storage=storage_param
-                    )
-                    self.logger.info(f"VM run response: {response if response else 'None'}")
-                except Exception as run_error:
-                    self.logger.error(f"Failed to run VM: {run_error}")
-                    raise RuntimeError(f"Failed to start VM: {run_error}")
+                        # Log the image being used
+                        self.logger.info(f"Running VM using image: {self.image}")
+                        
+                        # Call provider.run_vm with explicit image parameter
+                        response = await self.config.vm_provider.run_vm(
+                            image=self.image,
+                            name=self.config.name,
+                            run_opts=run_opts,
+                            storage=storage_param
+                        )
+                        self.logger.info(f"VM run response: {response if response else 'None'}")
+                    except Exception as run_error:
+                        self.logger.error(f"Failed to run VM: {run_error}")
+                        raise RuntimeError(f"Failed to start VM: {run_error}")
 
                 # Wait for VM to be ready with a valid IP address
                 self.logger.info("Waiting for VM to be ready with a valid IP address...")
@@ -386,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...")
@@ -406,6 +426,9 @@ class Computer:
                 raise TimeoutError(
                     f"Could not connect to WebSocket interface at {ip_address}:8000/ws: {str(e)}"
                 )
+                # self.logger.warning(
+                #     f"Could not connect to WebSocket interface at {ip_address}:8000/ws: {str(e)}, expect missing functionality"
+                # )
 
             # Create an event to keep the VM running in background if needed
             if not self.use_host_computer_server:
@@ -483,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}",
             ])

computer/ui/gradio/app.py

@@ -17,7 +17,7 @@ import base64
 from datetime import datetime
 from PIL import Image
 from huggingface_hub import DatasetCard, DatasetCardData
-from computer import Computer
+from computer import Computer, VMProviderType
 from gradio.components import ChatMessage
 import pandas as pd
 from datasets import Dataset, Features, Sequence, concatenate_datasets
@@ -528,21 +528,44 @@ async def execute(name, action, arguments):
     
     return results
 
-async def handle_init_computer():
-    """Initialize the computer instance and tools"""
+async def handle_init_computer(os_choice: str):
+    """Initialize the computer instance and tools for macOS or Ubuntu"""
     global computer, tool_call_logs, tools
-    
-    computer = Computer(os_type="macos", display="1024x768", memory="8GB", cpu="4")
+
+    if os_choice == "Ubuntu":
+        computer = Computer(
+            image="ubuntu-noble-vanilla:latest",
+            os_type="linux",
+            provider_type=VMProviderType.LUME,
+            display="1024x768",
+            memory="8GB",
+            cpu="4"
+        )
+        os_type_str = "linux"
+        image_str = "ubuntu-noble-vanilla:latest"
+    else:
+        computer = Computer(
+            image="macos-sequoia-cua:latest",
+            os_type="macos",
+            provider_type=VMProviderType.LUME,
+            display="1024x768",
+            memory="8GB",
+            cpu="4"
+        )
+        os_type_str = "macos"
+        image_str = "macos-sequoia-cua:latest"
+
     await computer.run()
-    
+
     # Log computer initialization as a tool call
     result = await execute("computer", "initialize", {
-        "os": "macos", 
-        "display": "1024x768", 
-        "memory": "8GB", 
+        "os": os_type_str,
+        "image": image_str,
+        "display": "1024x768",
+        "memory": "8GB",
         "cpu": "4"
     })
-    
+
     return result["screenshot"], json.dumps(tool_call_logs, indent=2)
 
 async def handle_screenshot():
@@ -1004,8 +1027,15 @@ def create_gradio_ui():
                             run_setup_btn = gr.Button("⚙️ Run Task Setup")
                     # Setup status textbox
                     setup_status = gr.Textbox(label="Setup Status", value="")
-                    
-                start_btn = gr.Button("Initialize Computer")
+                
+                with gr.Group():
+                    os_choice = gr.Radio(
+                        label="OS",
+                        choices=["macOS", "Ubuntu"],
+                        value="macOS",
+                        interactive=False # disable until the ubuntu image is ready
+                    )
+                    start_btn = gr.Button("Initialize Computer")
                 
                 with gr.Group():
                     input_text = gr.Textbox(label="Type Text")
@@ -1169,7 +1199,7 @@ def create_gradio_ui():
         )
                 
         img.select(handle_click, inputs=[img, click_type], outputs=[img, action_log])
-        start_btn.click(handle_init_computer, outputs=[img, action_log])
+        start_btn.click(handle_init_computer, inputs=[os_choice], outputs=[img, action_log])
         wait_btn.click(handle_wait, outputs=[img, action_log])
         
         # DONE and FAIL buttons just do a placeholder action

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cua-computer
-Version: 0.2.1
+Version: 0.2.3
 Summary: Computer-Use Interface (CUI) framework powering Cua
 Author-Email: TryCua <gh@trycua.com>
 Requires-Python: >=3.10
@@ -78,7 +78,7 @@ finally:
 To install the Computer-Use Interface (CUI):
 
 ```bash
-pip install cua-computer
+pip install "cua-computer[all]"
 ```
 
 The `cua-computer` PyPi package pulls automatically the latest executable version of Lume through [pylume](https://github.com/trycua/pylume).

{cua_computer-0.2.1.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=zOc2cqZeDLKygNFuNCLn7FPBm5_dYHJqYBChV0TscK0,30626
+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=IU4gmvXvUxJxt1MSAMT6bfNC2YjT_JQbQ0M60bLygMs,64086
+computer/ui/gradio/app.py,sha256=o31nphBcb6zM5OKPuODTjuOzSJ3lt61kQHpUeMBBs70,65077
 computer/utils.py,sha256=zY50NXB7r51GNLQ6l7lhG_qv0_ufpQ8n0-SDhCei8m4,2838
-cua_computer-0.2.1.dist-info/METADATA,sha256=GWVENklYmRbA3s69dj34Jxh-TJtobQhpt4vPwyxmpNY,5837
-cua_computer-0.2.1.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-cua_computer-0.2.1.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-cua_computer-0.2.1.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,,