ms-enclave 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

ms_enclave/sandbox/boxes/base.py

@@ -33,7 +33,7 @@ class Sandbox(abc.ABC):
             config: Sandbox configuration
             sandbox_id: Optional sandbox ID (will be generated if not provided)
         """
-        self.id = sandbox_id or str(uuid.uuid())
+        self.id = sandbox_id or uuid.ShortUUID(alphabet='23456789abcdefghijkmnopqrstuvwxyz').random(length=8)
         self.config = config
         self.status = SandboxStatus.INITIALIZING
         self.created_at = datetime.now()
@@ -136,12 +136,15 @@ class Sandbox(abc.ABC):
         result = await tool.execute(sandbox_context=self, **parameters)
         return result
 
-    async def execute_command(self, command: Union[str, List[str]], timeout: Optional[int] = None) -> CommandResult:
+    async def execute_command(
+        self, command: Union[str, List[str]], timeout: Optional[int] = None, stream: bool = True
+    ) -> CommandResult:
         """Execute a command in the sandbox environment.
 
         Args:
             command: Command to execute
             timeout: Optional execution timeout in seconds
+            stream: Whether to stream output (if supported)
         """
         raise NotImplementedError('execute_command must be implemented by subclasses')
 

ms_enclave/sandbox/boxes/docker_notebook.py

@@ -6,8 +6,6 @@ from pathlib import Path
 from textwrap import dedent
 from typing import Optional
 
-from docker import DockerClient
-
 from ms_enclave.utils import get_logger
 
 from ..model import DockerNotebookConfig, SandboxStatus, SandboxType
@@ -45,7 +43,7 @@ class DockerNotebookSandbox(DockerSandbox):
         self.kernel_id = None
         self.ws = None
         self.base_url = None
-        self.config.ports['8888/tcp'] = (self.host, self.port)
+        self.config.ports['8888/tcp'] = self.port
         self.config.network_enabled = True  # Ensure network is enabled for Jupyter
 
     @property
@@ -153,9 +151,9 @@ class DockerNotebookSandbox(DockerSandbox):
                     # Process and log build output
                     for log in build_logs[1]:  # build_logs[1] contains the build log generator
                         if 'stream' in log:
-                            logger.info(f"Docker build: {log['stream'].strip()}")
+                            logger.info(f"[📦 {self.id}] {log['stream'].strip()}")
                         elif 'error' in log:
-                            logger.error(f"Docker build error: {log['error']}")
+                            logger.error(f"[📦 {self.id}] {log['error']}")
                     return build_logs[0]  # Return the built image
 
                 await asyncio.get_event_loop().run_in_executor(None, build_image)

ms_enclave/sandbox/boxes/docker_sandbox.py

@@ -132,40 +132,105 @@ class DockerSandbox(Sandbox):
         """Return the container for tool execution."""
         return self.container
 
-    async def execute_command(self, command: Union[str, List[str]], timeout: Optional[int] = None) -> CommandResult:
-        """Execute a command in the container."""
-        if not self.container:
+    def _run_streaming(self, command: Union[str, List[str]]) -> tuple[int, str, str]:
+        """Execute command with streaming logs using low-level API.
+
+        Returns:
+            A tuple of (exit_code, stdout, stderr)
+        """
+        if not self.client or not self.container:
             raise RuntimeError('Container is not running')
 
+        # Use low-level API for precise control over streaming and exit code.
+        exec_id = self.client.api.exec_create(
+            container=self.container.id,
+            cmd=command,
+            tty=False,
+        )['Id']
+
+        stdout_parts: List[str] = []
+        stderr_parts: List[str] = []
+
         try:
-            # Determine actual timeout
-            actual_timeout = timeout or 30
-
-            # Execute command asynchronously
-            exec_result = await asyncio.wait_for(
-                asyncio.get_event_loop().run_in_executor(
-                    None, lambda: self.container.exec_run(command, tty=True, stream=False, demux=True)
-                ),
-                timeout=actual_timeout
-            )
+            for chunk in self.client.api.exec_start(exec_id, stream=True, demux=True):
+                if not chunk:
+                    continue
+                out, err = chunk  # each is Optional[bytes]
+                if out:
+                    text = out.decode('utf-8', errors='replace')
+                    stdout_parts.append(text)
+                    for line in text.splitlines():
+                        logger.info(f'[📦 {self.id}] {line}')
+                if err:
+                    text = err.decode('utf-8', errors='replace')
+                    stderr_parts.append(text)
+                    for line in text.splitlines():
+                        logger.error(f'[📦 {self.id}] {line}')
+        finally:
+            inspect = self.client.api.exec_inspect(exec_id)
+            exit_code = inspect.get('ExitCode')
+            if exit_code is None:
+                exit_code = -1
+
+        return exit_code, ''.join(stdout_parts), ''.join(stderr_parts)
+
+    def _run_buffered(self, command: Union[str, List[str]]) -> tuple[int, str, str]:
+        """Execute command and return buffered output using high-level API.
+
+        Returns:
+            A tuple of (exit_code, stdout, stderr)
+        """
+        if not self.container:
+            raise RuntimeError('Container is not running')
 
-            stdout = exec_result.output[0].decode('utf-8') if exec_result.output[0] else ''
-            stderr = exec_result.output[1].decode('utf-8') if exec_result.output[1] else ''
+        res = self.container.exec_run(command, tty=False, stream=False, demux=True)
+        out_tuple = res.output
+        if isinstance(out_tuple, tuple):
+            out_bytes, err_bytes = out_tuple
+        else:
+            # Fallback: when demux was not honored, treat all as stdout
+            out_bytes, err_bytes = out_tuple, b''
 
-            return CommandResult(
-                command=command,
-                status=ExecutionStatus.SUCCESS if exec_result.exit_code == 0 else ExecutionStatus.ERROR,
-                exit_code=exec_result.exit_code,
-                stdout=stdout,
-                stderr=stderr
+        stdout = out_bytes.decode('utf-8', errors='replace') if out_bytes else ''
+        stderr = err_bytes.decode('utf-8', errors='replace') if err_bytes else ''
+        return res.exit_code, stdout, stderr
+
+    async def execute_command(
+        self, command: Union[str, List[str]], timeout: Optional[int] = None, stream: bool = True
+    ) -> CommandResult:
+        """Execute a command in the container.
+
+        When stream=True (default), logs are printed in real-time through the logger,
+        while stdout/stderr are still accumulated and returned in the result.
+        When stream=False, the command is executed and buffered, returning the full output at once.
+
+        Args:
+            command: Command to run (str or list)
+            timeout: Optional timeout in seconds
+            stream: Whether to stream logs in real time
+
+        Returns:
+            CommandResult with status, exit_code, stdout and stderr
+        """
+        if not self.container or not self.client:
+            raise RuntimeError('Container is not running')
+
+        loop = asyncio.get_running_loop()
+
+        run_func = self._run_streaming if stream else self._run_buffered
+        try:
+            exit_code, stdout, stderr = await asyncio.wait_for(
+                loop.run_in_executor(None, lambda: run_func(command)), timeout=timeout
             )
+            status = ExecutionStatus.SUCCESS if exit_code == 0 else ExecutionStatus.ERROR
+            return CommandResult(command=command, status=status, exit_code=exit_code, stdout=stdout, stderr=stderr)
         except asyncio.TimeoutError:
             return CommandResult(
                 command=command,
                 status=ExecutionStatus.TIMEOUT,
                 exit_code=-1,
                 stdout='',
-                stderr=f'Command timed out after {actual_timeout} seconds'
+                stderr=f'Command timed out after {timeout} seconds'
             )
         except Exception as e:
             return CommandResult(command=command, status=ExecutionStatus.ERROR, exit_code=-1, stdout='', stderr=str(e))

ms_enclave/sandbox/model/config.py

@@ -1,6 +1,6 @@
 """Configuration data models."""
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from pydantic import BaseModel, Field, field_validator
 
@@ -25,7 +25,7 @@ class DockerSandboxConfig(SandboxConfig):
         default_factory=dict,
         description="Volume mounts. Format: { host_path: {'bind': container_path, 'mode': 'rw|ro'} }"
     )
-    ports: Dict[str, str] = Field(default_factory=dict, description='Port mappings')
+    ports: Dict[str, Union[int, str, Tuple[str, int]]] = Field(default_factory=dict, description='Port mappings')
     network: Optional[str] = Field('bridge', description='Network name')
     memory_limit: str = Field(default='1g', description='Memory limit')
     cpu_limit: float = Field(default=1.0, description='CPU limit')

ms_enclave/sandbox/tools/sandbox_tools/file_operation.py

@@ -3,6 +3,7 @@
 import io
 import os
 import tarfile
+import uuid
 from typing import TYPE_CHECKING, Literal, Optional
 
 from ms_enclave.sandbox.model import ExecutionStatus, SandboxType, ToolResult
@@ -16,6 +17,12 @@ if TYPE_CHECKING:
 
 @register_tool('file_operation')
 class FileOperation(SandboxTool):
+    """Tool for performing file operations within Docker containers.
+
+    Supports read, write, create, delete, list, and exists operations.
+    Uses temporary files and copy strategy to avoid permission issues
+    with mounted directories.
+    """
 
     _name = 'file_operation'
     _sandbox_type = SandboxType.DOCKER
@@ -53,17 +60,31 @@ class FileOperation(SandboxTool):
         content: Optional[str] = None,
         encoding: str = 'utf-8'
     ) -> ToolResult:
-        """Perform file operations in the Docker container."""
+        """Perform file operations in the Docker container.
+
+        Args:
+            sandbox_context: The sandbox instance to execute operations in
+            operation: Type of operation (read, write, create, delete, list, exists)
+            file_path: Path to the file or directory
+            content: Content to write (required for write/create operations)
+            encoding: File encoding for read/write operations
 
+        Returns:
+            ToolResult with operation status and output/error information
+        """
+
+        # Validate file path is provided and not empty
         if not file_path.strip():
             return ToolResult(
                 tool_name=self.name, status=ExecutionStatus.ERROR, output='', error='No file path provided'
             )
 
         try:
+            # Route to appropriate operation handler
             if operation == 'read':
                 return await self._read_file(sandbox_context, file_path, encoding)
             elif operation == 'write':
+                # Write operation requires content parameter
                 if content is None:
                     return ToolResult(
                         tool_name=self.name,
@@ -79,6 +100,7 @@ class FileOperation(SandboxTool):
             elif operation == 'exists':
                 return await self._check_exists(sandbox_context, file_path)
             elif operation == 'create':
+                # Create operation with empty content if none provided
                 if content is None:
                     content = ''
                 return await self._write_file(sandbox_context, file_path, content, encoding)
@@ -91,14 +113,24 @@ class FileOperation(SandboxTool):
                 )
 
         except Exception as e:
+            # Catch-all error handler for unexpected exceptions
             return ToolResult(
                 tool_name=self.name, status=ExecutionStatus.ERROR, output='', error=f'Operation failed: {str(e)}'
             )
 
     async def _read_file(self, sandbox_context: 'Sandbox', file_path: str, encoding: str) -> ToolResult:
-        """Read file content from the container."""
+        """Read file content from the container using cat command.
+
+        Args:
+            sandbox_context: Sandbox instance
+            file_path: Path to file to read
+            encoding: File encoding (currently not used by cat command)
+
+        Returns:
+            ToolResult with file content or error message
+        """
         try:
-            # Use cat command to read file content
+            # Use cat command to read file content - handles most file types well
             result = await sandbox_context.execute_command(f'cat "{file_path}"')
 
             if result.exit_code == 0:
@@ -116,15 +148,49 @@ class FileOperation(SandboxTool):
             )
 
     async def _write_file(self, sandbox_context: 'Sandbox', file_path: str, content: str, encoding: str) -> ToolResult:
-        """Write content to a file in the container."""
+        """Write content to a file in the container using temp file strategy.
+
+        This method uses a two-step process to avoid permission issues:
+        1. Write content to a temporary file in /tmp (always writable)
+        2. Copy the temp file to the target location using cp command
+        3. Clean up the temporary file
+
+        Args:
+            sandbox_context: Sandbox instance
+            file_path: Target file path to write to
+            content: Content to write to file
+            encoding: File encoding for content
+
+        Returns:
+            ToolResult indicating success or failure
+        """
         try:
-            # Create directory if it doesn't exist
+            # Create target directory structure if it doesn't exist
             dir_path = os.path.dirname(file_path)
             if dir_path:
                 await sandbox_context.execute_command(f'mkdir -p "{dir_path}"')
 
-            # Write file using tar archive (similar to python_executor)
-            await self._write_file_to_container(sandbox_context, file_path, content)
+            # Generate unique temporary file name to avoid conflicts
+            temp_file = f'/tmp/file_op_{uuid.uuid4().hex}'
+
+            # Step 1: Write content to temporary location using tar archive
+            await self._write_file_to_container(sandbox_context, temp_file, content, encoding)
+
+            # Step 2: Copy from temp to target location using cp command
+            # This handles permission issues better than direct tar extraction
+            copy_result = await sandbox_context.execute_command(f'cp "{temp_file}" "{file_path}"')
+
+            # Step 3: Clean up temporary file regardless of copy result
+            await sandbox_context.execute_command(f'rm -f "{temp_file}"')
+
+            # Check if copy operation succeeded
+            if copy_result.exit_code != 0:
+                return ToolResult(
+                    tool_name=self.name,
+                    status=ExecutionStatus.ERROR,
+                    output='',
+                    error=f'Failed to copy file to target location: {copy_result.stderr or "Unknown error"}'
+                )
 
             return ToolResult(
                 tool_name=self.name,
@@ -138,8 +204,19 @@ class FileOperation(SandboxTool):
             )
 
     async def _delete_file(self, sandbox_context: 'Sandbox', file_path: str) -> ToolResult:
-        """Delete a file or directory from the container."""
+        """Delete a file or directory from the container.
+
+        Uses 'rm -rf' to handle both files and directories recursively.
+
+        Args:
+            sandbox_context: Sandbox instance
+            file_path: Path to file or directory to delete
+
+        Returns:
+            ToolResult indicating success or failure
+        """
         try:
+            # Use rm -rf to handle both files and directories
             result = await sandbox_context.execute_command(f'rm -rf "{file_path}"')
 
             if result.exit_code == 0:
@@ -162,8 +239,19 @@ class FileOperation(SandboxTool):
             )
 
     async def _list_directory(self, sandbox_context: 'Sandbox', dir_path: str) -> ToolResult:
-        """List contents of a directory."""
+        """List contents of a directory with detailed information.
+
+        Uses 'ls -la' to show permissions, ownership, size, and timestamps.
+
+        Args:
+            sandbox_context: Sandbox instance
+            dir_path: Path to directory to list
+
+        Returns:
+            ToolResult with directory listing or error message
+        """
         try:
+            # Use ls -la for detailed directory listing
             result = await sandbox_context.execute_command(f'ls -la "{dir_path}"')
 
             if result.exit_code == 0:
@@ -181,10 +269,22 @@ class FileOperation(SandboxTool):
             )
 
     async def _check_exists(self, sandbox_context: 'Sandbox', file_path: str) -> ToolResult:
-        """Check if a file or directory exists."""
+        """Check if a file or directory exists.
+
+        Uses 'test -e' command which returns exit code 0 if path exists.
+
+        Args:
+            sandbox_context: Sandbox instance
+            file_path: Path to check for existence
+
+        Returns:
+            ToolResult with existence status message
+        """
         try:
+            # Use test -e to check existence (works for files and directories)
             result = await sandbox_context.execute_command(f'test -e "{file_path}"')
 
+            # test command returns 0 if path exists, non-zero otherwise
             exists = result.exit_code == 0
             return ToolResult(
                 tool_name=self.name,
@@ -197,19 +297,35 @@ class FileOperation(SandboxTool):
                 tool_name=self.name, status=ExecutionStatus.ERROR, output='', error=f'Exists check failed: {str(e)}'
             )
 
-    async def _write_file_to_container(self, sandbox_context: 'Sandbox', file_path: str, content: str) -> None:
-        """Write content to a file in the container using tar archive."""
-        # Create a tar archive in memory
+    async def _write_file_to_container(
+        self, sandbox_context: 'Sandbox', file_path: str, content: str, encoding: str
+    ) -> None:
+        """Write content to a file in the container using tar archive method.
+
+        This is a low-level method that creates a tar archive containing the file
+        and extracts it to the container. Used internally by _write_file.
+
+        Args:
+            sandbox_context: Sandbox instance with container access
+            file_path: Target file path in container
+            content: File content as string
+            encoding: Text encoding for content conversion
+
+        Raises:
+            Exception: If tar creation or container extraction fails
+        """
+        # Create a tar archive in memory to transfer file content
         tar_stream = io.BytesIO()
         tar = tarfile.TarFile(fileobj=tar_stream, mode='w')
 
-        # Add file to tar
-        file_data = content.encode('utf-8')
+        # Encode content using specified encoding and create tar entry
+        file_data = content.encode(encoding)
         tarinfo = tarfile.TarInfo(name=os.path.basename(file_path))
         tarinfo.size = len(file_data)
         tar.addfile(tarinfo, io.BytesIO(file_data))
         tar.close()
 
-        # Write to container
+        # Extract tar archive to container filesystem
+        # Note: This writes to the directory containing the target file
         tar_stream.seek(0)
-        sandbox_context.container.put_archive(os.path.dirname(file_path), tar_stream.getvalue())
+        sandbox_context.container.put_archive(os.path.dirname(file_path) or '/', tar_stream.getvalue())

ms_enclave/utils/logger.py

@@ -2,76 +2,127 @@
 import importlib.util
 import logging
 import os
-from contextlib import contextmanager
+import sys
+import threading
 from types import MethodType
 from typing import Optional
 
 init_loggers = {}
 
+# ANSI color helpers for levelname coloring in TTY streams
+RESET = '\033[0m'
+LEVEL_COLORS = {
+    'DEBUG': '\033[34m',  # Blue
+    'INFO': '\033[32m',  # Green
+    'WARNING': '\033[33m',  # Yellow
+    'ERROR': '\033[31m',  # Red
+    'CRITICAL': '\033[35m',  # Magenta
+}
+
 logger_format = logging.Formatter('[%(levelname)s:%(name)s] %(message)s')
 
 info_set = set()
 warning_set = set()
+_once_lock = threading.Lock()
+
+
+class ColorFormatter(logging.Formatter):
+    """Formatter that colors only the levelname for TTY streams."""
+
+    def __init__(self, fmt: str, datefmt: Optional[str] = None, style: str = '%', use_color: bool = True) -> None:
+        super().__init__(fmt=fmt, datefmt=datefmt, style=style)
+        self.use_color = use_color
+
+    def format(self, record: logging.LogRecord) -> str:
+        original_levelname = record.levelname
+        try:
+            if self.use_color:
+                color = LEVEL_COLORS.get(record.levelname, '')
+                if color:
+                    record.levelname = f'{color}{record.levelname}{RESET}'
+            return super().format(record)
+        finally:
+            record.levelname = original_levelname
+
+
+def _should_use_color(stream) -> bool:
+    """Decide if we should use colors for a given stream based on TTY and env."""
+    # Respect NO_COLOR to disable, FORCE_COLOR or LOG_COLOR=1 to force enable
+    if os.getenv('NO_COLOR'):
+        return False
+    if os.getenv('FORCE_COLOR') or os.getenv('LOG_COLOR') == '1':
+        return True
+    try:
+        return hasattr(stream, 'isatty') and stream.isatty()
+    except Exception:
+        return False
+
+
+def info_once(self: logging.Logger, msg: str, *args, **kwargs) -> None:
+    hash_id = kwargs.pop('hash_id', msg)
+    with _once_lock:
+        if hash_id in info_set:
+            return
+        info_set.add(hash_id)
+    self.info(msg, *args, **kwargs)
 
 
-def info_once(self, msg, *args, **kwargs):
-    hash_id = kwargs.get('hash_id') or msg
-    if hash_id in info_set:
-        return
-    info_set.add(hash_id)
-    self.info(msg)
+def warning_once(self: logging.Logger, msg: str, *args, **kwargs) -> None:
+    hash_id = kwargs.pop('hash_id', msg)
+    with _once_lock:
+        if hash_id in warning_set:
+            return
+        warning_set.add(hash_id)
+    self.warning(msg, *args, **kwargs)
 
 
-def warning_once(self, msg, *args, **kwargs):
-    hash_id = kwargs.get('hash_id') or msg
-    if hash_id in warning_set:
-        return
-    warning_set.add(hash_id)
-    self.warning(msg)
+def _update_handler_levels(logger: logging.Logger, log_level: int) -> None:
+    """Set all handler levels to the given log level."""
+    for handler in logger.handlers:
+        handler.setLevel(log_level)
 
 
 def get_logger(log_file: Optional[str] = None, log_level: Optional[int] = None, file_mode: str = 'w'):
-    """ Get logging logger
+    """Get project logger configured with colored console output and optional file output.
 
     Args:
-        log_file: Log filename, if specified, file handler will be added to
-            logger
-        log_level: Logging level.
-        file_mode: Specifies the mode to open the file, if filename is
-            specified (if filemode is unspecified, it defaults to 'w').
+        log_file: Log filename. If specified, a FileHandler will be added to the logger.
+        log_level: Logging level. If None, resolve from env LOG_LEVEL (default INFO).
+        file_mode: Mode to open the log file if log_file is provided (default 'w').
     """
     if log_level is None:
-        log_level = os.getenv('LOG_LEVEL', 'INFO').upper()
-        log_level = getattr(logging, log_level, logging.INFO)
+        env_level = os.getenv('LOG_LEVEL', 'INFO').upper()
+        log_level = getattr(logging, env_level, logging.INFO)
+
     logger_name = __name__.split('.')[0]
     logger = logging.getLogger(logger_name)
     logger.propagate = False
+
+    # If logger is already initialized, just ensure file handler and update handler levels.
     if logger_name in init_loggers:
         add_file_handler_if_needed(logger, log_file, file_mode, log_level)
+        _update_handler_levels(logger, log_level)
         return logger
 
-    # handle duplicate logs to the console
-    # Starting in 1.8.0, PyTorch DDP attaches a StreamHandler <stderr> (NOTSET)
-    # to the root logger. As logger.propagate is True by default, this root
-    # level handler causes logging messages from rank>0 processes to
-    # unexpectedly show up on the console, creating much unwanted clutter.
-    # To fix this issue, we set the root logger's StreamHandler, if any, to log
-    # at the ERROR level.
+    # Handle duplicate logs to the console (PyTorch DDP root StreamHandler quirk)
     for handler in logger.root.handlers:
-        if type(handler) is logging.StreamHandler:
+        if isinstance(handler, logging.StreamHandler):
             handler.setLevel(logging.ERROR)
 
-    stream_handler = logging.StreamHandler()
-    handlers = [stream_handler]
+    # Console handler with colorized levelname when appropriate
+    stream_handler = logging.StreamHandler(stream=sys.stderr)
+    use_color = _should_use_color(getattr(stream_handler, 'stream', sys.stderr))
+    color_fmt = ColorFormatter('[%(levelname)s:%(name)s] %(message)s', use_color=use_color)
+    stream_handler.setFormatter(color_fmt)
+    stream_handler.setLevel(log_level)
+    logger.addHandler(stream_handler)
 
+    # Optional file handler (no color)
     if log_file is not None:
         file_handler = logging.FileHandler(log_file, file_mode)
-        handlers.append(file_handler)
-
-    for handler in handlers:
-        handler.setFormatter(logger_format)
-        handler.setLevel(log_level)
-        logger.addHandler(handler)
+        file_handler.setFormatter(logger_format)
+        file_handler.setLevel(log_level)
+        logger.addHandler(file_handler)
 
     logger.setLevel(log_level)
     init_loggers[logger_name] = True
@@ -81,26 +132,39 @@ def get_logger(log_file: Optional[str] = None, log_level: Optional[int] = None,
 
 
 logger = get_logger()
-# ms_logger = get_ms_logger()
 
-logger.handlers[0].setFormatter(logger_format)
-# ms_logger.handlers[0].setFormatter(logger_format)
-log_level = os.getenv('LOG_LEVEL', 'INFO').upper()
-# ms_logger.setLevel(log_level)
 
+def add_file_handler_if_needed(logger: logging.Logger, log_file: Optional[str], file_mode: str, log_level: int) -> None:
+    """Attach a FileHandler for the given log_file if not already present.
 
-def add_file_handler_if_needed(logger, log_file, file_mode, log_level):
-    for handler in logger.handlers:
-        if isinstance(handler, logging.FileHandler):
-            return
+    Ensures:
+    - Only one FileHandler per log file path.
+    - FileHandler uses the standard, uncolored formatter.
+    - FileHandler level matches the requested log_level.
+    """
+    if log_file is None:
+        return
 
+    # Only worker 0 writes logs when torch DDP is present
     if importlib.util.find_spec('torch') is not None:
         is_worker0 = int(os.getenv('LOCAL_RANK', -1)) in {-1, 0}
     else:
         is_worker0 = True
 
-    if is_worker0 and log_file is not None:
-        file_handler = logging.FileHandler(log_file, file_mode)
-        file_handler.setFormatter(logger_format)
-        file_handler.setLevel(log_level)
-        logger.addHandler(file_handler)
+    if not is_worker0:
+        return
+
+    abs_path = os.path.abspath(log_file)
+    for handler in logger.handlers:
+        if isinstance(handler, logging.FileHandler):
+            # If a handler is already logging to the same file, just update it
+            if getattr(handler, 'baseFilename', None) == abs_path:
+                handler.setFormatter(logger_format)
+                handler.setLevel(log_level)
+                return
+
+    # Add a new file handler for this log file
+    file_handler = logging.FileHandler(abs_path, file_mode)
+    file_handler.setFormatter(logger_format)
+    file_handler.setLevel(log_level)
+    logger.addHandler(file_handler)

ms_enclave/version.py

@@ -1,2 +1,2 @@
-__version__ = '0.0.1'
-__release_date__ = '2025-10-20 12:00:00'
+__version__ = '0.0.2'
+__release_date__ = '2025-10-30 12:00:00'

{ms_enclave-0.0.1.dist-info → ms_enclave-0.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ms-enclave
-Version: 0.0.1
+Version: 0.0.2
 Summary: Modularized and Stable Sandbox runtime environment.
 Author: ModelScope team
 Author-email: contact@modelscope.cn
@@ -29,13 +29,26 @@ Requires-Dist: docker>=7.1.0; extra == "docker"
 Requires-Dist: websocket-client; extra == "docker"
 Dynamic: license-file
 
-# ms-enclave
+<p align="center">
+    <br>
+    <img src="doc/asset/image/logo.png"/>
+    <br>
+<p>
 
-A modular and stable sandbox runtime environment
+<p align="center">
+  <a href="README_zh.md">中文</a> &nbsp ｜ &nbsp English &nbsp
+</p>
+
+<p align="center">
+<img src="https://img.shields.io/badge/python-%E2%89%A53.10-5be.svg">
+<a href="https://badge.fury.io/py/ms-enclave"><img src="https://badge.fury.io/py/ms-enclave.svg" alt="PyPI version" height="18"></a>
+<a href="https://pypi.org/project/ms-enclave"><img alt="PyPI - Downloads" src="https://static.pepy.tech/badge/ms-enclave"></a>
+<a href="https://github.com/modelscope/ms-enclave/pulls"><img src="https://img.shields.io/badge/PR-welcome-55EB99.svg"></a>
+<p>
 
 ## Overview
 
-ms-enclave is a modular and stable sandbox runtime environment that provides a secure isolated execution environment for applications. It achieves strong isolation through Docker containers, with accompanying local/HTTP managers and an extensible tool system, enabling you to safely and efficiently execute code in a controlled environment.
+ms-enclave is a modular and stable agent sandbox runtime environment that provides a secure isolated execution environment for applications. It achieves strong isolation through Docker containers, with accompanying local/HTTP managers and an extensible tool system, enabling you to safely and efficiently execute code in a controlled environment.
 
 - 🔒 Secure Isolation: Full isolation and resource limitation based on Docker
 - 🧩 Modular: Extensible sandbox and tools (registration factory)
@@ -246,6 +259,45 @@ DockerNotebookConfig(tools_config={'notebook_executor': {}})
 - `network_enabled`: Enable network (Notebook sandbox requires True)
 - `remove_on_exit`: Automatically remove container on exit (default True)
 
+**Example of Installing Additional Dependencies in Sandbox**
+
+```python
+async with SandboxFactory.create_sandbox(SandboxType.DOCKER, config) as sandbox:
+    # 1) Write a file
+    requirements_file = '/sandbox/requirements.txt'
+    await sandbox.execute_tool('file_operation', {
+        'operation': 'write', 'file_path': f'{requirements_file}', 'content': 'numpy\npandas\nmodelscope\n'
+    })
+    # 2) Execute Python code
+    result = await sandbox.execute_tool('python_executor', {
+        'code': f"print('Hello from sandbox!')\nprint(open(f'{requirements_file}').read())"
+    })
+    print(result.output)
+
+    # 3) Execute CLI
+    result_cli = await sandbox.execute_command(f'pip install -r {requirements_file}')
+    print(result_cli.stdout, flush=True)
+```
+
+**Example of Reading and Writing Host Files in Sandbox**
+
+```python
+async with LocalSandboxManager() as manager:
+    # Create sandbox
+    config = DockerSandboxConfig(
+        # image='python-sandbox',
+        image='python:3.11-slim',
+        tools_config={'python_executor': {}, 'file_operation': {}},
+        volumes={'~/Code/ms-enclave/output': {'bind': '/sandbox/data', 'mode': 'rw'}}
+    )
+    sandbox_id = await manager.create_sandbox(SandboxType.DOCKER, config)
+
+    # Write file
+    result = await manager.execute_tool(
+        sandbox_id, 'file_operation', {'operation': 'write', 'file_path': '/sandbox/data/hello.txt', 'content': 'Hello, Sandbox!'}
+    )
+    print(result.model_dump())
+```
 ---
 
 ## Error Handling and Debugging

{ms_enclave-0.0.1.dist-info → ms_enclave-0.0.2.dist-info}/RECORD

@@ -1,21 +1,21 @@
 ms_enclave/__init__.py,sha256=IKXP5d9APyqXs14IU1mBKSr8tGxAwxeCtCnAWTOGhAU,98
-ms_enclave/version.py,sha256=iIYc2bTwqcyBXtHZ-2FADaG3HGNUR2-XWW7pz0aAdlc,63
+ms_enclave/version.py,sha256=WqqLptwhThO-50eN9GEdqDPEtMsOV0svfTEXxTezYvE,63
 ms_enclave/cli/__init__.py,sha256=I_ANdxdcIHpkIzIXc1yKOlWwzb4oY0FwTPq1kYtgzQw,50
 ms_enclave/cli/base.py,sha256=m1DFlF16L0Lyrn0YNuFj8ByGjVJIoI0jKzAoodIXjRk,404
 ms_enclave/cli/cli.py,sha256=AoSPw65_7OBMT8qgv5vPz1S3Fo91Y6yluaDGGHbUDj0,693
 ms_enclave/cli/start_server.py,sha256=FPmZ97MhWgsyXkl0y32D4XjhAak5Ogrt0Am3izRdi74,2858
 ms_enclave/sandbox/__init__.py,sha256=OPU_W5fZE98IQ8_pAaYkN66R8TZw435Co8uw9oAyZo4,783
 ms_enclave/sandbox/boxes/__init__.py,sha256=it3KgV8cAU4a1TQbiRz-kg7GgI5xA0nqhEAwEgUnpnQ,356
-ms_enclave/sandbox/boxes/base.py,sha256=bpo5fXtfIUeIlhcQBtNyH1fiPbYJlOfKx2mNyaBiHhA,8376
-ms_enclave/sandbox/boxes/docker_notebook.py,sha256=54s4SlttGpXSckVfncb75i1GsZ6FAkYRPeDVgzzHoQQ,8035
-ms_enclave/sandbox/boxes/docker_sandbox.py,sha256=JhrFbY8k7ELwRsUcdsce9wND8G90xCKW-g3Bc4pJnec,9069
+ms_enclave/sandbox/boxes/base.py,sha256=lLjktdh4YQABr7X-lTLne2VN2Uv6Rcc5TN5LYx_NLxc,8532
+ms_enclave/sandbox/boxes/docker_notebook.py,sha256=-6O54MRNpiGAaQTiI9_1LCl0zzvB2se2_M1Bi8FuZ3s,7989
+ms_enclave/sandbox/boxes/docker_sandbox.py,sha256=ouFPtJyoSeZrQKD61Qyhq13QSuZl1Ut2gD1KgBbKPUs,11755
 ms_enclave/sandbox/manager/__init__.py,sha256=juYJsmpRoCThcILPemx6VGU-brpNF4cbu1FPV-d-tNc,255
 ms_enclave/sandbox/manager/base.py,sha256=nXznN8Yysgkgk8i-yfL29gAh2gBi3sdxPlQciTXnN9g,3848
 ms_enclave/sandbox/manager/http_manager.py,sha256=heVehKDi_VMJ5g9BllzmK5o68c2WIagsl8e231SKWtc,15731
 ms_enclave/sandbox/manager/local_manager.py,sha256=lv7vF9sNOThOPnCz9RzNTcD0pZHoNTVldVanfF7c5Io,9402
 ms_enclave/sandbox/model/__init__.py,sha256=3Sbj5Id77MWOZ1IXHGbu2q5U_p5KMLKvwZEr1QwjUqg,550
 ms_enclave/sandbox/model/base.py,sha256=1X5PaCUC5B5GXVCTzQMybqF7t0QEhWUkYFC-DyYXdhY,709
-ms_enclave/sandbox/model/config.py,sha256=SfOUlzFY5pdzRX3Ts0T9Lc0J-WbbbNKLFnVMKiLXfyY,4580
+ms_enclave/sandbox/model/config.py,sha256=afiSu5QcaZsd36lSoWMDmzz6o6kxTGebHzAqgLQOG_w,4616
 ms_enclave/sandbox/model/requests.py,sha256=JDcANsACotKscWrLs0H_-J8BKEhALUNgmJnoy6_JZuA,2336
 ms_enclave/sandbox/model/responses.py,sha256=AZ_BspRHzlqIP7xjI9XnoeQasIzJqMV8Qmdw23-KAwA,2502
 ms_enclave/sandbox/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -25,16 +25,16 @@ ms_enclave/sandbox/tools/base.py,sha256=vLTJMFOQnfKyTyMMcgeq5f7KBFEFV5y7PFZmb4Ss
 ms_enclave/sandbox/tools/sandbox_tool.py,sha256=iATkvNax7aae53ZnmMwmQDuDb5qcXEUI-aPXD5eVfzo,1370
 ms_enclave/sandbox/tools/tool_info.py,sha256=A3RZLETWG9834J7r2KZfG6_JdV4UWnrFKSrEBfeCLHE,5223
 ms_enclave/sandbox/tools/sandbox_tools/__init__.py,sha256=Mtm2jQTrztLbRVDBiitogIB3GdIrwF3Hwk5KlruyntQ,176
-ms_enclave/sandbox/tools/sandbox_tools/file_operation.py,sha256=EdTvIjxnnG6kQ9y-6WESofyO6edqe_zee1wp-hsUBu0,8692
+ms_enclave/sandbox/tools/sandbox_tools/file_operation.py,sha256=3yqkMdx_yrHUM4oyhd5WQm_tSV3o1-JwmBeVoIwaLfE,13348
 ms_enclave/sandbox/tools/sandbox_tools/notebook_executor.py,sha256=kZf9QA0yk-aFOJjtAbzYdKfNwjcoBSrscT9mWsv906w,6029
 ms_enclave/sandbox/tools/sandbox_tools/python_executor.py,sha256=SlhenlO09B_eVfcnrqSZAVYC_JCMws0eXj-caR2BTmw,3259
 ms_enclave/sandbox/tools/sandbox_tools/shell_executor.py,sha256=d5qPv6O1K1V91fsGAf9MiArcRuLtjFWEthi4iwtmAEE,2263
 ms_enclave/utils/__init__.py,sha256=KYWYfti4m8TcWzjOfmollEfEArTgTasq2Zuaz9AkzZI,31
 ms_enclave/utils/json_schema.py,sha256=hBhdMilb9_7JZaFZBb_THPrq8N4m_rJPD43mfwnTx14,7431
-ms_enclave/utils/logger.py,sha256=kMqK-5d1S5uPmalHtEW8NuUiwuq3xR75i9xih4ayT58,3459
-ms_enclave-0.0.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ms_enclave-0.0.1.dist-info/METADATA,sha256=IBvVyPpZG1grwPjwhoCquEu-Qdms9z0eF1gCY5DSlHQ,9959
-ms_enclave-0.0.1.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-ms_enclave-0.0.1.dist-info/entry_points.txt,sha256=Av3oIAE91Jj-742sTPA90ktrrq8lDowFC2RfXLwM8JM,58
-ms_enclave-0.0.1.dist-info/top_level.txt,sha256=V_Q9rBOF-RGwACDP9ppukoyjaOtpjdht7dhe7StS86A,11
-ms_enclave-0.0.1.dist-info/RECORD,,
+ms_enclave/utils/logger.py,sha256=Hg_iVhgUX39LlWiQsvCyDx9NwQt3wQUukbOSCiLYEQU,5974
+ms_enclave-0.0.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ms_enclave-0.0.2.dist-info/METADATA,sha256=Pqe2xTBcURL8-edgOc9wBSo7SAUb8L2gjcURrqqYvyU,12016
+ms_enclave-0.0.2.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+ms_enclave-0.0.2.dist-info/entry_points.txt,sha256=Av3oIAE91Jj-742sTPA90ktrrq8lDowFC2RfXLwM8JM,58
+ms_enclave-0.0.2.dist-info/top_level.txt,sha256=V_Q9rBOF-RGwACDP9ppukoyjaOtpjdht7dhe7StS86A,11
+ms_enclave-0.0.2.dist-info/RECORD,,