massgen 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

massgen/filesystem_manager/_code_execution_server.py

@@ -62,7 +62,7 @@ def _validate_path_access(path: Path, allowed_paths: List[Path]) -> None:
     raise ValueError(f"Path not in allowed directories: {path}")
 
 
-def _sanitize_command(command: str) -> None:
+def _sanitize_command(command: str, enable_sudo: bool = False) -> None:
     """
     Sanitize the command to prevent dangerous operations.
 
@@ -71,6 +71,7 @@ def _sanitize_command(command: str) -> None:
 
     Args:
         command: The command to sanitize
+        enable_sudo: Whether sudo is enabled (in Docker mode with sudo variant)
 
     Raises:
         ValueError: If dangerous command is detected
@@ -82,13 +83,20 @@ def _sanitize_command(command: str) -> None:
         (r"\bdd\b", "Use of 'dd' command is not allowed"),
         (r">\s*/dev/sd[a-z][1-9]?", "Overwriting disk blocks directly is not allowed"),
         (r":\(\)\{\s*:\|\:&\s*\};:", "Fork bombs are not allowed"),
-        # Additional safety patterns
-        (r"\bsudo\b", "Use of 'sudo' is not allowed"),
-        (r"\bsu\b", "Use of 'su' is not allowed"),
-        (r"\bchown\b", "Use of 'chown' is not allowed"),
-        (r"\bchmod\b", "Use of 'chmod' is not allowed"),
     ]
 
+    # Only check these patterns if sudo is NOT enabled
+    # When sudo is enabled (Docker mode with sudo variant), these are safe
+    if not enable_sudo:
+        dangerous_patterns.extend(
+            [
+                (r"\bsudo\b", "Use of 'sudo' is not allowed"),
+                (r"\bsu\b", "Use of 'su' is not allowed"),
+                (r"\bchown\b", "Use of 'chown' is not allowed"),
+                (r"\bchmod\b", "Use of 'chmod' is not allowed"),
+            ],
+        )
+
     for pattern, message in dangerous_patterns:
         if re.search(pattern, command):
             raise ValueError(f"Potentially dangerous command detected: {message}")
@@ -202,6 +210,12 @@ async def create_server() -> fastmcp.FastMCP:
         default=None,
         help="Agent ID (required for Docker mode to identify container)",
     )
+    parser.add_argument(
+        "--enable-sudo",
+        action="store_true",
+        default=False,
+        help="Enable sudo in Docker containers (disables sudo command sanitization checks)",
+    )
     args = parser.parse_args()
 
     # Create the FastMCP server
@@ -215,6 +229,7 @@ async def create_server() -> fastmcp.FastMCP:
     mcp.blocked_commands = args.blocked_commands  # Blacklist patterns
     mcp.execution_mode = args.execution_mode
     mcp.agent_id = args.agent_id
+    mcp.enable_sudo = args.enable_sudo
 
     # Initialize Docker client if Docker mode
     mcp.docker_client = None
@@ -294,7 +309,7 @@ async def create_server() -> fastmcp.FastMCP:
         try:
             # Basic command sanitization (dangerous patterns)
             try:
-                _sanitize_command(command)
+                _sanitize_command(command, enable_sudo=mcp.enable_sudo)
             except ValueError as e:
                 return {
                     "success": False,

massgen/filesystem_manager/_docker_manager.py

@@ -45,6 +45,7 @@ class DockerManager:
         network_mode: str = "none",
         memory_limit: Optional[str] = None,
         cpu_limit: Optional[float] = None,
+        enable_sudo: bool = False,
     ):
         """
         Initialize Docker manager.
@@ -54,6 +55,7 @@ class DockerManager:
             network_mode: Network mode (none/bridge/host)
             memory_limit: Memory limit (e.g., "2g", "512m")
             cpu_limit: CPU limit (e.g., 2.0 for 2 CPUs)
+            enable_sudo: Enable sudo access in containers (isolated from host system)
 
         Raises:
             RuntimeError: If Docker is not available or cannot connect
@@ -61,7 +63,20 @@ class DockerManager:
         if not DOCKER_AVAILABLE:
             raise RuntimeError("Docker Python library not available. Install with: pip install docker")
 
-        self.image = image
+        # If sudo is enabled and user is using default image, switch to sudo variant
+        self.enable_sudo = enable_sudo
+        if enable_sudo and image == "massgen/mcp-runtime:latest":
+            self.image = "massgen/mcp-runtime-sudo:latest"
+            logger.info(
+                "ℹ️ [Docker] Sudo access enabled in container (isolated from host) - using 'massgen/mcp-runtime-sudo:latest' image.",
+            )
+        elif enable_sudo:
+            logger.info(
+                "ℹ️ [Docker] Sudo access enabled in container (isolated from host) with custom image.",
+            )
+        else:
+            self.image = image
+
         self.network_mode = network_mode
         self.memory_limit = memory_limit
         self.cpu_limit = cpu_limit
@@ -103,6 +118,11 @@ class DockerManager:
                 self.client.images.pull(self.image)
                 logger.info(f"✅ [Docker] Successfully pulled image '{self.image}'")
             except DockerException as e:
+                # Special handling for sudo image - it's built locally, not pulled
+                if "mcp-runtime-sudo" in self.image:
+                    raise RuntimeError(
+                        f"Failed to pull Docker image '{self.image}': {e}\n" f"The sudo image must be built locally. Run:\n" f"    bash massgen/docker/build.sh --sudo",
+                    )
                 raise RuntimeError(f"Failed to pull Docker image '{self.image}': {e}")
 
     def create_container(

massgen/filesystem_manager/_filesystem_manager.py

@@ -55,6 +55,7 @@ class FilesystemManager:
         command_line_docker_memory_limit: Optional[str] = None,
         command_line_docker_cpu_limit: Optional[float] = None,
         command_line_docker_network_mode: str = "none",
+        command_line_docker_enable_sudo: bool = False,
         enable_audio_generation: bool = False,
     ):
         """
@@ -75,6 +76,7 @@ class FilesystemManager:
             command_line_docker_memory_limit: Memory limit for Docker containers (e.g., "2g")
             command_line_docker_cpu_limit: CPU limit for Docker containers (e.g., 2.0 for 2 CPUs)
             command_line_docker_network_mode: Network mode for Docker containers (none/bridge/host)
+            command_line_docker_enable_sudo: Enable sudo access in Docker containers (isolated from host system)
         """
         self.agent_id = None  # Will be set by orchestrator via setup_orchestration_paths
         self.enable_image_generation = enable_image_generation
@@ -86,6 +88,7 @@ class FilesystemManager:
         self.command_line_docker_memory_limit = command_line_docker_memory_limit
         self.command_line_docker_cpu_limit = command_line_docker_cpu_limit
         self.command_line_docker_network_mode = command_line_docker_network_mode
+        self.command_line_docker_enable_sudo = command_line_docker_enable_sudo
 
         # Initialize Docker manager if Docker mode enabled
         self.docker_manager = None
@@ -97,6 +100,7 @@ class FilesystemManager:
                 network_mode=command_line_docker_network_mode,
                 memory_limit=command_line_docker_memory_limit,
                 cpu_limit=command_line_docker_cpu_limit,
+                enable_sudo=command_line_docker_enable_sudo,
             )
         self.enable_audio_generation = enable_audio_generation
 
@@ -360,6 +364,10 @@ class FilesystemManager:
         if self.command_line_execution_mode == "docker" and self.agent_id:
             config["args"].extend(["--agent-id", self.agent_id])
 
+        # Add sudo flag for Docker mode
+        if self.command_line_execution_mode == "docker" and self.command_line_docker_enable_sudo:
+            config["args"].append("--enable-sudo")
+
         # Add command filters if specified
         if self.command_line_allowed_commands:
             config["args"].extend(["--allowed-commands"] + self.command_line_allowed_commands)