cua-computer 0.4.6__tar.gz → 0.4.8__tar.gz

{cua_computer-0.4.6 → cua_computer-0.4.8}/PKG-INFO

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

{cua_computer-0.4.6 → cua_computer-0.4.8}/computer/computer.py

@@ -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.6 → cua_computer-0.4.8}/computer/providers/docker/provider.py

@@ -36,7 +36,7 @@ class DockerProvider(BaseVMProvider):
     """
     
     def __init__(
-        self, 
+        self,
         port: Optional[int] = 8000,
         host: str = "localhost",
         storage: Optional[str] = None,
@@ -47,13 +47,16 @@ class DockerProvider(BaseVMProvider):
         vnc_port: Optional[int] = 6901,
     ):
         """Initialize the Docker VM Provider.
-        
+
         Args:
             port: Currently unused (VM provider port)
             host: Hostname for the API server (default: localhost)
             storage: Path for persistent VM storage
             shared_path: Path for shared folder between host and container
             image: Docker image to use (default: "trycua/cua-ubuntu:latest")
+                   Supported images:
+                   - "trycua/cua-ubuntu:latest" (Kasm-based)
+                   - "trycua/cua-docker-xfce:latest" (vanilla XFCE)
             verbose: Enable verbose logging
             ephemeral: Use ephemeral (temporary) storage
             vnc_port: Port for VNC interface (default: 6901)
@@ -62,19 +65,35 @@ class DockerProvider(BaseVMProvider):
         self.api_port = 8000
         self.vnc_port = vnc_port
         self.ephemeral = ephemeral
-        
+
         # Handle ephemeral storage (temporary directory)
         if ephemeral:
             self.storage = "ephemeral"
         else:
             self.storage = storage
-            
+
         self.shared_path = shared_path
         self.image = image
         self.verbose = verbose
         self._container_id = None
         self._running_containers = {}  # Track running containers by name
+
+        # Detect image type and configure user directory accordingly
+        self._detect_image_config()
         
+    def _detect_image_config(self):
+        """Detect image type and configure paths accordingly."""
+        # Detect if this is a docker-xfce image or Kasm image
+        if "docker-xfce" in self.image.lower() or "xfce" in self.image.lower():
+            self._home_dir = "/home/cua"
+            self._image_type = "docker-xfce"
+            logger.info(f"Detected docker-xfce image: using {self._home_dir}")
+        else:
+            # Default to Kasm configuration
+            self._home_dir = "/home/kasm-user"
+            self._image_type = "kasm"
+            logger.info(f"Detected Kasm image: using {self._home_dir}")
+
     @property
     def provider_type(self) -> VMProviderType:
         """Return the provider type."""
@@ -277,12 +296,13 @@ class DockerProvider(BaseVMProvider):
             # Add volume mounts if storage is specified
             storage_path = storage or self.storage
             if storage_path and storage_path != "ephemeral":
-                # Mount storage directory
-                cmd.extend(["-v", f"{storage_path}:/home/kasm-user/storage"])
-            
+                # Mount storage directory using detected home directory
+                cmd.extend(["-v", f"{storage_path}:{self._home_dir}/storage"])
+
             # Add shared path if specified
             if self.shared_path:
-                cmd.extend(["-v", f"{self.shared_path}:/home/kasm-user/shared"])
+                # Mount shared directory using detected home directory
+                cmd.extend(["-v", f"{self.shared_path}:{self._home_dir}/shared"])
             
             # Add environment variables
             cmd.extend(["-e", "VNC_PW=password"])  # Set VNC password

{cua_computer-0.4.6 → cua_computer-0.4.8}/pyproject.toml

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