Update app.py

app.py

@@ -35,6 +35,7 @@ class WebSocketInputOutput:
         self.output_buffer = io.StringIO()
         self.error_buffer = io.StringIO()
         self.closed = False
+        print("DEBUG: WebSocketInputOutput initialized.")
 
     async def write(self, s: str):
         """Writes to stdout/stderr and sends to WebSocket."""
@@ -42,11 +43,12 @@ class WebSocketInputOutput:
         try:
             # Send output in chunks or lines to prevent large messages
             await self.websocket.send_text(json.dumps({"type": "output", "content": s}))
+            print(f"DEBUG: Sent output chunk: {s.strip()[:100]}...")
         except WebSocketDisconnect:
             self.closed = True
-            print("WebSocket disconnected during write.")
+            print("ERROR: WebSocket disconnected during write.")
         except Exception as e:
-            print(f"Error sending output over WebSocket: {e}")
+            print(f"ERROR: Error sending output over WebSocket: {e}")
             self.closed = True
 
     def flush(self):
@@ -56,44 +58,37 @@ class WebSocketInputOutput:
     async def readline(self) -> str:
         """Reads a line from stdin, waiting for input from WebSocket."""
         try:
+            print("DEBUG: Sending input_request to client.")
             await self.websocket.send_text(json.dumps({"type": "input_request"}))
             line = await self.input_queue.get() # Wait for input from client
+            print(f"DEBUG: Received input from queue: {line.strip()[:50]}...")
             return line
         except WebSocketDisconnect:
             self.closed = True
-            print("WebSocket disconnected during readline.")
+            print("ERROR: WebSocket disconnected during readline.")
             raise EOFError("Input stream closed due to WebSocket disconnect")
         except Exception as e:
-            print(f"Error requesting input over WebSocket: {e}")
+            print(f"ERROR: Error requesting input over WebSocket: {e}")
             self.closed = True
             raise EOFError(f"Input stream error: {e}")
 
     # For compatibility with sys.stdin, which expects a file-like object
     def _get_input_line(self):
         """Synchronous wrapper for readline for use with exec."""
-        # This is a bit tricky: exec is synchronous, but WebSocket is async.
-        # We need to bridge this. A simple way is to run the async part
-        # in the event loop, but it's usually better to refactor the executor
-        # to be fully async if input() is truly interactive.
-        # For this example, we'll use a blocking call to asyncio.run
-        # which is generally discouraged in a running event loop,
-        # but works for simple cases or if the exec is in a separate thread.
-        # A more robust solution involves a custom Future/Event loop integration.
         try:
-            # This will block the current thread until input is available
+            print("DEBUG: Synchronous input wrapper called.")
             return asyncio.run(self.readline())
         except Exception as e:
-            print(f"Synchronous input wrapper error: {e}")
+            print(f"ERROR: Synchronous input wrapper error: {e}")
             raise
 
     def read(self, n=-1):
         """Reads n characters. For simplicity, we'll treat it as readline."""
+        print(f"DEBUG: Read called with n={n}. Delegating to readline.")
         return self._get_input_line() # Or implement more complex buffering
 
     def __getattr__(self, name):
         """Delegate other attributes if needed, or raise AttributeError."""
-        # This is a placeholder; real implementation would be more robust
-        # For now, we only need write, flush, and readline.
         raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
 
 
@@ -314,11 +309,13 @@ class SecurePythonExecutor:
     async def execute_code(self, code: str, websocket_io: WebSocketInputOutput) -> Dict[str, Any]:
         """Execute Python code in a secure environment with WebSocket IO."""
         start_time = time.time()
+        print(f"DEBUG: execute_code called for client: {websocket_io.websocket.client}")
         
         # Input validation
         if not code or not code.strip():
             error_msg = 'No code provided'
             await websocket_io.write(f"Error: {error_msg}\n")
+            print(f"DEBUG: No code provided for execution. Client: {websocket_io.websocket.client}")
             return {
                 'success': False,
                 'output': '',
@@ -341,6 +338,7 @@ class SecurePythonExecutor:
         if not restricted_check['allowed']:
             error_msg = f"Security violation: Restricted module '{restricted_check['module']}' is not allowed"
             await websocket_io.write(f"Error: {error_msg}\n")
+            print(f"DEBUG: Restricted import detected: {restricted_check['module']}. Client: {websocket_io.websocket.client}")
             return {
                 'success': False,
                 'output': '',
@@ -352,6 +350,7 @@ class SecurePythonExecutor:
         # Execute code with timeout
         result = await self.run_with_timeout(code, websocket_io) # Pass websocket_io
         execution_time = time.time() - start_time
+        print(f"DEBUG: Code execution finished. Success: {result['success']}, Client: {websocket_io.websocket.client}")
         
         return {
             'success': result['success'],
@@ -374,12 +373,14 @@ class SecurePythonExecutor:
                     if node.module and node.module.split('.')[0] in self.restricted_modules:
                         return {'allowed': False, 'module': node.module}
             return {'allowed': True, 'module': None}
-        except Exception:
+        except Exception as e:
+            print(f"WARNING: AST parsing failed for restricted import check: {e}")
             return {'allowed': True, 'module': None}   # If parsing fails, let execution handle it
     
     async def run_with_timeout(self, code: str, websocket_io: WebSocketInputOutput) -> Dict[str, Any]:
         """Run code with timeout protection, interacting via WebSocketIO."""
         result = {'success': False, 'output': '', 'error': ''}
+        print(f"DEBUG: run_with_timeout called. Client: {websocket_io.websocket.client}")
         
         # Store original stdin/stdout/stderr
         original_stdin = sys.stdin
@@ -396,7 +397,8 @@ class SecurePythonExecutor:
                 sys.stdin = websocket_io
                 sys.stdout = websocket_io
                 sys.stderr = websocket_io
-
+                print(f"DEBUG: Thread '{threading.current_thread().name}' started. IO redirected.")
+                
                 # Create restricted execution environment
                 restricted_globals = {
                     '__builtins__': self.safe_builtins,
@@ -404,21 +406,27 @@ class SecurePythonExecutor:
                     '__doc__': None,
                 }
                 
+                print(f"DEBUG: Entering exec context for code (thread): {code[:100]}...") # NEW
                 # Execute the code
                 exec(code, restricted_globals)
+                print("DEBUG: Code execution completed successfully in thread.") # NEW
                 result['success'] = True
                 
             except EOFError as e:
                 # This happens if the WebSocket disconnects during input()
                 result['error'] = f"Input stream closed: {str(e)}"
                 result['success'] = False
+                print(f"ERROR: EOFError during execution in thread: {e}") # NEW
             except Exception as e:
                 error_msg = f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()}"
+                print(f"ERROR: Unhandled exception during execution in thread: {error_msg}") # NEW
                 # Write error to WebSocket and internal buffer
                 try:
+                    # Use asyncio.run for writing within a synchronous thread, if necessary
+                    # This is generally safe if it's a new event loop per call or in a separate thread.
                     asyncio.run(websocket_io.write(f"Error: {error_msg}\n"))
                 except Exception as write_e:
-                    print(f"Failed to write error to WebSocket: {write_e}")
+                    print(f"ERROR: Failed to write error to WebSocket from thread: {write_e}")
                 websocket_io.error_buffer.write(error_msg)
                 result['success'] = False
             finally:
@@ -427,16 +435,19 @@ class SecurePythonExecutor:
                 sys.stdout = original_stdout
                 sys.stderr = original_stderr
                 execution_finished_event.set() # Signal completion
+                print(f"DEBUG: Thread '{threading.current_thread().name}' finished. IO restored.")
 
         # Run the execution in a separate thread to allow for timeout
-        thread = threading.Thread(target=target)
+        thread = threading.Thread(target=target, name=f"CodeExecutorThread-{id(websocket_io)}")
         thread.daemon = True # Allow the program to exit even if thread is running
         thread.start()
+        print(f"DEBUG: Code execution thread '{thread.name}' started. Waiting for join.")
 
         # Wait for the thread to finish or timeout
         thread.join(timeout=self.timeout)
         
         if thread.is_alive():
+            print(f"DEBUG: Thread '{thread.name}' timed out after {self.timeout} seconds.") # NEW
             result['error'] = f"Code execution timed out after {self.timeout} seconds"
             result['success'] = False
             # Attempt to send timeout message to client
@@ -445,7 +456,7 @@ class SecurePythonExecutor:
             except Exception:
                 pass # Ignore if websocket is already closed
         else:
-            # Execution finished within timeout
+            print(f"DEBUG: Thread '{thread.name}' finished within timeout.") # NEW
             result['output'] = websocket_io.output_buffer.getvalue()
             if websocket_io.error_buffer.getvalue():
                 result['error'] = websocket_io.error_buffer.getvalue()
@@ -455,12 +466,16 @@ class SecurePythonExecutor:
         
         # Send a final message to the client indicating execution is complete
         try:
+            print(f"DEBUG: Attempting to send execution_complete message (success={result['success']}).") # NEW
             await websocket_io.send_text(json.dumps({"type": "execution_complete", "result": result}))
+            print("DEBUG: execution_complete message sent.")
         except WebSocketDisconnect:
+            print("DEBUG: WebSocketDisconnect when sending execution_complete.") # NEW
             pass # Ignore if websocket is already closed
         except Exception as e:
-            print(f"Error sending execution_complete message: {e}")
+            print(f"ERROR: Error sending execution_complete message: {e}") # Warning if this fails
 
+        print(f"DEBUG: run_with_timeout returning result for client: {websocket_io.websocket.client}")
         return result
 
 
@@ -479,6 +494,7 @@ app = FastAPI(
 async def get_index():
     """Serves the interactive frontend."""
     # This assumes index.html is in the same directory as app.py
+    [cite_start]# [cite: 9] Explicitly copy index.html to /app/index.html to avoid any ambiguity with '.'
     with open("index.html", "r") as f:
         return HTMLResponse(content=f.read())
 
@@ -493,6 +509,7 @@ async def websocket_endpoint(websocket: WebSocket):
         while True:
             message = await websocket.receive_text()
             data = json.loads(message)
+            print(f"DEBUG: Received message from {websocket.client}: type={data['type']}")
 
             if data["type"] == "code":
                 code = data["content"]
@@ -506,6 +523,7 @@ async def websocket_endpoint(websocket: WebSocket):
             elif data["type"] == "ping":
                 # Respond to pings to keep connection alive
                 await websocket.send_text(json.dumps({"type": "pong"}))
+                print(f"DEBUG: Sent pong to {websocket.client}")
             else:
                 await websocket_io.write(f"Unknown message type: {data['type']}\n")
 
@@ -548,5 +566,4 @@ if __name__ == "__main__":
         )
     except Exception as e:
         print(f"Failed to start server: {e}")
-        sys.exit(1)
-
+        sys.exit(1)