Update CHANGELOG.md

fix: Improve Linux path detection and config handling

.env

@@ -1,2 +1,2 @@
-version=1.7.15
-VERSION=1.7.15
+version=1.7.18
+VERSION=1.7.18

.github/workflows/build.yml

@@ -6,7 +6,7 @@ on:
       version:
         description: 'Version number (e.g. 1.0.9)'
         required: true
-        default: '1.7.16'
+        default: '1.7.17'
 
 permissions:
   contents: write

CHANGELOG.md

@@ -1,5 +1,23 @@
 # Change Log
 
+## v1.7.18
+1. Fix: No Write Permission | 修復沒有寫入權限
+2. Fix: Improve Linux path detection and config handling ｜ 修正 linux 路徑和config寫入讀取
+3. Fix: Locale path_no_exist missing ｜ 修正 path_no_exist 語言遺失
+4. Fix: Some Issues | 修復一些問題
+
+## v1.7.17
+1. Fix: Remove 10 options Totally Reset Cursor | 修復完全重置 Cursor 選項
+
+## v1.7.16
+1. Add bulgarian language | 增加保加利亚语
+2. Fix: Some Issues | 修復一些問題
+3. Add: Contributors | 增加貢獻者
+4. Fix: Total Reset Cursor | 修復完全重置 Cursor
+5. Add: Display Features and Warnings | 增加顯示功能與警告
+6. Fix: Totally Reset Cursor | 修復完全重置 Cursor
+7. Remake: Logo.py Center | 重做 Logo.py 居中
+
 ## v1.7.15
 1. Fix: Cant Verify the User is Human | 修復無法驗證用戶是否為人類
 2. Added temporary email & GitHub + Cursor AI registration automation | 增加临时邮箱 & GitHub + Cursor AI 注册自动化

README.md

@@ -10,7 +10,7 @@
 [![Release](https://img.shields.io/github/v/release/yeongpin/cursor-free-vip?style=flat-square&logo=github&color=blue)](https://github.com/yeongpin/cursor-free-vip/releases/latest)
 [![License: CC BY-NC-ND 4.0](https://img.shields.io/badge/License-CC_BY--NC--ND_4.0-lightgrey.svg)](https://creativecommons.org/licenses/by-nc-nd/4.0/)
 [![Stars](https://img.shields.io/github/stars/yeongpin/cursor-free-vip?style=flat-square&logo=github)](https://github.com/yeongpin/cursor-free-vip/stargazers)
-[![Download](https://img.shields.io/github/downloads/yeongpin/cursor-free-vip/total?style=flat-square&logo=github&color=52c41a)](https://github.com/yeongpin/cursor-free-vip/releases/latest)
+[![Download](https://img.shields.io/github/downloads/yeongpin/cursor-free-vip/total?style=flat-square&logo=github&color=52c41a1)](https://github.com/yeongpin/cursor-free-vip/releases/latest)
 
 </p>
 <h4>Support Latest 0.47.x Version | 支持最新 0.47.x 版本</h4>
@@ -21,7 +21,7 @@ Cursor's configuration.
 這是一個自動化工具，自動註冊，支持 Windows 和 macOS 系統，完成 Auth 驗證，重置 Cursor 的配置。
 
 <p align="center">
-  <img src="./images/new_2025-03-19_00-19-09.png" alt="new" width="400" style="border-radius: 6px;"/><br>
+  <img src="./images/new_2025-03-22_19-53-10.png" alt="new" width="400" style="border-radius: 6px;"/><br>
 </p>
 
 ##### If you don't have Google Chrome, you can download it from [here](https://www.google.com/intl/en_pk/chrome/)

github_cursor_register.py

@@ -13,195 +13,604 @@ from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
 from webdriver_manager.chrome import ChromeDriverManager
 import logging
+import platform
+from colorama import Fore, Style, init
+from selenium.common.exceptions import TimeoutException, WebDriverException, NoSuchElementException
+import shutil
+
+# Initialize colorama
+init()
 
 # Set up logging
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
-def generate_temp_email():
-    """Generates a temporary email using 1secmail API."""
-    try:
-        response = requests.get("https://www.1secmail.com/api/v1/?action=genRandomMailbox&count=1")
-        response.raise_for_status()
-        email = response.json()[0]
-        logging.info(f"Generated temp email: {email}")
-        return email
-    except requests.RequestException as e:
-        logging.error(f"Failed to generate temp email: {e}")
-        raise
-
-def extract_inbox(email, retries=5, wait_time=10):
-    """Extracts the inbox for the temp email with retries."""
-    domain = email.split('@')[1]
-    login = email.split('@')[0]
-    inbox_url = f"https://www.1secmail.com/api/v1/?action=getMessages&login={login}&domain={domain}"
-    
-    for attempt in range(retries):
-        time.sleep(wait_time)
-        try:
-            messages = requests.get(inbox_url).json()
-            if messages:
-                logging.info(f"Inbox found on attempt {attempt + 1}: {messages[0]['id']}")
-                return messages[0]['id']
-            logging.info(f"Retry {attempt + 1}/{retries}: No email yet...")
-        except requests.RequestException as e:
-            logging.error(f"Error fetching inbox: {e}")
-    logging.warning("No messages found after retries.")
-    return None
-
-def get_verification_link(email, message_id):
-    """Retrieves the verification link from the email inbox."""
-    domain = email.split('@')[1]
-    login = email.split('@')[0]
-    msg_url = f"https://www.1secmail.com/api/v1/?action=readMessage&login={login}&domain={domain}&id={message_id}"
-    try:
-        message = requests.get(msg_url).json()
-        for line in message['body'].splitlines():
-            if "https://github.com/" in line:
-                logging.info(f"Verification link found: {line}")
-                return line.strip()
-        logging.warning("Verification link not found in email.")
-        return None
-    except requests.RequestException as e:
-        logging.error(f"Failed to fetch email message: {e}")
-        return None
-
-def reset_machine_id():
-    """Resets the machine ID to bypass trial detection."""
-    new_id = str(uuid.uuid4())
-    try:
-        if os.name == 'nt':  # Windows
-            os.system(f'reg add "HKLM\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid /d {new_id} /f')
-            logging.info(f"Machine ID reset on Windows: {new_id}")
-        elif os.name == 'posix':  # Linux/macOS
-            if os.path.exists("/etc/machine-id"):
-                os.system(f'echo {new_id} | sudo tee /etc/machine-id')
-                logging.info(f"Machine ID reset on Linux: {new_id}")
-            else:
-                logging.info("Machine ID reset skipped (macOS or no /etc/machine-id)")
-        else:
-            logging.warning("Unsupported OS for machine ID reset.")
-    except Exception as e:
-        logging.error(f"Failed to reset machine ID: {e}")
-
-def register_github(email):
-    """Automates GitHub registration with temp email."""
-    options = Options()
-    options.add_argument('--headless')
-    options.add_argument('--no-sandbox')
-    options.add_argument('--disable-dev-shm-usage')
-    
-    driver = None
-    try:
-        driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
-        driver.get("https://github.com/join")
+# Define emoji constants
+EMOJI = {
+    'START': '🚀',
+    'FORM': '📝',
+    'VERIFY': '🔄',
+    'PASSWORD': '🔑',
+    'CODE': '📱',
+    'DONE': '✨',
+    'ERROR': '❌',
+    'WAIT': '⏳',
+    'SUCCESS': '✅',
+    'MAIL': '📧',
+    'KEY': '🔐',
+    'UPDATE': '🔄',
+    'INFO': 'ℹ️',
+    'EMAIL': '📧',
+    'REFRESH': '🔄',
+    'LINK': '🔗',
+    'WARNING': '⚠️'
+}
 
+class GitHubCursorRegistration:
+    def __init__(self, translator=None):
+        self.translator = translator
+        # Set browser to visible mode
+        os.environ['BROWSER_HEADLESS'] = 'False'
+        self.browser = None
+        self.email_address = None
+        
         # Generate random credentials
-        username = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
-        password = ''.join(random.choices(string.ascii_letters + string.digits, k=15))
-
-        # Fill in the registration form
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "user_login")))
-        driver.find_element(By.ID, "user_login").send_keys(username)
-        driver.find_element(By.ID, "user_email").send_keys(email)
-        driver.find_element(By.ID, "user_password").send_keys(password)
-        driver.find_element(By.ID, "signup_button").click()
-
-        # Wait for page transition (GitHub might redirect or show CAPTCHA)
-        time.sleep(5)
-        logging.info(f"GitHub account created: {username} | {email}")
-        return username, password
-    except Exception as e:
-        logging.error(f"GitHub registration failed: {e}")
-        raise
-    finally:
-        if driver:
-            driver.quit()
-
-def register_cursor_with_github(github_username, github_password):
-    """Logs into Cursor AI using GitHub authentication."""
-    options = Options()
-    options.add_argument('--headless')
-    driver = None
-    try:
-        driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
-        driver.get("https://cursor.sh")
-        
-        # Sign in with GitHub
-        WebDriverWait(driver, 10).until(EC.element_to_be_clickable((By.XPATH, "//a[contains(text(), 'Sign in with GitHub')]")))
-        driver.find_element(By.XPATH, "//a[contains(text(), 'Sign in with GitHub')]").click()
-
-        # GitHub login page
-        WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "login_field")))
-        driver.find_element(By.ID, "login_field").send_keys(github_username)
-        driver.find_element(By.ID, "password").send_keys(github_password)
-        driver.find_element(By.NAME, "commit").click()
-
-        time.sleep(5)  # Wait for login to complete
-        logging.info("Registered Cursor with GitHub")
-    except Exception as e:
-        logging.error(f"Cursor registration failed: {e}")
-        raise
-    finally:
-        if driver:
-            driver.quit()
-
-def save_credentials(email, github_username, github_password):
-    """Saves the credentials in a log file."""
-    try:
-        with open("github_cursor_accounts.txt", "a") as f:
-            f.write(json.dumps({
-                "email": email,
-                "github_username": github_username,
-                "github_password": github_password,
-                "timestamp": time.strftime('%Y-%m-%d %H:%M:%S')
-            }) + "\n")
-        logging.info("Credentials saved to github_cursor_accounts.txt")
-    except Exception as e:
-        logging.error(f"Failed to save credentials: {e}")
-
-def display_features_and_warnings():
-    """Displays features and warnings before proceeding."""
-    print("\n🚀 GitHub + Cursor AI Registration Automation")
-    print("=====================================")
-    print("Features:")
-    print("  - Generates a temporary email using 1secmail.")
-    print("  - Registers a new GitHub account with random credentials.")
-    print("  - Verifies the GitHub email automatically.")
-    print("  - Logs into Cursor AI using GitHub authentication.")
-    print("  - Resets the machine ID to bypass trial detection.")
-    print("  - Saves all credentials to a file.")
-    print("\n⚠️ Warnings:")
-    print("  - This script automates account creation, which may violate GitHub/Cursor terms of service.")
-    print("  - Requires internet access and administrative privileges.")
-    print("  - CAPTCHA or additional verification may interrupt automation.")
-    print("  - Use responsibly and at your own risk.")
-    print("=====================================\n")
-
-def get_user_confirmation():
-    """Prompts the user for confirmation to proceed."""
-    while True:
-        response = input("Do you want to proceed with GitHub + Cursor AI registration? (yes/no): ").lower().strip()
-        if response in ['yes', 'y']:
-            return True
-        elif response in ['no', 'n']:
-            return False
-        else:
-            print("Please enter 'yes' or 'no'.")
-
-def main(translator=None):
-    logging.info("Starting GitHub + Cursor AI Registration Automation")
+        self.github_username = ''.join(random.choices(string.ascii_lowercase + string.digits, k=10))
+        self.github_password = ''.join(random.choices(string.ascii_letters + string.digits + string.punctuation, k=16))
     
-    # 如果没有提供translator，使用默认英文提示
-    if translator is None:
-        # Display features and warnings in English
-        display_features_and_warnings()
+    def setup_browser(self):
+        """Setup and configure the web browser"""
+        try:
+            print(f"{Fore.CYAN}{EMOJI['START']} Setting up browser...{Style.RESET_ALL}")
+            
+            options = Options()
+            options.add_argument('--incognito')
+            options.add_argument('--no-sandbox')
+            options.add_argument('--disable-dev-shm-usage')
+            options.add_argument('--window-size=1920,1080')
+            options.add_argument('--disable-notifications')
+            options.add_argument('--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36')
+            
+            self.browser = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
+            self.browser.set_page_load_timeout(30)
+            return True
+        except Exception as e:
+            print(f"{Fore.RED}{EMOJI['ERROR']} Failed to setup browser: {str(e)}{Style.RESET_ALL}")
+            return False
+    
+    def get_temp_email(self):
+        """Get a temporary email address using YOPmail"""
+        try:
+            if not self.browser:
+                if not self.setup_browser():
+                    return False
+            
+            print(f"{Fore.CYAN}{EMOJI['MAIL']} Generating temporary email address...{Style.RESET_ALL}")
+            self.browser.get("https://yopmail.com/")
+            time.sleep(2)
+            
+            # Generate a realistic username
+            first_names = ["john", "sara", "michael", "emma", "david", "jennifer", "robert", "lisa"]
+            last_names = ["smith", "johnson", "williams", "brown", "jones", "miller", "davis", "garcia"]
+            
+            random_first = random.choice(first_names)
+            random_last = random.choice(last_names)
+            random_num = random.randint(100, 999)
+            
+            username = f"{random_first}.{random_last}{random_num}"
+            
+            # Enter the username and check inbox
+            email_field = self.browser.find_element(By.XPATH, "//input[@id='login']")
+            if email_field:
+                email_field.clear()
+                email_field.send_keys(username)
+                time.sleep(1)
+                
+                # Click the check button
+                check_button = self.browser.find_element(By.XPATH, "//button[@title='Check Inbox' or @class='sbut' or contains(@onclick, 'ver')]")
+                if check_button:
+                    check_button.click()
+                    time.sleep(2)
+                    self.email_address = f"{username}@yopmail.com"
+                    print(f"{Fore.GREEN}{EMOJI['SUCCESS']} Temp email created: {self.email_address}{Style.RESET_ALL}")
+                    return True
+            
+            print(f"{Fore.RED}{EMOJI['ERROR']} Failed to create YOPmail address{Style.RESET_ALL}")
+            return False
+            
+        except Exception as e:
+            print(f"{Fore.RED}{EMOJI['ERROR']} Error getting temporary email: {str(e)}{Style.RESET_ALL}")
+            return False
+    
+    def register_github(self):
+        """Register a new GitHub account"""
+        if not self.email_address:
+            print(f"{Fore.RED}{EMOJI['ERROR']} No email address available{Style.RESET_ALL}")
+            return False
+            
+        if not self.browser:
+            if not self.setup_browser():
+                return False
         
-        if not get_user_confirmation():
-            logging.info("Operation cancelled by user.")
-            print("❌ Operation cancelled.")
-            return
-    else:
-        # 使用translator显示多语言提示
+        try:
+            print(f"{Fore.CYAN}{EMOJI['FORM']} Registering GitHub account...{Style.RESET_ALL}")
+            self.browser.get("https://github.com/join")
+            time.sleep(3)
+
+            # Fill in the registration form
+            WebDriverWait(self.browser, 15).until(EC.visibility_of_element_located((By.ID, "user_login")))
+            self.browser.find_element(By.ID, "user_login").send_keys(self.github_username)
+            self.browser.find_element(By.ID, "user_email").send_keys(self.email_address)
+            self.browser.find_element(By.ID, "user_password").send_keys(self.github_password)
+            
+            print(f"{Fore.CYAN}{EMOJI['INFO']} GitHub username: {self.github_username}{Style.RESET_ALL}")
+            print(f"{Fore.CYAN}{EMOJI['INFO']} GitHub password: {self.github_password}{Style.RESET_ALL}")
+            
+            # Check for any notice or popup and handle it
+            try:
+                signup_button = self.browser.find_element(By.ID, "signup_button")
+                print(f"{Fore.CYAN}{EMOJI['INFO']} Clicking sign up button...{Style.RESET_ALL}")
+                signup_button.click()
+            except NoSuchElementException:
+                print(f"{Fore.YELLOW}{EMOJI['INFO']} Signup button not found, trying alternative selector{Style.RESET_ALL}")
+                buttons = self.browser.find_elements(By.TAG_NAME, "button")
+                for button in buttons:
+                    if "Sign up" in button.text:
+                        button.click()
+                        break
+
+            # Wait for page transition and check for CAPTCHA
+            time.sleep(5)
+            
+            # Check if registration was successful or if CAPTCHA appeared
+            current_url = self.browser.current_url
+            
+            # Look for CAPTCHA in URL or on page
+            if "captcha" in current_url.lower() or "are you a robot" in self.browser.page_source.lower():
+                print(f"{Fore.YELLOW}{EMOJI['WAIT']} CAPTCHA detected, please complete it manually{Style.RESET_ALL}")
+                print(f"{Fore.YELLOW}{EMOJI['INFO']} You have 60 seconds to solve the CAPTCHA...{Style.RESET_ALL}")
+                
+                # Wait for user to solve CAPTCHA (60 seconds max)
+                for i in range(60):
+                    current_url = self.browser.current_url
+                    if "captcha" not in current_url.lower() and "are you a robot" not in self.browser.page_source.lower():
+                        print(f"{Fore.GREEN}{EMOJI['SUCCESS']} CAPTCHA completed successfully{Style.RESET_ALL}")
+                        break
+                    time.sleep(1)
+                    if i % 10 == 0 and i > 0:
+                        print(f"{Fore.YELLOW}{EMOJI['WAIT']} Still waiting for CAPTCHA completion... {60-i} seconds remaining{Style.RESET_ALL}")
+                
+                # Check if CAPTCHA was solved after waiting
+                if "captcha" in self.browser.current_url.lower() or "are you a robot" in self.browser.page_source.lower():
+                    print(f"{Fore.RED}{EMOJI['ERROR']} CAPTCHA not solved within time limit{Style.RESET_ALL}")
+                    print(f"{Fore.YELLOW}{EMOJI['INFO']} Do you want more time to solve the CAPTCHA? (yes/no){Style.RESET_ALL}")
+                    response = input().lower().strip()
+                    if response in ['yes', 'y']:
+                        print(f"{Fore.YELLOW}{EMOJI['INFO']} Press Enter when you've completed the CAPTCHA...{Style.RESET_ALL}")
+                        input()
+                        if "captcha" in self.browser.current_url.lower() or "are you a robot" in self.browser.page_source.lower():
+                            print(f"{Fore.RED}{EMOJI['ERROR']} CAPTCHA still not solved{Style.RESET_ALL}")
+                            return False
+                    else:
+                        return False
+            
+            # Wait for registration to complete
+            time.sleep(5)
+            
+            print(f"{Fore.GREEN}{EMOJI['SUCCESS']} GitHub account registered{Style.RESET_ALL}")
+            return True
+            
+        except Exception as e:
+            print(f"{Fore.RED}{EMOJI['ERROR']} Failed to register GitHub account: {str(e)}{Style.RESET_ALL}")
+            return False
+    
+    def check_email_verification(self):
+        """Check for GitHub verification email and click the verification link"""
+        if not self.email_address or not self.browser:
+            print(f"{Fore.RED}{EMOJI['ERROR']} Email or browser not available{Style.RESET_ALL}")
+            return False
+        
+        try:
+            print(f"{Fore.CYAN}{EMOJI['EMAIL']} Checking for verification email...{Style.RESET_ALL}")
+            
+            # Extract username from email for YOPmail
+            username = self.email_address.split('@')[0]
+            
+            max_attempts = 10
+            for attempt in range(1, max_attempts + 1):
+                print(f"{Fore.CYAN}{EMOJI['REFRESH']} Checking YOPmail inbox (attempt {attempt}/{max_attempts})...{Style.RESET_ALL}")
+                
+                # Go to YOPmail inbox
+                self.browser.get(f"https://yopmail.com/en/wm")
+                time.sleep(2)
+                
+                # Enter email address
+                try:
+                    email_input = WebDriverWait(self.browser, 10).until(
+                        EC.presence_of_element_located((By.ID, "login"))
+                    )
+                    email_input.clear()
+                    email_input.send_keys(username)
+                    
+                    # Click the check inbox button
+                    check_button = self.browser.find_element(By.CSS_SELECTOR, "button[onclick='verif()']")
+                    check_button.click()
+                    time.sleep(3)
+                    
+                    # Switch to inbox frame
+                    iframe = WebDriverWait(self.browser, 10).until(
+                        EC.presence_of_element_located((By.ID, "ifinbox"))
+                    )
+                    self.browser.switch_to.frame(iframe)
+                    
+                    # Look for GitHub email
+                    emails = self.browser.find_elements(By.CSS_SELECTOR, "div.m")
+                    github_email = None
+                    
+                    for email in emails:
+                        if "github" in email.text.lower():
+                            github_email = email
+                            break
+                    
+                    if github_email:
+                        print(f"{Fore.GREEN}{EMOJI['SUCCESS']} GitHub verification email found{Style.RESET_ALL}")
+                        github_email.click()
+                        time.sleep(2)
+                        
+                        # Switch back to default content
+                        self.browser.switch_to.default_content()
+                        
+                        # Switch to email content frame
+                        iframe = WebDriverWait(self.browser, 10).until(
+                            EC.presence_of_element_located((By.ID, "ifmail"))
+                        )
+                        self.browser.switch_to.frame(iframe)
+                        
+                        # Find verification link
+                        try:
+                            # Look for the verification button or link
+                            verification_elements = self.browser.find_elements(By.XPATH, "//a[contains(text(), 'Verify') or contains(text(), 'verify') or contains(@href, 'verify')]")
+                            
+                            if verification_elements:
+                                verification_link = verification_elements[0].get_attribute('href')
+                                print(f"{Fore.CYAN}{EMOJI['LINK']} Found verification link{Style.RESET_ALL}")
+                                
+                                # Open the verification link in the same window
+                                self.browser.get(verification_link)
+                                time.sleep(5)
+                                
+                                # Check if verification was successful
+                                if "verified" in self.browser.page_source.lower() or "successful" in self.browser.page_source.lower():
+                                    print(f"{Fore.GREEN}{EMOJI['SUCCESS']} Email verified successfully{Style.RESET_ALL}")
+                                    return True
+                                else:
+                                    print(f"{Fore.YELLOW}{EMOJI['WARNING']} Email verification page loaded but success not confirmed{Style.RESET_ALL}")
+                                    print(f"{Fore.YELLOW}{EMOJI['INFO']} Please check if verification was successful manually and press Enter to continue...{Style.RESET_ALL}")
+                                    input()
+                                    return True
+                            else:
+                                print(f"{Fore.RED}{EMOJI['ERROR']} No verification link found in email{Style.RESET_ALL}")
+                        except Exception as e:
+                            print(f"{Fore.RED}{EMOJI['ERROR']} Error extracting verification link: {str(e)}{Style.RESET_ALL}")
+                    else:
+                        print(f"{Fore.YELLOW}{EMOJI['WAIT']} No GitHub verification email yet, waiting... ({attempt}/{max_attempts}){Style.RESET_ALL}")
+                        time.sleep(15)  # Wait before checking again
+                
+                except Exception as e:
+                    print(f"{Fore.RED}{EMOJI['ERROR']} Error checking email: {str(e)}{Style.RESET_ALL}")
+            
+            print(f"{Fore.RED}{EMOJI['ERROR']} No verification email received after {max_attempts} attempts{Style.RESET_ALL}")
+            print(f"{Fore.YELLOW}{EMOJI['INFO']} Do you want to check manually? (yes/no){Style.RESET_ALL}")
+            response = input().lower().strip()
+            if response in ['yes', 'y']:
+                print(f"{Fore.YELLOW}{EMOJI['INFO']} Please check your YOPmail inbox manually at: https://yopmail.com/en/wm")
+                print(f"{Fore.YELLOW}{EMOJI['INFO']} Username: {username}")
+                print(f"{Fore.YELLOW}{EMOJI['INFO']} Press Enter when you've verified the email...{Style.RESET_ALL}")
+                input()
+                return True
+            return False
+            
+        except Exception as e:
+            print(f"{Fore.RED}{EMOJI['ERROR']} Failed to check verification email: {str(e)}{Style.RESET_ALL}")
+            return False
+    
+    def register_cursor(self):
+        """Register with Cursor using GitHub"""
+        if not self.browser:
+            if not self.setup_browser():
+                return False
+                
+        try:
+            print(f"{Fore.CYAN}{EMOJI['KEY']} Registering with Cursor using GitHub...{Style.RESET_ALL}")
+            
+            # Navigate to Cursor login page
+            self.browser.get("https://cursor.sh/login")
+            time.sleep(3)
+            
+            try:
+                # Look for GitHub login button
+                github_buttons = WebDriverWait(self.browser, 15).until(
+                    EC.presence_of_all_elements_located((By.XPATH, "//button[contains(., 'GitHub') or contains(@class, 'github')]"))
+                )
+                
+                if not github_buttons:
+                    print(f"{Fore.RED}{EMOJI['ERROR']} GitHub login button not found{Style.RESET_ALL}")
+                    return False
+                
+                # Click the first GitHub button
+                print(f"{Fore.CYAN}{EMOJI['INFO']} Clicking GitHub login button...{Style.RESET_ALL}")
+                github_buttons[0].click()
+                time.sleep(5)
+                
+                # Check if we're redirected to GitHub login
+                current_url = self.browser.current_url
+                if "github.com" in current_url:
+                    print(f"{Fore.CYAN}{EMOJI['INFO']} Redirected to GitHub login{Style.RESET_ALL}")
+                    
+                    # Check if we need to log in to GitHub
+                    if "login" in current_url:
+                        print(f"{Fore.CYAN}{EMOJI['INFO']} Logging into GitHub...{Style.RESET_ALL}")
+                        
+                        try:
+                            # Enter GitHub credentials
+                            username_field = WebDriverWait(self.browser, 10).until(
+                                EC.presence_of_element_located((By.ID, "login_field"))
+                            )
+                            username_field.send_keys(self.github_username)
+                            
+                            password_field = self.browser.find_element(By.ID, "password")
+                            password_field.send_keys(self.github_password)
+                            
+                            # Click sign in
+                            signin_button = self.browser.find_element(By.CSS_SELECTOR, "input[type='submit']")
+                            signin_button.click()
+                            time.sleep(5)
+                        except Exception as e:
+                            print(f"{Fore.RED}{EMOJI['ERROR']} Error during GitHub login: {str(e)}{Style.RESET_ALL}")
+                            return False
+                    
+                    # Check if we're on the authorization page
+                    if "authorize" in self.browser.current_url:
+                        print(f"{Fore.CYAN}{EMOJI['INFO']} Authorizing Cursor app...{Style.RESET_ALL}")
+                        
+                        try:
+                            # Look for authorization button
+                            auth_buttons = self.browser.find_elements(By.XPATH, "//button[contains(., 'Authorize') or contains(@class, 'btn-primary')]")
+                            
+                            if auth_buttons:
+                                auth_buttons[0].click()
+                                print(f"{Fore.GREEN}{EMOJI['SUCCESS']} Cursor authorized with GitHub{Style.RESET_ALL}")
+                                time.sleep(5)
+                            else:
+                                print(f"{Fore.YELLOW}{EMOJI['WARNING']} No authorization button found, GitHub may be already authorized{Style.RESET_ALL}")
+                        except Exception as e:
+                            print(f"{Fore.RED}{EMOJI['ERROR']} Error during GitHub authorization: {str(e)}{Style.RESET_ALL}")
+                
+                # Wait for Cursor dashboard to load
+                timeout = 30
+                start_time = time.time()
+                while time.time() - start_time < timeout:
+                    if "cursor.sh" in self.browser.current_url and not "login" in self.browser.current_url:
+                        print(f"{Fore.GREEN}{EMOJI['SUCCESS']} Successfully logged into Cursor{Style.RESET_ALL}")
+                        break
+                    time.sleep(1)
+                
+                if "login" in self.browser.current_url:
+                    print(f"{Fore.RED}{EMOJI['ERROR']} Failed to log into Cursor after {timeout} seconds{Style.RESET_ALL}")
+                    return False
+                
+                # Wait for dashboard elements to load
+                time.sleep(3)
+                
+                print(f"{Fore.GREEN}{EMOJI['SUCCESS']} Cursor registered with GitHub successfully{Style.RESET_ALL}")
+                
+                # Now reset the machine ID
+                return self.reset_machine_id()
+                
+            except Exception as e:
+                print(f"{Fore.RED}{EMOJI['ERROR']} Error during Cursor registration: {str(e)}{Style.RESET_ALL}")
+                return False
+                
+        except Exception as e:
+            print(f"{Fore.RED}{EMOJI['ERROR']} Failed to register with Cursor: {str(e)}{Style.RESET_ALL}")
+            return False
+    
+    def reset_machine_id(self):
+        """Reset the Cursor machine ID to bypass limitations"""
+        try:
+            print(f"{Fore.CYAN}{EMOJI['UPDATE']} Resetting Cursor machine ID...{Style.RESET_ALL}")
+            
+            # Find Cursor app data location based on platform
+            cursor_data_dir = None
+            if platform.system() == "Windows":
+                appdata = os.getenv('APPDATA')
+                if appdata:
+                    cursor_data_dir = os.path.join(appdata, "cursor", "Local Storage", "leveldb")
+            elif platform.system() == "Darwin":  # macOS
+                home = os.path.expanduser("~")
+                cursor_data_dir = os.path.join(home, "Library", "Application Support", "cursor", "Local Storage", "leveldb")
+            elif platform.system() == "Linux":
+                home = os.path.expanduser("~")
+                cursor_data_dir = os.path.join(home, ".config", "cursor", "Local Storage", "leveldb")
+            
+            if not cursor_data_dir or not os.path.exists(cursor_data_dir):
+                print(f"{Fore.YELLOW}{EMOJI['WARNING']} Cursor data directory not found at: {cursor_data_dir}{Style.RESET_ALL}")
+                print(f"{Fore.YELLOW}{EMOJI['INFO']} You may need to reset the machine ID manually{Style.RESET_ALL}")
+                
+                # Try to find the Cursor data directory
+                if platform.system() == "Linux":
+                    possible_paths = [
+                        os.path.join(os.path.expanduser("~"), ".config", "cursor"),
+                        os.path.join(os.path.expanduser("~"), ".cursor")
+                    ]
+                    for path in possible_paths:
+                        if os.path.exists(path):
+                            print(f"{Fore.GREEN}{EMOJI['SUCCESS']} Found Cursor directory at: {path}{Style.RESET_ALL}")
+                            # Look for Local Storage subfolder
+                            for root, dirs, files in os.walk(path):
+                                if "Local Storage" in dirs:
+                                    cursor_data_dir = os.path.join(root, "Local Storage", "leveldb")
+                                    print(f"{Fore.GREEN}{EMOJI['SUCCESS']} Found Cursor data directory at: {cursor_data_dir}{Style.RESET_ALL}")
+                                    break
+                            break
+            
+            if cursor_data_dir and os.path.exists(cursor_data_dir):
+                # Generate a new UUID
+                new_machine_id = str(uuid.uuid4())
+                print(f"{Fore.CYAN}{EMOJI['KEY']} New machine ID: {new_machine_id}{Style.RESET_ALL}")
+                
+                # Ask for permission to modify files
+                print(f"{Fore.YELLOW}{EMOJI['WARNING']} This operation will modify Cursor app data files{Style.RESET_ALL}")
+                print(f"{Fore.YELLOW}{EMOJI['INFO']} Do you want to continue? (yes/no){Style.RESET_ALL}")
+                response = input().lower().strip()
+                if response not in ['yes', 'y']:
+                    print(f"{Fore.YELLOW}{EMOJI['INFO']} Machine ID reset aborted{Style.RESET_ALL}")
+                    return False
+                
+                # Backup the directory
+                backup_dir = cursor_data_dir + "_backup_" + time.strftime("%Y%m%d%H%M%S")
+                print(f"{Fore.CYAN}{EMOJI['INFO']} Creating backup of data directory to: {backup_dir}{Style.RESET_ALL}")
+                try:
+                    shutil.copytree(cursor_data_dir, backup_dir)
+                    print(f"{Fore.GREEN}{EMOJI['SUCCESS']} Backup created successfully{Style.RESET_ALL}")
+                except Exception as e:
+                    print(f"{Fore.YELLOW}{EMOJI['WARNING']} Failed to create backup: {str(e)}{Style.RESET_ALL}")
+                    print(f"{Fore.YELLOW}{EMOJI['INFO']} Continuing without backup...{Style.RESET_ALL}")
+                
+                # Find and modify files containing the machine ID
+                modified = False
+                for filename in os.listdir(cursor_data_dir):
+                    if filename.endswith(".log") or filename.endswith(".ldb"):
+                        file_path = os.path.join(cursor_data_dir, filename)
+                        try:
+                            with open(file_path, "rb") as f:
+                                content = f.read()
+                                
+                            # Look for patterns that might contain machine ID
+                            if b"machineId" in content:
+                                print(f"{Fore.CYAN}{EMOJI['INFO']} Found machineId reference in: {filename}{Style.RESET_ALL}")
+                                modified = True
+                                
+                                # For safety, don't modify the binary files directly
+                                # Instead, instruct user to uninstall and reinstall Cursor
+                                print(f"{Fore.YELLOW}{EMOJI['WARNING']} Binary files found that may contain machine ID{Style.RESET_ALL}")
+                                print(f"{Fore.YELLOW}{EMOJI['INFO']} For best results, please:{Style.RESET_ALL}")
+                                print(f"{Fore.YELLOW}{EMOJI['INFO']} 1. Close Cursor if it's running{Style.RESET_ALL}")
+                                print(f"{Fore.YELLOW}{EMOJI['INFO']} 2. Uninstall Cursor completely{Style.RESET_ALL}")
+                                print(f"{Fore.YELLOW}{EMOJI['INFO']} 3. Reinstall Cursor{Style.RESET_ALL}")
+                                print(f"{Fore.YELLOW}{EMOJI['INFO']} 4. Login with your new GitHub account{Style.RESET_ALL}")
+                                break
+                                
+                        except Exception as e:
+                            print(f"{Fore.YELLOW}{EMOJI['WARNING']} Error processing file {filename}: {str(e)}{Style.RESET_ALL}")
+                
+                if not modified:
+                    print(f"{Fore.YELLOW}{EMOJI['WARNING']} No machine ID references found in data files{Style.RESET_ALL}")
+                    print(f"{Fore.YELLOW}{EMOJI['INFO']} You may need to reinstall Cursor for a complete reset{Style.RESET_ALL}")
+                
+                # Save credentials before returning
+                self.save_credentials()
+                
+                print(f"{Fore.GREEN}{EMOJI['SUCCESS']} Machine ID reset process completed{Style.RESET_ALL}")
+                return True
+            else:
+                print(f"{Fore.YELLOW}{EMOJI['WARNING']} Cursor data directory not found{Style.RESET_ALL}")
+                print(f"{Fore.YELLOW}{EMOJI['INFO']} You may need to manually reset the machine ID by reinstalling Cursor{Style.RESET_ALL}")
+                
+                # Still save credentials
+                self.save_credentials()
+                return True
+                
+        except Exception as e:
+            print(f"{Fore.RED}{EMOJI['ERROR']} Failed to reset machine ID: {str(e)}{Style.RESET_ALL}")
+            # Still save credentials even if machine ID reset fails
+            self.save_credentials()
+            return False
+            
+    def save_credentials(self):
+        """Save the generated credentials to a file"""
+        try:
+            if not self.email_address or not self.github_username or not self.github_password:
+                print(f"{Fore.RED}{EMOJI['ERROR']} No credentials to save{Style.RESET_ALL}")
+                return False
+                
+            output_file = "github_cursor_accounts.txt"
+            timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+            
+            credentials = {
+                "timestamp": timestamp,
+                "github_username": self.github_username,
+                "github_password": self.github_password,
+                "email": self.email_address
+            }
+            
+            credentials_json = json.dumps(credentials)
+            
+            # Check if file exists and create if not
+            file_exists = os.path.exists(output_file)
+            
+            with open(output_file, "a") as f:
+                if not file_exists:
+                    f.write("# GitHub + Cursor AI Accounts\n")
+                    f.write("# Format: JSON with timestamp, github_username, github_password, email\n\n")
+                
+                f.write(credentials_json + "\n")
+            
+            print(f"{Fore.GREEN}{EMOJI['SUCCESS']} Credentials saved to: {output_file}{Style.RESET_ALL}")
+            
+            # Print a summary
+            print(f"\n{Fore.GREEN}{EMOJI['SUCCESS']} Registration Summary:{Style.RESET_ALL}")
+            print(f"{Fore.CYAN}  • GitHub Username: {self.github_username}{Style.RESET_ALL}")
+            print(f"{Fore.CYAN}  • GitHub Password: {self.github_password}{Style.RESET_ALL}")
+            print(f"{Fore.CYAN}  • Email Address: {self.email_address}{Style.RESET_ALL}")
+            print(f"{Fore.CYAN}  • Saved to: {output_file}{Style.RESET_ALL}\n")
+            
+            return True
+            
+        except Exception as e:
+            print(f"{Fore.RED}{EMOJI['ERROR']} Failed to save credentials: {str(e)}{Style.RESET_ALL}")
+            print(f"\n{Fore.YELLOW}{EMOJI['WARNING']} Make sure to copy these credentials manually:{Style.RESET_ALL}")
+            print(f"{Fore.CYAN}  • GitHub Username: {self.github_username}{Style.RESET_ALL}")
+            print(f"{Fore.CYAN}  • GitHub Password: {self.github_password}{Style.RESET_ALL}")
+            print(f"{Fore.CYAN}  • Email Address: {self.email_address}{Style.RESET_ALL}\n")
+            return False
+    
+    def cleanup(self):
+        """Clean up resources"""
+        if self.browser:
+            try:
+                self.browser.quit()
+            except:
+                pass
+    
+    def start_registration(self):
+        """Start the GitHub Cursor registration process"""
+        try:
+            # Step 1: Get temporary email
+            if not self.get_temp_email():
+                return False
+            
+            # Step 2: Register GitHub account
+            if not self.register_github():
+                return False
+            
+            # Step 3: Check and verify email
+            if not self.check_email_verification():
+                return False
+            
+            # Step 4: Register Cursor with GitHub
+            if not self.register_cursor():
+                return False
+            
+            # Step 5: Reset machine ID
+            self.reset_machine_id()
+            
+            return True
+        finally:
+            self.cleanup()
+
+def display_features_and_warnings(translator=None):
+    """Display features and warnings before proceeding"""
+    if translator:
         print(f"\n🚀 {translator.get('github_register.title')}")
         print("=====================================")
         print(f"{translator.get('github_register.features_header')}:")
@@ -217,58 +626,76 @@ def main(translator=None):
         print(f"  - {translator.get('github_register.warning3')}")
         print(f"  - {translator.get('github_register.warning4')}")
         print("=====================================\n")
-        
-        while True:
+    else:
+        print("\n🚀 GitHub + Cursor AI Registration Automation")
+        print("=====================================")
+        print("Features:")
+        print("  - Creates a temporary email using YOPmail")
+        print("  - Registers a new GitHub account with random credentials")
+        print("  - Verifies the GitHub email automatically")
+        print("  - Logs into Cursor AI using GitHub authentication")
+        print("  - Resets the machine ID to bypass trial detection")
+        print("  - Saves all credentials to a file")
+        print("\n⚠️ Warnings:")
+        print("  - This script automates account creation, which may violate GitHub/Cursor terms of service")
+        print("  - Requires internet access and administrative privileges")
+        print("  - CAPTCHA or additional verification may interrupt automation")
+        print("  - Use responsibly and at your own risk")
+        print("=====================================\n")
+
+def get_user_confirmation(translator=None):
+    """Prompt the user for confirmation to proceed"""
+    while True:
+        if translator:
             response = input(f"{translator.get('github_register.confirm')} (yes/no): ").lower().strip()
-            if response in ['yes', 'y']:
-                break
-            elif response in ['no', 'n']:
-                print(f"❌ {translator.get('github_register.cancelled')}")
-                return
-            else:
-                print(f"{translator.get('github_register.invalid_choice')}")
-
-    try:
-        # Step 1: Generate temp email
-        email = generate_temp_email()
-
-        # Step 2: Register GitHub account
-        github_username, github_password = register_github(email)
-
-        # Step 3: Extract and verify email
-        inbox_id = extract_inbox(email)
-        if inbox_id:
-            verify_link = get_verification_link(email, inbox_id)
-            if verify_link:
-                options = Options()
-                options.add_argument('--headless')
-                driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
-                try:
-                    driver.get(verify_link)
-                    logging.info("GitHub email verified")
-                finally:
-                    driver.quit()
-            else:
-                logging.error("Verification link not found")
-                return
         else:
-            logging.error("Email verification failed")
-            return
+            response = input("Do you want to proceed with GitHub + Cursor AI registration? (yes/no): ").lower().strip()
+            
+        if response in ['yes', 'y']:
+            return True
+        elif response in ['no', 'n']:
+            if translator:
+                print(f"❌ {translator.get('github_register.cancelled')}")
+            else:
+                print("❌ Operation cancelled.")
+            return False
+        else:
+            if translator:
+                print(f"{translator.get('github_register.invalid_choice')}")
+            else:
+                print("Please enter 'yes' or 'no'.")
 
-        # Step 4: Register Cursor with GitHub
-        register_cursor_with_github(github_username, github_password)
+def main(translator=None):
+    """Main function to run the GitHub Cursor registration process"""
+    logging.info(f"{Fore.CYAN} {translator.get('github_register.starting_automation')}{Style.RESET_ALL}")
+    
+    # Display features and warnings
+    display_features_and_warnings(translator)
+    
+    # Get user confirmation
+    if not get_user_confirmation(translator):
+        return
+    
+    # Start registration process
+    registration = GitHubCursorRegistration(translator)
+    success = registration.start_registration()
+    
+    # Display final message
+    if success:
+        print(f"\n{Fore.GREEN}{EMOJI['DONE']} {translator.get('github_register.completed_successfully')}{Style.RESET_ALL}")
+        print(f"{Fore.CYAN}{EMOJI['INFO']} {translator.get('github_register.github_username')}: {registration.github_username}{Style.RESET_ALL}")
+        print(f"{Fore.CYAN}{EMOJI['INFO']} {translator.get('github_register.github_password')}: {registration.github_password}{Style.RESET_ALL}")
+        print(f"{Fore.CYAN}{EMOJI['INFO']} {translator.get('github_register.email')}: {registration.email_address}{Style.RESET_ALL}")
+        print(f"\n{Fore.CYAN}{EMOJI['INFO']} {translator.get('github_register.credentials_saved')}{Style.RESET_ALL}")
+    else:
+        print(f"\n{Fore.RED}{EMOJI['ERROR']} {translator.get('github_register.registration_encountered_issues')}{Style.RESET_ALL}")
+        print(f"{Fore.YELLOW}{EMOJI['INFO']} {translator.get('github_register.check_browser_windows_for_manual_intervention_or_try_again_later')}{Style.RESET_ALL}")
+    
+    # Wait for user acknowledgment
+    if translator:
+        input(f"\n{EMOJI['INFO']} {translator.get('register.press_enter')}...")
+    else:
+        input(f"\n{EMOJI['INFO']} Press Enter to continue...")
 
-        # Step 5: Reset Machine ID
-        reset_machine_id()
-
-        # Step 6: Save credentials
-        save_credentials(email, github_username, github_password)
-
-        logging.info("All steps completed successfully!")
-        print("✅ All steps completed!")
-    except Exception as e:
-        logging.error(f"Script failed: {e}")
-        print(f"❌ An error occurred: {e}")
-
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

locales/bg.json

@@ -0,0 +1,392 @@
+{
+    "menu": {
+        "title": "Възможни избори",
+        "exit": "Затвори програмата",
+        "reset": "Нулирай ид-то на компютъра",
+        "register": "Регистрирай нов Курсор акаунт",
+        "register_google": "Регистрирай се с Google акаунт",
+        "register_github": "Регистрирай се с GitHub акаунт",
+        "register_manual": "Регистрирай се със свой имейл по избор",
+        "quit": "Затвори приложението Курсор",
+        "select_language": "Избери език",
+        "es": "Spanish",
+        "input_choice": "Моля, въведете своя избор ({choices})",
+        "invalid_choice": "Невалиден избор. Моля, въведете избор от {choices}.",
+        "program_terminated": "Програмата беше затворена от вас",
+        "error_occurred": "Възникна грешка: {error}. Опитайте отново",
+        "press_enter": "Натиснете Enter, за да излезете",
+        "disable_auto_update": "Спрете автоматичните ъпдейти на Курсор",
+        "lifetime_access_enabled": "ДОЖИВОТЕН ДОСТЪП Е АКТИВИРАН",
+        "totally_reset": "Нулирайте изцяло Курсор",
+        "outdate": "Изтекъл срок",
+        "temp_github_register": "Временно регистриране с GitHub",
+        "coming_soon": "Очаквайте скоро"
+    },
+    "languages": {
+        "en": "English",
+        "zh_cn": "简体中文",
+        "zh_tw": "繁體中文",
+        "vi": "Vietnamese",
+        "nl": "Dutch",
+        "de": "German",
+        "fr": "French",
+        "pt": "Portuguese",
+        "ru": "Russian",
+        "tr": "Turkish",
+        "bg": "Bulgarian",
+        "es": "Spanish"
+    },
+    "quit_cursor": {
+        "start": "Започни излизането от Курсор",
+        "no_process": "Няма съществуващ процес, засягащ Курсор",
+        "terminating": "Прекратяване на процес {pid}",
+        "waiting": "Изчакване на процеса да приключи",
+        "success": "Всички процеси, свързани с Курсор, бяха прекратени",
+        "timeout": "Таймаут на процеса: {pids}",
+        "error": "Възникна грешка: {error}"
+    },
+    "reset": {
+        "title": "",
+        "checking": "Проверка на конфигурационния файл",
+        "not_found": "Конфигурационният файл не беше намерен",
+        "no_permission": "Конфигурационният файл не може да бъде прочетен или записан. Моля, проверете разрешенията на файла",
+        "reading": "Четене на текущата конфигурация",
+        "creating_backup": "Създаване на резервно копие на конфигурацията",
+        "backup_exists": "Резервното копие вече съществува. Стъпката за резервно копие се пропуска",
+        "generating": "Генериране на ново машинно ID",
+        "saving_json": "Запазване на новата конфигурация в JSON",
+        "success": "Машинното ID беше успешно нулирано",
+        "new_id": "Ново машинно ID",
+        "permission_error": "Грешка в разрешенията: {error}",
+        "run_as_admin": "Моля, опитайте да стартирате тази програма като администратор",
+        "process_error": "Грешка при нулиране: {error}",
+        "updating_sqlite": "Актуализиране на SQLite базата данни",
+        "updating_pair": "Актуализиране на двойката ключ-стойност",
+        "sqlite_success": "SQLite базата данни беше успешно актуализирана",
+        "sqlite_error": "Грешка при актуализиране на SQLite базата данни: {error}",
+        "press_enter": "Натиснете Enter, за да излезете",
+        "unsupported_os": "Неподдържана операционна система: {os}",
+        "linux_path_not_found": "Linux пътят не беше намерен",
+        "updating_system_ids": "Актуализиране на системните ID",
+        "system_ids_updated": "Системните ID бяха успешно актуализирани",
+        "system_ids_update_failed": "Грешка при актуализиране на системните ID: {error}",
+        "windows_guid_updated": "Windows GUID беше успешно актуализиран",
+        "windows_permission_denied": "Достъпът до Windows беше отказан",
+        "windows_guid_update_failed": "Грешка при актуализиране на Windows GUID",
+        "macos_uuid_updated": "macOS UUID беше успешно актуализиран",
+        "plutil_command_failed": "Командата plutil не беше успешна",
+        "start_patching": "Започване на прилагане на корекция за getMachineId",
+        "macos_uuid_update_failed": "Грешка при актуализиране на macOS UUID",
+        "current_version": "Текуща версия на Курсор: {version}",
+        "patch_completed": "Корекцията на getMachineId беше успешно завършена",
+        "patch_failed": "Грешка при прилагане на корекция за getMachineId: {error}",
+        "version_check_passed": "Проверката на версията на Курсор беше успешна",
+        "file_modified": "Файлът беше променен",
+        "version_less_than_0_45": "Версията на Курсор е < 0.45.0, корекцията на getMachineId се пропуска",
+        "detecting_version": "Откриване на версията на Курсор",
+        "patching_getmachineid": "Прилагане на корекция за getMachineId",
+        "version_greater_than_0_45": "Версията на Курсор е >= 0.45.0, прилага се корекция за getMachineId",
+        "permission_denied": "Достъпът беше отказан: {error}",
+        "backup_created": "Резервното копие беше създадено",
+        "update_success": "Актуализацията беше успешна",
+        "update_failed": "Грешка при актуализация: {error}",
+        "windows_machine_guid_updated": "Windows машинното GUID беше успешно актуализирано",
+        "reading_package_json": "Четене на package.json {path}",
+        "invalid_json_object": "Невалиден JSON обект",
+        "no_version_field": "Няма поле за версия в package.json",
+        "version_field_empty": "Полето за версия е празно",
+        "invalid_version_format": "Невалиден формат на версията: {version}",
+        "found_version": "Намерена версия: {version}",
+        "version_parse_error": "Грешка при анализ на версията: {error}",
+        "package_not_found": "Package.json не беше намерен: {path}",
+        "check_version_failed": "Грешка при проверка на версията: {error}",
+        "stack_trace": "Проследяване на стека",
+        "version_too_low": "Версията на Курсор е твърде ниска: {version} < 0.45.0"
+    },
+    "register": {
+        "title": "Инструмент за регистрация в Курсор",
+        "start": "Започване на процеса на регистрация...",
+        "handling_turnstile": "Обработка на проверка за сигурност...",
+        "retry_verification": "Опит за повторна проверка...",
+        "detect_turnstile": "Проверка на защитната врата...",
+        "verification_success": "Проверката за сигурност беше успешна",
+        "starting_browser": "Стартиране на браузъра...",
+        "form_success": "Формата беше успешно изпратена",
+        "browser_started": "Браузърът беше успешно стартиран",
+        "waiting_for_second_verification": "Изчакване на втората проверка по имейл...",
+        "waiting_for_verification_code": "Изчакване на код за потвърждение...",
+        "password_success": "Паролата беше успешно зададена",
+        "password_error": "Грешка при задаване на парола: {error}. Моля, опитайте отново",
+        "waiting_for_page_load": "Зареждане на страницата...",
+        "first_verification_passed": "Първата проверка беше успешна",
+        "mailbox": "Успешен достъп до пощенската кутия",
+        "register_start": "Начало на регистрацията",
+        "form_submitted": "Формата беше изпратена, започване на проверка...",
+        "filling_form": "Попълване на формуляра",
+        "visiting_url": "Посещение на URL",
+        "basic_info": "Основните данни бяха изпратени",
+        "handle_turnstile": "Обработка на защитната врата",
+        "no_turnstile": "Няма защитна врата",
+        "turnstile_passed": "Защитната врата беше премината",
+        "verification_start": "Започване на получаване на код за потвърждение",
+        "verification_timeout": "Времето за получаване на код за потвърждение изтече",
+        "verification_not_found": "Кодът за потвърждение не беше намерен",
+        "try_get_code": "Опит | {attempt} Получаване на код за потвърждение | Оставащо време: {time}s",
+        "get_account": "Получаване на информация за акаунта",
+        "get_token": "Получаване на токен за сесия на Курсор",
+        "token_success": "Токенът беше успешно получен",
+        "token_attempt": "Опит | {attempt} опита за получаване на токен | Ще бъде опит отново след {time}s",
+        "token_max_attempts": "Достигнат максимален брой опити ({max}) | Неуспешно получаване на токен",
+        "token_failed": "Грешка при получаване на токен: {error}",
+        "account_error": "Грешка при получаване на информация за акаунта: {error}",
+        "press_enter": "Натиснете Enter, за да излезете",
+        "browser_start": "Стартиране на браузъра",
+        "open_mailbox": "Отваряне на страницата на пощенската кутия",
+        "email_error": "Грешка при получаване на имейл адрес",
+        "setup_error": "Грешка при настройка на имейл: {error}",
+        "start_getting_verification_code": "Започване на получаване на код за потвърждение, ще бъде опит след 60 секунди",
+        "get_verification_code_timeout": "Времето за получаване на код за потвърждение изтече",
+        "get_verification_code_success": "Кодът за потвърждение беше успешно получен",
+        "try_get_verification_code": "Опит | {attempt} Получаване на код за потвърждение | Оставащо време: {remaining_time}s",
+        "verification_code_filled": "Кодът за потвърждение беше попълнен",
+        "login_success_and_jump_to_settings_page": "Успешен вход и преход към страницата с настройки",
+        "detect_login_page": "Открита е страница за вход, започване на влизане...",
+        "cursor_registration_completed": "Регистрацията в Курсор беше завършена!",
+        "set_password": "Задаване на парола",
+        "basic_info_submitted": "Основните данни бяха изпратени",
+        "cursor_auth_info_updated": "Информацията за удостоверяване на Курсор беше актуализирана",
+        "cursor_auth_info_update_failed": "Грешка при актуализиране на информацията за удостоверяване на Курсор",
+        "reset_machine_id": "Нулиране на машинното ID",
+        "account_info_saved": "Информацията за акаунта беше запазена",
+        "save_account_info_failed": "Грешка при запазване на информацията за акаунта",
+        "get_email_address": "Получаване на имейл адрес",
+        "update_cursor_auth_info": "Актуализиране на информацията за удостоверяване на Курсор",
+        "register_process_error": "Грешка в процеса на регистрация: {error}",
+        "setting_password": "Задаване на парола",
+        "manual_code_input": "Ръчно въвеждане на код",
+        "manual_email_input": "Ръчно въвеждане на имейл",
+        "password": "Парола",
+        "first_name": "Име",
+        "last_name": "Фамилия",
+        "exit_signal": "Сигнал за изход",
+        "email_address": "Имейл адрес",
+        "config_created": "Конфигурацията беше създадена",
+        "verification_failed": "Проверката беше неуспешна",
+        "verification_error": "Грешка при проверка: {error}",
+        "config_option_added": "Добавена е опция за конфигурация: {option}",
+        "config_updated": "Конфигурацията беше актуализирана",
+        "password_submitted": "Паролата беше изпратена",
+        "total_usage": "Общо използване: {usage}",
+        "setting_on_password": "Задаване на парола",
+        "getting_code": "Получаване на код за потвърждение, ще бъде опит след 60 секунди",
+        "human_verify_error": "Не може да се потвърди, че потребителят е човек. Опитва се отново...",
+        "max_retries_reached": "Достигнат максимален брой опити. Регистрацията беше неуспешна."
+    },
+    "auth": {
+        "title": "Управление на удостоверяването на Курсор",
+        "checking_auth": "Проверка на файла за удостоверяване",
+        "auth_not_found": "Файлът за удостоверяване не беше намерен",
+        "auth_file_error": "Грешка във файла за удостоверяване: {error}",
+        "reading_auth": "Четене на файла за удостоверяване",
+        "updating_auth": "Актуализиране на информацията за удостоверяване",
+        "auth_updated": "Информацията за удостоверяване беше успешно актуализирана",
+        "auth_update_failed": "Грешка при актуализиране на информацията за удостоверяване: {error}",
+        "auth_file_created": "Файлът за удостоверяване беше създаден",
+        "auth_file_create_failed": "Грешка при създаване на файла за удостоверяване: {error}",
+        "press_enter": "Натиснете Enter, за да излезете",
+        "reset_machine_id": "Нулиране на машинното ID",
+        "database_connection_closed": "Връзката с базата беше затворена",
+        "database_updated_successfully": "Базата данни беше успешно актуализирана",
+        "connected_to_database": "Успешно свързване с базата данни",
+        "updating_pair": "Актуализиране на двойката ключ-стойност",
+        "db_not_found": "Файлът на базата данни не беше намерен: {path}",
+        "db_permission_error": "Няма достъп до файла на базата данни. Моля, проверете разрешенията",
+        "db_connection_error": "Грешка при свързване с базата данни: {error}"
+    },
+    "control": {
+        "generate_email": "Създаване на нов имейл",
+        "blocked_domain": "Блокиран домейн",
+        "select_domain": "Избиране на случаен домейн",
+        "copy_email": "Копиране на имейл адрес",
+        "enter_mailbox": "Влизане в пощенската кутия",
+        "refresh_mailbox": "Опресняване на пощенската кутия",
+        "check_verification": "Проверка на кода за потвърждение",
+        "verification_found": "Кодът за потвърждение беше намерен",
+        "verification_not_found": "Кодът за потвърждение не беше намерен",
+        "browser_error": "Грешка при контрол на браузъра: {error}",
+        "navigation_error": "Грешка при навигация: {error}",
+        "email_copy_error": "Грешка при копиране на имейл: {error}",
+        "mailbox_error": "Грешка в пощенската кутия: {error}",
+        "token_saved_to_file": "Токенът беше запазен във файла cursor_tokens.txt",
+        "navigate_to": "Навигиране към {url}",
+        "generate_email_success": "Имейлът беше успешно създаден",
+        "select_email_domain": "Избор на домейн за имейл",
+        "select_email_domain_success": "Успешен избор на домейн за имейл",
+        "get_email_name": "Получаване на име на имейл",
+        "get_email_name_success": "Успешно получаване на име на имейл",
+        "get_email_address": "Получаване на имейл адрес",
+        "get_email_address_success": "Успешно получаване на имейл адрес",
+        "enter_mailbox_success": "Успешно влизане в пощенската кутия",
+        "found_verification_code": "Кодът за потвърждение беше намерен",
+        "get_cursor_session_token": "Получаване на токен за сесия на Курсор",
+        "get_cursor_session_token_success": "Успешно получаване на токен за сесия на Курсор",
+        "get_cursor_session_token_failed": "Грешка при получаване на токен за сесия на Курсор",
+        "save_token_failed": "Грешка при запазване на токен",
+        "database_updated_successfully": "Базата данни беше успешно актуализирана",
+        "database_connection_closed": "Връзката с базата данни беше затворена",
+        "no_valid_verification_code": "Няма валиден код за потвърждение"
+    },
+    "email": {
+        "starting_browser": "Стартиране на браузъра",
+        "visiting_site": "Посещение на сайтове за имейл домейни",
+        "create_success": "Имейлът беше успешно създаден",
+        "create_failed": "Грешка при създаване на имейл",
+        "create_error": "Грешка при създаване на имейл: {error}",
+        "refreshing": "Опресняване на имейл",
+        "refresh_success": "Имейлът беше успешно опреснен",
+        "refresh_error": "Грешка при опресняване на имейл: {error}",
+        "refresh_button_not_found": "Бутонът за опресняване не беше намерен",
+        "verification_found": "Потвърждението беше намерено",
+        "verification_not_found": "Потвърждението не беше намерено",
+        "verification_error": "Грешка при потвърждение: {error}",
+        "verification_code_found": "Кодът за потвърждение беше намерен",
+        "verification_code_not_found": "Кодът за потвърждение не беше намерен",
+        "verification_code_error": "Грешка при код за потвърждение: {error}",
+        "address": "Имейл адрес",
+        "all_domains_blocked": "Всички домейни са блокирани, смяна на услуга",
+        "no_available_domains_after_filtering": "Няма налични домейни след филтриране",
+        "switching_service": "Смяна на услугата {service}",
+        "domains_list_error": "Грешка при получаване на списък с домейни: {error}",
+        "failed_to_get_available_domains": "Неуспешно получаване на налични домейни",
+        "domains_excluded": "Изключени домейни: {domains}",
+        "failed_to_create_account": "Неуспешно създаване на акаунт",
+        "account_creation_error": "Грешка при създаване на акаунт: {error}",
+        "blocked_domains": "Блокирани домейни: {domains}",
+        "blocked_domains_loaded": "Блокирани домейни са заредени: {count}",
+        "blocked_domains_loaded_error": "Грешка при зареждане на блокирани домейни: {error}",
+        "blocked_domains_loaded_success": "Блокираните домейни бяха успешно заредени",
+        "blocked_domains_loaded_timeout": "Време за зареждане на блокирани домейни: {timeout}s",
+        "blocked_domains_loaded_timeout_error": "Грешка при време за зареждане на блокирани домейни: {error}",
+        "available_domains_loaded": "Налични домейни са заредени: {count}",
+        "domains_filtered": "Филтрирани домейни: {count}",
+        "trying_to_create_email": "Опит за създаване на имейл: {email}",
+        "domain_blocked": "Домейнът е блокиран: {domain}"
+    },
+    "update": {
+        "title": "Деактивиране на автоматичните актуализации на Курсор",
+        "disable_success": "Автоматичните актуализации бяха успешно деактивирани",
+        "disable_failed": "Грешка при деактивиране на автоматичните актуализации: {error}",
+        "press_enter": "Натиснете Enter, за да излезете",
+        "start_disable": "Започване на деактивиране на автоматичните актуализации",
+        "killing_processes": "Прекратяване на процеси",
+        "processes_killed": "Процесите бяха прекратени",
+        "removing_directory": "Премахване на директория",
+        "directory_removed": "Директорията беше премахната",
+        "creating_block_file": "Създаване на блокиращ файл",
+        "block_file_created": "Блокиращият файл беше създаден"
+    },
+    "updater": {
+        "checking": "Проверка за актуализации...",
+        "new_version_available": "Налична е нова версия! (Текуща: {current}, Последна: {latest})",
+        "updating": "Актуализиране до последната версия. Програмата ще се рестартира автоматично.",
+        "up_to_date": "Използвате последната версия.",
+        "check_failed": "Грешка при проверка за актуализации: {error}",
+        "continue_anyway": "Продължаване с текущата версия...",
+        "update_confirm": "Искате ли да актуализирате до последната версия? (Y/n)",
+        "update_skipped": "Актуализацията беше пропусната.",
+        "invalid_choice": "Невалиден избор. Моля, въведете 'Y' или 'n'.",
+        "development_version": "Версия за разработка {current} > {latest}",
+        "changelog_title": "Списък с промени"
+    },
+    "totally_reset": {
+        "title": "Пълно нулиране на Курсор",
+        "checking_config": "Проверка на конфигурационния файл",
+        "config_not_found": "Конфигурационният файл не беше намерен",
+        "no_permission": "Конфигурационният файл не може да бъде прочетен или записан. Моля, проверете разрешенията на файла",
+        "reading_config": "Четене на текущата конфигурация",
+        "creating_backup": "Създаване на резервно копие на конфигурацията",
+        "backup_exists": "Резервното копие вече съществува. Стъпката за резервно копие се пропуска",
+        "generating_new_machine_id": "Генериране на ново машинно ID",
+        "saving_new_config": "Запазване на новата конфигурация в JSON",
+        "success": "Курсор беше успешно нулиран",
+        "error": "Грешка при нулиране на Курсор: {error}",
+        "press_enter": "Натиснете Enter, за да излезете",
+        "reset_machine_id": "Нулиране на машинното ID",
+        "database_connection_closed": "Връзката с базата данни беше затворена",
+        "database_updated_successfully": "Базата данни беше успешно актуализирана",
+        "connected_to_database": "Успешно свързване с базата данни",
+        "updating_pair": "Актуализиране на двойката ключ-стойност",
+        "db_not_found": "Файлът на базата данни не беше намерен: {path}",
+        "db_permission_error": "Няма достъп до файла на базата данни. Моля, проверете разрешенията",
+        "db_connection_error": "Грешка при свързване с базата данни: {error}",
+        "feature_title": "ФУНКЦИИ",
+        "feature_1": "Пълно премахване на настройките и конфигурациите на Курсор AI",
+        "feature_2": "Изчистване на всички кеширани данни, включително историята и командите на AI",
+        "feature_3": "Нулиране на машинното ID за заобикаляне на ограниченията за пробен период",
+        "feature_4": "Генериране на нови случайни машинни идентификатори",
+        "feature_5": "Премахване на персонализирани разширения и предпочитания",
+        "feature_6": "Нулиране на информацията за пробния период и активиране",
+        "feature_7": "Дълбоко сканиране за скрити файлове, свързани с лицензи и пробен период",
+        "feature_8": "Безопасно запазване на файлове и приложения, които не са свързани с Курсор",
+        "feature_9": "Съвместимост с Windows, macOS и Linux",
+        "disclaimer_title": "ПРАВНО ИЗВЕСТВИЕ",
+        "disclaimer_1": "Този инструмент ще изтрие за постоянно всички настройки на Курсор AI,",
+        "disclaimer_2": "конфигурации и кеширани данни. Това действие е необратимо.",
+        "disclaimer_3": "Вашите кодови файлове НЯМА да бъдат засегнати и този инструмент",
+        "disclaimer_4": "е проектиран специално да се фокусира върху файловете на редактора на Курсор AI и механизмите за откриване на пробен период.",
+        "disclaimer_5": "Другите приложения на вашата система няма да бъдат засегнати.",
+        "disclaimer_6": "След като използвате този инструмент, ще трябва да преинсталирате Курсор AI.",
+        "disclaimer_7": "Вие носите отговорността за използването му",
+        "confirm_title": "Сигурни ли сте, че искате да продължите?",
+        "confirm_1": "Това действие ще изтрие всички настройки на Курсор AI,",
+        "confirm_2": "конфигурации и кеширани данни. Това действие е необратимо.",
+        "confirm_3": "Вашите кодови файлове НЯМА да бъдат засегнати и този инструмент",
+        "confirm_4": "е проектиран специално да се фокусира върху файловете на редактора на Курсор AI и механизмите за откриване на пробен период.",
+        "confirm_5": "Другите приложения на вашата система няма да бъдат засегнати.",
+        "confirm_6": "След като използвате този инструмент, ще трябва да преинсталирате Курсор AI.",
+        "confirm_7": "Вие носите отговорността за използването му",
+        "invalid_choice": "Моля, въведете 'Y' или 'n'",
+        "skipped_for_safety": "Пропуснато за безопасност (не е свързано с Курсор): {path}",
+        "deleted": "Изтрито: {path}",
+        "error_deleting": "Грешка при изтриване на {path}: {error}",
+        "not_found": "Файлът не беше намерен: {path}",
+        "resetting_machine_id": "Нулиране на машинните идентификатори за заобикаляне на ограниченията за пробен период...",
+        "created_machine_id": "Създадено е ново машинно ID: {path}",
+        "error_creating_machine_id": "Грешка при създаване на файл за машинно ID {path}: {error}",
+        "error_searching": "Грешка при търсене на файлове в {path}: {error}",
+        "created_extended_trial_info": "Създадена е нова информация за удължен пробен период: {path}",
+        "error_creating_trial_info": "Грешка при създаване на файл за информация за пробен период {path}: {error}",
+        "resetting_cursor_ai_editor": "Нулиране на редактора на Курсор AI... Моля, изчакайте.",
+        "reset_cancelled": "Нулирането беше отменено. Излизане без промени.",
+        "windows_machine_id_modification_skipped": "Промяната на машинното ID на Windows беше пропусната: {error}",
+        "linux_machine_id_modification_skipped": "Промяната на machine-id на Linux беше пропусната: {error}",
+        "note_complete_machine_id_reset_may_require_running_as_administrator": "Забележка: Пълното нулиране на машинното ID може да изисква работа като администратор",
+        "note_complete_system_machine_id_reset_may_require_sudo_privileges": "Забележка: Пълното нулиране на системното machine-id може да изисква sudo права",
+        "windows_registry_instructions": "📝 ЗАБЕЛЕЖКА: За пълно нулиране на Windows може да се наложи да изчистите и записите в регистъра.",
+        "windows_registry_instructions_2": "   Стартирайте 'regedit' и потърсете и изтрийте ключове, съдържащи 'Cursor' или 'CursorAI' в HKEY_CURRENT_USER\\Software\\.\n",
+        "reset_log_1": "Курсор AI беше напълно нулиран и ограниченията за пробен период бяха заобиколени!",
+        "reset_log_2": "Моля, рестартирайте системата си, за да влязат в сила промените.",
+        "reset_log_3": "Ще трябва да преинсталирате Курсор AI и сега трябва да имате нов пробен период.",
+        "reset_log_4": "За най-добри резултати, помислете за следното:",
+        "reset_log_5": "Използвайте различен имейл адрес при регистрация за нов пробен период",
+        "reset_log_6": "Ако е възможно, използвайте VPN за промяна на IP адреса си",
+        "reset_log_7": "Изчистете бисквитките и кеша на браузъра си, преди да посетите уебсайта на Курсор AI",
+        "reset_log_8": "Ако проблемите продължават, опитайте да инсталирате Курсор AI на друго място",
+        "reset_log_9": "Ако срещнете проблеми, посетете Github Issue Tracker и създайте проблем на https://github.com/yeongpin/cursor-free-vip/issues",
+        "unexpected_error": "Възникна неочаквана грешка: {error}",
+        "report_issue": "Моля, докладвайте този проблем в Github Issue Tracker на https://github.com/yeongpin/cursor-free-vip/issues",
+        "keyboard_interrupt": "Процесът беше прекратен от потребителя. Излизане...",
+        "return_to_main_menu": "Връщане към главното меню...",
+        "process_interrupted": "Процесът беше прекратен. Излизане...",
+        "press_enter_to_return_to_main_menu": "Натиснете Enter, за да се върнете към главното меню...",
+        "removing_known": "Премахване на известни файлове за пробен период/лиценз",
+        "performing_deep_scan": "Извършване на дълбоко сканиране за допълнителни файлове за пробен период/лиценз",
+        "found_additional_potential_license_trial_files": "Намерени са {count} допълнителни потенциални файлове за лиценз/пробен период",
+        "checking_for_electron_localstorage_files": "Проверка на Electron localStorage файлове",
+        "no_additional_license_trial_files_found_in_deep_scan": "Няма намерени допълнителни файлове за лиценз/пробен период при дълбоко сканиране",
+        "removing_electron_localstorage_files": "Премахване на Electron localStorage файлове",
+        "electron_localstorage_files_removed": "Electron localStorage файлове бяха премахнати",
+        "electron_localstorage_files_removal_error": "Грешка при премахване на Electron localStorage файлове: {error}",
+        "removing_electron_localstorage_files_completed": "Премахването на Electron localStorage файлове беше завършено"
+    }
+}

locales/de.json

@@ -32,7 +32,8 @@
         "de": "Deutsch",
         "fr": "Französisch",
         "pt": "Portugiesisch",
-        "ru": "Russisch"
+        "ru": "Russisch",
+        "es": "Spanisch"
     },
     "quit_cursor": {
         "start": "Beginne Cursor zu Beenden",

locales/en.json

@@ -21,7 +21,8 @@
         "temp_github_register": "Temporary GitHub Register",
         "admin_required": "Running as executable, administrator privileges required.",
         "admin_required_continue": "Continuing without administrator privileges.",
-        "coming_soon": "Coming Soon"
+        "coming_soon": "Coming Soon",
+        "fixed_soon": "Fixed Soon"
     },
     "languages": {
         "en": "English",
@@ -32,7 +33,10 @@
         "de": "German",
         "fr": "French",
         "pt": "Portuguese",
-        "ru": "Russian"
+        "ru": "Russian",
+        "tr": "Turkish",
+        "bg": "Bulgarian",
+        "es": "Spanish"
     },
     "quit_cursor": {
         "start": "Start Quitting Cursor",
@@ -99,8 +103,9 @@
         "package_not_found": "Package.json Not Found: {path}",
         "check_version_failed": "Check Version Failed: {error}",
         "stack_trace": "Stack Trace",
-        "version_too_low": "Cursor Version Too Low: {version} < 0.45.0"
-        
+        "version_too_low": "Cursor Version Too Low: {version} < 0.45.0",
+        "no_write_permission": "No Write Permission: {path}",
+        "path_not_found": "Path Not Found: {path}"
     },
     "register": {
         "title": "Cursor Registration Tool",
@@ -386,7 +391,28 @@
         "removing_electron_localstorage_files": "Removing Electron localStorage files",
         "electron_localstorage_files_removed": "Electron localStorage files removed",
         "electron_localstorage_files_removal_error": "Error removing Electron localStorage files: {error}",
-        "removing_electron_localstorage_files_completed": "Electron localStorage files removal completed"
+        "removing_electron_localstorage_files_completed": "Electron localStorage files removal completed",
+        "warning_title": "WARNING",
+        "warning_1": "This action will delete all Cursor AI settings,",
+        "warning_2": "configurations, and cached data. This action cannot be undone.",
+        "warning_3": "Your code files will NOT be affected, and the tool is designed",
+        "warning_4": "to only target Cursor AI editor files and trial detection mechanisms.",
+        "warning_5": "Other applications on your system will not be affected.",
+        "warning_6": "You will need to set up Cursor AI again after running this tool.",
+        "warning_7": "Use at your own risk",
+        "removed": "Removed: {path}",
+        "failed_to_reset_machine_guid": "Failed to reset machine GUID",
+        "failed_to_remove": "Failed to remove: {path}",
+        "failed_to_delete_file": "Failed to delete file: {path}",
+        "failed_to_delete_directory": "Failed to delete directory: {path}",
+        "failed_to_delete_file_or_directory": "Failed to delete file or directory: {path}",
+        "deep_scanning": "Performing deep scan for additional trial/license files",
+        "resetting_cursor": "Resetting Cursor AI Editor... Please wait.",
+        "completed_in": "Completed in {time} seconds",
+        "cursor_reset_completed": "Cursor AI Editor has been fully reset and trial detection bypassed!",
+        "cursor_reset_failed": "Cursor AI Editor reset failed: {error}",
+        "cursor_reset_cancelled": "Cursor AI Editor reset cancelled. Exiting without making any changes.",
+        "operation_cancelled": "Operation cancelled. Exiting without making any changes."
     },
     "github_register": {
         "title": "GitHub + Cursor AI Registration Automation",
@@ -405,6 +431,14 @@
         "confirm": "Are you sure you want to proceed?",
         "invalid_choice": "Invalid choice. Please enter 'yes' or 'no'",
         "cancelled": "Operation cancelled",
-        "program_terminated": "Program terminated by user"
+        "program_terminated": "Program terminated by user",
+        "starting_automation": "Starting automation...",
+        "github_username": "GitHub Username",
+        "github_password": "GitHub Password",
+        "email_address": "Email Address",
+        "credentials_saved": "These credentials have been saved to github_cursor_accounts.txt",
+        "completed_successfully": "GitHub + Cursor registration completed successfully!",
+        "registration_encountered_issues": "GitHub + Cursor registration encountered issues.",
+        "check_browser_windows_for_manual_intervention_or_try_again_later": "Check browser windows for manual intervention or try again later."
     }   
 }   

locales/es.json

@@ -0,0 +1,443 @@
+{
+    "menu": {
+        "title": "Opciones Disponibles",
+        "exit": "Salir del Programa",
+        "reset": "Restablecer ID de Máquina",
+        "register": "Registrar Nueva Cuenta de Cursor",
+        "register_google": "Registrarse con Cuenta de Google",
+        "register_github": "Registrarse con Cuenta de GitHub",
+        "register_manual": "Registrar Cursor con Correo Personalizado",
+        "quit": "Cerrar Aplicación Cursor",
+        "select_language": "Cambiar Idioma",
+        "input_choice": "Por favor, ingrese su elección ({choices})",
+        "invalid_choice": "Selección inválida. Por favor ingrese un número de {choices}",
+        "program_terminated": "El programa fue terminado por el usuario",
+        "error_occurred": "Ocurrió un error: {error}. Por favor intente de nuevo",
+        "press_enter": "Presione Enter para Salir",
+        "disable_auto_update": "Deshabilitar Actualización Automática de Cursor",
+        "lifetime_access_enabled": "ACCESO DE POR VIDA ACTIVADO",
+        "totally_reset": "Restablecer Cursor Completamente",
+        "outdate": "Desactualizado",
+        "temp_github_register": "Registro Temporal de GitHub",
+        "admin_required": "Ejecutando como ejecutable, se requieren privilegios de administrador.",
+        "admin_required_continue": "Continuando sin privilegios de administrador.",
+        "coming_soon": "Próximamente",
+        "fixed_soon": "Arreglado Pronto"
+    },
+    "languages": {
+        "en": "Inglés",
+        "zh_cn": "简体中文",
+        "zh_tw": "繁體中文",
+        "vi": "Vietnamita",
+        "nl": "Holandés",
+        "de": "Alemán",
+        "fr": "Francés",
+        "pt": "Portugués",
+        "ru": "Ruso",
+        "tr": "Turco",
+        "bg": "Búlgaro",
+        "es": "Español"
+    },
+    "quit_cursor": {
+        "start": "Comenzando a Cerrar Cursor",
+        "no_process": "No Hay Procesos de Cursor en Ejecución",
+        "terminating": "Terminando Proceso {pid}",
+        "waiting": "Esperando que el Proceso Termine",
+        "success": "Todos los Procesos de Cursor Cerrados",
+        "timeout": "Tiempo de Espera Agotado: {pids}",
+        "error": "Ocurrió un Error: {error}"
+    },
+    "reset": {
+        "title": "Herramienta de Restablecimiento de ID de Máquina de Cursor",
+        "checking": "Verificando Archivo de Configuración",
+        "not_found": "Archivo de Configuración No Encontrado",
+        "no_permission": "No se Puede Leer o Escribir el Archivo de Configuración, Verifique los Permisos",
+        "reading": "Leyendo Configuración Actual",
+        "creating_backup": "Creando Copia de Seguridad de la Configuración",
+        "backup_exists": "El Archivo de Respaldo ya Existe, Omitiendo Paso de Respaldo",
+        "generating": "Generando Nuevo ID de Máquina",
+        "saving_json": "Guardando Nueva Configuración en JSON",
+        "success": "ID de Máquina Restablecido Exitosamente",
+        "new_id": "Nuevo ID de Máquina",
+        "permission_error": "Error de Permisos: {error}",
+        "run_as_admin": "Por Favor Intente Ejecutar Este Programa como Administrador",
+        "process_error": "Error en el Proceso de Restablecimiento: {error}",
+        "updating_sqlite": "Actualizando Base de Datos SQLite",
+        "updating_pair": "Actualizando Par Clave-Valor",
+        "sqlite_success": "Base de Datos SQLite Actualizada Exitosamente",
+        "sqlite_error": "Falló la Actualización de la Base de Datos SQLite: {error}",
+        "press_enter": "Presione Enter para Salir",
+        "unsupported_os": "Sistema Operativo No Soportado: {os}",
+        "linux_path_not_found": "Ruta de Linux No Encontrada",
+        "updating_system_ids": "Actualizando IDs del Sistema",
+        "system_ids_updated": "IDs del Sistema Actualizados Exitosamente",
+        "system_ids_update_failed": "Falló la Actualización de IDs del Sistema: {error}",
+        "windows_guid_updated": "GUID de Windows Actualizado Exitosamente",
+        "windows_permission_denied": "Permisos de Windows Denegados",
+        "windows_guid_update_failed": "Falló la Actualización del GUID de Windows",
+        "macos_uuid_updated": "UUID de macOS Actualizado Exitosamente",
+        "plutil_command_failed": "Falló el Comando plutil",
+        "start_patching": "Iniciando Parcheo de getMachineId",
+        "macos_uuid_update_failed": "Falló la Actualización del UUID de macOS",
+        "current_version": "Versión Actual de Cursor: {version}",
+        "patch_completed": "Parcheo de getMachineId Completado",
+        "patch_failed": "Falló el Parcheo de getMachineId: {error}",
+        "version_check_passed": "Verificación de Versión de Cursor Exitosa",
+        "file_modified": "Archivo Modificado",
+        "version_less_than_0_45": "Versión de Cursor < 0.45.0, Omitiendo Parcheo de getMachineId",
+        "detecting_version": "Detectando Versión de Cursor",
+        "patching_getmachineid": "Parcheando getMachineId",
+        "version_greater_than_0_45": "Versión de Cursor >= 0.45.0, Parcheando getMachineId",
+        "permission_denied": "Permiso Denegado: {error}",
+        "backup_created": "Copia de Seguridad Creada",
+        "update_success": "Actualización Exitosa",
+        "update_failed": "Falló la Actualización: {error}",
+        "windows_machine_guid_updated": "GUID de Máquina Windows Actualizado Exitosamente",
+        "reading_package_json": "Leyendo package.json {path}",
+        "invalid_json_object": "Objeto JSON Inválido",
+        "no_version_field": "No se Encontró el Campo de Versión en package.json",
+        "version_field_empty": "El Campo de Versión está Vacío",
+        "invalid_version_format": "Formato de Versión Inválido: {version}",
+        "found_version": "Versión Encontrada: {version}",
+        "version_parse_error": "Error al Analizar Versión: {error}",
+        "package_not_found": "Package.json No Encontrado: {path}",
+        "check_version_failed": "Falló la Verificación de Versión: {error}",
+        "stack_trace": "Traza de la Pila",
+        "version_too_low": "Versión de Cursor Muy Baja: {version} < 0.45.0"
+        
+    },
+    "register": {
+        "title": "Herramienta de Registro de Cursor",
+        "start": "Iniciando proceso de registro...",
+        "handling_turnstile": "Procesando verificación de seguridad...",
+        "retry_verification": "Reintentando verificación...",
+        "detect_turnstile": "Comprobando verificación de seguridad...",
+        "verification_success": "Verificación de seguridad exitosa",
+        "starting_browser": "Abriendo navegador...",
+        "form_success": "Formulario enviado exitosamente",
+        "browser_started": "Navegador abierto exitosamente",
+        "waiting_for_second_verification": "Esperando verificación por correo electrónico...",
+        "waiting_for_verification_code": "Esperando código de verificación...",
+        "password_success": "Contraseña establecida exitosamente",
+        "password_error": "No se pudo establecer la contraseña: {error}. Por favor intente de nuevo",
+        "waiting_for_page_load": "Cargando página...",
+        "first_verification_passed": "Verificación inicial exitosa",
+        "mailbox": "Acceso exitoso a la bandeja de entrada",
+        "register_start": "Iniciar Registro",
+        "form_submitted": "Formulario Enviado, Iniciando Verificación...",
+        "filling_form": "Rellenando Formulario",
+        "visiting_url": "Visitando URL",
+        "basic_info": "Información Básica Enviada",
+        "handle_turnstile": "Manejar Turnstile",
+        "no_turnstile": "No se Detectó Turnstile",
+        "turnstile_passed": "Turnstile Superado",
+        "verification_start": "Comenzar a Obtener Código de Verificación",
+        "verification_timeout": "Tiempo de Espera Agotado para Código de Verificación",
+        "verification_not_found": "No se Encontró Código de Verificación",
+        "try_get_code": "Intento | {attempt} Obtener Código de Verificación | Tiempo Restante: {time}s",
+        "get_account": "Obteniendo Información de la Cuenta",
+        "get_token": "Obtener Token de Sesión de Cursor",
+        "token_success": "Token Obtenido Exitosamente",
+        "token_attempt": "Intento | {attempt} veces para obtener Token | Se reintentará en {time}s",
+        "token_max_attempts": "Alcanzado Máximo de Intentos ({max}) | No se pudo obtener Token",
+        "token_failed": "Falló al Obtener Token: {error}",
+        "account_error": "Falló al Obtener Información de la Cuenta: {error}",
+        "press_enter": "Presione Enter para Salir",
+        "browser_start": "Iniciando Navegador",
+        "open_mailbox": "Abriendo Página de Correo",
+        "email_error": "Falló al Obtener Dirección de Correo",
+        "setup_error": "Error de Configuración de Correo: {error}",
+        "start_getting_verification_code": "Comenzando a Obtener Código de Verificación, Se Intentará en 60s",
+        "get_verification_code_timeout": "Tiempo de Espera Agotado para Código de Verificación",
+        "get_verification_code_success": "Código de Verificación Obtenido Exitosamente",
+        "try_get_verification_code": "Intento | {attempt} Obtener Código de Verificación | Tiempo Restante: {remaining_time}s",
+        "verification_code_filled": "Código de Verificación Completado",
+        "login_success_and_jump_to_settings_page": "Inicio de Sesión Exitoso y Salto a Página de Configuración",
+        "detect_login_page": "Página de Inicio de Sesión Detectada, Iniciando Sesión...",
+        "cursor_registration_completed": "¡Registro de Cursor Completado!",
+        "set_password": "Establecer Contraseña",
+        "basic_info_submitted": "Información Básica Enviada",
+        "cursor_auth_info_updated": "Información de Autenticación de Cursor Actualizada",
+        "cursor_auth_info_update_failed": "Falló la Actualización de Información de Autenticación de Cursor",
+        "reset_machine_id": "Restablecer ID de Máquina",
+        "account_info_saved": "Información de Cuenta Guardada",
+        "save_account_info_failed": "Falló al Guardar Información de Cuenta",
+        "get_email_address": "Obtener Dirección de Correo",
+        "update_cursor_auth_info": "Actualizar Información de Autenticación de Cursor",
+        "register_process_error": "Error en el Proceso de Registro: {error}",
+        "setting_password": "Estableciendo Contraseña",
+        "manual_code_input": "Entrada Manual de Código",
+        "manual_email_input": "Entrada Manual de Correo",
+        "password": "Contraseña",
+        "first_name": "Nombre",
+        "last_name": "Apellido",
+        "exit_signal": "Señal de Salida",
+        "email_address": "Dirección de Correo",
+        "config_created": "Configuración Creada",
+        "verification_failed": "Verificación Fallida",
+        "verification_error": "Error de Verificación: {error}",
+        "config_option_added": "Opción de Configuración Añadida: {option}",
+        "config_updated": "Configuración Actualizada",
+        "password_submitted": "Contraseña Enviada",
+        "total_usage": "Uso Total: {usage}",
+        "setting_on_password": "Estableciendo Contraseña",
+        "getting_code": "Obteniendo Código de Verificación, Se Intentará en 60s",
+        "human_verify_error": "No se puede verificar que el usuario es humano. Reintentando...",
+        "max_retries_reached": "Se alcanzó el máximo de intentos. Registro fallido."
+    },
+    "auth": {
+        "title": "Administrador de Autenticación de Cursor",
+        "checking_auth": "Verificando Archivo de Autenticación",
+        "auth_not_found": "Archivo de Autenticación No Encontrado",
+        "auth_file_error": "Error en Archivo de Autenticación: {error}",
+        "reading_auth": "Leyendo Archivo de Autenticación",
+        "updating_auth": "Actualizando Información de Autenticación",
+        "auth_updated": "Información de Autenticación Actualizada Exitosamente",
+        "auth_update_failed": "Falló la Actualización de Información de Autenticación: {error}",
+        "auth_file_created": "Archivo de Autenticación Creado",
+        "auth_file_create_failed": "Falló la Creación del Archivo de Autenticación: {error}",
+        "press_enter": "Presione Enter para Salir",
+        "reset_machine_id": "Restablecer ID de Máquina",
+        "database_connection_closed": "Conexión a la Base de Datos Cerrada",
+        "database_updated_successfully": "Base de Datos Actualizada Exitosamente",
+        "connected_to_database": "Conectado a la Base de Datos",
+        "updating_pair": "Actualizando Par Clave-Valor",
+        "db_not_found": "Archivo de base de datos no encontrado en: {path}",
+        "db_permission_error": "No se puede acceder al archivo de base de datos. Verifique los permisos",
+        "db_connection_error": "Falló la conexión a la base de datos: {error}"
+    },
+    "control": {
+        "generate_email": "Generando Nuevo Correo",
+        "blocked_domain": "Dominio Bloqueado",
+        "select_domain": "Seleccionando Dominio Aleatorio",
+        "copy_email": "Copiando Dirección de Correo",
+        "enter_mailbox": "Entrando al Buzón de Correo",
+        "refresh_mailbox": "Actualizando Buzón de Correo",
+        "check_verification": "Verificando Código de Verificación",
+        "verification_found": "Código de Verificación Encontrado",
+        "verification_not_found": "No se Encontró Código de Verificación",
+        "browser_error": "Error de Control del Navegador: {error}",
+        "navigation_error": "Error de Navegación: {error}",
+        "email_copy_error": "Error al Copiar Correo: {error}",
+        "mailbox_error": "Error en el Buzón de Correo: {error}",
+        "token_saved_to_file": "Token Guardado en cursor_tokens.txt",
+        "navigate_to": "Navegando a {url}",
+        "generate_email_success": "Generación de Correo Exitosa",
+        "select_email_domain": "Seleccionar Dominio de Correo",
+        "select_email_domain_success": "Selección de Dominio de Correo Exitosa",
+        "get_email_name": "Obtener Nombre de Correo",
+        "get_email_name_success": "Nombre de Correo Obtenido Exitosamente",
+        "get_email_address": "Obtener Dirección de Correo",
+        "get_email_address_success": "Dirección de Correo Obtenida Exitosamente",
+        "enter_mailbox_success": "Entrada al Buzón de Correo Exitosa",
+        "found_verification_code": "Código de Verificación Encontrado",
+        "get_cursor_session_token": "Obtener Token de Sesión de Cursor",
+        "get_cursor_session_token_success": "Token de Sesión de Cursor Obtenido Exitosamente",
+        "get_cursor_session_token_failed": "Falló al Obtener Token de Sesión de Cursor",
+        "save_token_failed": "Falló al Guardar Token",
+        "database_updated_successfully": "Base de Datos Actualizada Exitosamente",
+        "database_connection_closed": "Conexión a la Base de Datos Cerrada",
+        "no_valid_verification_code": "No Hay Código de Verificación Válido"
+    },
+    "email": {
+        "starting_browser": "Iniciando Navegador",
+        "visiting_site": "Visitando dominios de correo",
+        "create_success": "Correo Creado Exitosamente",
+        "create_failed": "Falló al Crear Correo",
+        "create_error": "Error en la Creación del Correo: {error}",
+        "refreshing": "Actualizando Correo",
+        "refresh_success": "Correo Actualizado Exitosamente",
+        "refresh_error": "Error al Actualizar Correo: {error}",
+        "refresh_button_not_found": "Botón de Actualización No Encontrado",
+        "verification_found": "Verificación Encontrada",
+        "verification_not_found": "Verificación No Encontrada",
+        "verification_error": "Error de Verificación: {error}",
+        "verification_code_found": "Código de Verificación Encontrado",
+        "verification_code_not_found": "Código de Verificación No Encontrado",
+        "verification_code_error": "Error en el Código de Verificación: {error}",
+        "address": "Dirección de Correo",
+        "all_domains_blocked": "Todos los Dominios Bloqueados, Cambiando Servicio",
+        "no_available_domains_after_filtering": "No Hay Dominios Disponibles Después del Filtrado",
+        "switching_service": "Cambiando al Servicio {service}",
+        "domains_list_error": "Falló al Obtener Lista de Dominios: {error}",
+        "failed_to_get_available_domains": "Falló al Obtener Dominios Disponibles",
+        "domains_excluded": "Dominios Excluidos: {domains}",
+        "failed_to_create_account": "Falló al Crear Cuenta",
+        "account_creation_error": "Error en la Creación de la Cuenta: {error}",
+        "blocked_domains": "Dominios Bloqueados: {domains}",
+        "blocked_domains_loaded": "Dominios Bloqueados Cargados: {count}",
+        "blocked_domains_loaded_error": "Error al Cargar Dominios Bloqueados: {error}",
+        "blocked_domains_loaded_success": "Dominios Bloqueados Cargados Exitosamente",
+        "blocked_domains_loaded_timeout": "Tiempo de Espera Agotado para Cargar Dominios Bloqueados: {timeout}s",
+        "blocked_domains_loaded_timeout_error": "Error de Tiempo de Espera al Cargar Dominios Bloqueados: {error}",
+        "available_domains_loaded": "Dominios Disponibles Cargados: {count}",
+        "domains_filtered": "Dominios Filtrados: {count}",
+        "trying_to_create_email": "Intentando crear correo: {email}",
+        "domain_blocked": "Dominio Bloqueado: {domain}"
+    },
+    "update": {
+        "title": "Deshabilitar Actualización Automática de Cursor",
+        "disable_success": "Actualización Automática Deshabilitada Exitosamente",
+        "disable_failed": "Falló al Deshabilitar Actualización Automática: {error}",
+        "press_enter": "Presione Enter para Salir",
+        "start_disable": "Comenzar a Deshabilitar Actualización Automática",
+        "killing_processes": "Terminando Procesos",
+        "processes_killed": "Procesos Terminados",
+        "removing_directory": "Eliminando Directorio",
+        "directory_removed": "Directorio Eliminado",
+        "creating_block_file": "Creando Archivo de Bloqueo",
+        "block_file_created": "Archivo de Bloqueo Creado"
+    },
+    "updater": {
+        "checking": "Buscando actualizaciones...",
+        "new_version_available": "¡Nueva versión disponible! (Actual: {current}, Última: {latest})",
+        "updating": "Actualizando a la última versión. El programa se reiniciará automáticamente.",
+        "up_to_date": "Está utilizando la última versión.",
+        "check_failed": "Falló al verificar actualizaciones: {error}",
+        "continue_anyway": "Continuando con la versión actual...",
+        "update_confirm": "¿Desea actualizar a la última versión? (Y/n)",
+        "update_skipped": "Omitiendo actualización.",
+        "invalid_choice": "Elección inválida. Por favor ingrese 'Y' o 'n'.",
+        "development_version": "Versión de Desarrollo {current} > {latest}",
+        "changelog_title": "Registro de Cambios"
+    },
+    "totally_reset": {
+        "title": "Restablecer Cursor Completamente",
+        "checking_config": "Verificando Archivo de Configuración",
+        "config_not_found": "Archivo de Configuración No Encontrado",
+        "no_permission": "No se Puede Leer o Escribir el Archivo de Configuración, Verifique los Permisos",
+        "reading_config": "Leyendo Configuración Actual",
+        "creating_backup": "Creando Copia de Seguridad de la Configuración",
+        "backup_exists": "El Archivo de Respaldo ya Existe, Omitiendo Paso de Respaldo",
+        "generating_new_machine_id": "Generando Nuevo ID de Máquina",
+        "saving_new_config": "Guardando Nueva Configuración en JSON",
+        "success": "Cursor Restablecido Exitosamente",
+        "error": "Falló el Restablecimiento de Cursor: {error}",
+        "press_enter": "Presione Enter para Salir",
+        "reset_machine_id": "Restablecer ID de Máquina",
+        "database_connection_closed": "Conexión a la Base de Datos Cerrada",
+        "database_updated_successfully": "Base de Datos Actualizada Exitosamente",
+        "connected_to_database": "Conectado a la Base de Datos",
+        "updating_pair": "Actualizando Par Clave-Valor",
+        "db_not_found": "Archivo de base de datos no encontrado en: {path}",
+        "db_permission_error": "No se puede acceder al archivo de base de datos. Verifique los permisos",
+        "db_connection_error": "Falló la conexión a la base de datos: {error}",
+        "feature_title": "CARACTERÍSTICAS",
+        "feature_1": "Eliminación completa de configuraciones y ajustes de Cursor AI",
+        "feature_2": "Limpia todos los datos en caché incluyendo historial de IA y peticiones",
+        "feature_3": "Restablece el ID de máquina para evitar la detección de prueba",
+        "feature_4": "Crea nuevos identificadores de máquina aleatorios",
+        "feature_5": "Elimina extensiones personalizadas y preferencias",
+        "feature_6": "Restablece información de prueba y datos de activación",
+        "feature_7": "Escaneo profundo de archivos ocultos relacionados con licencias y pruebas",
+        "feature_8": "Preserva de forma segura archivos y aplicaciones que no son de Cursor",
+        "feature_9": "Compatible con Windows, macOS y Linux",
+        "disclaimer_title": "AVISO IMPORTANTE",
+        "disclaimer_1": "Esta herramienta eliminará permanentemente todas las configuraciones de Cursor AI,",
+        "disclaimer_2": "ajustes y datos en caché. Esta acción no se puede deshacer.",
+        "disclaimer_3": "Sus archivos de código NO se verán afectados, y la herramienta está diseñada",
+        "disclaimer_4": "para dirigirse solo a archivos del editor Cursor AI y mecanismos de detección de prueba.",
+        "disclaimer_5": "Otras aplicaciones en su sistema no se verán afectadas.",
+        "disclaimer_6": "Necesitará configurar Cursor AI nuevamente después de ejecutar esta herramienta.",
+        "disclaimer_7": "Use bajo su propio riesgo",
+        "confirm_title": "¿Está seguro de que desea continuar?",
+        "confirm_1": "Esta acción eliminará todas las configuraciones de Cursor AI,",
+        "confirm_2": "ajustes y datos en caché. Esta acción no se puede deshacer.",
+        "confirm_3": "Sus archivos de código NO se verán afectados, y la herramienta está diseñada",
+        "confirm_4": "para dirigirse solo a archivos del editor Cursor AI y mecanismos de detección de prueba.",
+        "confirm_5": "Otras aplicaciones en su sistema no se verán afectadas.",
+        "confirm_6": "Necesitará configurar Cursor AI nuevamente después de ejecutar esta herramienta.",
+        "confirm_7": "Use bajo su propio riesgo",
+        "invalid_choice": "Por favor ingrese 'Y' o 'n'",
+        "skipped_for_safety": "Omitido por seguridad (no relacionado con Cursor): {path}",
+        "deleted": "Eliminado: {path}",
+        "error_deleting": "Error al eliminar {path}: {error}",
+        "not_found": "Archivo no encontrado: {path}",
+        "resetting_machine_id": "Restableciendo identificadores de máquina para evitar la detección de prueba...",
+        "created_machine_id": "Creado nuevo ID de máquina: {path}",
+        "error_creating_machine_id": "Error al crear archivo de ID de máquina {path}: {error}",
+        "error_searching": "Error al buscar archivos en {path}: {error}",
+        "created_extended_trial_info": "Creada nueva información de prueba extendida: {path}",
+        "error_creating_trial_info": "Error al crear archivo de información de prueba {path}: {error}",
+        "resetting_cursor_ai_editor": "Restableciendo Editor Cursor AI... Por favor espere.",
+        "reset_cancelled": "Restablecimiento cancelado. Saliendo sin realizar cambios.",
+        "windows_machine_id_modification_skipped": "Modificación de ID de máquina de Windows omitida: {error}",
+        "linux_machine_id_modification_skipped": "Modificación de machine-id de Linux omitida: {error}",
+        "note_complete_machine_id_reset_may_require_running_as_administrator": "Nota: El restablecimiento completo del ID de máquina puede requerir ejecutar como administrador",
+        "note_complete_system_machine_id_reset_may_require_sudo_privileges": "Nota: El restablecimiento completo del machine-id del sistema puede requerir privilegios sudo",
+        "windows_registry_instructions": "📝 NOTA: Para un restablecimiento completo en Windows, es posible que también deba limpiar entradas del registro.",
+        "windows_registry_instructions_2": "   Ejecute 'regedit' y busque claves que contengan 'Cursor' o 'CursorAI' bajo HKEY_CURRENT_USER\\Software\\ y elimínelas.",
+        "reset_log_1": "¡Cursor AI ha sido completamente restablecido y se ha evitado la detección de prueba!",
+        "reset_log_2": "Por favor reinicie su sistema para que los cambios surtan efecto.",
+        "reset_log_3": "Necesitará reinstalar Cursor AI y ahora debería tener un nuevo período de prueba.",
+        "reset_log_4": "Para mejores resultados, considere también:",
+        "reset_log_5": "Usar una dirección de correo diferente al registrarse para una nueva prueba",
+        "reset_log_6": "Si está disponible, usar una VPN para cambiar su dirección IP",
+        "reset_log_7": "Limpiar las cookies y caché de su navegador antes de visitar el sitio web de Cursor AI",
+        "reset_log_8": "Si los problemas persisten, intente instalar Cursor AI en una ubicación diferente",
+        "reset_log_9": "Si encuentra algún problema, vaya al Rastreador de Problemas de Github y cree un problema en https://github.com/yeongpin/cursor-free-vip/issues",
+        "unexpected_error": "Ocurrió un error inesperado: {error}",
+        "report_issue": "Por favor reporte este problema al Rastreador de Problemas de Github en https://github.com/yeongpin/cursor-free-vip/issues",
+        "keyboard_interrupt": "Proceso interrumpido por el usuario. Saliendo...",
+        "return_to_main_menu": "Volviendo al menú principal...",
+        "process_interrupted": "Proceso interrumpido. Saliendo...",
+        "press_enter_to_return_to_main_menu": "Presione Enter para volver al menú principal...",
+        "removing_known": "Eliminando archivos conocidos de prueba/licencia",
+        "performing_deep_scan": "Realizando escaneo profundo para archivos adicionales de prueba/licencia",
+        "found_additional_potential_license_trial_files": "Se encontraron {count} archivos potenciales adicionales de licencia/prueba",
+        "checking_for_electron_localstorage_files": "Verificando archivos de localStorage de Electron",
+        "no_additional_license_trial_files_found_in_deep_scan": "No se encontraron archivos adicionales de licencia/prueba en el escaneo profundo",
+        "removing_electron_localstorage_files": "Eliminando archivos de localStorage de Electron",
+        "electron_localstorage_files_removed": "Archivos de localStorage de Electron eliminados",
+        "electron_localstorage_files_removal_error": "Error al eliminar archivos de localStorage de Electron: {error}",
+        "removing_electron_localstorage_files_completed": "Eliminación de archivos de localStorage de Electron completada",
+        "warning_title": "ADVERTENCIA",
+        "warning_1": "Esta acción eliminará todas las configuraciones de Cursor AI,",
+        "warning_2": "ajustes y datos en caché. Esta acción no se puede deshacer.",
+        "warning_3": "Sus archivos de código NO se verán afectados, y la herramienta está diseñada",
+        "warning_4": "para dirigirse solo a archivos del editor Cursor AI y mecanismos de detección de prueba.",
+        "warning_5": "Otras aplicaciones en su sistema no se verán afectadas.",
+        "warning_6": "Necesitará configurar Cursor AI nuevamente después de ejecutar esta herramienta.",
+        "warning_7": "Use bajo su propio riesgo",
+        "removed": "Eliminado: {path}",
+        "failed_to_reset_machine_guid": "Falló al restablecer GUID de máquina",
+        "failed_to_remove": "Falló al eliminar: {path}",
+        "failed_to_delete_file": "Falló al eliminar archivo: {path}",
+        "failed_to_delete_directory": "Falló al eliminar directorio: {path}",
+        "failed_to_delete_file_or_directory": "Falló al eliminar archivo o directorio: {path}",
+        "deep_scanning": "Realizando escaneo profundo para archivos adicionales de prueba/licencia",
+        "resetting_cursor": "Restableciendo Editor Cursor AI... Por favor espere.",
+        "completed_in": "Completado en {time} segundos",
+        "cursor_reset_completed": "¡El Editor Cursor AI ha sido completamente restablecido y se ha evitado la detección de prueba!",
+        "cursor_reset_failed": "Falló el restablecimiento del Editor Cursor AI: {error}",
+        "cursor_reset_cancelled": "Restablecimiento del Editor Cursor AI cancelado. Saliendo sin realizar cambios.",
+        "operation_cancelled": "Operación cancelada. Saliendo sin realizar cambios."
+    },
+    "github_register": {
+        "title": "Automatización de Registro de GitHub + Cursor AI",
+        "features_header": "Características",
+        "feature1": "Genera un correo temporal usando 1secmail.",
+        "feature2": "Registra una nueva cuenta de GitHub con credenciales aleatorias.",
+        "feature3": "Verifica el correo de GitHub automáticamente.",
+        "feature4": "Inicia sesión en Cursor AI usando autenticación de GitHub.",
+        "feature5": "Restablece el ID de máquina para evitar la detección de prueba.",
+        "feature6": "Guarda todas las credenciales en un archivo.",
+        "warnings_header": "Advertencias",
+        "warning1": "Este script automatiza la creación de cuentas, lo que puede violar los términos de servicio de GitHub/Cursor.",
+        "warning2": "Requiere acceso a internet y privilegios administrativos.",
+        "warning3": "CAPTCHA o verificación adicional pueden interrumpir la automatización.",
+        "warning4": "Use responsablemente y bajo su propio riesgo.",
+        "confirm": "¿Está seguro de que desea continuar?",
+        "invalid_choice": "Elección inválida. Por favor ingrese 'yes' o 'no'",
+        "cancelled": "Operación cancelada",
+        "program_terminated": "Programa terminado por el usuario",
+        "starting_automation": "Iniciando automatización...",
+        "github_username": "Nombre de Usuario de GitHub",
+        "github_password": "Contraseña de GitHub",
+        "email_address": "Dirección de Correo",
+        "credentials_saved": "Estas credenciales han sido guardadas en github_cursor_accounts.txt",
+        "completed_successfully": "¡Registro de GitHub + Cursor completado exitosamente!",
+        "registration_encountered_issues": "El registro de GitHub + Cursor encontró problemas.",
+        "check_browser_windows_for_manual_intervention_or_try_again_later": "Revise las ventanas del navegador para intervención manual o intente nuevamente más tarde."
+    }   
+}   

locales/fr.json

@@ -30,7 +30,8 @@
         "de": "Allemand",
         "fr": "Français",
         "pt": "Portugais",
-        "ru": "Russe"
+        "ru": "Russe",
+        "es": "Espagnol"
     },
     "quit_cursor": {
         "start": "Début de la Fermeture de Cursor",

locales/nl.json

@@ -30,7 +30,8 @@
         "de": "Duits",
         "fr": "Frans",
         "pt": "Portugees",
-        "ru": "Russisch"
+        "ru": "Russisch",
+        "es": "Spaans"
     },
     "quit_cursor": {
         "start": "Start met afsluiten van Cursor",

locales/pt.json

@@ -30,7 +30,8 @@
         "de": "Alemão",
         "fr": "Francês",
         "pt": "Português do Brasil",
-        "ru": "Russo"
+        "ru": "Russo",
+        "es": "Espanhol"
     },
     "quit_cursor": {
         "start": "Iniciando fechamento do Cursor",

locales/ru.json

@@ -30,7 +30,8 @@
         "de": "Немецкий",
         "fr": "Французский",
         "pt": "Бразильский португальский",
-        "ru": "Русский"
+        "ru": "Русский",
+        "es": "Испанский"
     },
     "quit_cursor": {
         "start": "Начало закрытия Cursor",

locales/tr.json

@@ -31,7 +31,8 @@
         "fr": "French",
         "pt": "Portuguese",
         "ru": "Russian",
-        "tr": "Turkish"
+        "tr": "Turkish",
+        "es": "Spanish"
     },
     "quit_cursor": {
         "start": "Cursor'dan Çıkış Başlatılıyor",

locales/vi.json

@@ -28,7 +28,8 @@
         "de": "Tiếng Đức",
         "fr": "Tiếng Pháp",
         "pt": "Tiếng Bồ Đào Nha",
-        "ru": "Tiếng Nga"
+        "ru": "Tiếng Nga",
+        "es": "Tiếng Tây Ban Nha"
     },
     "quit_cursor": {
         "start": "Bắt Đầu Thoát Cursor",

locales/zh_cn.json

@@ -21,7 +21,8 @@
         "temp_github_register": "临时GitHub注册",
         "admin_required": "运行可执行文件，需要管理员权限",
         "admin_required_continue": "继续使用当前版本...",
-        "coming_soon": "即将推出"
+        "coming_soon": "即将推出",
+        "fixed_soon": "即将修复"
     },
     "languages": {
         "en": "英语",
@@ -32,7 +33,10 @@
         "de": "德语",
         "fr": "法语",
         "pt": "葡萄牙语",
-        "ru": "俄语"
+        "ru": "俄语",
+        "tr": "土耳其语",
+        "bg": "保加利亚语",
+        "es": "西班牙语"
     },
     "quit_cursor": {
         "start": "开始退出 Cursor",
@@ -99,7 +103,9 @@
         "package_not_found": "package.json未找到: {path}",
         "check_version_failed": "检查版本失败: {error}",
         "stack_trace": "堆栈跟踪",
-        "version_too_low": "Cursor版本太低: {version} < 0.45.0"
+        "version_too_low": "Cursor版本太低: {version} < 0.45.0",
+        "no_write_permission": "没有写入权限: {path}",
+        "path_not_found": "路径未找到: {path}"
     },
     "register": {
         "title": "Cursor 注册工具",
@@ -380,7 +386,28 @@
         "removing_electron_localstorage_files": "正在移除 Electron localStorage 文件",
         "electron_localstorage_files_removed": "Electron localStorage 文件已移除",
         "electron_localstorage_files_removal_error": "移除 Electron localStorage 文件时出错：{error}",
-        "removing_electron_localstorage_files_completed": "Electron localStorage 文件移除完成"
+        "removing_electron_localstorage_files_completed": "Electron localStorage 文件移除完成",
+        "warning_title": "警告",
+        "warning_1": "此操作将删除所有 Cursor AI 设置、",
+        "warning_2": "配置和缓存数据。此操作无法撤销。",
+        "warning_3": "您的代码文件 **不会** 受到影响，工具设计为",
+        "warning_4": "仅针对 Cursor AI 编辑器文件和试用检测机制。",
+        "warning_5": "系统中的其他应用程序不会受到影响。",
+        "warning_6": "运行此工具后，您需要重新设置 Cursor AI。",
+        "warning_7": "请自行承担风险",
+        "removed": "已删除：{path}",
+        "failed_to_reset_machine_guid": "无法重置机器 GUID",
+        "failed_to_remove": "无法删除：{path}",
+        "failed_to_delete_file": "无法删除文件：{path}",
+        "failed_to_delete_directory": "无法删除目录：{path}",
+        "failed_to_delete_file_or_directory": "无法删除文件或目录：{path}",
+        "deep_scanning": "正在进行深度扫描以查找其他试用/授权文件",
+        "resetting_cursor": "正在重置 Cursor AI 编辑器... 请稍候。",
+        "completed_in": "完成时间：{time} 秒",
+        "cursor_reset_completed": "Cursor AI 编辑器已完全重置且绕过试用检测！",
+        "cursor_reset_failed": "Cursor AI 编辑器重置失败：{error}",
+        "cursor_reset_cancelled": "Cursor AI 编辑器重置已取消，未进行任何更改。",
+        "operation_cancelled": "操作已取消，未进行任何更改。"
     },
     "github_register": {
         "title": "GitHub + Cursor AI 注册自动化",
@@ -399,6 +426,14 @@
         "confirm": "您确定要继续吗？",
         "invalid_choice": "无效选择。请输入 'yes' 或 'no'",
         "cancelled": "操作已取消",
-        "program_terminated": "程序已由用户终止"
+        "program_terminated": "程序已由用户终止",
+        "starting_automation": "开始自动化...",
+        "github_username": "GitHub 用户名",
+        "github_password": "GitHub 密码",
+        "email_address": "邮箱地址",
+        "credentials_saved": "这些凭证已保存到 github_cursor_accounts.txt",
+        "completed_successfully": "GitHub + Cursor 注册成功",
+        "registration_encountered_issues": "GitHub + Cursor 注册遇到问题",
+        "check_browser_windows_for_manual_intervention_or_try_again_later": "检查浏览器窗口进行手动干预或稍后再试"
     }
 } 

locales/zh_tw.json

@@ -19,7 +19,8 @@
         "temp_github_register": "臨時GitHub註冊",
         "admin_required": "運行可執行文件，需要管理員權限",
         "admin_required_continue": "繼續使用當前版本...",
-        "coming_soon": "即將推出"
+        "coming_soon": "即將推出",
+        "fixed_soon": "即將修復"
     },
     "languages": {
         "en": "英文",
@@ -30,7 +31,10 @@
         "de": "德文",
         "fr": "法文",
         "pt": "葡萄牙文",
-        "ru": "俄文"
+        "ru": "俄文",
+        "tr": "土耳其文",
+        "bg": "保加利亞文",
+        "es": "西班牙文"
     },
     "quit_cursor": {
         "start": "開始退出 Cursor",
@@ -97,7 +101,9 @@
         "package_not_found": "package.json未找到: {path}",
         "check_version_failed": "檢查版本失敗: {error}",
         "stack_trace": "堆疊跟踪",
-        "version_too_low": "Cursor版本太低: {version} < 0.45.0"
+        "version_too_low": "Cursor版本太低: {version} < 0.45.0",
+        "no_write_permission": "沒有寫入權限: {path}",
+        "path_not_found": "路徑未找到: {path}"
     },
 
     "register": {
@@ -359,7 +365,28 @@
         "removing_electron_localstorage_files": "正在移除 Electron localStorage 檔案",
         "electron_localstorage_files_removed": "已移除 Electron localStorage 檔案",
         "electron_localstorage_files_removal_error": "移除 Electron localStorage 檔案時出錯：{error}",
-        "removing_electron_localstorage_files_completed": "Electron localStorage 檔案移除完成"
+        "removing_electron_localstorage_files_completed": "Electron localStorage 檔案移除完成",
+        "warning_title": "警告",
+        "warning_1": "此操作將刪除所有 Cursor AI 設定、",
+        "warning_2": "配置與快取資料。此操作無法還原。",
+        "warning_3": "您的程式碼檔案將 **不會** 受到影響，且此工具僅針對",
+        "warning_4": "Cursor AI 編輯器檔案與試用偵測機制。",
+        "warning_5": "系統中的其他應用程式不會受到影響。",
+        "warning_6": "執行此工具後，您需要重新設定 Cursor AI。",
+        "warning_7": "請自行承擔風險",
+        "removed": "已刪除：{path}",
+        "failed_to_reset_machine_guid": "無法重置機器 GUID",
+        "failed_to_remove": "無法刪除：{path}",
+        "failed_to_delete_file": "無法刪除檔案：{path}",
+        "failed_to_delete_directory": "無法刪除目錄：{path}",
+        "failed_to_delete_file_or_directory": "無法刪除檔案或目錄：{path}",
+        "deep_scanning": "正在進行深度掃描以查找其他試用/授權檔案",
+        "resetting_cursor": "正在重置 Cursor AI 編輯器... 請稍候。",
+        "completed_in": "完成時間：{time} 秒",
+        "cursor_reset_completed": "Cursor AI 編輯器已完全重置且繞過試用偵測！",
+        "cursor_reset_failed": "Cursor AI 編輯器重置失敗：{error}",
+        "cursor_reset_cancelled": "Cursor AI 編輯器重置已取消，未進行任何更改。",
+        "operation_cancelled": "操作已取消，未進行任何更改。"
     },
     "github_register": {
         "title": "GitHub + Cursor AI 注册自动化",
@@ -378,6 +405,14 @@
         "confirm": "您确定要继续吗？",
         "invalid_choice": "无效选择。请输入 'yes' 或 'no'",
         "cancelled": "操作已取消",
-        "program_terminated": "程序已由用户终止"
+        "program_terminated": "程序已由用户终止",
+        "starting_automation": "開始自動化...",
+        "github_username": "GitHub 用戶名",
+        "github_password": "GitHub 密碼",
+        "email_address": "郵箱地址",
+        "credentials_saved": "這些憑證已保存到 github_cursor_accounts.txt",
+        "completed_successfully": "GitHub + Cursor 註冊成功",
+        "registration_encountered_issues": "GitHub + Cursor 註冊遇到問題",
+        "check_browser_windows_for_manual_intervention_or_try_again_later": "檢查瀏覽器視窗進行手動干預或稍後再試"
     }
 } 

logo.py

@@ -1,6 +1,8 @@
 from colorama import Fore, Style, init
 from dotenv import load_dotenv
 import os
+import shutil
+import re
 
 # Get the current script directory
 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -15,27 +17,85 @@ version = os.getenv('VERSION', '1.0.0')
 # Initialize colorama
 init()
 
-CURSOR_LOGO = f"""
-{Fore.CYAN}
+# get terminal width
+def get_terminal_width():
+    try:
+        columns, _ = shutil.get_terminal_size()
+        return columns
+    except:
+        return 80  # default width
+
+# center display text (not handling Chinese characters)
+def center_multiline_text(text, handle_chinese=False):
+    width = get_terminal_width()
+    lines = text.split('\n')
+    centered_lines = []
+    
+    for line in lines:
+        # calculate actual display width (remove ANSI color codes)
+        clean_line = line
+        for color in [Fore.CYAN, Fore.YELLOW, Fore.GREEN, Fore.RED, Style.RESET_ALL]:
+            clean_line = clean_line.replace(color, '')
+        
+        # remove all ANSI escape sequences to get the actual length
+        ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+        clean_line = ansi_escape.sub('', clean_line)
+        
+        # calculate display width
+        if handle_chinese:
+            # consider Chinese characters occupying two positions
+            display_width = 0
+            for char in clean_line:
+                if ord(char) > 127:  # non-ASCII characters
+                    display_width += 2
+                else:
+                    display_width += 1
+        else:
+            # not handling Chinese characters
+            display_width = len(clean_line)
+        
+        # calculate the number of spaces to add
+        padding = max(0, (width - display_width) // 2)
+        centered_lines.append(' ' * padding + line)
+    
+    return '\n'.join(centered_lines)
+
+# original LOGO text
+LOGO_TEXT = f"""{Fore.CYAN}
    ██████╗██╗   ██╗██████╗ ███████╗ ██████╗ ██████╗      ██████╗ ██████╗  ██████╗   
   ██╔════╝██║   ██║██╔══██╗██╔════╝██╔═══██╗██╔══██╗     ██╔══██╗██╔══██╗██╔═══██╗  
   ██║     ██║   ██║██████╔╝███████╗██║   ██║██████╔╝     ██████╔╝██████╔╝██║   ██║  
   ██║     ██║   ██║██╔══██╗╚════██║██║   ██║██╔══██╗     ██╔═══╝ ██╔══██╗██║   ██║  
   ╚██████╗╚██████╔╝██║  ██║███████║╚██████╔╝██║  ██║     ██║     ██║  ██║╚██████╔╝  
    ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═╝  ╚═╝     ╚═╝     ╚═╝  ╚═╝ ╚═════╝  
-{Fore.YELLOW}
-                Pro Version Activator v{version}
-{Fore.GREEN}
-                Author: Pin Studios | yeongpin
+{Style.RESET_ALL}"""
 
-      Github: https://github.com/yeongpin/cursor-free-vip
-{Fore.RED}
-        Press 7 to change language | 按下 7 键切换语言
-{Style.RESET_ALL}
-    """
+DESCRIPTION_TEXT = f"""{Fore.YELLOW}
+Pro Version Activator v{version}{Fore.GREEN}
+Author: Pin Studios (yeongpin)"""
+
+CONTRIBUTORS_TEXT = f"""{Fore.BLUE}
+Contributors:
+BasaiCorp  aliensb  handwerk2016  Nigel1992
+UntaDotMy  RenjiYuusei  imbajin  ahmed98Osama
+bingoohuang  mALIk-sHAHId  MFaiqKhan  httpmerak
+muhammedfurkan plamkatawe
+"""
+OTHER_INFO_TEXT = f"""{Fore.YELLOW}
+Github: https://github.com/yeongpin/cursor-free-vip{Fore.RED}
+Press 7 to change language | 按下 7 键切换语言{Style.RESET_ALL}"""
+
+# center display LOGO and DESCRIPTION
+CURSOR_LOGO = center_multiline_text(LOGO_TEXT, handle_chinese=False)
+CURSOR_DESCRIPTION = center_multiline_text(DESCRIPTION_TEXT, handle_chinese=False)
+CURSOR_CONTRIBUTORS = center_multiline_text(CONTRIBUTORS_TEXT, handle_chinese=False)
+CURSOR_OTHER_INFO = center_multiline_text(OTHER_INFO_TEXT, handle_chinese=True)
 
 def print_logo():
     print(CURSOR_LOGO)
+    print(CURSOR_DESCRIPTION)
+    print(CURSOR_CONTRIBUTORS)
+    print(CURSOR_OTHER_INFO)
 
 if __name__ == "__main__":
     print_logo()

main.py

@@ -110,6 +110,7 @@ class Translator:
                 0x0422: 'vi',      # Vietnamese
                 0x0419: 'ru',      # Russian
                 0x0415: 'tr',      # Turkish
+                0x0402: 'bg',      # Bulgarian
             }
             
             return language_map.get(layout_id, 'en')
@@ -147,7 +148,8 @@ class Translator:
                 return 'ru'
             elif system_locale.startswith('tr'):
                 return 'tr'
-            
+            elif system_locale.startswith('bg'):
+                return 'bg'
             # Try to get language from LANG environment variable as fallback
             env_lang = os.getenv('LANG', '').lower()
             if 'tw' in env_lang or 'hk' in env_lang:
@@ -168,6 +170,8 @@ class Translator:
                 return 'ru'
             elif 'tr' in env_lang:
                 return 'tr'
+            elif 'bg' in env_lang:
+                return 'bg'
 
             return 'en'
         except:
@@ -449,7 +453,7 @@ def main():
     
     while True:
         try:
-            choice = input(f"\n{EMOJI['ARROW']} {Fore.CYAN}{translator.get('menu.input_choice', choices='0-9')}: {Style.RESET_ALL}")
+            choice = input(f"\n{EMOJI['ARROW']} {Fore.CYAN}{translator.get('menu.input_choice', choices='0-10')}: {Style.RESET_ALL}")
 
             if choice == "0":
                 print(f"\n{Fore.YELLOW}{EMOJI['INFO']} {translator.get('menu.exit')}...{Style.RESET_ALL}")
@@ -494,7 +498,8 @@ def main():
                 print_menu()
             elif choice == "10":
                 import totally_reset_cursor
-                totally_reset_cursor.run(translator)
+                # totally_reset_cursor.main(translator)
+                print(f"{Fore.YELLOW}{EMOJI['INFO']} {translator.get('menu.fixed_soon')}{Style.RESET_ALL}")
                 print_menu()
             else:
                 print(f"{Fore.RED}{EMOJI['ERROR']} {translator.get('menu.invalid_choice')}{Style.RESET_ALL}")

new_tempemail.py

@@ -131,45 +131,45 @@ class NewTempEmail:
             return False
             
     def create_email(self):
-        """创建临时邮箱"""
+        """create temporary email"""
         try:
             if self.translator:
                 print(f"{Fore.CYAN}ℹ️ {self.translator.get('email.visiting_site')}{Style.RESET_ALL}")
             else:
                 print(f"{Fore.CYAN}ℹ️ 正在访问 smailpro.com...{Style.RESET_ALL}")
             
-            # 加载被屏蔽域名列表
+            # load blocked domains list
             self.blocked_domains = self.get_blocked_domains()
             
-            # 访问网站
+            # visit website
             self.page.get("https://smailpro.com/")
             time.sleep(2)
             
-            # 点击创建邮箱按钮
+            # click create email button
             create_button = self.page.ele('xpath://button[@title="Create temporary email"]')
             if create_button:
                 create_button.click()
                 time.sleep(1)
                 
-                # 点击弹窗中的 Create 按钮
+                # click Create button in popup
                 modal_create_button = self.page.ele('xpath://button[contains(text(), "Create")]')
                 if modal_create_button:
                     modal_create_button.click()
                     time.sleep(2)
                     
-                    # 获取邮箱地址 - 修改选择器
+                    # get email address - modify selector
                     email_div = self.page.ele('xpath://div[@class="text-base sm:text-lg md:text-xl text-gray-700"]')
                     if email_div:
                         email = email_div.text.strip()
-                        if '@' in email:  # 验证是否是有效的邮箱地址
-                            # 检查域名是否被屏蔽
+                        if '@' in email:  # check if it's a valid email address
+                            # check if domain is blocked
                             domain = email.split('@')[1]
                             if self.blocked_domains and domain in self.blocked_domains:
                                 if self.translator:
                                     print(f"{Fore.YELLOW}⚠️ {self.translator.get('email.domain_blocked')}: {domain}{Style.RESET_ALL}")
                                 else:
                                     print(f"{Fore.YELLOW}⚠️ 域名已被屏蔽: {domain}，尝试重新创建邮箱{Style.RESET_ALL}")
-                                # 重新创建邮箱
+                                # create email again
                                 return self.create_email()
                             
                             if self.translator:
@@ -191,23 +191,23 @@ class NewTempEmail:
             return None
             
     def close(self):
-        """关闭浏览器"""
+        """close browser"""
         if self.page:
             self.page.quit()
 
     def refresh_inbox(self):
-        """刷新邮箱"""
+        """refresh inbox"""
         try:
             if self.translator:
                 print(f"{Fore.CYAN}🔄 {self.translator.get('email.refreshing')}{Style.RESET_ALL}")
             else:
                 print(f"{Fore.CYAN}🔄 正在刷新邮箱...{Style.RESET_ALL}")
             
-            # 点击刷新按钮
+            # click refresh button
             refresh_button = self.page.ele('xpath://button[@id="refresh"]')
             if refresh_button:
                 refresh_button.click()
-                time.sleep(2)  # 等待刷新完成
+                time.sleep(2)  # wait for refresh to complete
                 if self.translator:
                     print(f"{Fore.GREEN}✅ {self.translator.get('email.refresh_success')}{Style.RESET_ALL}")
                 else:
@@ -230,16 +230,16 @@ class NewTempEmail:
     def check_for_cursor_email(self):
         """检查是否有 Cursor 的验证邮件"""
         try:
-            # 查找验证邮件 - 使用更精确的选择器
+            # find verification email - use more accurate selector
             email_div = self.page.ele('xpath://div[contains(@class, "p-2") and contains(@class, "cursor-pointer") and contains(@class, "bg-white") and contains(@class, "shadow") and .//b[text()="no-reply@cursor.sh"] and .//span[text()="Verify your email address"]]')
             if email_div:
                 if self.translator:
                     print(f"{Fore.GREEN}✅ {self.translator.get('email.verification_found')}{Style.RESET_ALL}")
                 else:
                     print(f"{Fore.GREEN}✅ 找到验证邮件{Style.RESET_ALL}")
-                # 使用 JavaScript 点击元素
+                # use JavaScript to click element
                 self.page.run_js('arguments[0].click()', email_div)
-                time.sleep(2)  # 等待邮件内容加载
+                time.sleep(2)  # wait for email content to load
                 return True
             if self.translator:
                 print(f"{Fore.YELLOW}⚠️ {self.translator.get('email.verification_not_found')}{Style.RESET_ALL}")
@@ -257,7 +257,7 @@ class NewTempEmail:
     def get_verification_code(self):
         """获取验证码"""
         try:
-            # 查找验证码元素
+            # find verification code element
             code_element = self.page.ele('xpath://td//div[contains(@style, "font-size:28px") and contains(@style, "letter-spacing:2px")]')
             if code_element:
                 code = code_element.text.strip()
@@ -291,7 +291,7 @@ def main(translator=None):
             else:
                 print(f"\n{Fore.CYAN}📧 临时邮箱地址: {email}{Style.RESET_ALL}")
             
-            # 测试刷新功能
+            # test refresh function
             while True:
                 if translator:
                     choice = input(f"\n{translator.get('email.refresh_prompt')}: ").lower()

reset_machine_manual.py

@@ -37,10 +37,41 @@ def get_cursor_paths(translator=None) -> Tuple[str, str]:
     config_dir = os.path.join(get_user_documents_path(), ".cursor-free-vip")
     config_file = os.path.join(config_dir, "config.ini")
     
+    # Create config directory if it doesn't exist
+    if not os.path.exists(config_dir):
+        os.makedirs(config_dir)
+    
+    # Default paths for different systems
+    default_paths = {
+        "Darwin": "/Applications/Cursor.app/Contents/Resources/app",
+        "Windows": os.path.join(os.getenv("LOCALAPPDATA", ""), "Programs", "Cursor", "resources", "app"),
+        "Linux": ["/opt/Cursor/resources/app", "/usr/share/cursor/resources/app", os.path.expanduser("~/.local/share/cursor/resources/app")]
+    }
+    
+    # If config doesn't exist, create it with default paths
     if not os.path.exists(config_file):
-        raise OSError(translator.get('reset.config_not_found') if translator else "找不到配置文件")
+        for section in ['MacPaths', 'WindowsPaths', 'LinuxPaths']:
+            if not config.has_section(section):
+                config.add_section(section)
         
-    config.read(config_file, encoding='utf-8')  # Specify encoding
+        if system == "Darwin":
+            config.set('MacPaths', 'cursor_path', default_paths["Darwin"])
+        elif system == "Windows":
+            config.set('WindowsPaths', 'cursor_path', default_paths["Windows"])
+        elif system == "Linux":
+            # For Linux, try to find the first existing path
+            for path in default_paths["Linux"]:
+                if os.path.exists(path):
+                    config.set('LinuxPaths', 'cursor_path', path)
+                    break
+            else:
+                # If no path exists, use the first one as default
+                config.set('LinuxPaths', 'cursor_path', default_paths["Linux"][0])
+        
+        with open(config_file, 'w', encoding='utf-8') as f:
+            config.write(f)
+    else:
+        config.read(config_file, encoding='utf-8')
     
     # Get path based on system
     if system == "Darwin":
@@ -51,15 +82,26 @@ def get_cursor_paths(translator=None) -> Tuple[str, str]:
         section = 'LinuxPaths'
     else:
         raise OSError(translator.get('reset.unsupported_os', system=system) if translator else f"不支持的操作系统: {system}")
-        
+    
     if not config.has_section(section) or not config.has_option(section, 'cursor_path'):
         raise OSError(translator.get('reset.path_not_configured') if translator else "未配置 Cursor 路徑")
-        
+    
     base_path = config.get(section, 'cursor_path')
     
+    # For Linux, try to find the first existing path if the configured one doesn't exist
+    if system == "Linux" and not os.path.exists(base_path):
+        for path in default_paths["Linux"]:
+            if os.path.exists(path):
+                base_path = path
+                # Update config with the found path
+                config.set(section, 'cursor_path', path)
+                with open(config_file, 'w', encoding='utf-8') as f:
+                    config.write(f)
+                break
+    
     if not os.path.exists(base_path):
         raise OSError(translator.get('reset.path_not_found', path=base_path) if translator else f"找不到 Cursor 路徑: {base_path}")
-        
+    
     pkg_path = os.path.join(base_path, "package.json")
     main_path = os.path.join(base_path, "out/main.js")
     

totally_reset_cursor.py

@@ -4,30 +4,42 @@ import platform
 import time
 import uuid
 import subprocess
+from colorama import Fore, Style, init
 
-def delete_directory(path):
+init()
+
+EMOJI = {
+    "SUCCESS": "✅",
+    "ERROR": "❌",
+    "INFO": "ℹ️",
+    "RESET": "🔄",
+    "MENU": "📋",
+    "WARNING": "⚠️"
+}
+
+def delete_directory(path, translator=None):
     """Deletes a directory and all its contents."""
     if os.path.exists(path):
         try:
             shutil.rmtree(path)
-            print(f"✅ Removed: {path}")
+            print(f"{Fore.GREEN}{EMOJI['SUCCESS']} {translator.get('totally_reset.removed', path=path)}{Style.RESET_ALL}")
         except Exception as e:
-            print(f"❌ Failed to remove: {path} -> {e}")
+            print(f"{Fore.RED}{EMOJI['ERROR']} {translator.get('totally_reset.failed_to_remove', path=path, error=e)}{Style.RESET_ALL}")
     else:
-        print(f"🔍 Not found: {path}")
+        print(f"{Fore.YELLOW}{EMOJI['INFO']} {translator.get('totally_reset.not_found', path=path)}{Style.RESET_ALL}")
 
-def delete_file(path):
+def delete_file(path, translator=None):
     """Deletes a file if it exists."""
     if os.path.isfile(path):
         try:
             os.remove(path)
-            print(f"✅ Removed file: {path}")
+            print(f"{Fore.GREEN}{EMOJI['SUCCESS']} {translator.get('totally_reset.removed', path=path)}{Style.RESET_ALL}")
         except Exception as e:
-            print(f"❌ Failed to remove file: {path} -> {e}")
+            print(f"{Fore.RED}{EMOJI['ERROR']} {translator.get('totally_reset.failed_to_remove', path=path, error=e)}{Style.RESET_ALL}")
     else:
-        print(f"🔍 Not found: {path}")
+        print(f"{Fore.YELLOW}{EMOJI['INFO']} {translator.get('totally_reset.not_found', path=path)}{Style.RESET_ALL}")
 
-def reset_machine_id():
+def reset_machine_id(translator=None):
     """Resets the machine ID to a new UUID."""
     new_id = str(uuid.uuid4())
     if platform.system() == "Windows":
@@ -38,9 +50,9 @@ def reset_machine_id():
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE
             )
-            print(f"✅ MachineGuid reset to: {new_id}")
+            print(f"{Fore.GREEN}{EMOJI['SUCCESS']} {translator.get('totally_reset.machine_guid_reset', new_id=new_id)}{Style.RESET_ALL}")
         except subprocess.CalledProcessError as e:
-            print(f"❌ Failed to reset MachineGuid: {e}")
+            print(f"{Fore.RED}{EMOJI['ERROR']} {translator.get('totally_reset.failed_to_reset_machine_guid', error=e)}{Style.RESET_ALL}")
     elif platform.system() == "Linux":
         machine_id_paths = ["/etc/machine-id", "/var/lib/dbus/machine-id"]
         for path in machine_id_paths:
@@ -48,44 +60,51 @@ def reset_machine_id():
                 try:
                     with open(path, 'w') as f:
                         f.write(new_id)
-                    print(f"✅ Reset machine ID at: {path}")
+                    print(f"{Fore.GREEN}{EMOJI['SUCCESS']} {translator.get('totally_reset.machine_id_reset', path=path)}{Style.RESET_ALL}")
                 except Exception as e:
-                    print(f"❌ Failed to reset machine ID at {path}: {e}")
+                    print(f"{Fore.RED}{EMOJI['ERROR']} {translator.get('totally_reset.failed_to_reset_machine_id', path=path, error=e)}{Style.RESET_ALL}")
     elif platform.system() == "Darwin":  # macOS
         print("ℹ️ macOS does not use a machine-id file. Skipping machine ID reset.")
     else:
-        print("❌ Unsupported operating system for machine ID reset.")
+        print(f"{Fore.RED}{EMOJI['ERROR']} {translator.get('totally_reset.unsupported_os')}{Style.RESET_ALL}")
 
-def display_features_and_warnings():
+def display_features_and_warnings(translator=None):
     """Displays features and warnings before proceeding."""
-    print("\n🚀 Cursor AI Reset Script")
+    print(f"\n{Fore.GREEN}{EMOJI['MENU']} {translator.get('totally_reset.title')}")
     print("=====================================")
-    print("Features:")
-    print("  - Removes Cursor AI configuration directories and files.")
-    print("  - Cleans up cache, preferences, and application data.")
-    print("  - Performs a deep scan for hidden Cursor-related files.")
-    print("  - Resets the machine ID to a new UUID (where applicable).")
-    print("  - Supports Windows, Linux, and macOS.")
-    print("\n⚠️ Warnings:")
-    print("  - This action is IRREVERSIBLE. All Cursor AI data will be deleted.")
-    print("  - Requires administrative privileges for some operations (e.g., machine ID reset on Windows/Linux).")
-    print("  - May disrupt Cursor AI functionality until reinstalled or reconfigured.")
-    print("  - Backup any important Cursor data before proceeding.")
+    print(f"{translator.get('totally_reset.feature_title')}")
+    print(f"{Fore.GREEN}{translator.get('totally_reset.feature_1')}")
+    print(f"{Fore.GREEN}{translator.get('totally_reset.feature_2')}")
+    print(f"{Fore.GREEN}{translator.get('totally_reset.feature_3')}")
+    print(f"{Fore.GREEN}{translator.get('totally_reset.feature_4')}")
+    print(f"{Fore.GREEN}{translator.get('totally_reset.feature_5')}")
+    print(f"{Fore.GREEN}{translator.get('totally_reset.feature_6')}")
+    print(f"{Fore.GREEN}{translator.get('totally_reset.feature_7')}")
+    print(f"{Fore.GREEN}{translator.get('totally_reset.feature_8')}")
+    print(f"{Fore.GREEN}{translator.get('totally_reset.feature_9')}")
+    print(f"\n{Fore.YELLOW}{EMOJI['WARNING']} {translator.get('totally_reset.warning_title')}")
+    print(f"{Fore.YELLOW}{translator.get('totally_reset.warning_1')}")
+    print(f"{Fore.YELLOW}{translator.get('totally_reset.warning_2')}")
+    print(f"{Fore.YELLOW}{translator.get('totally_reset.warning_3')}")
+    print(f"{Fore.YELLOW}{translator.get('totally_reset.warning_4')}")
+    print(f"{Fore.YELLOW}{translator.get('totally_reset.warning_5')}")
+    print(f"{Fore.YELLOW}{translator.get('totally_reset.warning_6')}")
+    print(f"{Fore.YELLOW}{translator.get('totally_reset.warning_7')}")
     print("=====================================\n")
 
-def get_user_confirmation():
+def get_user_confirmation(translator=None):
     """Prompts the user for confirmation to proceed."""
     while True:
-        response = input("Do you want to proceed with resetting Cursor AI? (yes/no): ").lower().strip()
+        response = input(f"{Fore.YELLOW} {translator.get('totally_reset.confirm_title')} {translator.get('totally_reset.invalid_choice')}: ").lower().strip()
         if response in ['yes', 'y']:
             return True
         elif response in ['no', 'n']:
             return False
         else:
-            print("Please enter 'yes' or 'no'.")
+            print(f"{Fore.RED}{translator.get('totally_reset.invalid_choice')}{Style.RESET_ALL}")
 
-def reset_cursor():
-    print("\n🚀 Resetting Cursor AI...\n")
+def reset_cursor(translator=None):
+    print(f"\n{Fore.GREEN}{EMOJI['RESET']} {translator.get('totally_reset.resetting_cursor')}\n")
 
     # Platform-specific paths
     paths = []
@@ -125,7 +144,7 @@ def reset_cursor():
 
     # Remove directories
     for path in paths:
-        delete_directory(path)
+        delete_directory(path, translator)
 
     # Remove common files related to Cursor
     files = [
@@ -136,10 +155,10 @@ def reset_cursor():
     ]
 
     for file in files:
-        delete_file(file)
+        delete_file(file, translator)
 
     # Extra cleanup (wildcard search)
-    print("\n🔍 Deep scanning for hidden Cursor files...")
+    print(f"\n{Fore.YELLOW}{EMOJI['INFO']} {translator.get('totally_reset.deep_scanning')}")
     base_dirs = ["/tmp", "/var/tmp", os.path.expanduser("~")]  # Linux and macOS
     if platform.system() == "Windows":
         base_dirs = ["C:\\Temp", "C:\\Windows\\Temp", os.path.expanduser("~")]  # Windows
@@ -148,29 +167,30 @@ def reset_cursor():
         for root, dirs, files in os.walk(base):
             for dir in dirs:
                 if "cursor" in dir.lower():
-                    delete_directory(os.path.join(root, dir))
+                    delete_directory(os.path.join(root, dir), translator)
             for file in files:
                 if "cursor" in file.lower():
-                    delete_file(os.path.join(root, file))
+                    delete_file(os.path.join(root, file), translator)
 
     # Reset machine ID
-    reset_machine_id()
+    reset_machine_id(translator)
 
-    print("\n✅ Cursor AI has been completely reset!")
+    print(f"\n{Fore.GREEN}{EMOJI['SUCCESS']} {translator.get('totally_reset.cursor_reset_completed')}")
 
-def main():
+def main(translator=None):
     start_time = time.time()
     
     # Display features and warnings
-    display_features_and_warnings()
+    display_features_and_warnings(translator)
     
     # Get user confirmation
-    if get_user_confirmation():
-        reset_cursor()
+    if get_user_confirmation(translator):
+        reset_cursor(translator)
         end_time = time.time()
-        print(f"\n⏱️ Completed in {end_time - start_time:.2f} seconds.")
+        print(f"\n{Fore.GREEN}⏱️ {translator.get('totally_reset.completed_in', time=f'{end_time - start_time:.2f} seconds')}{Style.RESET_ALL}")
     else:
-        print("\n❌ Operation cancelled by user.")
+        print(f"\n{Fore.RED}❌ {translator.get('totally_reset.operation_cancelled')}{Style.RESET_ALL}")
 
 if __name__ == '__main__':
-    main()
+    from main import translator
+    main(translator)