Resolve all critical and high-priority Gemini review issues

Critical Issues Fixed:
- Unified MCP and REST API into single process (main.py)
- Moved KernelPool to core/kernel_pool.py, eliminating circular dependencies
- Removed monkey-patching by adding proper KernelPool.execute_on_kernel method
- Implemented proper async execution using FastAPI BackgroundTasks

High Priority Issues Fixed:
- Eliminated code duplication in execute_on_kernel functions
- Replaced all bare except clauses with specific exception types
- Fixed setup.py to use read_requirements() function

Architecture Improvements:
- Single unified app on port 8222 with REST API mounted on /api
- Clean module structure with core/ components
- Proper error handling throughout codebase
- Functional async task execution

Author: abhishek-anand

__init__.py

@@ -55,13 +55,13 @@ def __init__(self, auto_start: bool = True, base_url: str = None, isolated: bool
             # Create isolated fresh container
             try:
                 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']}")
+                self.base_url = f"http://localhost:{ports['mcp']}/api"
+                logger.info(f"Created isolated container {self.container_id} on port {ports['mcp']}")
             except Exception as 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"
+            # Use shared container (backward compatibility) - now unified on port 8222
+            self.base_url = base_url or "http://localhost:8222/api"
             if auto_start:
                 try:
                     ContainerManager.ensure_running()
@@ -106,7 +106,7 @@ def execute(self, code: str, language: str = "python", timeout: int = 30) -> Dic
                 try:
                     error_data = response.json()
                     error_detail = error_data.get("detail", error_detail)
-                except:
+                except (ValueError, requests.exceptions.JSONDecodeError):
                     error_detail = response.text
 
                 raise ExecutionError(f"Execution failed: {error_detail}")
@@ -159,7 +159,7 @@ def execute_async(self, code: str, language: str = "python", timeout: int = 30)
                 try:
                     error_data = response.json()
                     error_detail = error_data.get("detail", error_detail)
-                except:
+                except (ValueError, requests.exceptions.JSONDecodeError):
                     error_detail = response.text
 
                 raise ExecutionError(f"Async execution failed: {error_detail}")
@@ -250,7 +250,7 @@ def is_session_active(self) -> bool:
         try:
             response = self._session.get(f"{self.base_url}/sessions/{self.session_id}")
             return response.status_code == 200
-        except:
+        except requests.exceptions.RequestException:
             return False
 
     def list_sessions(self) -> Dict[str, Any]:
@@ -331,7 +331,7 @@ def _create_session(self) -> str:
                 try:
                     error_data = response.json()
                     error_detail = error_data.get("detail", error_detail)
-                except:
+                except (ValueError, requests.exceptions.JSONDecodeError):
                     error_detail = response.text
 
                 raise SessionError(f"Failed to create session: {error_detail}")

api/rest_server.py

@@ -1,6 +1,6 @@
 """REST API server for CodeRunner - InstaVM compatible interface"""
 
-from fastapi import FastAPI, HTTPException, Depends
+from fastapi import FastAPI, HTTPException, Depends, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 import logging
@@ -69,7 +69,7 @@ async def health_check():
         session_count = len(session_manager.sessions)
 
         # Check kernel pool
-        from server import kernel_pool
+        from core.kernel_pool import kernel_pool
         kernel_status = {
             "total_kernels": len(kernel_pool.kernels),
             "available_kernels": len([k for k in kernel_pool.kernels.values() if k.is_available()]),
@@ -165,13 +165,70 @@ async def execute_command(request: CommandRequest):
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
 
+async def _execute_task_background(task_id: str, command: str, language: str, session_id: str):
+    """Background task to execute code asynchronously"""
+    try:
+        # Update status to running
+        async_tasks[task_id]["status"] = "running"
+        
+        # Get or create session
+        if not session_id:
+            session_id = await session_manager.create_session(language)
+        elif not await session_manager.get_session(session_id):
+            async_tasks[task_id]["status"] = "failed"
+            async_tasks[task_id]["error"] = "Session not found"
+            return
+        
+        # Execute command
+        result = await session_manager.execute_in_session(session_id, command)
+        
+        # Extract output from result
+        stdout = ""
+        stderr = ""
+        
+        if isinstance(result, dict):
+            if "stdout" in result:
+                stdout = result["stdout"]
+            elif "output" in result:
+                stdout = result["output"]
+            else:
+                stdout = str(result)
+                
+            if "stderr" in result:
+                stderr = result["stderr"]
+            elif "error" in result and result.get("error"):
+                stderr = str(result["error"])
+        else:
+            stdout = str(result)
+        
+        # Update task with results
+        async_tasks[task_id].update({
+            "status": "completed",
+            "result": {
+                "stdout": stdout,
+                "stderr": stderr,
+                "session_id": session_id
+            },
+            "completed_at": time.time()
+        })
+        
+    except Exception as e:
+        logger.error(f"Background task {task_id} failed: {e}")
+        async_tasks[task_id].update({
+            "status": "failed",
+            "error": str(e),
+            "completed_at": time.time()
+        })
+
+
 @app.post("/execute_async", response_model=AsyncExecutionResponse)
-async def execute_command_async(request: CommandRequest):
+async def execute_command_async(request: CommandRequest, background_tasks: BackgroundTasks):
     """
     Execute command asynchronously - InstaVM compatible interface
     
     Args:
         request: Command execution request
+        background_tasks: FastAPI background tasks
         
     Returns:
         Task ID for checking execution status
@@ -199,9 +256,14 @@ async def execute_command_async(request: CommandRequest):
             "error": None
         }
 
-        # TODO: Implement actual async execution with background tasks
-        # For now, just return the task ID
-        # In a full implementation, this would use Celery or similar
+        # Add background task for execution
+        background_tasks.add_task(
+            _execute_task_background,
+            task_id,
+            request.command,
+            request.language,
+            request.session_id
+        )
 
         return AsyncExecutionResponse(task_id=task_id, status="queued")
 

container_manager.py

@@ -61,11 +61,11 @@ def is_healthy(cls) -> bool:
         """
         try:
             response = requests.get(
-                f"http://localhost:{cls.REST_PORT}/health", 
+                f"http://localhost:{cls.MCP_PORT}/api/health", 
                 timeout=3
             )
             return response.status_code == 200
-        except:
+        except requests.exceptions.RequestException:
             return False
 
     @classmethod
@@ -238,7 +238,7 @@ def _show_container_logs(cls):
                 print(result.stdout)
             if result.stderr:
                 print("STDERR:", result.stderr)
-        except:
+        except subprocess.CalledProcessError:
             print("   Could not retrieve container logs")
 
     @classmethod
@@ -366,7 +366,6 @@ def create_isolated_container(cls) -> Tuple[str, Dict[str, int]]:
             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",
@@ -377,7 +376,7 @@ def create_isolated_container(cls) -> Tuple[str, Dict[str, int]]:
             container_id = result.stdout.strip()
 
             # Wait for container to be healthy
-            cls._wait_for_isolated_health(ports['rest'])
+            cls._wait_for_isolated_health(ports['mcp'])
 
             logger.info(f"Created isolated container {container_id} ({container_name})")
             return container_id, ports
@@ -418,24 +417,24 @@ def is_port_available(port: int) -> bool:
         return ports
 
     @classmethod
-    def _wait_for_isolated_health(cls, rest_port: int, timeout: int = 120):
+    def _wait_for_isolated_health(cls, mcp_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",
+                    f"http://localhost:{mcp_port}/api/health",
                     timeout=3
                 )
                 if response.status_code == 200:
                     return
-            except:
+            except requests.exceptions.RequestException:
                 pass
 
             time.sleep(2)
 
-        raise TimeoutError(f"Isolated container on port {rest_port} failed to become healthy")
+        raise TimeoutError(f"Isolated container on port {mcp_port} failed to become healthy")
 
     @classmethod
     def remove_isolated_container(cls, container_id: str) -> bool: