Correcciones actualizadas para el botón de Detener (SIGKILL) de la terminal

Author: Shuuida

core/executor.py

@@ -13,37 +13,35 @@
 import time
 from typing import Dict, Any
 
-if multiprocessing.current_process().name == 'MainProcess':
-    input_queue = multiprocessing.Queue()
-    gui_queue = multiprocessing.Queue()
-    wait_flag = multiprocessing.Value('b', False)
-else:
-    input_queue = None
-    gui_queue = None
-    wait_flag = None
+# Variables globales dinámicas (Se regenerarán en cada ejecución)
+input_queue = None
+gui_queue = None
+wait_flag = None
 
 current_process = None
 current_process_lock = threading.Lock()
 
-def _global_log_worker():
+# Worker independiente: Nace y muere con cada ejecución
+def _log_worker_routine(g_queue):
     import gevent
     while True:
-        if gui_queue is not None:
-            while not gui_queue.empty():
-                try:
-                    msg = gui_queue.get_nowait()
-                    if msg == "__TRIGGER_INPUT__":
-                        eel.trigger_frontend_input()()
-                    else:
-                        eel.api_realtime_log(msg)()
-                except Exception:
-                    pass
+        # Extraemos todo lo que el proceso haya escupido
+        while not g_queue.empty():
+            try:
+                msg = g_queue.get_nowait()
+                if msg == "__TRIGGER_INPUT__":
+                    eel.trigger_frontend_input() 
+                else:
+                    eel.api_realtime_log(msg) 
+            except Exception:
+                pass
+        
+        with current_process_lock:
+            if current_process is None or not current_process.is_alive():
+                if g_queue.empty():
+                    break
         gevent.sleep(0.05)
 
-# Iniciamos el worker del log solo en el proceso principal
-if multiprocessing.current_process().name == 'MainProcess':
-    eel.spawn(_global_log_worker)
-
 # -------------------------------------
 # CONFIGURACIÓN DE SEGURIDAD
 ALLOWED_MODULES = {
@@ -118,72 +116,90 @@ def interactive_input(prompt=""):
         result_queue.put({'success': False, 'output': '', 'error': traceback.format_exc()})
 
 
-def kill_execution() -> bool:
-    global current_process
-    if current_process is None:
-        return False
+def submit_input(val: str):
+    global input_queue, wait_flag
+    if input_queue is not None:
+        input_queue.put(val)
+    if wait_flag is not None:
+        wait_flag.value = False
 
+def kill_execution():
+    global current_process, gui_queue, wait_flag
     with current_process_lock:
-        if current_process is not None and current_process.is_alive():
+        if current_process and current_process.is_alive():
             current_process.terminate()
-            current_process.join(timeout=1)
+            
+            # Vaciamos la cola para destruir "inputs fantasmas" de último milisegundo
+            if gui_queue is not None:
+                while not gui_queue.empty():
+                    try:
+                        gui_queue.get_nowait()
+                    except:
+                        break
+                        
             if wait_flag is not None:
                 wait_flag.value = False
+                
+            current_process.join(timeout=1)
             current_process = None
-            return True
-
+            
+            try:
+                eel.api_realtime_log("\n[SISTEMA] Ejecución detenida forzosamente.")
+            except:
+                pass
+                
+            return True 
+            
     return False
 
 # ---------------------------------------------
 # EJECUTOR PRINCIPAL
 def execute_user_code(code: str, timeout: int = 5) -> Dict[str, Any]:
-    global current_process
-    result = {'success': False, 'output': '', 'error': ''}
-
-    if input_queue is None or gui_queue is None or wait_flag is None:
-        return {'success': False, 'output': '', 'error': 'El entorno de ejecución no está inicializado correctamente.'}
-
+    global current_process, input_queue, gui_queue, wait_flag
+    
     if current_process is not None and current_process.is_alive():
-        return {'success': False, 'output': '', 'error': 'Ejecutor ocupado. Espere a que termine la ejecución actual.'}
-
-    while not input_queue.empty():
-        try:
-            input_queue.get_nowait()
-        except queue.Empty:
-            break
+        return {'success': False, 'output': '', 'error': 'Ejecutor ocupado.'}
 
-    # Usamos la cola nativa en lugar del manager
+    # Creamos colas completamente nuevas y limpias para cada ejecución.
+    # Esto ignora cualquier candado roto que haya dejado un "Kill" anterior.
+    input_queue = multiprocessing.Queue()
+    gui_queue = multiprocessing.Queue()
+    wait_flag = multiprocessing.Value('b', False)
     result_queue = multiprocessing.Queue()
+
     process = multiprocessing.Process(
         target=_execution_target,
         args=(result_queue, input_queue, gui_queue, wait_flag, code)
     )
 
     with current_process_lock:
         current_process = process
+        
     process.start()
+    
+    # Iniciamos el obrero de la terminal específico para estas colas
+    eel.spawn(_log_worker_routine, gui_queue)
 
     time_elapsed = 0.0
     while process.is_alive() and time_elapsed < timeout:
         eel.sleep(0.05)
+        # Solo sumamos tiempo si no estamos esperando input del usuario
         if not wait_flag.value:
             time_elapsed += 0.05
 
+    # Si se excedió el tiempo límite natural
     if process.is_alive():
         process.terminate()
         process.join(timeout=1)
         with current_process_lock:
             current_process = None
-        wait_flag.value = False
-        result['error'] = 'Tiempo excedido (Timeout). ¿El proceso se colgó?'
-        return result
+        return {'success': False, 'output': '', 'error': 'Tiempo excedido (Timeout). ¿El proceso se colgó?'}
 
     with current_process_lock:
         current_process = None
 
     try:
         result = result_queue.get_nowait()
+        return result
     except queue.Empty:
-        result = {'success': False, 'output': '', 'error': 'Error desconocido de procesamiento.'}
-
-    return result
+        return {'success': False, 'output': '', 'error': 'Proceso terminado inesperadamente (posible SIGKILL).'}

main.py

@@ -30,7 +30,7 @@
 from core.ml_struct_rules import block_to_struct as ml_block_to_struct
 from storage import ml_exporter
 from storage import file_handler
-from core.executor import execute_user_code, input_queue, kill_execution
+from core.executor import execute_user_code, submit_input, kill_execution
 from core import ml_manager
 from estimators import memory_estimator
 # import maker_edu.auth
@@ -1085,7 +1085,7 @@ def api_get_grades():
 @eel.expose
 def api_provide_input(user_text):
     """Recibe la respuesta de la terminal visual y desbloquea el hilo de Python"""
-    input_queue.put(user_text)
+    submit_input(user_text)
 
 # --------------------------------------------
 # PUNTO DE ENTRADA PRINCIPAL

web/index.html

@@ -1472,6 +1472,7 @@ <h3 className="text-red-400 font-bold uppercase text-xs mb-3 flex items-center g
             });
             const [showSettings, setShowSettings] = useState(false);
             const [showTeacherDashboard, setShowTeacherDashboard] = useState(false);
+            const isExecutingRef = useRef(false);
 
 
             useEffect(() => {
@@ -1488,6 +1489,24 @@ <h3 className="text-red-400 font-bold uppercase text-xs mb-3 flex items-center g
                 }
             }, []);
 
+            useEffect(() => {
+                isExecutingRef.current = isExecuting;
+            }, [isExecuting]);
+
+            useEffect(() => {
+                window.eel.expose(api_realtime_log, 'api_realtime_log');
+                function api_realtime_log(text) {
+                    setLogs(p => [...p, { time: new Date().toLocaleTimeString(), msg: text, type: 'output' }]);
+                }
+
+                window.eel.expose(trigger_frontend_input, 'trigger_frontend_input');
+                function trigger_frontend_input() {
+                    if (isExecutingRef.current) {
+                        setIsWaitingInput(true);
+                    }
+                }
+            }, []);
+
             const handleTerminalSubmit = async (e) => {
                 if (e.key === 'Enter') {
                     const val = terminalInput;