Upload 5 files

aworld/sandbox/__init__.py

@@ -0,0 +1,112 @@
+from typing import Dict, List, Any, Optional
+
+from aworld.sandbox.base import Sandbox
+from aworld.sandbox.common import BaseSandbox
+from aworld.sandbox.models import SandboxEnvType
+from aworld.sandbox.implementations import LocalSandbox, KubernetesSandbox, SuperSandbox
+
+
+# For backward compatibility, use LocalSandbox as the default Sandbox implementation
+DefaultSandbox = LocalSandbox
+
+
+# Override Sandbox class constructor to create the appropriate sandbox based on env_type
+def create_sandbox(
+    env_type: Optional[int] = None,
+    sandbox_id: Optional[str] = None,
+    metadata: Optional[Dict[str, str]] = None,
+    timeout: Optional[int] = None,
+    mcp_servers: Optional[List[str]] = None,
+    mcp_config: Optional[Any] = None,
+    **kwargs
+) -> Sandbox:
+    """
+    Factory function to create a sandbox instance based on the environment type.
+    
+    Args:
+        env_type: The environment type. Defaults to LOCAL if None.
+        sandbox_id: Unique identifier for the sandbox. If None, one will be generated.
+        metadata: Additional metadata for the sandbox.
+        timeout: Timeout for sandbox operations.
+        mcp_servers: List of MCP servers to use.
+        mcp_config: Configuration for MCP servers.
+        **kwargs: Additional parameters for specific sandbox types.
+        
+    Returns:
+        Sandbox: An instance of a sandbox implementation.
+        
+    Raises:
+        ValueError: If an invalid environment type is provided.
+    """
+    env_type = env_type or SandboxEnvType.LOCAL
+    
+    if env_type == SandboxEnvType.LOCAL:
+        return LocalSandbox(
+            sandbox_id=sandbox_id,
+            metadata=metadata,
+            timeout=timeout,
+            mcp_servers=mcp_servers,
+            mcp_config=mcp_config,
+            **kwargs
+        )
+    elif env_type == SandboxEnvType.K8S:
+        return KubernetesSandbox(
+            sandbox_id=sandbox_id,
+            metadata=metadata,
+            timeout=timeout,
+            mcp_servers=mcp_servers,
+            mcp_config=mcp_config,
+            **kwargs
+        )
+    elif env_type == SandboxEnvType.SUPERCOMPUTER:
+        return SuperSandbox(
+            sandbox_id=sandbox_id,
+            metadata=metadata,
+            timeout=timeout,
+            mcp_servers=mcp_servers,
+            mcp_config=mcp_config,
+            **kwargs
+        )
+    else:
+        raise ValueError(f"Invalid environment type: {env_type}")
+
+
+# Monkey patch the Sandbox class to make direct instantiation work
+old_init = Sandbox.__init__
+
+def _sandbox_init(self, *args, **kwargs):
+    if type(self) is Sandbox:
+        # This should never be called directly, as __new__ will return a different type
+        pass
+    else:
+        # Pass through to the original __init__ for actual implementations
+        old_init(self, *args, **kwargs)
+
+# Store the original __new__ method
+original_new = object.__new__
+
+# Create a new __new__ method that intercepts Sandbox instantiation
+def _sandbox_new(cls, *args, **kwargs):
+    if cls is Sandbox:
+        # If trying to instantiate Sandbox directly, use our factory instead
+        return create_sandbox(**kwargs)
+    else:
+        # For subclasses, use the original __new__
+        return original_new(cls)
+
+# Apply the monkey patches
+Sandbox.__init__ = _sandbox_init
+Sandbox.__new__ = _sandbox_new
+
+
+# Expose key classes and functions
+__all__ = [
+    'Sandbox',
+    'BaseSandbox',
+    'LocalSandbox',
+    'KubernetesSandbox',
+    'SuperSandbox',
+    'DefaultSandbox',
+    'SandboxEnvType',
+    'create_sandbox'
+]

aworld/sandbox/base.py

@@ -0,0 +1,156 @@
+import abc
+import asyncio
+import logging
+import uuid
+from typing import Dict, List, Any, Optional
+
+from aworld.sandbox.api.setup import SandboxSetup
+from aworld.sandbox.models import SandboxStatus, SandboxEnvType, SandboxInfo
+from aworld.sandbox.run.mcp_servers import McpServers
+
+
+class Sandbox(SandboxSetup):
+    """
+    Sandbox abstract base class that defines the interface for all sandbox implementations.
+    A sandbox provides an isolated environment for executing code and operations.
+    """
+    
+    default_sandbox_timeout = 3000
+    
+    @property
+    def sandbox_id(self) -> str:
+        """
+        Returns the unique identifier of the sandbox.
+        """
+        return self._sandbox_id
+
+    @property
+    def status(self) -> SandboxStatus:
+        """
+        Returns the current status of the sandbox.
+        """
+        return self._status
+
+    @property
+    def timeout(self) -> int:
+        """
+        Returns the timeout value for sandbox operations.
+        """
+        return self._timeout
+
+    @property
+    def metadata(self) -> Dict[str, Any]:
+        """
+        Returns the sandbox metadata.
+        """
+        return self._metadata
+
+    @property
+    def env_type(self) -> SandboxEnvType:
+        """
+        Returns the environment type of the sandbox.
+        """
+        return self._env_type
+
+    @property
+    def mcp_config(self) -> Any:
+        """
+        Returns the MCP configuration.
+        """
+        return self._mcp_config
+
+    @property
+    def mcp_servers(self) -> List[str]:
+        """
+        Returns the list of MCP servers.
+        """
+        return self._mcp_servers
+    
+    @property
+    @abc.abstractmethod
+    def mcpservers(self) -> McpServers:
+        """
+        Module for running MCP in the sandbox.
+        
+        Returns:
+            McpServers: The MCP servers instance.
+        """
+        pass
+
+    def __init__(
+            self,
+            sandbox_id: Optional[str] = None,
+            env_type: Optional[int] = None,
+            metadata: Optional[Dict[str, str]] = None,
+            timeout: Optional[int] = None,
+            mcp_servers: Optional[List[str]] = None,
+            mcp_config: Optional[Any] = None,
+    ):
+        """
+        Initialize a new Sandbox instance.
+        
+        Args:
+            sandbox_id: Unique identifier for the sandbox. If None, one will be generated.
+            env_type: The environment type (LOCAL, K8S, SUPERCOMPUTER).
+            metadata: Additional metadata for the sandbox.
+            timeout: Timeout for sandbox operations.
+            mcp_servers: List of MCP servers to use.
+            mcp_config: Configuration for MCP servers.
+        """
+        # Initialize basic attributes
+        self._sandbox_id = sandbox_id or str(uuid.uuid4())
+        self._status = SandboxStatus.INIT
+        self._timeout = timeout or self.default_sandbox_timeout
+        self._metadata = metadata or {}
+        self._env_type = env_type or SandboxEnvType.LOCAL
+        self._mcp_servers = mcp_servers or []
+        self._mcp_config = mcp_config or {}
+        
+    @abc.abstractmethod
+    def get_info(self) -> SandboxInfo:
+        """
+        Returns information about the sandbox.
+        
+        Returns:
+            SandboxInfo: Information about the sandbox.
+        """
+        pass
+    
+    @abc.abstractmethod
+    async def remove(self) -> bool:
+        """
+        Remove the sandbox and clean up all resources.
+        
+        Returns:
+            bool: True if removal was successful, False otherwise.
+        """
+        pass
+    
+    @abc.abstractmethod
+    async def cleanup(self) -> bool:
+        """
+        Clean up the sandbox resources.
+        
+        Returns:
+            bool: True if cleanup was successful, False otherwise.
+        """
+        pass
+    
+    def __del__(self):
+        """
+        Ensure resources are cleaned up when the object is garbage collected.
+        """
+        try:
+            # Handle the case where an event loop already exists
+            try:
+                loop = asyncio.get_running_loop()
+                logging.warning("Cannot clean up sandbox in __del__ when event loop is already running")
+                return
+            except RuntimeError:
+                # No running event loop, create a new one
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                loop.run_until_complete(self.cleanup())
+                loop.close()
+        except Exception as e:
+            logging.warning(f"Failed to cleanup sandbox resources during garbage collection: {e}")

aworld/sandbox/common.py

@@ -0,0 +1,104 @@
+import asyncio
+import logging
+import abc
+from typing import Dict, List, Any, Optional
+
+from aworld.sandbox.base import Sandbox
+from aworld.sandbox.models import SandboxStatus, SandboxEnvType, SandboxInfo
+from aworld.sandbox.run.mcp_servers import McpServers
+
+
+class BaseSandbox(Sandbox):
+    """
+    Base sandbox implementation with common functionality for all sandbox types.
+    This class implements common methods and provides a foundation for specific sandbox implementations.
+    """
+
+    def __init__(
+            self,
+            sandbox_id: Optional[str] = None,
+            env_type: Optional[int] = None,
+            metadata: Optional[Dict[str, str]] = None,
+            timeout: Optional[int] = None,
+            mcp_servers: Optional[List[str]] = None,
+            mcp_config: Optional[Any] = None,
+    ):
+        """
+        Initialize a new BaseSandbox instance.
+        
+        Args:
+            sandbox_id: Unique identifier for the sandbox. If None, one will be generated.
+            env_type: The environment type (LOCAL, K8S, SUPERCOMPUTER).
+            metadata: Additional metadata for the sandbox.
+            timeout: Timeout for sandbox operations.
+            mcp_servers: List of MCP servers to use.
+            mcp_config: Configuration for MCP servers.
+        """
+        super().__init__(
+            sandbox_id=sandbox_id,
+            env_type=env_type,
+            metadata=metadata,
+            timeout=timeout,
+            mcp_servers=mcp_servers,
+            mcp_config=mcp_config
+        )
+        self._logger = self._setup_logger()
+        
+    def _setup_logger(self):
+        """
+        Set up a logger for the sandbox instance.
+        
+        Returns:
+            logging.Logger: Configured logger instance.
+        """
+        logger = logging.getLogger(f"sandbox.{self.__class__.__name__}.{self.sandbox_id[:8]}")
+        return logger
+        
+    def get_info(self) -> SandboxInfo:
+        """
+        Get information about the sandbox.
+        
+        Returns:
+            SandboxInfo: Information about the sandbox.
+        """
+        return {
+            "sandbox_id": self.sandbox_id,
+            "status": self.status,
+            "metadata": self.metadata,
+            "env_type": self.env_type
+        }
+    
+    @property
+    def mcpservers(self) -> McpServers:
+        """
+        Module for running MCP servers in the sandbox.
+        This property provides access to the MCP servers instance.
+        
+        Returns:
+            McpServers: The MCP servers instance.
+        """
+        if hasattr(self, '_mcpservers'):
+            return self._mcpservers
+        return None
+    
+    @abc.abstractmethod
+    async def cleanup(self) -> bool:
+        """
+        Clean up sandbox resources.
+        This method must be implemented by subclasses to provide environment-specific cleanup.
+        
+        Returns:
+            bool: True if cleanup was successful, False otherwise.
+        """
+        pass
+    
+    @abc.abstractmethod
+    async def remove(self) -> bool:
+        """
+        Remove the sandbox.
+        This method must be implemented by subclasses to provide environment-specific removal.
+        
+        Returns:
+            bool: True if removal was successful, False otherwise.
+        """
+        pass 

aworld/sandbox/demo.py

@@ -0,0 +1,41 @@
+import asyncio
+
+from aworld.sandbox import Sandbox, SandboxEnvType
+
+
+# Define an asynchronous function to call asynchronous methods
+async def run_async_tasks(sand_box):
+    tools = await sand_box.mcpservers.list_tools()
+    print(f"Tools: {tools}")
+    return tools
+
+if __name__ == "__main__":
+    # 只使用memory服务器
+    mcp_servers = ["memory","amap-amap-sse"]
+    mcp_config = {
+      "mcpServers": {
+        "memory": {
+          "type": "stdio",
+          "command": "npx",
+          "args": [
+            "-y",
+            "@modelcontextprotocol/server-memory"
+          ]
+        }
+
+      }
+    }
+    sand_box = Sandbox(mcp_servers=mcp_servers, mcp_config=mcp_config,env_type=SandboxEnvType.SUPERCOMPUTER)
+    print(f"Sandbox ID: {sand_box.sandbox_id}")
+    print(f"Status: {sand_box.status}")
+    print(f"Timeout: {sand_box.timeout}")
+    print(f"Metadata: {sand_box.metadata}")
+    print(f"Environment Type: {sand_box.env_type}")
+    print(f"MCP Servers: {sand_box.mcp_servers}")
+    print(f"MCP Config: {sand_box.mcp_config}")
+    
+    # Use asyncio to run asynchronous methods
+    asyncio.run(run_async_tasks(sand_box))
+    
+    print(f"MCP Servers-new: {sand_box.mcp_servers}")
+    print(f"MCP Config-new: {sand_box.mcp_config}")

aworld/sandbox/models.py

@@ -0,0 +1,66 @@
+import uuid
+from dataclasses import dataclass
+from enum import IntEnum, StrEnum
+
+from pydantic import BaseModel
+from typing_extensions import Optional, Dict,Any
+
+
+class SandboxStatus(StrEnum):
+    """Sandbox status enumeration."""
+    INIT = 'Pending'       # Initialization state
+    RUNNING = 'Running'    # Running
+    STOPPED = 'Stopped'    # Stopped
+    ERROR = 'Failed'      # Error state
+    REMOVED = 'Removed'    # Removed
+    UNKNOWN = 'Unknown'  # Removed
+
+class SandboxEnvType(IntEnum):
+    """Sandbox env type enumeration."""
+    LOCAL = 1
+    K8S = 2
+    SUPERCOMPUTER = 3
+
+
+
+@dataclass
+class SandboxCreateResponse:
+    sandbox_id: str = str(uuid.uuid4())
+    env_type: int = SandboxEnvType.LOCAL
+    status: Optional[str] = None
+    mcp_config: Optional[Any] = None
+
+@dataclass
+class SandboxK8sResponse(SandboxCreateResponse):
+    pod_name: Optional[str] = None
+    service_name: Optional[str] = None
+    cluster_ip: Optional[str] = None
+    host: Optional[str] = None
+
+
+@dataclass
+class SandboxLocalResponse(SandboxCreateResponse):
+    host: Optional[str] = None
+
+@dataclass
+class SandboxSuperResponse(SandboxCreateResponse):
+    host: Optional[str] = None
+
+@dataclass
+class SandboxInfo:
+    """Information about a sandbox."""
+
+    sandbox_id: str
+    """Sandbox ID."""
+    status: str
+    """sandbox status"""
+    metadata: Dict[str, str]
+    """Saved sandbox metadata."""
+
+
+
+class EnvConfig(BaseModel):
+    """Data structure contained in the environment"""
+    name: str = "default"
+    version: str = "1.0.0"
+    dockerfile: Optional[str] = None    #Dockerfile of the image required when creating the environment