feat: update README files with task completion status and enhance process management in main.py

Author: WesleyQDev

README.md

@@ -352,8 +352,8 @@ if __name__ == "__main__":
 
 - [ ] **Custom Functions**: Manage Python functions by creating separate threads.
 - [ ] **Per-Project Conditions**: Allow a specific project to pause only if a specific app opens.
-- [ ] **Graceful Shutdown**: Try a graceful shutdown (SIGINT/CTRL+C) before forcing process termination.
-- [ ] **Dead Process Handling**: Periodically check if started processes are still alive.
+- [x] **Graceful Shutdown**: Try a graceful shutdown (SIGINT/CTRL+C) before forcing process termination.
+- [x] **Dead Process Handling**: Periodically check if started processes are still alive.
 - [ ] **Project Abstraction**: Refactor into classes (`PythonProject`, `NodeProject`) to easily add new languages.
 - [x] **Type Hinting**: Improve typing across all methods for better IDE support.
 
@@ -380,7 +380,10 @@ if __name__ == "__main__":
 - [x] Configuration via code arguments
 - [x] Event callbacks (`on_pause` and `on_resume`)
 - [x] Configurable log levels (DEBUG, INFO, WARNING, ERROR)
-- [x] Safe process termination (tree-kill)
+- [x] Safe process termination (Graceful Shutdown + Kill)
+- [x] Process health monitoring (Automatic restart/idle on exit)
+- [x] Option to enable/disable script windows (Windows OS only)
+- [x] Type Hinting: Improved typing across all methods for better IDE support.
 
 ---
 

README_ptBR.md

@@ -385,8 +385,8 @@ if __name__ == "__main__":
 
 - [ ] **Funções Customizadas**: Gerenciar funções Python criando threads separadas.
 - [ ] **Condições por Projeto**: Permitir que um projeto específico só pause se um aplicativo específico abrir.
-- [ ] **Encerramento Amigável**: Tentar um encerramento gracioso (SIGINT/CTRL+C) antes de forçar o término do processo.
-- [ ] **Tratamento de Processos Mortos**: Verificar periodicamente se os processos iniciados ainda estão vivos.
+- [x] **Encerramento Amigável**: Tentar um encerramento gracioso (SIGINT/CTRL+C) antes de forçar o término do processo.
+- [x] **Tratamento de Processos Mortos**: Verificar periodicamente se os processos iniciados ainda estão vivos.
 - [ ] **Abstração de Projetos**: Refatorar para classes (`PythonProject`, `NodeProject`) facilitando a adição de novas linguagens.
 - [ ] Arrumar bugs relacionado a path, atualmente se adicionar um script python e ele não estiver na raiz do projeto o venv não sera executado, fortscript tenta executar com python padrão, mas da erro por não possuir os imports e a janela do terminal se encerra
 
@@ -413,7 +413,8 @@ if __name__ == "__main__":
 - [x] Configuração via argumentos no código
 - [x] Callbacks de eventos (`on_pause` e `on_resume`)
 - [x] Níveis de log configuráveis (DEBUG, INFO, WARNING, ERROR)
-- [x] Encerramento seguro de processos (tree-kill)
+- [x] Encerramento seguro de processos (Graceful Shutdown + Kill)
+- [x] Monitoramento de saúde dos processos (Reinício automático em caso de falha)
 - [x] Adicionar opção de ativar ou desativar as janelas que aparecem dos scripts (Apenas em OS Windows)
 - [x] Type Hinting: Melhorar a tipagem em todos os métodos para melhor suporte em IDEs.
 

src/fortscript/__init__.py

@@ -1,4 +1,4 @@
-from .main import FortScript, RamConfig
+from .main import FortScript, RamConfig, Callbacks
 from .games import GAMES
 
-__all__ = ['FortScript', 'RamConfig', 'GAMES']
+__all__ = ['FortScript', 'RamConfig', 'GAMES', 'Callbacks']

src/fortscript/main.py

@@ -254,19 +254,38 @@ def _start_project(self, project: ProjectConfig) -> None:
     def stop_scripts(self) -> None:
         """Terminates active scripts and their child processes."""
         logger.info('Closing active scripts and their child processes...')
+
+        procs_to_kill = []
+
+        # 1. Collect all processes (parents and children)
         for proc in self.active_processes:
             try:
-                # 1. Get the process by PID using psutil
                 parent_process = psutil.Process(proc.pid)
+                procs_to_kill.append(parent_process)
+                procs_to_kill.extend(parent_process.children(recursive=True))
+            except psutil.NoSuchProcess:
+                pass
 
-                # 2. List all children (the python script, etc.)
-                for child_process in parent_process.children(recursive=True):
-                    child_process.terminate()  # Close the child
+        # 2. Send terminate signal (SIGTERM / CTRL_C_EVENT equivalent attempt)
+        for p in procs_to_kill:
+            try:
+                p.terminate()
+            except psutil.NoSuchProcess:
+                pass
 
-                # 3. Close the parent (the uv/pnpm command)
-                parent_process.terminate()
+        # 3. Wait for processes to exit (Graceful period)
+        # We give them 3 seconds to close connections, save state, etc.
+        gone, alive = psutil.wait_procs(procs_to_kill, timeout=3)
 
-            except (psutil.NoSuchProcess, Exception):
+        # 4. Force kill if they are still alive
+        for p in alive:
+            try:
+                logger.warning(
+                    f'Process {p.name()} (PID: {p.pid}) did not exit. '
+                    'Forcing kill.'
+                )
+                p.kill()
+            except psutil.NoSuchProcess:
                 pass
 
         self.active_processes = []
@@ -285,61 +304,91 @@ def process_manager(self) -> None:
 
         while True:
             status_dict = self.apps_monitoring.active_process_list()
-            is_heavy_process_open = any(status_dict.values())
+            is_heavy_open = any(status_dict.values())
 
             current_ram = self.ram_monitoring.get_percent()
             is_ram_critical = current_ram > self.ram_config.safe
 
-            # Initial feedback if system is already heavy
-            if first_check and (is_heavy_process_open or is_ram_critical):
-                reason = (
-                    'heavy processes' if is_heavy_process_open else 'high RAM'
-                )
+            # Initial feedback
+            if first_check and (is_heavy_open or is_ram_critical):
+                reason = 'heavy processes' if is_heavy_open else 'high RAM'
                 logger.info(
                     f'System is busy ({reason}). Waiting for stabilization...'
                 )
                 first_check = False
 
-            if (is_heavy_process_open or is_ram_critical) and script_running:
-                if is_heavy_process_open:
-                    detected = [k for k, v in status_dict.items() if v]
-                    logger.warning(
-                        f'Closing scripts due to heavy processes: {detected}'
-                    )
-                else:
-                    logger.warning(
-                        'Closing scripts due to high RAM usage:'
-                        f'{current_ram}%'
-                    )
-
-                self.stop_scripts()
-                logger.info('Scripts stopped.')
+            # Stop Condition
+            if (is_heavy_open or is_ram_critical) and script_running:
+                self._handle_stop_condition(
+                    is_heavy_open, status_dict, current_ram
+                )
                 script_running = False
+
+            # Start Condition
             elif (
-                not is_heavy_process_open
+                not is_heavy_open
                 and not is_ram_critical
                 and not script_running
                 and current_ram < self.ram_config.safe
             ):
-                logger.info(
-                    f'System stable (RAM: {current_ram}%). Starting scripts...'
-                )
-                self.start_scripts()
+                self._handle_start_condition(current_ram)
                 script_running = True
                 first_check = False
-            elif not is_heavy_process_open:
-                # Optional: showing status even when already running,
-                # or just pass
-                pass
 
-            if not self.active_processes and script_running:
-                logger.error(
-                    'No valid scripts found to start. '
-                    'FortScript is shutting down.'
-                )
-                break
+            # Dead Process Handling
+            if script_running and self.active_processes:
+                script_running = self._check_dead_processes(script_running)
+
             time.sleep(5)
 
+    def _handle_stop_condition(
+        self,
+        is_heavy_open: bool,
+        status_dict: dict[str, bool],
+        current_ram: float,
+    ) -> None:
+        if is_heavy_open:
+            detected = [k for k, v in status_dict.items() if v]
+            logger.warning(
+                f'Closing scripts due to heavy processes: {detected}'
+            )
+        else:
+            logger.warning(
+                f'Closing scripts due to high RAM usage: {current_ram}%'
+            )
+
+        self.stop_scripts()
+        logger.info('Scripts stopped.')
+
+    def _handle_start_condition(self, current_ram: float) -> None:
+        logger.info(
+            f'System stable (RAM: {current_ram}%). Starting scripts...'
+        )
+        self.start_scripts()
+
+    def _check_dead_processes(self, script_running: bool) -> bool:
+        alive_processes = []
+        for proc in self.active_processes:
+            ret_code = proc.poll()
+            if ret_code is None:
+                alive_processes.append(proc)
+            elif ret_code == 0:
+                logger.info(
+                    f'Process (PID: {proc.pid}) finished successfully.'
+                )
+            else:
+                logger.warning(
+                    f'Process (PID: {proc.pid}) crashed/exited '
+                    f'with code {ret_code}.'
+                )
+
+        self.active_processes = alive_processes
+
+        if not self.active_processes:
+            logger.info('All scripts finished. Waiting for system changes...')
+            return False
+        return script_running
+
     def run(self) -> None:
         """Runs the main application loop."""
         self.process_manager()