opencode_remover.py

#!/usr/bin/env python3
"""
Cross-Platform OpenCode Complete Removal Tool
================================================

This tool completely removes OpenCode from your system and makes it appear
as if it was never installed.

Usage:
    python opencode_remover.py
    
or make it executable:
    chmod +x opencode_remover.py
    ./opencode_remover.py
"""

import os
import sys
import platform
import subprocess
import shutil
import glob
import time
from pathlib import Path


def show_banner():
    """Display simple banner"""
    print("\n" + "="*60)
    print(r"""
   ___  ____  _____ _   _  ____ ___  ____  _____
  / _ \|  _ \| ____| \ | |/ ___/ _ \|  _ \| ____|
 | | | | |_) |  _| |  \| | |  | | | | | | |  _|  
 | |_| |  __/| |___| |\  | |__| |_| | |_| | |___ 
  \___/|_|   |_____|_| \_|\____\___/|____/|_____|
                                                   
  ____  _____ __  __  _____     _______ ____  
 |  _ \| ____|  \/  |/ _ \ \   / / ____|  _ \ 
 | |_) |  _| | |\/| | | | \ \ / /|  _| | |_) |
 |  _ <| |___| |  | | |_| |\ V / | |___|  _ < 
 |_| \_\_____|_|  |_|\___/  \_/  |_____|_| \_\
""")
    print("="*60)
    print("|" + " "*10 + "OPENCODE COMPLETE REMOVAL TOOL" + " "*10 + "|")
    print("| codeiva4u (c) 2025                                       |")
    print("| github.com/codeiva4u/Warp-Bypass-Tools                   |")
    print("| youtube.com/@codeiva4u                                   |")
    print("="*60 + "\n")


class OpenCodeRemover:
    def __init__(self):
        self.system = platform.system()
        self.home = Path.home()
        self.removed_count = 0
        
    def print_emoji(self, emoji, message):
        """Print message with emoji (works cross-platform)"""
        print(f"  {emoji} {message}")
        
    def safe_remove(self, path_pattern):
        """Safely remove files/directories matching pattern with retry logic"""
        if isinstance(path_pattern, str):
            paths = glob.glob(path_pattern)
        elif isinstance(path_pattern, Path):
            paths = [str(path_pattern)] if path_pattern.exists() else []
        else:
            paths = [str(path_pattern)]
            
        for path in paths:
            try:
                path_obj = Path(path).resolve()
                cwd = Path.cwd().resolve()
                script_dir = Path(__file__).parent.resolve() if '__file__' in dir() else cwd
                
                if path_obj == cwd or path_obj == script_dir:
                    continue
                if str(cwd).startswith(str(path_obj)) or str(script_dir).startswith(str(path_obj)):
                    continue
                
                if not os.path.exists(path):
                    continue
                    
                basename = os.path.basename(path)
                max_retries = 5
                success = False
                
                for attempt in range(max_retries):
                    if success:
                        break
                    try:
                        if self.system == "Windows":
                            try:
                                subprocess.run(f'attrib -r -s -h "{path}"', shell=True,
                                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                                             check=False, timeout=10)
                                if os.path.isdir(path):
                                    subprocess.run(f'attrib -r -s -h /s /d "{path}\\*.*"', shell=True,
                                                 stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                                                 check=False, timeout=15)
                            except: pass
                            
                            try:
                                subprocess.run(f'takeown /f "{path}" /r /d y', shell=True,
                                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                                             check=False, timeout=30)
                            except: pass
                            
                            try:
                                subprocess.run(f'icacls "{path}" /grant Everyone:F /t /c /q', shell=True,
                                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                                             check=False, timeout=30)
                                subprocess.run(f'icacls "{path}" /grant Administrators:F /t /c /q', shell=True,
                                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                                             check=False, timeout=30)
                            except: pass
                            
                            time.sleep(0.3)
                            
                            if os.path.isdir(path):
                                subprocess.run(f'rd /s /q "{path}"', shell=True,
                                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                                             check=False, timeout=60)
                                if not os.path.exists(path):
                                    self.print_emoji("[DIR]", f"Removed: {basename}")
                                    self.removed_count += 1
                                    success = True
                                    break
                                
                                subprocess.run(f'del /f /s /q "{path}\\*.*"', shell=True,
                                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                                             check=False, timeout=60)
                                subprocess.run(f'rmdir /s /q "{path}"', shell=True,
                                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                                             check=False, timeout=30)
                                if not os.path.exists(path):
                                    self.print_emoji("[DIR]", f"Removed: {basename}")
                                    self.removed_count += 1
                                    success = True
                                    break
                            
                            # Rename then delete
                            if os.path.exists(path):
                                try:
                                    import uuid
                                    temp_name = f"{path}_{uuid.uuid4().hex[:8]}_delete"
                                    os.rename(path, temp_name)
                                    if os.path.isdir(temp_name):
                                        shutil.rmtree(temp_name, ignore_errors=True)
                                    else:
                                        os.remove(temp_name)
                                    if not os.path.exists(path) and not os.path.exists(temp_name):
                                        self.print_emoji("[DIR]", f"Removed: {basename}")
                                        self.removed_count += 1
                                        success = True
                                        break
                                except: pass
                        
                        # Python native fallback
                        if os.path.isdir(path):
                            try:
                                for root, dirs, files in os.walk(path):
                                    for d in dirs:
                                        try: os.chmod(os.path.join(root, d), 0o777)
                                        except: pass
                                    for f in files:
                                        try: os.chmod(os.path.join(root, f), 0o777)
                                        except: pass
                            except: pass
                            shutil.rmtree(path, ignore_errors=False)
                            self.print_emoji("[DIR]", f"Removed: {basename}")
                            self.removed_count += 1
                            success = True
                            break
                        elif os.path.isfile(path):
                            try: os.chmod(path, 0o777)
                            except: pass
                            os.remove(path)
                            self.print_emoji("[FILE]", f"Removed: {basename}")
                            self.removed_count += 1
                            success = True
                            break
                            
                    except PermissionError:
                        if attempt < max_retries - 1:
                            time.sleep(1)
                        else:
                            self.print_emoji("[X]", f"Permission denied: {basename}")
                    except FileNotFoundError:
                        success = True
                        break
                    except OSError as e:
                        if attempt < max_retries - 1:
                            time.sleep(1)
                        else:
                            self.print_emoji("[!]", f"Could not remove {basename}: {e}")
            except Exception as e:
                self.print_emoji("[!]", f"Error: {os.path.basename(str(path))} - {e}")

    def kill_opencode_processes(self):
        """Kill all OpenCode processes (cross-platform)"""
        self.print_emoji("[*]", "Stopping OpenCode processes...")
        try:
            if self.system in ("Darwin", "Linux"):
                process_names = ["opencode", "OpenCode", "ai.opencode.desktop"]
                for proc_name in process_names:
                    subprocess.run(["pkill", "-f", "-i", proc_name],
                                   stderr=subprocess.DEVNULL, check=False)
            elif self.system == "Windows":
                process_names = [
                    "OpenCode.exe", "opencode.exe", "ai.opencode.desktop.exe",
                    "opencode-cli.exe",
                    "SearchIndexer.exe", "SearchProtocolHost.exe", "SearchFilterHost.exe"
                ]
                for proc_name in process_names:
                    subprocess.run(["taskkill", "/F", "/IM", proc_name],
                                   stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL, check=False)
                try:
                    subprocess.run('taskkill /F /FI "WINDOWTITLE eq OpenCode*"', 
                                 shell=True, stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)
                except: pass
                
                # Stop Windows Search
                try:
                    subprocess.run(["net", "stop", "WSearch"], 
                                 stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL, check=False, timeout=10)
                except: pass
            
            time.sleep(4)
            self.print_emoji("[OK]", "OpenCode processes stopped")
        except Exception as e:
            self.print_emoji("[!]", f"Process stop warning: {e}")

    def clean_chromium_browser(self, browser_path, browser_name):
        """Clean OpenCode data from a Chromium-based browser"""
        if not browser_path.exists():
            return
            
        self.print_emoji("[*]", f"Checking {browser_name}...")
        
        profiles = []
        default_profile = browser_path / "Default"
        if default_profile.exists():
            profiles.append(default_profile)
        
        for item in browser_path.iterdir():
            if item.is_dir() and item.name.startswith("Profile"):
                profiles.append(item)
        
        for profile in profiles:
            opencode_patterns = ["https_opencode*", "*opencode*", "*OpenCode*"]
            
            indexeddb_path = profile / "IndexedDB"
            if indexeddb_path.exists():
                for pattern in opencode_patterns:
                    for item in indexeddb_path.glob(pattern):
                        self.safe_remove(item)
                        self.print_emoji("[DEL]", f"Removed OpenCode IndexedDB in {browser_name} ({profile.name})")
            
            local_storage = profile / "Local Storage" / "leveldb"
            if local_storage.exists():
                for item in local_storage.iterdir():
                    if item.is_file() and "opencode" in item.name.lower():
                        self.safe_remove(item)
            
            session_storage = profile / "Session Storage"
            if session_storage.exists():
                for item in session_storage.iterdir():
                    if item.is_file() and "opencode" in item.name.lower():
                        self.safe_remove(item)
            
            cache_dir = profile / "Cache" / "Cache_Data"
            if not cache_dir.exists():
                cache_dir = profile / "Cache"
            if cache_dir.exists():
                for pattern in ["*opencode*", "*OpenCode*"]:
                    self.safe_remove(str(cache_dir / pattern))

    def clean_firefox_browser(self, firefox_profiles_path):
        """Clean OpenCode data from Firefox browser"""
        if not firefox_profiles_path.exists():
            return
            
        self.print_emoji("[*]", f"Checking Firefox...")
        
        for profile_dir in firefox_profiles_path.iterdir():
            if not profile_dir.is_dir():
                continue
            indexeddb = profile_dir / "storage" / "default"
            if indexeddb.exists():
                for item in indexeddb.iterdir():
                    if item.is_dir() and "opencode" in item.name.lower():
                        self.safe_remove(item)
                        self.print_emoji("[DEL]", f"Removed OpenCode data in Firefox ({profile_dir.name})")

    def clean_browser_data(self):
        """Clean OpenCode data from all browsers"""
        self.print_emoji("[*]", "Cleaning browser data...")
        
        self.kill_browser_processes()
        
        local_appdata = Path(os.environ.get('LOCALAPPDATA', str(self.home / 'AppData/Local')))
        appdata = Path(os.environ.get('APPDATA', str(self.home / 'AppData/Roaming')))
        
        chromium_browsers = {
            "Google Chrome": local_appdata / "Google" / "Chrome" / "User Data",
            "Microsoft Edge": local_appdata / "Microsoft" / "Edge" / "User Data",
            "Brave Browser": local_appdata / "BraveSoftware" / "Brave-Browser" / "User Data",
            "Opera": appdata / "Opera Software" / "Opera Stable",
            "Opera GX": appdata / "Opera Software" / "Opera GX Stable",
            "Vivaldi": local_appdata / "Vivaldi" / "User Data",
            "Arc": local_appdata / "Arc" / "User Data",
        }
        
        for browser_name, browser_path in chromium_browsers.items():
            self.clean_chromium_browser(browser_path, browser_name)
        
        firefox_profiles = appdata / "Mozilla" / "Firefox" / "Profiles"
        self.clean_firefox_browser(firefox_profiles)
        
        self.print_emoji("[OK]", "Browser data cleanup completed")

    def kill_browser_processes(self):
        """Kill browser processes to allow cleanup"""
        self.print_emoji("[*]", "Closing browsers for cleanup...")
        browser_processes = [
            "chrome.exe", "msedge.exe", "brave.exe", "opera.exe", 
            "vivaldi.exe", "firefox.exe", "arc.exe"
        ]
        for proc in browser_processes:
            try:
                subprocess.run(["taskkill", "/F", "/IM", proc], 
                             stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL, check=False)
            except: pass
        time.sleep(3)
        self.print_emoji("[OK]", "Browsers closed")

    def clean_browser_data_macos(self):
        """Clean OpenCode data from browsers on macOS"""
        self.print_emoji("[*]", "Cleaning browser data...")
        
        chromium_browsers = {
            "Google Chrome": self.home / "Library" / "Application Support" / "Google" / "Chrome",
            "Microsoft Edge": self.home / "Library" / "Application Support" / "Microsoft Edge",
            "Brave Browser": self.home / "Library" / "Application Support" / "BraveSoftware" / "Brave-Browser",
            "Opera": self.home / "Library" / "Application Support" / "com.operasoftware.Opera",
            "Vivaldi": self.home / "Library" / "Application Support" / "Vivaldi",
            "Arc": self.home / "Library" / "Application Support" / "Arc",
        }
        
        for browser_name, browser_path in chromium_browsers.items():
            self.clean_chromium_browser(browser_path, browser_name)
        
        firefox_profiles = self.home / "Library" / "Application Support" / "Firefox" / "Profiles"
        self.clean_firefox_browser(firefox_profiles)
        
        self.print_emoji("[OK]", "Browser data cleanup completed")

    def clean_browser_data_linux(self):
        """Clean OpenCode data from browsers on Linux"""
        self.print_emoji("[*]", "Cleaning browser data...")
        
        xdg_config = Path(os.environ.get('XDG_CONFIG_HOME', self.home / '.config'))
        
        chromium_browsers = {
            "Google Chrome": xdg_config / "google-chrome",
            "Chromium": xdg_config / "chromium",
            "Microsoft Edge": xdg_config / "microsoft-edge",
            "Brave Browser": xdg_config / "BraveSoftware" / "Brave-Browser",
            "Opera": xdg_config / "opera",
            "Vivaldi": xdg_config / "vivaldi",
        }
        
        for browser_name, browser_path in chromium_browsers.items():
            self.clean_chromium_browser(browser_path, browser_name)
        
        firefox_profiles = self.home / ".mozilla" / "firefox"
        self.clean_firefox_browser(firefox_profiles)
        
        self.print_emoji("[OK]", "Browser data cleanup completed")

    def remove_vscode_extension_data(self, vscode_path):
        """Remove OpenCode extension data from VSCode-like editors"""
        if not vscode_path.exists():
            return
            
        self.print_emoji("[*]", f"Checking VSCode extensions at {vscode_path}...")
        
        extensions_dir = vscode_path / "extensions"
        if extensions_dir.exists():
            for ext in extensions_dir.iterdir():
                if ext.is_dir() and "opencode" in ext.name.lower():
                    self.safe_remove(ext)
        
        user_data = vscode_path / "User"
        if user_data.exists():
            global_storage = user_data / "globalStorage"
            if global_storage.exists():
                for item in global_storage.iterdir():
                    if item.is_dir() and "opencode" in item.name.lower():
                        self.safe_remove(item)
            
            workspace_storage = user_data / "workspaceStorage"
            if workspace_storage.exists():
                for ws in workspace_storage.iterdir():
                    if ws.is_dir():
                        for item in ws.iterdir():
                            if "opencode" in item.name.lower():
                                self.safe_remove(item)

    def remove_macos_opencode(self):
        """Remove OpenCode from macOS"""
        self.print_emoji("[*]", "Removing OpenCode from macOS...")
        
        # Application
        self.safe_remove("/Applications/OpenCode.app")
        self.safe_remove(str(self.home / "Applications/OpenCode.app"))
        
        # Application Support
        self.safe_remove(str(self.home / "Library/Application Support/*opencode*"))
        self.safe_remove(str(self.home / "Library/Application Support/*OpenCode*"))
        
        # Preferences
        self.safe_remove(str(self.home / "Library/Preferences/*opencode*"))
        self.safe_remove(str(self.home / "Library/Preferences/*OpenCode*"))
        self.safe_remove(str(self.home / "Library/Preferences/ai.opencode*"))
        
        # Caches
        self.safe_remove(str(self.home / "Library/Caches/*opencode*"))
        self.safe_remove(str(self.home / "Library/Caches/*OpenCode*"))
        self.safe_remove(str(self.home / "Library/Caches/ai.opencode*"))
        
        # Logs
        self.safe_remove(str(self.home / "Library/Logs/*opencode*"))
        self.safe_remove(str(self.home / "Library/Logs/*OpenCode*"))
        
        # Saved Application State
        self.safe_remove(str(self.home / "Library/Saved Application State/*opencode*"))
        self.safe_remove(str(self.home / "Library/Saved Application State/*OpenCode*"))
        
        # HTTP Storage
        self.safe_remove(str(self.home / "Library/HTTPStorages/*opencode*"))
        self.safe_remove(str(self.home / "Library/HTTPStorages/*OpenCode*"))
        
        # Group Containers
        self.safe_remove(str(self.home / "Library/Group Containers/*opencode*"))
        self.safe_remove(str(self.home / "Library/Group Containers/*OpenCode*"))
        
        # Application Scripts
        self.safe_remove(str(self.home / "Library/Application Scripts/*opencode*"))
        self.safe_remove(str(self.home / "Library/Application Scripts/*OpenCode*"))
        
        # Update Launch Services
        try:
            lsregister_path = ("/System/Library/Frameworks/CoreServices.framework/"
                             "Frameworks/LaunchServices.framework/Support/lsregister")
            subprocess.run([lsregister_path, "-kill", "-r", "-domain", "local", 
                          "-domain", "system", "-domain", "user"], 
                         stderr=subprocess.DEVNULL, check=False)
        except: pass
        
        # Clean VSCode extensions
        self.remove_vscode_extension_data(self.home / "Library/Application Support/Code")
        self.remove_vscode_extension_data(self.home / ".vscode")
        
        # Clean browsers
        self.clean_browser_data_macos()

    def remove_linux_opencode(self):
        """Remove OpenCode from Linux"""
        self.print_emoji("[*]", "Removing OpenCode from Linux...")
        
        xdg_config = Path(os.environ.get('XDG_CONFIG_HOME', self.home / '.config'))
        xdg_data = Path(os.environ.get('XDG_DATA_HOME', self.home / '.local/share'))
        xdg_cache = Path(os.environ.get('XDG_CACHE_HOME', self.home / '.cache'))
        xdg_state = Path(os.environ.get('XDG_STATE_HOME', self.home / '.local/state'))
        
        # Application binaries
        app_paths = [
            "/opt/OpenCode",
            "/opt/opencode",
            "/usr/share/opencode",
            "/usr/local/bin/opencode",
            "/usr/bin/opencode",
            str(self.home / ".local/bin/opencode"),
        ]
        for path in app_paths:
            self.safe_remove(path)
        
        # Try package manager removal
        try:
            subprocess.run(["apt", "remove", "-y", "opencode"], 
                         stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL, check=False)
        except: pass
        try:
            subprocess.run(["snap", "remove", "opencode"], 
                         stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL, check=False)
        except: pass
        try:
            subprocess.run(["flatpak", "uninstall", "-y", "ai.opencode.desktop"], 
                         stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL, check=False)
        except: pass
        
        # Configuration
        self.safe_remove(str(xdg_config / 'opencode'))
        self.safe_remove(str(xdg_config / 'OpenCode'))
        self.safe_remove(str(self.home / '.opencode'))
        
        # Application data
        self.safe_remove(str(xdg_data / 'opencode'))
        self.safe_remove(str(xdg_data / 'OpenCode'))
        
        # Cache files
        self.safe_remove(str(xdg_cache / 'opencode'))
        self.safe_remove(str(xdg_cache / 'OpenCode'))
        
        # State and logs
        self.safe_remove(str(xdg_state / 'opencode'))
        
        # Desktop entries
        self.safe_remove(str(xdg_data / 'applications/opencode.desktop'))
        self.safe_remove(str(xdg_data / 'applications/OpenCode.desktop'))
        self.safe_remove(str(xdg_data / 'applications/ai.opencode.desktop.desktop'))
        
        # Runtime files
        try:
            uid = os.getuid()
            self.safe_remove(f"/run/user/{uid}/opencode")
        except: pass
        self.safe_remove(f"/tmp/opencode-{os.getenv('USER', '*')}")
        
        # Clean VSCode extensions
        self.remove_vscode_extension_data(xdg_config / "Code")
        self.remove_vscode_extension_data(self.home / ".vscode")
        
        # Clean browsers
        self.clean_browser_data_linux()

    def remove_windows_opencode(self):
        """Remove OpenCode from Windows"""
        self.print_emoji("[*]", "Removing OpenCode from Windows...")
        
        local_appdata = Path(os.environ.get('LOCALAPPDATA', str(self.home / 'AppData/Local')))
        appdata = Path(os.environ.get('APPDATA', str(self.home / 'AppData/Roaming')))
        program_files = Path(os.environ.get('PROGRAMFILES', 'C:/Program Files'))
        program_files_x86 = Path(os.environ.get('PROGRAMFILES(X86)', 'C:/Program Files (x86)'))
        
        # Application installation directories
        app_dirs = [
            local_appdata / "OpenCode",
            local_appdata / "Programs" / "OpenCode",
            program_files / "OpenCode",
            program_files_x86 / "OpenCode",
        ]
        
        # Data directories
        data_dirs = [
            appdata / "OpenCode",
            appdata / "opencode",
            local_appdata / "opencode",
        ]
        
        for d in app_dirs + data_dirs:
            if d.exists():
                self.safe_remove(d)
        
        # Temp files
        temp_dir = Path(os.environ.get('TEMP', 'C:/Windows/Temp'))
        self.safe_remove(str(temp_dir / "*opencode*"))
        self.safe_remove(str(temp_dir / "*OpenCode*"))
        
        # Start Menu shortcuts
        start_menu = appdata / "Microsoft/Windows/Start Menu/Programs"
        self.safe_remove(str(start_menu / "*OpenCode*.lnk"))
        self.safe_remove(str(start_menu / "*opencode*.lnk"))
        
        # Desktop shortcuts
        desktop = self.home / "Desktop"
        self.safe_remove(str(desktop / "*OpenCode*.lnk"))
        self.safe_remove(str(desktop / "*opencode*.lnk"))
        
        # Registry cleanup
        self.print_emoji("[*]", "Cleaning registry...")
        try:
            import winreg
            registry_patterns = [
                "Software\\OpenCode",
                "Software\\opencode",
                "Software\\ai.opencode",
                "Software\\ai.opencode.desktop",
            ]
            
            for subkey in registry_patterns:
                try:
                    winreg.DeleteKeyEx(winreg.HKEY_CURRENT_USER, subkey)
                    self.print_emoji("[OK]", f"Removed registry: {subkey}")
                except FileNotFoundError:
                    pass
                except PermissionError:
                    self.print_emoji("[X]", f"Permission denied: {subkey}")
                except OSError as e:
                    self.print_emoji("[!]", f"Error: {subkey}: {e}")
        except ImportError:
            self.print_emoji("[!]", "Registry cleanup requires Windows")
        except Exception as e:
            self.print_emoji("[!]", f"Registry warning: {e}")
        
        # Clean VSCode extensions
        self.remove_vscode_extension_data(appdata / "Code")
        self.remove_vscode_extension_data(self.home / ".vscode")
        
        # Clean browsers
        self.clean_browser_data()

    def verify_removal(self):
        """Verify that OpenCode has been completely removed"""
        self.print_emoji("[*]", "Verifying OpenCode removal...")
        
        remaining = []
        
        if self.system == "Darwin":
            check_paths = [
                "/Applications/OpenCode.app",
                str(self.home / "Library/Application Support/OpenCode"),
            ]
        elif self.system == "Windows":
            local_appdata = Path(os.environ.get('LOCALAPPDATA', str(self.home / 'AppData/Local')))
            appdata = Path(os.environ.get('APPDATA', str(self.home / 'AppData/Roaming')))
            check_paths = [
                str(local_appdata / "OpenCode"),
                str(appdata / "OpenCode"),
            ]
        elif self.system == "Linux":
            xdg_config = Path(os.environ.get('XDG_CONFIG_HOME', self.home / '.config'))
            xdg_data = Path(os.environ.get('XDG_DATA_HOME', self.home / '.local/share'))
            check_paths = [
                str(xdg_config / "OpenCode"),
                str(xdg_data / "OpenCode"),
                "/opt/OpenCode",
            ]
        else:
            check_paths = []
        
        for path in check_paths:
            if os.path.exists(path):
                remaining.append(path)
                self.print_emoji("[!]", f"Still exists: {path}")
        
        if not remaining:
            self.print_emoji("[OK]", "OpenCode completely removed!")
            return True
        else:
            self.print_emoji("[!]", f"{len(remaining)} items still remain")
            self.print_emoji("[!]", "Try closing all apps and running again")
            return False

    def is_admin(self):
        """Check for admin privileges"""
        try:
            import ctypes
            return ctypes.windll.shell32.IsUserAnAdmin() != 0
        except Exception:
            return False

    def run(self):
        """Main removal process"""
        print("=" * 70)
        self.print_emoji("[*]", "Starting OpenCode Complete Removal...")
        self.print_emoji("[*]", f"Detected system: {self.system}")
        self.print_emoji("[!]", "WARNING: This will COMPLETELY REMOVE OpenCode!")
        print("=" * 70)
        
        if self.system == "Windows" and not self.is_admin():
            self.print_emoji("[X]", "This tool requires administrator privileges on Windows.")
            self.print_emoji("[!]", "Please re-run with 'Run as Administrator'.")
            return False
        
        # Step 1: Kill processes
        self.kill_opencode_processes()
        
        # Step 2: Platform-specific removal
        if self.system == "Darwin":
            self.remove_macos_opencode()
        elif self.system == "Windows":
            self.remove_windows_opencode()
        elif self.system == "Linux":
            self.remove_linux_opencode()
        else:
            self.print_emoji("[X]", f"Unsupported system: {self.system}")
            return False
        
        # Step 3: Verify removal
        clean = self.verify_removal()
        
        # Final report
        print("\n" + "=" * 70)
        self.print_emoji("[OK]", "OPENCODE REMOVAL COMPLETE!")
        print(f"[+] Removed {self.removed_count} items")
        
        if clean:
            self.print_emoji("[OK]", "OpenCode has been completely removed")
        else:
            self.print_emoji("[!]", "Some files may remain - try rebooting and running again")
        
        self.print_emoji("[*]", "To reinstall, download OpenCode from the official website")
        print("=" * 70)
        
        return True


def is_admin():
    """Check if running with admin privileges"""
    try:
        import ctypes
        return ctypes.windll.shell32.IsUserAnAdmin() != 0
    except:
        return False


def run_as_admin():
    """Re-launch the script with admin privileges"""
    import ctypes
    
    python_exe = sys.executable
    script_path = os.path.abspath(sys.argv[0])
    
    if len(sys.argv) > 1:
        params = ' '.join([f'"{arg}"' for arg in sys.argv[1:]])
        cmd = f'"{script_path}" {params}'
    else:
        cmd = f'"{script_path}"'
    
    try:
        result = ctypes.windll.shell32.ShellExecuteW(
            None, "runas", python_exe, cmd, None, 1
        )
        return result > 32
    except:
        return False


def main():
    """Entry point"""
    if len(sys.argv) > 1 and sys.argv[1] in ['-h', '--help', 'help']:
        print(__doc__)
        return
    
    show_banner()
    
    # Auto-elevate on Windows
    if platform.system() == "Windows" and not is_admin():
        print("[!] Requesting administrator privileges...")
        print("    (Click 'Yes' on the UAC prompt)")
        print()
        
        if run_as_admin():
            sys.exit(0)
        else:
            print("[!] Could not get admin privileges. Some files may not be removable.")
            print()
    
    print("[*] OPENCODE COMPLETE REMOVAL")
    print("=" * 45)
    print("This tool will:")
    print("[!] COMPLETELY REMOVE OpenCode from your system")
    print("[!] You will need to reinstall OpenCode after this")
    print()
    
    response = input("[?] Are you SURE you want to completely remove OpenCode? (y/N): ")
    if response.lower() not in ['y', 'yes']:
        print("[X] Cancelled by user")
        return
    
    response2 = input("[?] This CANNOT be undone. Type 'REMOVE' to confirm: ")
    if response2 != 'REMOVE':
        print("[X] Cancelled by user")
        return
    
    remover = OpenCodeRemover()
    success = remover.run()
    
    if success:
        print("\n[OK] OpenCode has been removed!")
        print("[*] To reinstall, download from the official website")
    else:
        print("\n[X] Removal failed or incomplete")
        sys.exit(1)


if __name__ == "__main__":
    main()