cua-computer 0.4.5__tar.gz → 0.4.7__tar.gz

{cua_computer-0.4.5 → cua_computer-0.4.7}/PKG-INFO

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

{cua_computer-0.4.5 → cua_computer-0.4.7}/computer/computer.py

@@ -154,8 +154,8 @@ class Computer:
         self.interface_logger = Logger("computer.interface", verbosity)
 
         if not use_host_computer_server:
-            if ":" not in image or len(image.split(":")) != 2:
-                raise ValueError("Image must be in the format <image_name>:<tag>")
+            if ":" not in image:
+                image = f"{image}:latest"
 
             if not name:
                 # Normalize the name to be used for the VM
@@ -794,19 +794,33 @@ class Computer:
             Tuple of (stdout, stderr) from the installation command
         """
         requirements = requirements or []
-
-        # Create virtual environment if it doesn't exist
-        venv_path = f"~/.venvs/{venv_name}"
-        create_cmd = f"mkdir -p ~/.venvs && python3 -m venv {venv_path}"
-        
-        # Check if venv exists, if not create it
-        check_cmd = f"test -d {venv_path} || ({create_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)
+        # Windows vs POSIX handling
+        if self.os_type == "windows":
+            # Use %USERPROFILE% for home directory and cmd.exe semantics
+            venv_path = f"%USERPROFILE%\\.venvs\\{venv_name}"
+            ensure_dir_cmd = "if not exist \"%USERPROFILE%\\.venvs\" mkdir \"%USERPROFILE%\\.venvs\""
+            create_cmd = f"if not exist \"{venv_path}\" python -m venv \"{venv_path}\""
+            requirements_str = " ".join(requirements)
+            # Activate via activate.bat and install
+            install_cmd = f"call \"{venv_path}\\Scripts\\activate.bat\" && pip install {requirements_str}" if requirements_str else f"echo No requirements to install"
+            await self.interface.run_command(ensure_dir_cmd)
+            await self.interface.run_command(create_cmd)
+            return await self.interface.run_command(install_cmd)
+        else:
+            # POSIX (macOS/Linux)
+            venv_path = f"$HOME/.venvs/{venv_name}"
+            create_cmd = f"mkdir -p \"$HOME/.venvs\" && python3 -m venv \"{venv_path}\""
+            # Check if venv exists, if not create it
+            check_cmd = f"test -d \"{venv_path}\" || ({create_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}"
+                if requirements_str
+                else "echo No requirements to install"
+            )
+            return await self.interface.run_command(install_cmd)
     
     async def venv_cmd(self, venv_name: str, command: str):
         """Execute a shell command in a virtual environment.
@@ -818,18 +832,30 @@ class Computer:
         Returns:
             Tuple of (stdout, stderr) from the command execution
         """
-        venv_path = f"~/.venvs/{venv_name}"
-        
-        # Check if virtual environment exists
-        check_cmd = f"test -d {venv_path}"
-        result = await self.interface.run_command(check_cmd)
-        
-        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
-        full_command = f". {venv_path}/bin/activate && {command}"
-        return await self.interface.run_command(full_command)
+        if self.os_type == "windows":
+            # Windows (cmd.exe)
+            venv_path = f"%USERPROFILE%\\.venvs\\{venv_name}"
+            # Check existence and signal if missing
+            check_cmd = f"if not exist \"{venv_path}\" (echo VENV_NOT_FOUND) else (echo VENV_FOUND)"
+            result = await self.interface.run_command(check_cmd)
+            if "VENV_NOT_FOUND" in getattr(result, "stdout", ""):
+                # Auto-create the venv with no requirements
+                await self.venv_install(venv_name, [])
+            # Activate and run the command
+            full_command = f"call \"{venv_path}\\Scripts\\activate.bat\" && {command}"
+            return await self.interface.run_command(full_command)
+        else:
+            # POSIX (macOS/Linux)
+            venv_path = f"$HOME/.venvs/{venv_name}"
+            # Check if virtual environment exists
+            check_cmd = f"test -d \"{venv_path}\""
+            result = await self.interface.run_command(check_cmd)
+            if result.stderr or "test:" in result.stdout:  # venv doesn't exist
+                # Auto-create the venv with no requirements
+                await self.venv_install(venv_name, [])
+            # Activate virtual environment and run command
+            full_command = f". \"{venv_path}/bin/activate\" && {command}"
+            return await self.interface.run_command(full_command)
     
     async def venv_exec(self, venv_name: str, python_func, *args, **kwargs):
         """Execute Python function in a virtual environment using source code extraction.

{cua_computer-0.4.5 → cua_computer-0.4.7}/computer/providers/winsandbox/provider.py

@@ -5,6 +5,7 @@ import asyncio
 import logging
 import time
 from typing import Dict, Any, Optional, List
+from pathlib import Path
 
 from ..base import BaseVMProvider, VMProviderType
 
@@ -242,8 +243,15 @@ class WinSandboxProvider(BaseVMProvider):
             
             networking = run_opts.get("networking", self.networking)
             
-            # Create folder mappers if shared directories are specified
+            # Create folder mappers; always map a persistent venv directory on host for caching packages
             folder_mappers = []
+            # Ensure host side persistent venv directory exists (Path.home()/wsb_venv)
+            host_wsb_env = Path.home() / ".cua" / "wsb_cache"
+            try:
+                host_wsb_env.mkdir(parents=True, exist_ok=True)
+            except Exception:
+                # If cannot create, continue without persistent mapping
+                host_wsb_env = None
             shared_directories = run_opts.get("shared_directories", [])
             for shared_dir in shared_directories:
                 if isinstance(shared_dir, dict):
@@ -255,6 +263,15 @@ class WinSandboxProvider(BaseVMProvider):
                     
                 if host_path and os.path.exists(host_path):
                     folder_mappers.append(winsandbox.FolderMapper(host_path))
+
+            # Add mapping for the persistent venv directory (read/write) so it appears in Sandbox Desktop
+            if host_wsb_env is not None and host_wsb_env.exists():
+                try:
+                    folder_mappers.append(
+                        winsandbox.FolderMapper(str(host_wsb_env), read_only=False)
+                    )
+                except Exception as e:
+                    self.logger.warning(f"Failed to map host winsandbox_venv: {e}")
             
             self.logger.info(f"Creating Windows Sandbox: {name}")
             self.logger.info(f"Memory: {memory_mb}MB, Networking: {networking}")
@@ -290,8 +307,10 @@ class WinSandboxProvider(BaseVMProvider):
             
             self.logger.info(f"Windows Sandbox {name} created successfully")
             
+            venv_exists = (host_wsb_env / "venv" / "Lib" / "site-packages" / "computer_server").exists() if host_wsb_env else False
+
             # Setup the computer server in the sandbox
-            await self._setup_computer_server(sandbox, name)
+            await self._setup_computer_server(sandbox, name, wait_for_venv=(not venv_exists))
             
             return {
                 "success": True,
@@ -423,7 +442,7 @@ class WinSandboxProvider(BaseVMProvider):
             if total_attempts % 10 == 0:
                 self.logger.info(f"Still waiting for Windows Sandbox {name} IP after {total_attempts} attempts...")
     
-    async def _setup_computer_server(self, sandbox, name: str, visible: bool = False):
+    async def _setup_computer_server(self, sandbox, name: str, visible: bool = False, wait_for_venv: bool = True):
         """Setup the computer server in the Windows Sandbox using RPyC.
         
         Args:
@@ -471,10 +490,12 @@ class WinSandboxProvider(BaseVMProvider):
                 creationflags=creation_flags,
                 shell=False
             )
-            
-            # # Sleep for 30 seconds
-            # await asyncio.sleep(30)
 
+            if wait_for_venv:
+                print("Waiting for venv to be created for the first time setup of Windows Sandbox...")
+                print("This may take a minute...")
+                await asyncio.sleep(120)
+            
             ip = await self.get_ip(name)
             self.logger.info(f"Sandbox IP: {ip}")
             self.logger.info(f"Setup script started in background in sandbox {name} with PID: {process.pid}")

{cua_computer-0.4.5 → cua_computer-0.4.7}/computer/providers/winsandbox/setup_script.ps1

@@ -79,23 +79,48 @@ try {
     $pythonVersion = & $pythonExe --version 2>&1
     Write-Host "Python version: $pythonVersion"
 
-    # Step 2: Install cua-computer-server directly
-    Write-Host "Step 2: Installing cua-computer-server..."
+    # Step 2: Create a dedicated virtual environment in mapped Desktop folder (persistent)
+    Write-Host "Step 2: Creating virtual environment (if needed)..."
+    $cachePath = "C:\Users\WDAGUtilityAccount\Desktop\wsb_cache"
+    $venvPath = "C:\Users\WDAGUtilityAccount\Desktop\wsb_cache\venv"
+    if (!(Test-Path $venvPath)) {
+        Write-Host "Creating venv at: $venvPath"
+        & $pythonExe -m venv $venvPath
+    } else {
+        Write-Host "Venv already exists at: $venvPath"
+    }
+    # Hide the folder to keep Desktop clean
+    try {
+        $item = Get-Item $cachePath -ErrorAction SilentlyContinue
+        if ($item) {
+            if (-not ($item.Attributes -band [IO.FileAttributes]::Hidden)) {
+                $item.Attributes = $item.Attributes -bor [IO.FileAttributes]::Hidden
+            }
+        }
+    } catch { }
+    $venvPython = Join-Path $venvPath "Scripts\python.exe"
+    if (!(Test-Path $venvPython)) {
+        throw "Virtual environment Python not found at $venvPython"
+    }
+    Write-Host "Using venv Python: $venvPython"
+
+    # Step 3: Install cua-computer-server into the venv
+    Write-Host "Step 3: Installing cua-computer-server..."
     
     Write-Host "Upgrading pip..."
-    & $pythonExe -m pip install --upgrade pip --quiet
+    & $venvPython -m pip install --upgrade pip --quiet
     
     Write-Host "Installing cua-computer-server..."
-    & $pythonExe -m pip install cua-computer-server --quiet
+    & $venvPython -m pip install cua-computer-server
     
     Write-Host "cua-computer-server installation completed."
 
-    # Step 3: Start computer server in background
-    Write-Host "Step 3: Starting computer server in background..."
-    Write-Host "Starting computer server with: $pythonExe"
+    # Step 4: Start computer server in background using the venv Python
+    Write-Host "Step 4: Starting computer server in background..."
+    Write-Host "Starting computer server with: $venvPython"
     
     # Start the computer server in the background
-    $serverProcess = Start-Process -FilePath $pythonExe -ArgumentList "-m", "computer_server.main" -WindowStyle Hidden -PassThru
+    $serverProcess = Start-Process -FilePath $venvPython -ArgumentList "-m", "computer_server.main" -WindowStyle Hidden -PassThru
     Write-Host "Computer server started in background with PID: $($serverProcess.Id)"
     
     # Give it a moment to start

{cua_computer-0.4.5 → cua_computer-0.4.7}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "cua-computer"
-version = "0.4.5"
+version = "0.4.7"
 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.4.5"
+target-version = "0.4.7"
 select = [
     "E",
     "F",
@@ -71,7 +71,7 @@ docstring-code-format = true
 
 [tool.mypy]
 strict = true
-python_version = "0.4.5"
+python_version = "0.4.7"
 ignore_missing_imports = true
 disallow_untyped_defs = true
 check_untyped_defs = true