kolega-code 0.1.0__py3-none-any.whl

kolega_code/sandbox/filesystem.py

@@ -0,0 +1,341 @@
+"""FileSystem implementation for sandbox environments."""
+
+import os
+import base64
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional, Union, BinaryIO
+from contextlib import contextmanager
+from datetime import datetime
+
+from ..services.file_system import FileSystem
+
+
+class SandboxFileSystem(FileSystem):
+    """FileSystem implementation that operates within a sandbox."""
+
+    def __init__(self, sandbox: Any, root_path: str = "/home/user/workspace"):
+        """
+        Initialize sandbox filesystem.
+
+        Args:
+            sandbox: The sandbox instance (e.g., E2B Sandbox)
+            root_path: Root path within the sandbox
+        """
+        self.sandbox = sandbox
+        self.root_path = root_path
+
+    def _resolve_path(self, path: str) -> str:
+        """Resolve path relative to root."""
+        if os.path.isabs(path):
+            return path
+        if path == ".":
+            return self.root_path
+        return os.path.join(self.root_path, path)
+
+    # Synchronous methods using E2B v1.5.0 API
+    def open(self, path: str, mode: str = "r", encoding: Optional[str] = None) -> Any:
+        """Open is not directly supported in sandbox - use read/write methods instead."""
+        raise NotImplementedError("Direct file handles not supported in sandbox. Use read_text/write_text instead.")
+
+    def read_text(self, path: str, encoding: str = "utf-8") -> str:
+        """Read text from file."""
+        full_path = self._resolve_path(path)
+        try:
+            content = self.sandbox.files.read(full_path)
+            if isinstance(content, bytes):
+                return content.decode(encoding)
+            return content
+        except Exception as e:
+            raise FileNotFoundError(f"Could not read file {path}: {e}")
+
+    def read_bytes(self, path: str) -> bytes:
+        """Read bytes from file."""
+        full_path = self._resolve_path(path)
+        try:
+            # For binary data, use base64 encoding via shell commands
+            # to avoid E2B files API text encoding issues
+            result = self.sandbox.commands.run(f"base64 {full_path}")
+
+            if result.exit_code != 0:
+                raise FileNotFoundError(f"Could not read file {path}")
+
+            # Decode the base64 content
+            return base64.b64decode(result.stdout.strip())
+
+        except Exception as e:
+            raise FileNotFoundError(f"Could not read file {path}: {e}")
+
+    def write_text(self, path: str, content: str, encoding: str = "utf-8") -> None:
+        """Write text to file."""
+        full_path = self._resolve_path(path)
+        try:
+            # Ensure parent directory exists
+            parent_dir = os.path.dirname(full_path)
+            if parent_dir != self.root_path:
+                self.sandbox.commands.run(f"mkdir -p {parent_dir}")
+
+            self.sandbox.files.write(full_path, content)
+        except Exception as e:
+            raise OSError(f"Could not write file {path}: {e}")
+
+    def write_bytes(self, path: str, content: bytes) -> None:
+        """Write bytes to file."""
+        full_path = self._resolve_path(path)
+        try:
+            # Ensure parent directory exists
+            parent_dir = os.path.dirname(full_path)
+            if parent_dir != self.root_path:
+                self.sandbox.commands.run(f"mkdir -p {parent_dir}")
+
+            # For binary data, use base64 encoding and write via shell commands
+            # to avoid E2B files API text encoding issues
+            encoded_content = base64.b64encode(content).decode("ascii")
+
+            # Write the base64 encoded content and decode it
+            result = self.sandbox.commands.run(f"echo '{encoded_content}' | base64 -d > {full_path}")
+
+            if result.exit_code != 0:
+                raise OSError(f"Failed to write binary file {path}: {result.stderr}")
+
+        except Exception as e:
+            raise OSError(f"Could not write file {path}: {e}")
+
+    def exists(self, path: str) -> bool:
+        """Check if path exists."""
+        full_path = self._resolve_path(path)
+        try:
+            result = self.sandbox.commands.run(f"test -e {full_path}")
+            return result.exit_code == 0
+        except:
+            return False
+
+    def is_file(self, path: str) -> bool:
+        """Check if path is a file."""
+        full_path = self._resolve_path(path)
+        try:
+            result = self.sandbox.commands.run(f"test -f {full_path}")
+            return result.exit_code == 0
+        except:
+            return False
+
+    def is_dir(self, path: str) -> bool:
+        """Check if path is a directory."""
+        full_path = self._resolve_path(path)
+        try:
+            result = self.sandbox.commands.run(f"test -d {full_path}")
+            return result.exit_code == 0
+        except:
+            return False
+
+    def stat(self, path: str) -> Dict[str, Any]:
+        """Get file statistics."""
+        full_path = self._resolve_path(path)
+        try:
+            # Use stat command to get file info
+            result = self.sandbox.commands.run(f"stat -c '%s %Y %Z' {full_path}")
+            if result.exit_code != 0:
+                raise FileNotFoundError(f"File not found: {path}")
+
+            size, mtime, ctime = result.stdout.strip().split()
+
+            return {
+                "size": int(size),
+                "modified_time": int(mtime),
+                "created_time": int(ctime),
+                "is_file": self.is_file(path),
+                "is_directory": self.is_dir(path),
+            }
+        except Exception as e:
+            raise OSError(f"Could not stat {path}: {e}")
+
+    def mkdir(self, path: str, parents: bool = False, exist_ok: bool = False) -> None:
+        """Create directory."""
+        full_path = self._resolve_path(path)
+
+        # Check if directory already exists
+        if self.exists(path):
+            if not exist_ok:
+                raise FileExistsError(f"Directory already exists: {path}")
+            return
+
+        try:
+            if parents:
+                result = self.sandbox.commands.run(f"mkdir -p {full_path}")
+            else:
+                result = self.sandbox.commands.run(f"mkdir {full_path}")
+
+            if result.exit_code != 0:
+                raise OSError(f"Failed to create directory {path}: {result.stderr}")
+        except Exception as e:
+            raise OSError(f"Could not create directory {path}: {e}")
+
+    def remove(self, path: str, missing_ok: bool = False) -> None:
+        """Remove file."""
+        full_path = self._resolve_path(path)
+
+        if not self.exists(path):
+            if not missing_ok:
+                raise FileNotFoundError(f"File not found: {path}")
+            return
+
+        try:
+            result = self.sandbox.commands.run(f"rm -f {full_path}")
+            if result.exit_code != 0:
+                raise OSError(f"Failed to remove file {path}: {result.stderr}")
+        except Exception as e:
+            raise OSError(f"Could not remove file {path}: {e}")
+
+    def rmdir(self, path: str) -> None:
+        """Remove empty directory."""
+        full_path = self._resolve_path(path)
+        try:
+            result = self.sandbox.commands.run(f"rmdir {full_path}")
+            if result.exit_code != 0:
+                raise OSError(f"Failed to remove directory {path}: {result.stderr}")
+        except Exception as e:
+            raise OSError(f"Could not remove directory {path}: {e}")
+
+    def rmtree(self, path: str) -> None:
+        """Remove directory tree."""
+        full_path = self._resolve_path(path)
+        try:
+            result = self.sandbox.commands.run(f"rm -rf {full_path}")
+            if result.exit_code != 0:
+                raise OSError(f"Failed to remove directory tree {path}: {result.stderr}")
+        except Exception as e:
+            raise OSError(f"Could not remove directory tree {path}: {e}")
+
+    def listdir(self, path: str) -> List[str]:
+        """List directory contents."""
+        full_path = self._resolve_path(path)
+
+        if not self.is_dir(path):
+            raise NotADirectoryError(f"Not a directory: {path}")
+
+        try:
+            result = self.sandbox.commands.run(f"ls -1 {full_path}")
+            if result.exit_code != 0:
+                raise FileNotFoundError(f"Directory not found: {path}")
+
+            if not result.stdout.strip():
+                return []
+
+            return [line.strip() for line in result.stdout.strip().split("\n") if line.strip()]
+        except Exception as e:
+            raise OSError(f"Could not list directory {path}: {e}")
+
+    def iterdir(self, path: str) -> Iterator[str]:
+        """Iterate directory contents."""
+        return iter(self.listdir(path))
+
+    def glob(self, pattern: str) -> List[str]:
+        """Find paths matching pattern."""
+        try:
+            # Handle different types of glob patterns
+            if pattern.startswith("**/"):
+                # Recursive pattern like **/*.py or **/*
+                remaining_pattern = pattern[3:]  # Remove '**/'
+
+                if remaining_pattern == "*":
+                    # Pattern is **/* - find all files and directories recursively
+                    result = self.sandbox.commands.run(
+                        f"cd {self.root_path} && find . -mindepth 1 2>/dev/null | sed 's|^./||' | sort"
+                    )
+                else:
+                    # Pattern like **/*.py - find files matching pattern recursively
+                    if "*" in remaining_pattern or "?" in remaining_pattern:
+                        # Use find with -name for pattern matching
+                        result = self.sandbox.commands.run(
+                            f"cd {self.root_path} && find . -name '{remaining_pattern}' 2>/dev/null | sed 's|^./||' | sort"
+                        )
+                    else:
+                        # Exact filename search recursively
+                        result = self.sandbox.commands.run(
+                            f"cd {self.root_path} && find . -name '{remaining_pattern}' 2>/dev/null | sed 's|^./||' | sort"
+                        )
+
+            elif "*" in pattern or "?" in pattern:
+                # Simple glob pattern like *.py or test*.txt
+                if "/" in pattern:
+                    # Pattern has directory component like subdir/*.txt
+                    parent_dir = os.path.dirname(pattern)
+                    filename_pattern = os.path.basename(pattern)
+                    result = self.sandbox.commands.run(
+                        f"cd {self.root_path} && find {parent_dir} -maxdepth 1 -name '{filename_pattern}' 2>/dev/null | sort"
+                    )
+                else:
+                    # Simple pattern like *.py in current directory
+                    result = self.sandbox.commands.run(
+                        f"cd {self.root_path} && find . -maxdepth 1 -name '{pattern}' 2>/dev/null | sed 's|^./||' | sort"
+                    )
+
+            else:
+                # No wildcards - check if exact path exists
+                if self.exists(pattern):
+                    return [pattern]
+                else:
+                    return []
+
+            # Process the result
+            if result.exit_code == 0 and result.stdout.strip():
+                paths = [line.strip() for line in result.stdout.strip().split("\n") if line.strip()]
+                # Filter out empty strings and current directory
+                return [path for path in paths if path and path != "."]
+            else:
+                return []
+
+        except Exception as e:
+            # If any error occurs, return empty list to match expected behavior
+            return []
+
+    def is_binary_file(self, path: str) -> bool:
+        """Check if file is binary."""
+        full_path = self._resolve_path(path)
+        try:
+            # Use file command to detect binary
+            result = self.sandbox.commands.run(f"file -b --mime {full_path}")
+            return result.exit_code == 0 and "charset=binary" in result.stdout
+        except:
+            return False
+
+    def get_name(self, path: str) -> str:
+        """Get basename of path."""
+        return os.path.basename(path)
+
+    def get_suffix(self, path: str) -> str:
+        """Get file extension."""
+        return os.path.splitext(path)[1]
+
+    def get_parent(self, path: str) -> str:
+        """Get parent directory."""
+        parent = os.path.dirname(path)
+        # Return "." for root-level files to match LocalFileSystem behavior
+        return parent if parent else "."
+
+    def get_parents(self, path: str) -> List[str]:
+        """Get all parent directories."""
+        parents = []
+        current = os.path.dirname(path)
+        while current and current != "/":
+            parents.append(current)
+            current = os.path.dirname(current)
+        return parents
+
+    def relative_to(self, path: str, other: str) -> str:
+        """Get relative path."""
+        return os.path.relpath(path, other)
+
+    def join_path(self, *parts: str) -> str:
+        """Join path components."""
+        return os.path.join(*parts)
+
+    def is_absolute(self, path: str) -> bool:
+        """Check if path is absolute."""
+        return os.path.isabs(path)
+
+    def get_path(self, path: str) -> Path:
+        """Get a Path object for the given path."""
+        resolved = self._resolve_path(path)
+        # Since _resolve_path returns a string for sandbox filesystem,
+        # we need to create a Path object from it
+        return Path(resolved)

kolega_code/sandbox/local.py

@@ -0,0 +1,118 @@
+"""Local development implementation of sandbox manager."""
+
+from typing import Dict, Any, Optional, List
+
+from .base import SandboxConfig, SandboxManager
+from ..services.file_system import FileSystem, LocalFileSystem
+from ..services.base import TerminalManager, BrowserManager
+from ..services.terminal import LocalTerminalManager
+from ..services.browser import PlaywrightBrowserManager
+
+
+class LocalSandboxManager(SandboxManager):
+    """Local development implementation that doesn't use actual sandboxes."""
+
+    def __init__(self, connection_manager=None):
+        """Initialize local sandbox manager."""
+        self.connection_manager = connection_manager
+        # Use local services
+        self.filesystem = None
+        self.terminal_manager = None
+        self.browser_manager = None
+
+    async def create_sandbox(
+        self,
+        workspace_id: str,
+        thread_id: str,
+        config: Optional[SandboxConfig] = None,
+        workspace: Optional[Any] = None,
+        connection_manager: Optional[Any] = None,
+    ) -> str:
+        """Create a 'local' sandbox (just returns a fake ID)."""
+        # In local mode, we don't actually create sandboxes
+        # Use a simple consistent ID
+        sandbox_id = "local"
+
+        # Initialize local services if not already done
+        if self.filesystem is None and workspace:
+            self.filesystem = LocalFileSystem(root_path=workspace.directory_path)
+        if self.terminal_manager is None:
+            self.terminal_manager = LocalTerminalManager(workspace_id, thread_id, self.connection_manager)
+        if self.browser_manager is None:
+            self.browser_manager = PlaywrightBrowserManager()
+
+        return sandbox_id
+
+    async def destroy_sandbox(self, sandbox_id: str) -> None:
+        """Destroy a 'local' sandbox (no-op in local mode)."""
+        # In local mode, we don't need to destroy anything
+        pass
+
+    async def get_sandbox_status(self, sandbox_id: str) -> Dict[str, Any]:
+        """Get sandbox status (always 'alive' in local mode)."""
+        return {
+            "sandbox_id": sandbox_id,
+            "is_alive": True,
+            "is_local": True,
+        }
+
+    async def commit_changes(self, sandbox_id: str, message: str, files: Optional[List[str]] = None) -> str:
+        """Commit changes (no-op in local mode, returns empty string)."""
+        # In local mode, we don't manage git
+        return ""
+
+    async def push_changes(self, sandbox_id: str) -> bool:
+        """Push changes (no-op in local mode, returns False)."""
+        # In local mode, we don't manage git
+        return False
+
+    def get_filesystem(self, sandbox_id: str) -> FileSystem:
+        """Get filesystem for local development."""
+        if self.filesystem is None:
+            raise ValueError("Filesystem not initialized - call create_sandbox first")
+        return self.filesystem
+
+    def get_terminal_manager(self, sandbox_id: str) -> TerminalManager:
+        """Get terminal manager for local development."""
+        if self.terminal_manager is None:
+            raise ValueError("Terminal manager not initialized - call create_sandbox first")
+        return self.terminal_manager
+
+    def get_browser_manager(self, sandbox_id: str) -> BrowserManager:
+        """Get browser manager for local development."""
+        if self.browser_manager is None:
+            raise ValueError("Browser manager not initialized - call create_sandbox first")
+        return self.browser_manager
+
+    async def get_host(self, sandbox_id: str, port: int) -> str:
+        """Always returns localhost for local development."""
+        return f"localhost:{port}"
+
+    async def pause_sandbox(self, sandbox_id: str) -> str:
+        """Pause sandbox (no-op in local mode, returns sandbox_id)."""
+        # In local mode, we don't pause sandboxes
+        # Just return the sandbox_id as the "persistent" ID
+        return sandbox_id
+
+    async def resume_sandbox(self, persistent_sandbox_id: str, workspace_id: str, thread_id: str) -> str:
+        """Resume sandbox (no-op in local mode, returns same ID)."""
+        # In local mode, we don't actually resume sandboxes
+        # Just return the same ID
+        return persistent_sandbox_id
+
+    def has_sandbox(self, sandbox_id: str) -> bool:
+        """Check if a sandbox is currently active (always true in local mode if initialized)."""
+        # In local mode, if we have services initialized, the "sandbox" is active
+        return self.filesystem is not None
+
+    async def adopt_sandbox(self, sandbox_id: str, workspace_id: str, thread_id: str) -> str:
+        """Adopt sandbox (no-op in local mode, returns same ID)."""
+        # In local mode, we don't actually adopt sandboxes
+        # Just return the same ID
+        return sandbox_id
+
+    async def sync_sandbox_env_vars(self, sandbox_id: str, workspace_id: str, sandbox: Optional[Any] = None, skip_integration_env_sync: bool = False) -> None:
+        """Sync environment variables (no-op in local mode)."""
+        # In local mode, environment variables are managed by the local system
+        # No need to sync to a sandbox profile
+        pass

kolega_code/sandbox/serializer.py

@@ -0,0 +1,175 @@
+"""Terminal manager state serialization utilities."""
+
+from typing import Dict, Any, Optional, List
+from datetime import datetime, timezone
+from kolega_code.models.sandbox_terminal_state import SandboxTerminalState, TerminalInfo, TerminalOutput
+
+
+class TerminalStateSerializer:
+    """Handles serialization and deserialization of terminal manager state."""
+
+    @staticmethod
+    def serialize_to_model(terminal_manager, workspace_id: str, sandbox_id: str) -> SandboxTerminalState:
+        """Serialize terminal manager state to a SandboxTerminalState model."""
+        state = SandboxTerminalState(workspace_id=workspace_id, sandbox_id=sandbox_id)
+
+        if not hasattr(terminal_manager, "terminals"):
+            return state  # Can't serialize local terminal managers
+
+        # Serialize terminals
+        for terminal_id, info in terminal_manager.terminals.items():
+            state.terminals[terminal_id] = TerminalInfo(
+                terminal_id=terminal_id,
+                created_at=info["created_at"],
+                cwd=info["cwd"],
+                env=info["env"],
+                last_command=info.get("last_command", ""),
+                last_command_purpose=info.get("last_command_purpose", ""),
+            )
+
+        # Serialize outputs with size tracking
+        total_size = 0
+        for terminal_id, outputs in terminal_manager.outputs.items():
+            terminal_outputs = []
+            terminal_size = 0
+
+            # Process outputs in reverse order (keep most recent)
+            for output in reversed(outputs):
+                terminal_output = TerminalOutput(
+                    type=output["type"],
+                    data=output["data"],
+                    timestamp=output["timestamp"],
+                    purpose=output.get("purpose"),
+                    exit_code=output.get("exit_code"),
+                )
+                output_size = len(output["data"].encode("utf-8"))
+
+                # Check if adding this output would exceed limits
+                if (
+                    terminal_size + output_size > state.MAX_OUTPUT_PER_TERMINAL
+                    or total_size + output_size > state.MAX_OUTPUT_SIZE
+                ):
+                    # Add truncation notice at the beginning
+                    if not any(o.type == "truncation" for o in terminal_outputs):
+                        terminal_outputs.insert(
+                            0,
+                            TerminalOutput(
+                                type="truncation",
+                                data="[Earlier terminal output truncated due to size limits]",
+                                timestamp=datetime.now(timezone.utc),
+                            ),
+                        )
+                    break
+
+                terminal_outputs.insert(0, terminal_output)  # Insert at beginning to maintain order
+                terminal_size += output_size
+                total_size += output_size
+
+            state.outputs[terminal_id] = terminal_outputs
+
+            # Break if we've hit total size limit
+            if total_size >= state.MAX_OUTPUT_SIZE:
+                break
+
+        state.total_output_size = total_size
+        state.default_terminal_id = getattr(terminal_manager, "_default_terminal_id", None)
+
+        return state
+
+    @staticmethod
+    def restore_from_model(terminal_manager, state: SandboxTerminalState) -> None:
+        """Restore terminal manager state from a SandboxTerminalState model."""
+        if not state or not hasattr(terminal_manager, "terminals"):
+            return
+
+        # Clear existing state
+        terminal_manager.terminals.clear()
+        terminal_manager.outputs.clear()
+
+        # Restore terminals
+        for terminal_id, terminal_info in state.terminals.items():
+            terminal_manager.terminals[terminal_id] = {
+                "created_at": terminal_info.created_at,
+                "cwd": terminal_info.cwd,
+                "env": terminal_info.env,
+                "process": None,  # Process references can't be restored
+                "last_command": terminal_info.last_command,
+                "last_command_purpose": terminal_info.last_command_purpose,
+                "active_commands": {},  # Active commands start fresh
+            }
+
+        # Restore outputs
+        for terminal_id, outputs in state.outputs.items():
+            terminal_manager.outputs[terminal_id] = [
+                {
+                    "type": output.type,
+                    "data": output.data,
+                    "timestamp": output.timestamp,
+                    "purpose": output.purpose,
+                    "exit_code": output.exit_code,
+                }
+                for output in outputs
+                if output.type != "truncation"  # Skip truncation notices
+            ]
+
+        # Restore default terminal ID
+        if hasattr(terminal_manager, "_default_terminal_id"):
+            terminal_manager._default_terminal_id = state.default_terminal_id
+
+    @staticmethod
+    def to_frontend_format(state: SandboxTerminalState) -> Dict[str, Any]:
+        """Convert terminal state to frontend format."""
+        terminal_tabs = []
+
+        for terminal_id, outputs in state.outputs.items():
+            content = ""
+            for output in outputs:
+                if output.type == "command":
+                    content += f"$ {output.data}\n"
+                elif output.type == "truncation":
+                    content += f"{output.data}\n"
+                elif output.type in ["stdout", "stderr"]:
+                    content += output.data
+                    if not output.data.endswith("\n"):
+                        content += "\n"
+                elif output.type == "exit":
+                    content += f"{output.data}\n"
+
+            if content:  # Only add tabs with content
+                terminal_tabs.append({"id": terminal_id, "content": content.rstrip()})  # Remove trailing whitespace
+
+        return {"terminals": terminal_tabs}
+
+    @staticmethod
+    def get_recent_outputs(outputs: List[Dict[str, Any]], max_lines: int = 100) -> List[Dict[str, Any]]:
+        """Get the most recent outputs, limited by line count."""
+        if not outputs:
+            return []
+
+        recent_outputs = []
+        line_count = 0
+
+        # Process outputs in reverse order
+        for output in reversed(outputs):
+            if output["type"] in ["stdout", "stderr"]:
+                lines = output["data"].count("\n") + 1
+                if line_count + lines > max_lines:
+                    # Partial output to fit within limit
+                    remaining_lines = max_lines - line_count
+                    if remaining_lines > 0:
+                        lines_data = output["data"].split("\n")
+                        partial_output = output.copy()
+                        partial_output["data"] = "\n".join(lines_data[-remaining_lines:])
+                        recent_outputs.insert(0, partial_output)
+                    break
+                line_count += lines
+
+            recent_outputs.insert(0, output)
+
+            if output["type"] == "command":
+                line_count += 1
+
+            if line_count >= max_lines:
+                break
+
+        return recent_outputs