kill_orphaned_aggressive.py

"""Aggressive orphaned process killer - removes idle console and Node processes"""
import psutil
import time
from datetime import datetime
from pathlib import Path

class AggressiveOrphanKiller:
    """Aggressively kills idle console and Node processes"""

    # These are the targets we WANT to kill if idle
    KILL_TARGETS = {
        'node.exe', 'conhost.exe', 'cmd.exe', 'powershell.exe',
        'node', 'npm', 'npx', 'npm.cmd', 'conhost'
    }

    # Only protect these critical system processes
    PROTECTED = {
        'svchost.exe', 'csrss.exe', 'lsass.exe', 'services.exe',
        'smss.exe', 'wininit.exe', 'winlogon.exe', 'explorer.exe',
        'dwm.exe', 'taskhostw.exe', 'python.exe', 'vscode.exe',
        'cursor.exe', 'kiro.exe'
    }

    def __init__(self):
        self.killed = []
        self.protected = []
        self.log_file = Path("data/aggressive_kill_log.txt")

    def is_idle(self, proc):
        """Check if process is idle"""
        try:
            # Get CPU times
            cpu_times = proc.cpu_times()
            
            # If zero CPU usage, it's idle
            if cpu_times.user == 0 and cpu_times.system == 0:
                return True
            
            # Check I/O
            try:
                io = proc.io_counters()
                if io.read_bytes == 0 and io.write_bytes == 0:
                    return True
            except:
                pass
            
            return False
        except:
            return False

    def kill_process(self, proc):
        """Kill a process"""
        try:
            pid = proc.pid
            name = proc.name()
            proc.terminate()
            time.sleep(0.1)
            
            # If still alive, force kill
            if proc.is_running():
                proc.kill()
            
            self.killed.append((pid, name))
            self._log(pid, name, "KILLED")
            return True
        except Exception as e:
            self._log(proc.pid, proc.name(), f"FAILED: {e}")
            return False

    def _log(self, pid, name, status):
        """Log action"""
        try:
            self.log_file.parent.mkdir(parents=True, exist_ok=True)
            with open(self.log_file, 'a') as f:
                f.write(f"{datetime.now().isoformat()} | {status} | PID {pid} | {name}\n")
        except:
            pass

    def run(self):
        """Run the killer"""
        print("=" * 80)
        print("AGGRESSIVE ORPHANED PROCESS KILLER")
        print("=" * 80)

        print("\n[SCANNING] Looking for idle processes...")
        
        candidates = []
        for proc in psutil.process_iter(['pid', 'name']):
            try:
                name = proc.info['name'].lower()
                
                # Check if it's a target
                if not any(target in name for target in self.KILL_TARGETS):
                    continue
                
                # Check if it's protected
                if any(protected in name for protected in self.PROTECTED):
                    self.protected.append((proc.info['pid'], proc.info['name']))
                    continue
                
                # Check if idle
                if self.is_idle(proc):
                    candidates.append(proc)
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                pass

        print(f"Found {len(candidates)} idle processes to kill")
        print(f"Protected {len(self.protected)} critical processes\n")

        if candidates:
            print("[KILLING] Terminating idle processes...")
            for proc in candidates:
                try:
                    self.kill_process(proc)
                    print(f"  ✓ Killed PID {proc.pid} ({proc.name()})")
                except:
                    pass

        print("\n" + "=" * 80)
        print(f"✓ Killed {len(self.killed)} processes")
        print("=" * 80 + "\n")

        return len(self.killed)


if __name__ == "__main__":
    killer = AggressiveOrphanKiller()
    killed = killer.run()
    exit(0 if killed > 0 else 1)