Add isolated container functionality for fresh instances

- Modified CodeRunner constructor to support isolated=True parameter (default)
- Added ContainerManager.create_isolated_container() with unique port allocation
- Implemented cleanup methods for isolated containers with context manager support
- Added comprehensive tests for isolated vs shared container modes
- Users now get fresh isolated containers by default instead of shared ones
- Maintains backward compatibility with isolated=False for shared containers

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: abhishek-anand

__init__.py

@@ -3,13 +3,16 @@
 
 Zero-configuration local code execution with seamless cloud migration.
 
-Basic Usage:
+Basic Usage (Isolated Fresh Container):
     from coderunner import CodeRunner
     
-    runner = CodeRunner()  # Auto-starts container
+    runner = CodeRunner()  # Creates fresh isolated container
     result = runner.execute("print('Hello World!')")
     print(result['stdout'])  # "Hello World!"
 
+Shared Container (for backward compatibility):
+    runner = CodeRunner(isolated=False)  # Reuses shared container
+
 Cloud Migration:
     from coderunner.cloud import InstaVM as CodeRunner
     
@@ -32,26 +35,40 @@
 class CodeRunner:
     """Local code execution without API keys or cloud setup"""
 
-    def __init__(self, auto_start: bool = True, base_url: str = None):
+    def __init__(self, auto_start: bool = True, base_url: str = None, isolated: bool = True):
         """
         Initialize CodeRunner client
         
         Args:
             auto_start: Automatically start container if not running
             base_url: Custom REST API base URL (for testing)
+            isolated: Create isolated fresh container (True) or reuse shared (False)
         """
-        self.base_url = base_url or "http://localhost:8223"
-        self.session_id: Optional[str] = None
+        self.isolated = isolated
+        self.container_id: Optional[str] = None
         self._session = requests.Session()
 
         # Set reasonable timeouts
         self._session.timeout = 30
 
-        if auto_start:
+        if isolated and auto_start:
+            # Create isolated fresh container
             try:
-                ContainerManager.ensure_running()
+                self.container_id, ports = ContainerManager.create_isolated_container()
+                self.base_url = f"http://localhost:{ports['rest']}"
+                logger.info(f"Created isolated container {self.container_id} on port {ports['rest']}")
             except Exception as e:
-                raise CodeRunnerError(f"Failed to start CodeRunner: {e}")
+                raise CodeRunnerError(f"Failed to create isolated container: {e}")
+        else:
+            # Use shared container (backward compatibility)
+            self.base_url = base_url or "http://localhost:8223"
+            if auto_start:
+                try:
+                    ContainerManager.ensure_running()
+                except Exception as e:
+                    raise CodeRunnerError(f"Failed to start CodeRunner: {e}")
+        
+        self.session_id: Optional[str] = None
 
     def execute(self, code: str, language: str = "python", timeout: int = 30) -> Dict[str, Any]:
         """
@@ -207,6 +224,19 @@ def close_session(self):
             finally:
                 self.session_id = None
 
+    def cleanup(self):
+        """Cleanup resources including isolated container if created"""
+        self.close_session()
+        
+        if self.isolated and self.container_id:
+            try:
+                ContainerManager.remove_isolated_container(self.container_id)
+                logger.info(f"Cleaned up isolated container {self.container_id}")
+            except Exception as e:
+                logger.warning(f"Error cleaning up container {self.container_id}: {e}")
+            finally:
+                self.container_id = None
+                
     def is_session_active(self) -> bool:
         """
         Check if current session is active (InstaVM compatible)
@@ -331,14 +361,39 @@ def stop_container(self) -> bool:
 
     def get_container_status(self) -> Dict[str, Any]:
         """Get container status information"""
-        return ContainerManager.get_container_status()
+        if self.isolated and self.container_id:
+            # For isolated containers, get specific status
+            containers = ContainerManager.list_isolated_containers()
+            container_info = containers.get(self.container_id, {})
+            return {
+                "isolated": True,
+                "container_id": self.container_id,
+                "base_url": self.base_url,
+                **container_info
+            }
+        else:
+            # For shared container, get standard status
+            status = ContainerManager.get_container_status()
+            status["isolated"] = False
+            return status
+            
+    def is_isolated(self) -> bool:
+        """Check if this instance uses an isolated container"""
+        return self.isolated
+        
+    def get_container_id(self) -> Optional[str]:
+        """Get the container ID (for isolated containers)"""
+        return self.container_id
 
     # Context manager support (InstaVM compatible)
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close_session()
+        if self.isolated:
+            self.cleanup()  # Cleanup isolated container
+        else:
+            self.close_session()  # Just close session for shared container
 
 
 # Import cloud migration support

container_manager.py

@@ -6,8 +6,10 @@
 import os
 import platform
 import logging
+import uuid
+import socket
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Dict, Tuple
 
 logger = logging.getLogger(__name__)
 
@@ -332,4 +334,159 @@ def get_container_status(cls) -> dict:
                 "healthy": False,
                 "error": str(e),
                 "docker_available": cls.check_docker()
-            }
+            }
+            
+    # Isolated container methods for fresh instances
+    
+    @classmethod
+    def create_isolated_container(cls) -> Tuple[str, Dict[str, int]]:
+        """
+        Create a fresh isolated container with unique ports
+        
+        Returns:
+            Tuple of (container_id, port_mapping)
+            
+        Raises:
+            RuntimeError: If container creation fails
+        """
+        if not cls.check_docker():
+            raise RuntimeError("Docker not available")
+            
+        # Generate unique container name
+        container_name = f"coderunner-{uuid.uuid4().hex[:8]}"
+        
+        # Find available ports
+        ports = cls._find_available_ports()
+        
+        try:
+            # Pull image if needed
+            cls._pull_image_if_needed()
+            
+            # Create isolated container
+            result = subprocess.run([
+                "docker", "run", "-d",
+                "--name", container_name,
+                "-p", f"{ports['rest']}:8223",
+                "-p", f"{ports['mcp']}:8222",
+                "-p", f"{ports['jupyter']}:8888", 
+                "-p", f"{ports['playwright']}:3000",
+                "--rm",  # Auto-remove when stopped
+                cls.DOCKER_IMAGE
+            ], capture_output=True, text=True, check=True)
+            
+            container_id = result.stdout.strip()
+            
+            # Wait for container to be healthy
+            cls._wait_for_isolated_health(ports['rest'])
+            
+            logger.info(f"Created isolated container {container_id} ({container_name})")
+            return container_id, ports
+            
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to create isolated container: {e}")
+            raise RuntimeError(f"Failed to create isolated container: {e.stderr}")
+            
+    @classmethod
+    def _find_available_ports(cls) -> Dict[str, int]:
+        """Find available ports for isolated container"""
+        def is_port_available(port: int) -> bool:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                try:
+                    s.bind(('localhost', port))
+                    return True
+                except OSError:
+                    return False
+        
+        # Start from base ports and find available ones
+        base_ports = {
+            'rest': 8223,
+            'mcp': 8222,
+            'jupyter': 8888,
+            'playwright': 3000
+        }
+        
+        ports = {}
+        for service, base_port in base_ports.items():
+            # Try ports starting from base + 100 to avoid conflicts
+            for port in range(base_port + 100, base_port + 200):
+                if is_port_available(port):
+                    ports[service] = port
+                    break
+            else:
+                raise RuntimeError(f"No available port found for {service}")
+                
+        return ports
+        
+    @classmethod
+    def _wait_for_isolated_health(cls, rest_port: int, timeout: int = 120):
+        """Wait for isolated container to be healthy"""
+        start_time = time.time()
+        
+        while time.time() - start_time < timeout:
+            try:
+                response = requests.get(
+                    f"http://localhost:{rest_port}/health",
+                    timeout=3
+                )
+                if response.status_code == 200:
+                    return
+            except:
+                pass
+                
+            time.sleep(2)
+            
+        raise TimeoutError(f"Isolated container on port {rest_port} failed to become healthy")
+        
+    @classmethod
+    def remove_isolated_container(cls, container_id: str) -> bool:
+        """
+        Remove isolated container
+        
+        Args:
+            container_id: Container ID to remove
+            
+        Returns:
+            True if removed successfully
+        """
+        try:
+            # Stop container (will auto-remove due to --rm flag)
+            subprocess.run(
+                ["docker", "stop", container_id],
+                capture_output=True,
+                check=True
+            )
+            logger.info(f"Removed isolated container {container_id}")
+            return True
+            
+        except subprocess.CalledProcessError as e:
+            logger.warning(f"Failed to remove container {container_id}: {e}")
+            return False
+            
+    @classmethod
+    def list_isolated_containers(cls) -> Dict[str, Dict]:
+        """List all isolated CodeRunner containers"""
+        try:
+            result = subprocess.run([
+                "docker", "ps", "-a",
+                "--filter", "name=coderunner-",
+                "--format", "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}"
+            ], capture_output=True, text=True, check=True)
+            
+            containers = {}
+            lines = result.stdout.strip().split('\n')[1:]  # Skip header
+            
+            for line in lines:
+                if line.strip():
+                    parts = line.split('\t')
+                    if len(parts) >= 4:
+                        containers[parts[0]] = {
+                            "id": parts[0],
+                            "name": parts[1], 
+                            "status": parts[2],
+                            "ports": parts[3]
+                        }
+                        
+            return containers
+            
+        except subprocess.CalledProcessError:
+            return {}