{"repo_name": "cursor-free-everyday", "file_name": "/cursor-free-everyday/reset_machine.rs", "inference_info": {"prefix_code": "use colored::*;\nuse directories::{BaseDirs, UserDirs};\nuse is_elevated::is_elevated;\nuse serde::{Deserialize, Serialize};\nuse serde_json::Value;\nuse std::collections::HashMap;\nuse std::env;\nuse std::fs;\nuse std::io::{self, Write};\nuse std::path::{Path, PathBuf};\nuse std::process::{Command, Stdio};\nuse sysinfo::{System};\nuse uuid::Uuid;\nuse winreg::enums::*;\nuse winreg::RegKey;\nuse chrono::Local;\nuse rand::{thread_rng, Rng, distributions::Alphanumeric};\n\n// Color definitions (approximated from PowerShell)\nconst RED: &str = \"red\";\nconst GREEN: &str = \"green\";\nconst YELLOW: &str = \"yellow\";\nconst BLUE: &str = \"blue\";\n// const NC: &str = \"clear\"; // `colored` crate handles reset implicitly or via `.normal()`\n\n// Max retries and wait time for process termination\nconst MAX_RETRIES: u32 = 5;\nconst WAIT_TIME_SECONDS: u64 = 1;\n\n// Configuration file paths\nfn get_storage_file_path() -> Option<PathBuf> {\n    if let Some(base_dirs) = BaseDirs::new() {\n        let app_data_dir = base_dirs.config_dir(); // Typically %APPDATA% or ~/.config\n        Some(app_data_dir.join(\"Cursor\").join(\"User\").join(\"globalStorage\").join(\"storage.json\"))\n    } else {\n        None\n    }\n}\n\nfn get_backup_dir_path() -> Option<PathBuf> {\n    if let Some(base_dirs) = BaseDirs::new() {\n        let app_data_dir = base_dirs.config_dir();\n        Some(app_data_dir.join(\"Cursor\").join(\"User\").join(\"globalStorage\").join(\"backups\"))\n    } else {\n        None\n    }\n}\n\nfn get_cursor_package_path() -> Option<PathBuf> {\n    if let Some(user_dirs) = BaseDirs::new() {\n        let local_app_data_dir = user_dirs.data_local_dir();\n        let primary_path = local_app_data_dir.join(\"Programs\").join(\"cursor\").join(\"resources\").join(\"app\").join(\"package.json\");\n        if primary_path.exists() {\n            return Some(primary_path);\n        }\n        let alt_path = local_app_data_dir.join(\"cursor\").join(\"resources\").join(\"app\").join(\"package.json\");\n        if alt_path.exists() {\n            return Some(alt_path);\n        }\n    }\n    None\n}\n\nfn get_cursor_updater_path() -> Option<PathBuf> {\n    if let Some(user_dirs) = BaseDirs::new() {\n        let local_app_data_dir = user_dirs.data_local_dir();\n        Some(local_app_data_dir.join(\"cursor-updater\"))\n    } else {\n        None\n    }\n}\n\n\nfn press_enter_to_exit(exit_code: i32) {\n    print!(\"Press Enter to exit...\");\n    io::stdout().flush().unwrap();\n    let mut buffer = String::new();\n    io::stdin().read_line(&mut buffer).unwrap();\n    std::process::exit(exit_code);\n}\n\nfn main() {\n    // Set output encoding to UTF-8 (Rust strings are UTF-8 by default, console might need setup on Windows)\n    // On Windows, `chcp 65001` might be needed in the terminal before running for full UTF-8 display.\n    // The script itself cannot reliably change the parent console's encoding.\n\n    // Check administrator privileges\n    if !is_elevated() {\n        println!(\"{}\", \"[ERROR] Please run this script as administrator\".color(RED));\n        println!(\"Right-click the executable and select 'Run as administrator'\");\n        press_enter_to_exit(1);\n    }\n\n    // Display Logo\n    // Using simple print for now, can be enhanced\n    Command::new(\"cmd\").args(&[\"/c\", \"cls\"]).status().unwrap(); // Clear screen on Windows\n\n    println!(\"{}\", r#\"\n    ██████╗██╗   ██╗██████╗ ███████╗ ██████╗ ██████╗ \n   ██╔════╝██║   ██║██╔══██╗██╔════╝██╔═══██╗██╔══██╗\n   ██║     ██║   ██║██████╔╝███████╗██║   ██║██████╔╝\n   ██║     ██║   ██║██╔══██╗╚════██║██║   ██║██╔══██╗\n   ╚██████╗╚██████╔╝██║  ██║███████║╚██████╔╝██║  ██║\n    ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═╝  ╚═╝\n\n\"#.bright_cyan());\n    println!(\"{}\", \"================================\".color(BLUE));\n    println!(\"   {}\", \"Cursor Device ID Modifier Tool\".color(GREEN));\n    println!(\"  {}\", \"Cursor ID Reset Tool - Community Edition\".color(YELLOW));\n    println!(\"  {}\", \"Free tool for Cursor device ID management\".color(YELLOW));\n    println!(\"  {}\", \"[IMPORTANT] This is a free community tool\".color(YELLOW));\n    println!(\"{}\", \"================================\".color(BLUE));\n    println!(\"  {}\", \"QQ群: 951642519 (交流/下载纯免费自动账号切换工具)\".color(YELLOW));\n    println!(\"\");\n\n    // Get and display Cursor version\n    let cursor_version = get_cursor_version();\n    match &cursor_version {\n        Some(version) => println!(\"{} Current Cursor version: v{}\", \"[INFO]\".color(GREEN), version),\n        None => {\n            println!(\"{} Unable to detect Cursor version\", \"[WARNING]\".color(YELLOW));\n            println!(\"{} Please ensure Cursor is properly installed\", \"[TIP]\".color(YELLOW));\n        }\n    }\n    println!(\"\");\n\n    println!(\"{} Latest 0.45.x (supported)\", \"[IMPORTANT NOTE]\".color(YELLOW));\n    println!(\"\");\n\n    // Check and close Cursor processes\n    println!(\"{} Checking Cursor processes...\", \"[INFO]\".color(GREEN));\n    close_cursor_process(\"Cursor\");\n    close_cursor_process(\"cursor\");\n    println!(\"\");\n\n    let storage_file_path = match get_storage_file_path() {\n        Some(path) => path,\n        None => {\n            println!(\"{}\", \"[ERROR] Could not determine APPDATA path for storage file.\".color(RED));\n            press_enter_to_exit(1);\n            unreachable!(); // press_enter_to_exit exits\n        }\n    };\n    // println!(\"Storage file path: {:?}\", storage_file_path);\n\n    let backup_dir_path = match get_backup_dir_path() {\n        Some(path) => path,\n        None => {\n            println!(\"{}\", \"[ERROR] Could not determine APPDATA path for backup directory.\".color(RED));\n            press_enter_to_exit(1);\n            unreachable!();\n        }\n    };\n    // println!(\"Backup dir path: {:?}\", backup_dir_path);\n\n    // Create backup directory\n    if !backup_dir_path.exists() {\n        match fs::create_dir_all(&backup_dir_path) {\n            Ok(_) => println!(\"{} Created backup directory at {:?}\", \"[INFO]\".color(GREEN), backup_dir_path),\n            Err(e) => {\n                println!(\"{} Failed to create backup directory at {:?}: {}\", \"[ERROR]\".color(RED), backup_dir_path, e);\n                press_enter_to_exit(1);\n            }\n        }\n    }\n\n    // Backup existing configuration\n    if storage_file_path.exists() {\n        println!(\"{} Backing up configuration file...\", \"[INFO]\".color(GREEN));\n        let backup_name = format!(\"storage.json.backup_{}\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n        let backup_file_path = backup_dir_path.join(backup_name);\n        match fs::copy(&storage_file_path, &backup_file_path) {\n            Ok(_) => println!(\"{} Configuration backed up to {:?}\", \"[INFO]\".color(GREEN), backup_file_path),\n            Err(e) => {\n                println!(\"{} Failed to backup configuration file to {:?}: {}\", \"[ERROR]\".color(RED), backup_file_path, e);\n                // Decide if this is a fatal error or a warning\n            }\n        }\n    } else {\n        println!(\"{} No existing configuration file found at {:?} to back up.\", \"[INFO]\".color(GREEN), storage_file_path);\n    }\n    println!(\"\");\n\n    // Generate new IDs\n    println!(\"{} Generating new IDs...\", \"[INFO]\".color(GREEN));\n    let mac_machine_id = new_standard_machine_id();\n    let uuid_str = Uuid::new_v4().to_string();\n    let prefix_hex = \"auth0|user_\".as_bytes().iter().map(|b| format!(\"{:02x}\", b)).collect::<String>();\n    let random_part = get_random_hex(32);\n    let machine_id = format!(\"{}{}\", prefix_hex, random_part);\n    let sqm_id = format!(\"{{{}}}\", Uuid::new_v4().to_string().to_uppercase());\n\n    // println!(\"Generated MAC_MACHINE_ID: {}\", mac_machine_id);\n    // println!(\"Generated UUID_STR: {}\", uuid_str);\n    // println!(\"Generated MACHINE_ID: {}\", machine_id);\n    // println!(\"Generated SQM_ID: {}\", sqm_id);\n    // println!(\"\");\n\n    // Update MachineGuid in registry\n    let mut machine_guid_updated = false;\n    if cfg!(target_os = \"windows\") { // Only run on Windows\n        machine_guid_updated = update_machine_guid(&backup_dir_path);\n    } else {\n        println!(\"{} Skipping MachineGuid update (not on Windows)\", \"[INFO]\".color(YELLOW));\n    }\n\n    // Create or update configuration file\n    println!(\"{} Updating configuration...\", \"[INFO]\".color(GREEN));\n    let storage_update_successful = update_storage_file(\n        &storage_file_path,\n        &machine_id,\n        &mac_machine_id,\n        &uuid_str, // This was $UUID in PowerShell, which corresponds to devDeviceId\n        &sqm_id\n    );\n\n    if storage_update_successful {\n        println!(\"{} Configuration updated successfully.\", \"[INFO]\".color(GREEN));\n        // Display results\n        println!(\"\");\n        println!(\"{} Configuration updated details:\", \"[INFO]\".color(GREEN));\n        println!(\"{} machineId: {}\", \"[DEBUG]\".color(BLUE), machine_id);\n        println!(\"{} macMachineId: {}\", \"[DEBUG]\".color(BLUE), mac_machine_id);\n        println!(\"{} devDeviceId: {}\", \"[DEBUG]\".color(BLUE), uuid_str);\n        println!(\"{} sqmId: {}\", \"[DEBUG]\".color(BLUE), sqm_id);\n    } else {\n        println!(\"{} Main operation failed to update storage file.\", \"[ERROR]\".color(RED));\n        // The PS script has an alternative method here, which is complex.\n        // For now, we'll just indicate failure.\n        press_enter_to_exit(1);\n    }\n    println!(\"\");\n\n    // Display file tree structure\n    println!(\"{} File structure:\", \"[INFO]\".color(GREEN));\n    if let Some(user_dirs) = UserDirs::new() {\n        // %APPDATA%\\Cursor\\User is not directly available via UserDirs or BaseDirs in a cross-platform way for this specific structure.\n        // We'll construct it based on APPDATA which UserDirs doesn't directly give, BaseDirs::config_dir() is the closest.\n        if let Some(base_dirs) = BaseDirs::new() {\n             let app_data_dir_equivalent = base_dirs.config_dir(); // This is platform specific, e.g. %APPDATA% on Windows\n             println!(\"{}\", app_data_dir_equivalent.join(\"Cursor\").join(\"User\").display().to_string().color(BLUE));\n        }\n    } else {\n        println!(\"{} Could not determine APPDATA path for display.\", \"[WARNING]\".color(YELLOW));\n    }\n    println!(\"├── globalStorage\");\n    println!(\"│   ├── storage.json (modified)\");\n    println!(\"│   └── backups\");\n\n    // List backup files\n    match fs::read_dir(&backup_dir_path) {\n        Ok(entries) => {\n            let mut backup_files_found = false;\n            for entry in entries {\n                if let Ok(entry) = entry {\n                    if entry.path().is_file() {\n                        println!(\"│       └── {}\", entry.file_name().to_string_lossy());\n                        backup_files_found = true;\n                    }\n                }\n            }\n            if !backup_files_found {\n                println!(\"│       └── (empty)\");\n            }\n        }\n        Err(e) => {\n            println!(\"│       └── (Error reading backups: {})\", e);\n        }\n    }\n    println!(\"\");\n\n    // Display completion message\n    println!(\"{}\", \"================================\".color(GREEN));\n    println!(\"  {}\", \"Cursor ID Reset Tool - Community Edition\".color(YELLOW));\n    println!(\"{}\", \"================================\".color(GREEN));\n    println!(\"\");\n    println!(\"{} Please restart Cursor to apply new configuration\", \"[INFO]\".color(GREEN));\n    println!(\"\");\n\n    press_enter_to_exit(0);\n}\n\nfn get_random_hex(length: usize) -> String {\n    thread_rng()\n        .sample_iter(&Alphanumeric)\n        .take(length)\n        .map(char::from)\n        .collect::<String>()\n        .to_lowercase() // PowerShell version produces lowercase hex\n}\n\nfn new_standard_machine_id() -> String {\n    // Template: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\n    // y is one of 8, 9, a, b\n    let mut rng = thread_rng();\n    let mut id = String::with_capacity(36);\n    for (i, char_template) in \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".chars().enumerate() {\n        if char_template == '-' || char_template == '4' {\n            id.push(char_template);\n        } else if char_template == 'x' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(0..16)));\n        } else if char_template == 'y' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(8..12))); // 8, 9, a, b\n        }\n    }\n    id\n}\n\n#[derive(Deserialize)]\nstruct PackageJson {\n    version: String,\n}\n\n", "suffix_code": "\n\nfn close_cursor_process(process_name: &str) {\n    let mut sys = System::new_all();\n    sys.refresh_processes();\n\n    let processes_to_kill: Vec<_> = sys\n        .processes()\n        .values()\n        .filter(|p| p.name().eq_ignore_ascii_case(process_name))\n        .collect();\n\n    if !processes_to_kill.is_empty() {\n        println!(\"{} Found {} running\", \"[WARNING]\".color(YELLOW), process_name);\n        for p in &processes_to_kill {\n            println!(\"  PID: {}, Name: {}, Path: {:?}\", p.pid(), p.name(), p.exe());\n        }\n\n        println!(\"{} Attempting to close {}...\", \"[WARNING]\".color(YELLOW), process_name);\n        for p in processes_to_kill {\n            if !p.kill() { // kill() sends SIGKILL by default on Unix, TerminateProcess on Windows\n                println!(\"{} Failed to send termination signal to {} (PID: {}). Trying to wait...\", \"[ERROR]\".color(RED), process_name, p.pid());\n            }\n        }\n\n        let mut retry_count = 0;\n        loop {\n            sys.refresh_processes();\n            let still_running: Vec<_> = sys\n                .processes()\n                .values()\n                .filter(|p| p.name().eq_ignore_ascii_case(process_name))\n                .collect();\n\n            if still_running.is_empty() {\n                break;\n            }\n\n            retry_count += 1;\n            if retry_count >= MAX_RETRIES {\n                println!(\"{} Unable to close {} after {} attempts\", \"[ERROR]\".color(RED), process_name, MAX_RETRIES);\n                for p in still_running {\n                     println!(\"  Still running - PID: {}, Name: {}, Path: {:?}\", p.pid(), p.name(), p.exe());\n                }\n                println!(\"{} Please close the process manually and try again\", \"[ERROR]\".color(RED));\n                press_enter_to_exit(1);\n            }\n\n            println!(\"{} Waiting for process to close, attempt {}/{}...\", \"[WARNING]\".color(YELLOW), retry_count, MAX_RETRIES);\n            std::thread::sleep(std::time::Duration::from_secs(WAIT_TIME_SECONDS));\n        }\n        println!(\"{} {} successfully closed\", \"[INFO]\".color(GREEN), process_name);\n    }\n}\n\n#[cfg(target_os = \"windows\")]\nfn update_machine_guid(backup_dir: &Path) -> bool {\n    println!(\"{} Updating MachineGuid in registry...\", \"[INFO]\".color(GREEN));\n    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);\n    let reg_path = \"SOFTWARE\\\\Microsoft\\\\Cryptography\";\n    let reg_key_name = \"MachineGuid\";\n    let full_reg_key_path_for_export = \"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Cryptography\";\n\n    let crypto_key = match hklm.open_subkey_with_flags(reg_path, KEY_READ | KEY_WRITE) {\n        Ok(key) => key,\n        Err(e) => {\n            println!(\"{} Failed to open registry key '{}': {}. Ensure you have admin rights.\", \"[ERROR]\".color(RED), reg_path, e);\n            return false;\n        }\n    };\n\n    let current_guid_val: Result<String, _> = crypto_key.get_value(reg_key_name);\n    let original_guid = match current_guid_val {\n        Ok(guid) => {\n            println!(\"{} Current registry value:\", \"[INFO]\".color(GREEN));\n            println!(\"  {}\", full_reg_key_path_for_export);\n            println!(\"    {}    REG_SZ    {}\", reg_key_name, guid);\n            guid\n        }\n        Err(e) => {\n            println!(\"{} Unable to get current {}: {}. This might indicate a problem or the value might not exist.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            // Proceeding to set a new one if it doesn't exist, or fail if it's a permission issue.\n            String::new() // Or handle as a more critical error if needed.\n        }\n    };\n\n    if !backup_dir.exists() {\n        if let Err(e) = fs::create_dir_all(backup_dir) {\n            println!(\"{} Failed to create backup directory for registry backup: {}. Proceeding without registry backup.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n\n    let backup_file_name = format!(\"MachineGuid_{}.reg\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n    let backup_file_path = backup_dir.join(&backup_file_name);\n    let backup_command_str = format!(\"reg.exe export \\\"{}\\\" \\\"{}\\\" /y\", full_reg_key_path_for_export, backup_file_path.display());\n    \n    println!(\"{} Attempting to backup registry key to: {:?}\", \"[INFO]\".color(GREEN), backup_file_path);\n    match Command::new(\"cmd\").args(&[\"/C\", &backup_command_str]).status() {\n        Ok(status) if status.success() => {\n            println!(\"{} Registry key backed up successfully.\", \"[INFO]\".color(GREEN));\n        }\n        Ok(status) => {\n            println!(\"{} Registry backup command finished with status: {}. Check permissions or if reg.exe is available.\", \"[WARNING]\".color(YELLOW), status);\n        }\n        Err(e) => {\n            println!(\"{} Failed to execute registry backup command: {}. Proceeding with caution.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n\n    let new_guid = Uuid::new_v4().to_string();\n    match crypto_key.set_value(reg_key_name, &new_guid) {\n        Ok(_) => {\n            println!(\"{} Registry value {} set to: {}\", \"[INFO]\".color(GREEN), reg_key_name, new_guid);\n            // Verification\n            let verify_guid: Result<String, _> = crypto_key.get_value(reg_key_name);\n            match verify_guid {\n                Ok(val) if val == new_guid => {\n                    println!(\"{} Registry update verified successfully.\", \"[INFO]\".color(GREEN));\n                    println!(\"  {}\", full_reg_key_path_for_export);\n                    println!(\"    {}    REG_SZ    {}\", reg_key_name, new_guid);\n                    true\n                }\n                Ok(val) => {\n                    println!(\"{} Registry verification failed: Updated value ({}) does not match expected value ({}).\", \"[ERROR]\".color(RED), val, new_guid);\n                    // Attempt restore\n                    false // Placeholder for restore logic\n                }\n                Err(e) => {\n                    println!(\"{} Failed to verify registry update: {}.\", \"[ERROR]\".color(RED), e);\n                    false // Placeholder for restore logic\n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to set registry value {}: {}.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            // Attempt restore if original_guid was present and backup_file_path exists\n            if !original_guid.is_empty() && backup_file_path.exists() {\n                println!(\"{} Attempting to restore registry from backup: {:?}\", \"[YELLOW]\".color(YELLOW), backup_file_path);\n                let restore_command_str = format!(\"reg.exe import \\\"{}\\\"\", backup_file_path.display());\n                match Command::new(\"cmd\").args(&[\"/C\", &restore_command_str]).status() {\n                    Ok(status) if status.success() => println!(\"{} Registry restored successfully from backup.\", \"[INFO]\".color(GREEN)),\n                    Ok(status) => println!(\"{} Registry restore command failed with status: {}. Manual restore may be needed from {:?}\", \"[ERROR]\".color(RED), status, backup_file_path),\n                    Err(re) => println!(\"{} Failed to execute registry restore command: {}. Manual restore needed from {:?}\", \"[ERROR]\".color(RED), re, backup_file_path),\n                }\n            }\n            false\n        }\n    }\n}\n\nfn update_storage_file(\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {\n    if !storage_file_path.exists() {\n        println!(\"{} Configuration file not found: {:?}\", \"[ERROR]\".color(RED), storage_file_path);\n        println!(\"{} Please install and run Cursor once before using this script\", \"[TIP]\".color(YELLOW));\n        return false;\n    }\n\n    let original_content = match fs::read_to_string(storage_file_path) {\n        Ok(content) => content,\n        Err(e) => {\n            println!(\"{} Failed to read configuration file {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n            return false;\n        }\n    };\n\n    let mut config: Value = match serde_json::from_str(&original_content) {\n        Ok(json_value) => json_value,\n        Err(e) => {\n            println!(\"{} Failed to parse configuration file JSON: {}\", \"[ERROR]\".color(RED), e);\n            // Attempt to restore original content is not applicable here as we haven't written yet\n            return false;\n        }\n    };\n\n    // Ensure the path to telemetry values exists or create it\n    // serde_json::Value uses `pointer_mut` for this kind of access.\n    // Example: /telemetry/machineId\n    // We need to ensure `config[\"telemetry\"]` is an object.\n    if !config.get(\"telemetry\").map_or(false, |v| v.is_object()) {\n        if config.as_object_mut().is_some() { // Check if config itself is an object\n            config[\"telemetry\"] = serde_json::json!({});\n        } else {\n            println!(\"{} Configuration root is not a JSON object. Cannot set telemetry.\", \"[ERROR]\".color(RED));\n            return false;\n        }\n    }\n    \n    // Update specific values\n    // Using .get_mut(\"telemetry\") and then working with the resulting Option<&mut Value>\n    if let Some(telemetry) = config.get_mut(\"telemetry\") {\n        if let Some(telemetry_obj) = telemetry.as_object_mut() {\n            telemetry_obj.insert(\"machineId\".to_string(), Value::String(machine_id.to_string()));\n            telemetry_obj.insert(\"macMachineId\".to_string(), Value::String(mac_machine_id.to_string()));\n            telemetry_obj.insert(\"devDeviceId\".to_string(), Value::String(dev_device_id.to_string()));\n            telemetry_obj.insert(\"sqmId\".to_string(), Value::String(sqm_id.to_string()));\n        } else {\n            println!(\"{} 'telemetry' field is not an object.\", \"[ERROR]\".color(RED));\n            return false; // Or attempt to restore original_content\n        }\n    } else {\n        // This case should ideally be covered by the creation logic above.\n        println!(\"{} Failed to access or create 'telemetry' object.\", \"[ERROR]\".color(RED));\n        return false; // Or attempt to restore original_content\n    }\n    \n    match serde_json::to_string_pretty(&config) { // Using pretty for readability, PowerShell does compact\n        Ok(updated_json) => {\n            match fs::write(storage_file_path, updated_json.as_bytes()) { // .as_bytes() for UTF-8\n                Ok(_) => {\n                    println!(\"{} Configuration file updated successfully at {:?}\", \"[INFO]\".color(GREEN), storage_file_path);\n                    true\n                }\n                Err(e) => {\n                    println!(\"{} Failed to write updated configuration to {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n                    // Attempt to restore original content\n                    if fs::write(storage_file_path, original_content.as_bytes()).is_err() {\n                        println!(\"{} CRITICAL: Failed to restore original content to {:?} after write error.\", \"[ERROR]\".color(RED), storage_file_path);\n                    }\n                    false\n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to serialize updated configuration to JSON: {}\", \"[ERROR]\".color(RED), e);\n            // Attempt to restore original content if we had changed it in memory (not the case here with direct write path)\n            // No need to restore file if serialization failed before writing.\n            false\n        }\n    }\n}\n", "middle_code": "fn get_cursor_version() -> Option<String> {\n    if let Some(package_path) = get_cursor_package_path() {\n        if package_path.exists() {\n            match fs::read_to_string(&package_path) {\n                Ok(contents) => match serde_json::from_str::<PackageJson>(&contents) {\n                    Ok(json) => Some(json.version),\n                    Err(e) => {\n                        println!(\"{} Failed to parse package.json: {}\", \"[ERROR]\".color(RED), e);\n                        None\n                    }\n                },\n                Err(e) => {\n                    println!(\"{} Failed to read package.json at {:?}: {}\", \"[ERROR]\".color(RED), package_path, e);\n                    None\n                }\n            }\n        } else {\n            println!(\"{} package.json not found at {:?}\", \"[WARNING]\".color(YELLOW), package_path);\n            None\n        }\n    } else {\n        println!(\"{} Could not determine path to Cursor's package.json\", \"[WARNING]\".color(YELLOW));\n        None\n    }\n}", "code_description": null, "fill_type": "FUNCTION_TYPE", "language_type": "rust", "sub_task_type": null}, "context_code": [], "task_instance_info": {"created_time": "2025-08-21 01:31:56", "created_task_model": "DeepSeek-R1", "function_skeleton": "fn get_cursor_version () -> Option<String> {}", "code_description": "This code segment functions to: Retrieve and parse version information from a software configuration file while handling potential file access and data format errors during the extraction process."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```rust\n[TASK_BEGIN]\nfn get_cursor_version() -> Option<String> {\n    let package_path = get_cursor_package_path()?;\n    let package_content = fs::read_to_string(package_path).ok()?;\n    let package_json: PackageJson = serde_json::from_str(&package_content).ok()?;\n    Some(package_json.version)\n}\n[TASK_END]\n```", "inference_time": "2025-08-21 01-32-13"}, "editdistance_info": {"edit_distance": 14.0777, "calculate_time": "2025-08-21 01:32:13", "true_code_clean": "fn get_cursor_version() -> Option<String> {\n    if let Some(package_path) = get_cursor_package_path() {\n        if package_path.exists() {\n            match fs::read_to_string(&package_path) {\n                Ok(contents) => match serde_json::from_str::<PackageJson>(&contents) {\n                    Ok(json) => Some(json.version),\n                    Err(e) => {\n                        println!(\"{} Failed to parse package.json: {}\", \"[ERROR]\".color(RED), e);\n                        None\n                    }\n                },\n                Err(e) => {\n                    println!(\"{} Failed to read package.json at {:?}: {}\", \"[ERROR]\".color(RED), package_path, e);\n                    None\n                }\n            }\n        } else {\n            println!(\"{} package.json not found at {:?}\", \"[WARNING]\".color(YELLOW), package_path);\n            None\n        }\n    } else {\n        println!(\"{} Could not determine path to Cursor's package.json\", \"[WARNING]\".color(YELLOW));\n        None\n    }\n}", "predict_code_clean": "fn get_cursor_version() -> Option<String> {\n    let package_path = get_cursor_package_path()?;\n    let package_content = fs::read_to_string(package_path).ok()?;\n    let package_json: PackageJson = serde_json::from_str(&package_content).ok()?;\n    Some(package_json.version)\n}"}}
{"repo_name": "cursor-free-everyday", "file_name": "/cursor-free-everyday/reset_machine.rs", "inference_info": {"prefix_code": "use colored::*;\nuse directories::{BaseDirs, UserDirs};\nuse is_elevated::is_elevated;\nuse serde::{Deserialize, Serialize};\nuse serde_json::Value;\nuse std::collections::HashMap;\nuse std::env;\nuse std::fs;\nuse std::io::{self, Write};\nuse std::path::{Path, PathBuf};\nuse std::process::{Command, Stdio};\nuse sysinfo::{System};\nuse uuid::Uuid;\nuse winreg::enums::*;\nuse winreg::RegKey;\nuse chrono::Local;\nuse rand::{thread_rng, Rng, distributions::Alphanumeric};\n\n// Color definitions (approximated from PowerShell)\nconst RED: &str = \"red\";\nconst GREEN: &str = \"green\";\nconst YELLOW: &str = \"yellow\";\nconst BLUE: &str = \"blue\";\n// const NC: &str = \"clear\"; // `colored` crate handles reset implicitly or via `.normal()`\n\n// Max retries and wait time for process termination\nconst MAX_RETRIES: u32 = 5;\nconst WAIT_TIME_SECONDS: u64 = 1;\n\n// Configuration file paths\nfn get_storage_file_path() -> Option<PathBuf> {\n    if let Some(base_dirs) = BaseDirs::new() {\n        let app_data_dir = base_dirs.config_dir(); // Typically %APPDATA% or ~/.config\n        Some(app_data_dir.join(\"Cursor\").join(\"User\").join(\"globalStorage\").join(\"storage.json\"))\n    } else {\n        None\n    }\n}\n\nfn get_backup_dir_path() -> Option<PathBuf> {\n    if let Some(base_dirs) = BaseDirs::new() {\n        let app_data_dir = base_dirs.config_dir();\n        Some(app_data_dir.join(\"Cursor\").join(\"User\").join(\"globalStorage\").join(\"backups\"))\n    } else {\n        None\n    }\n}\n\nfn get_cursor_package_path() -> Option<PathBuf> {\n    if let Some(user_dirs) = BaseDirs::new() {\n        let local_app_data_dir = user_dirs.data_local_dir();\n        let primary_path = local_app_data_dir.join(\"Programs\").join(\"cursor\").join(\"resources\").join(\"app\").join(\"package.json\");\n        if primary_path.exists() {\n            return Some(primary_path);\n        }\n        let alt_path = local_app_data_dir.join(\"cursor\").join(\"resources\").join(\"app\").join(\"package.json\");\n        if alt_path.exists() {\n            return Some(alt_path);\n        }\n    }\n    None\n}\n\nfn get_cursor_updater_path() -> Option<PathBuf> {\n    if let Some(user_dirs) = BaseDirs::new() {\n        let local_app_data_dir = user_dirs.data_local_dir();\n        Some(local_app_data_dir.join(\"cursor-updater\"))\n    } else {\n        None\n    }\n}\n\n\nfn press_enter_to_exit(exit_code: i32) {\n    print!(\"Press Enter to exit...\");\n    io::stdout().flush().unwrap();\n    let mut buffer = String::new();\n    io::stdin().read_line(&mut buffer).unwrap();\n    std::process::exit(exit_code);\n}\n\nfn main() {\n    // Set output encoding to UTF-8 (Rust strings are UTF-8 by default, console might need setup on Windows)\n    // On Windows, `chcp 65001` might be needed in the terminal before running for full UTF-8 display.\n    // The script itself cannot reliably change the parent console's encoding.\n\n    // Check administrator privileges\n    if !is_elevated() {\n        println!(\"{}\", \"[ERROR] Please run this script as administrator\".color(RED));\n        println!(\"Right-click the executable and select 'Run as administrator'\");\n        press_enter_to_exit(1);\n    }\n\n    // Display Logo\n    // Using simple print for now, can be enhanced\n    Command::new(\"cmd\").args(&[\"/c\", \"cls\"]).status().unwrap(); // Clear screen on Windows\n\n    println!(\"{}\", r#\"\n    ██████╗██╗   ██╗██████╗ ███████╗ ██████╗ ██████╗ \n   ██╔════╝██║   ██║██╔══██╗██╔════╝██╔═══██╗██╔══██╗\n   ██║     ██║   ██║██████╔╝███████╗██║   ██║██████╔╝\n   ██║     ██║   ██║██╔══██╗╚════██║██║   ██║██╔══██╗\n   ╚██████╗╚██████╔╝██║  ██║███████║╚██████╔╝██║  ██║\n    ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═╝  ╚═╝\n\n\"#.bright_cyan());\n    println!(\"{}\", \"================================\".color(BLUE));\n    println!(\"   {}\", \"Cursor Device ID Modifier Tool\".color(GREEN));\n    println!(\"  {}\", \"Cursor ID Reset Tool - Community Edition\".color(YELLOW));\n    println!(\"  {}\", \"Free tool for Cursor device ID management\".color(YELLOW));\n    println!(\"  {}\", \"[IMPORTANT] This is a free community tool\".color(YELLOW));\n    println!(\"{}\", \"================================\".color(BLUE));\n    println!(\"  {}\", \"QQ群: 951642519 (交流/下载纯免费自动账号切换工具)\".color(YELLOW));\n    println!(\"\");\n\n    // Get and display Cursor version\n    let cursor_version = get_cursor_version();\n    match &cursor_version {\n        Some(version) => println!(\"{} Current Cursor version: v{}\", \"[INFO]\".color(GREEN), version),\n        None => {\n            println!(\"{} Unable to detect Cursor version\", \"[WARNING]\".color(YELLOW));\n            println!(\"{} Please ensure Cursor is properly installed\", \"[TIP]\".color(YELLOW));\n        }\n    }\n    println!(\"\");\n\n    println!(\"{} Latest 0.45.x (supported)\", \"[IMPORTANT NOTE]\".color(YELLOW));\n    println!(\"\");\n\n    // Check and close Cursor processes\n    println!(\"{} Checking Cursor processes...\", \"[INFO]\".color(GREEN));\n    close_cursor_process(\"Cursor\");\n    close_cursor_process(\"cursor\");\n    println!(\"\");\n\n    let storage_file_path = match get_storage_file_path() {\n        Some(path) => path,\n        None => {\n            println!(\"{}\", \"[ERROR] Could not determine APPDATA path for storage file.\".color(RED));\n            press_enter_to_exit(1);\n            unreachable!(); // press_enter_to_exit exits\n        }\n    };\n    // println!(\"Storage file path: {:?}\", storage_file_path);\n\n    let backup_dir_path = match get_backup_dir_path() {\n        Some(path) => path,\n        None => {\n            println!(\"{}\", \"[ERROR] Could not determine APPDATA path for backup directory.\".color(RED));\n            press_enter_to_exit(1);\n            unreachable!();\n        }\n    };\n    // println!(\"Backup dir path: {:?}\", backup_dir_path);\n\n    // Create backup directory\n    if !backup_dir_path.exists() {\n        match fs::create_dir_all(&backup_dir_path) {\n            Ok(_) => println!(\"{} Created backup directory at {:?}\", \"[INFO]\".color(GREEN), backup_dir_path),\n            Err(e) => {\n                println!(\"{} Failed to create backup directory at {:?}: {}\", \"[ERROR]\".color(RED), backup_dir_path, e);\n                press_enter_to_exit(1);\n            }\n        }\n    }\n\n    // Backup existing configuration\n    if storage_file_path.exists() {\n        println!(\"{} Backing up configuration file...\", \"[INFO]\".color(GREEN));\n        let backup_name = format!(\"storage.json.backup_{}\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n        let backup_file_path = backup_dir_path.join(backup_name);\n        match fs::copy(&storage_file_path, &backup_file_path) {\n            Ok(_) => println!(\"{} Configuration backed up to {:?}\", \"[INFO]\".color(GREEN), backup_file_path),\n            Err(e) => {\n                println!(\"{} Failed to backup configuration file to {:?}: {}\", \"[ERROR]\".color(RED), backup_file_path, e);\n                // Decide if this is a fatal error or a warning\n            }\n        }\n    } else {\n        println!(\"{} No existing configuration file found at {:?} to back up.\", \"[INFO]\".color(GREEN), storage_file_path);\n    }\n    println!(\"\");\n\n    // Generate new IDs\n    println!(\"{} Generating new IDs...\", \"[INFO]\".color(GREEN));\n    let mac_machine_id = new_standard_machine_id();\n    let uuid_str = Uuid::new_v4().to_string();\n    let prefix_hex = \"auth0|user_\".as_bytes().iter().map(|b| format!(\"{:02x}\", b)).collect::<String>();\n    let random_part = get_random_hex(32);\n    let machine_id = format!(\"{}{}\", prefix_hex, random_part);\n    let sqm_id = format!(\"{{{}}}\", Uuid::new_v4().to_string().to_uppercase());\n\n    // println!(\"Generated MAC_MACHINE_ID: {}\", mac_machine_id);\n    // println!(\"Generated UUID_STR: {}\", uuid_str);\n    // println!(\"Generated MACHINE_ID: {}\", machine_id);\n    // println!(\"Generated SQM_ID: {}\", sqm_id);\n    // println!(\"\");\n\n    // Update MachineGuid in registry\n    let mut machine_guid_updated = false;\n    if cfg!(target_os = \"windows\") { // Only run on Windows\n        machine_guid_updated = update_machine_guid(&backup_dir_path);\n    } else {\n        println!(\"{} Skipping MachineGuid update (not on Windows)\", \"[INFO]\".color(YELLOW));\n    }\n\n    // Create or update configuration file\n    println!(\"{} Updating configuration...\", \"[INFO]\".color(GREEN));\n    let storage_update_successful = update_storage_file(\n        &storage_file_path,\n        &machine_id,\n        &mac_machine_id,\n        &uuid_str, // This was $UUID in PowerShell, which corresponds to devDeviceId\n        &sqm_id\n    );\n\n    if storage_update_successful {\n        println!(\"{} Configuration updated successfully.\", \"[INFO]\".color(GREEN));\n        // Display results\n        println!(\"\");\n        println!(\"{} Configuration updated details:\", \"[INFO]\".color(GREEN));\n        println!(\"{} machineId: {}\", \"[DEBUG]\".color(BLUE), machine_id);\n        println!(\"{} macMachineId: {}\", \"[DEBUG]\".color(BLUE), mac_machine_id);\n        println!(\"{} devDeviceId: {}\", \"[DEBUG]\".color(BLUE), uuid_str);\n        println!(\"{} sqmId: {}\", \"[DEBUG]\".color(BLUE), sqm_id);\n    } else {\n        println!(\"{} Main operation failed to update storage file.\", \"[ERROR]\".color(RED));\n        // The PS script has an alternative method here, which is complex.\n        // For now, we'll just indicate failure.\n        press_enter_to_exit(1);\n    }\n    println!(\"\");\n\n    // Display file tree structure\n    println!(\"{} File structure:\", \"[INFO]\".color(GREEN));\n    if let Some(user_dirs) = UserDirs::new() {\n        // %APPDATA%\\Cursor\\User is not directly available via UserDirs or BaseDirs in a cross-platform way for this specific structure.\n        // We'll construct it based on APPDATA which UserDirs doesn't directly give, BaseDirs::config_dir() is the closest.\n        if let Some(base_dirs) = BaseDirs::new() {\n             let app_data_dir_equivalent = base_dirs.config_dir(); // This is platform specific, e.g. %APPDATA% on Windows\n             println!(\"{}\", app_data_dir_equivalent.join(\"Cursor\").join(\"User\").display().to_string().color(BLUE));\n        }\n    } else {\n        println!(\"{} Could not determine APPDATA path for display.\", \"[WARNING]\".color(YELLOW));\n    }\n    println!(\"├── globalStorage\");\n    println!(\"│   ├── storage.json (modified)\");\n    println!(\"│   └── backups\");\n\n    // List backup files\n    match fs::read_dir(&backup_dir_path) {\n        Ok(entries) => {\n            let mut backup_files_found = false;\n            for entry in entries {\n                if let Ok(entry) = entry {\n                    if entry.path().is_file() {\n                        println!(\"│       └── {}\", entry.file_name().to_string_lossy());\n                        backup_files_found = true;\n                    }\n                }\n            }\n            if !backup_files_found {\n                println!(\"│       └── (empty)\");\n            }\n        }\n        Err(e) => {\n            println!(\"│       └── (Error reading backups: {})\", e);\n        }\n    }\n    println!(\"\");\n\n    // Display completion message\n    println!(\"{}\", \"================================\".color(GREEN));\n    println!(\"  {}\", \"Cursor ID Reset Tool - Community Edition\".color(YELLOW));\n    println!(\"{}\", \"================================\".color(GREEN));\n    println!(\"\");\n    println!(\"{} Please restart Cursor to apply new configuration\", \"[INFO]\".color(GREEN));\n    println!(\"\");\n\n    press_enter_to_exit(0);\n}\n\nfn get_random_hex(length: usize) -> String {\n    thread_rng()\n        .sample_iter(&Alphanumeric)\n        .take(length)\n        .map(char::from)\n        .collect::<String>()\n        .to_lowercase() // PowerShell version produces lowercase hex\n}\n\nfn new_standard_machine_id() -> String {\n    // Template: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\n    // y is one of 8, 9, a, b\n    let mut rng = thread_rng();\n    let mut id = String::with_capacity(36);\n    for (i, char_template) in \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".chars().enumerate() {\n        if char_template == '-' || char_template == '4' {\n            id.push(char_template);\n        } else if char_template == 'x' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(0..16)));\n        } else if char_template == 'y' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(8..12))); // 8, 9, a, b\n        }\n    }\n    id\n}\n\n#[derive(Deserialize)]\nstruct PackageJson {\n    version: String,\n}\n\nfn get_cursor_version() -> Option<String> {\n    if let Some(package_path) = get_cursor_package_path() {\n        if package_path.exists() {\n            match fs::read_to_string(&package_path) {\n                Ok(contents) => match serde_json::from_str::<PackageJson>(&contents) {\n                    Ok(json) => Some(json.version),\n                    Err(e) => {\n                        println!(\"{} Failed to parse package.json: {}\", \"[ERROR]\".color(RED), e);\n                        None\n                    }\n                },\n                Err(e) => {\n                    println!(\"{} Failed to read package.json at {:?}: {}\", \"[ERROR]\".color(RED), package_path, e);\n                    None\n                }\n            }\n        } else {\n            println!(\"{} package.json not found at {:?}\", \"[WARNING]\".color(YELLOW), package_path);\n            None\n        }\n    } else {\n        println!(\"{} Could not determine path to Cursor's package.json\", \"[WARNING]\".color(YELLOW));\n        None\n    }\n}\n\nfn close_cursor_process(process_name: &str) {\n    let mut sys = System::new_all();\n    sys.refresh_processes();\n\n    let processes_to_kill: Vec<_> = sys\n        .processes()\n        .values()\n        .filter(|p| p.name().eq_ignore_ascii_case(process_name))\n        .collect();\n\n    if !processes_to_kill.is_empty() {\n        println!(\"{} Found {} running\", \"[WARNING]\".color(YELLOW), process_name);\n        for p in &processes_to_kill {\n            println!(\"  PID: {}, Name: {}, Path: {:?}\", p.pid(), p.name(), p.exe());\n        }\n\n        println!(\"{} Attempting to close {}...\", \"[WARNING]\".color(YELLOW), process_name);\n        for p in processes_to_kill {\n            if !p.kill() { // kill() sends SIGKILL by default on Unix, TerminateProcess on Windows\n                println!(\"{} Failed to send termination signal to {} (PID: {}). Trying to wait...\", \"[ERROR]\".color(RED), process_name, p.pid());\n            }\n        }\n\n        let mut retry_count = 0;\n        loop {\n            sys.refresh_processes();\n            let still_running: Vec<_> = sys\n                .processes()\n                .values()\n                .filter(|p| p.name().eq_ignore_ascii_case(process_name))\n                .collect();\n\n            if still_running.is_empty() {\n                break;\n            }\n\n            retry_count += 1;\n            if retry_count >= MAX_RETRIES {\n                println!(\"{} Unable to close {} after {} attempts\", \"[ERROR]\".color(RED), process_name, MAX_RETRIES);\n                for p in still_running {\n                     println!(\"  Still running - PID: {}, Name: {}, Path: {:?}\", p.pid(), p.name(), p.exe());\n                }\n                println!(\"{} Please close the process manually and try again\", \"[ERROR]\".color(RED));\n                press_enter_to_exit(1);\n            }\n\n            println!(\"{} Waiting for process to close, attempt {}/{}...\", \"[WARNING]\".color(YELLOW), retry_count, MAX_RETRIES);\n            std::thread::sleep(std::time::Duration::from_secs(WAIT_TIME_SECONDS));\n        }\n        println!(\"{} {} successfully closed\", \"[INFO]\".color(GREEN), process_name);\n    }\n}\n\n#[cfg(target_os = \"windows\")]\n", "suffix_code": "\n\nfn update_storage_file(\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {\n    if !storage_file_path.exists() {\n        println!(\"{} Configuration file not found: {:?}\", \"[ERROR]\".color(RED), storage_file_path);\n        println!(\"{} Please install and run Cursor once before using this script\", \"[TIP]\".color(YELLOW));\n        return false;\n    }\n\n    let original_content = match fs::read_to_string(storage_file_path) {\n        Ok(content) => content,\n        Err(e) => {\n            println!(\"{} Failed to read configuration file {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n            return false;\n        }\n    };\n\n    let mut config: Value = match serde_json::from_str(&original_content) {\n        Ok(json_value) => json_value,\n        Err(e) => {\n            println!(\"{} Failed to parse configuration file JSON: {}\", \"[ERROR]\".color(RED), e);\n            // Attempt to restore original content is not applicable here as we haven't written yet\n            return false;\n        }\n    };\n\n    // Ensure the path to telemetry values exists or create it\n    // serde_json::Value uses `pointer_mut` for this kind of access.\n    // Example: /telemetry/machineId\n    // We need to ensure `config[\"telemetry\"]` is an object.\n    if !config.get(\"telemetry\").map_or(false, |v| v.is_object()) {\n        if config.as_object_mut().is_some() { // Check if config itself is an object\n            config[\"telemetry\"] = serde_json::json!({});\n        } else {\n            println!(\"{} Configuration root is not a JSON object. Cannot set telemetry.\", \"[ERROR]\".color(RED));\n            return false;\n        }\n    }\n    \n    // Update specific values\n    // Using .get_mut(\"telemetry\") and then working with the resulting Option<&mut Value>\n    if let Some(telemetry) = config.get_mut(\"telemetry\") {\n        if let Some(telemetry_obj) = telemetry.as_object_mut() {\n            telemetry_obj.insert(\"machineId\".to_string(), Value::String(machine_id.to_string()));\n            telemetry_obj.insert(\"macMachineId\".to_string(), Value::String(mac_machine_id.to_string()));\n            telemetry_obj.insert(\"devDeviceId\".to_string(), Value::String(dev_device_id.to_string()));\n            telemetry_obj.insert(\"sqmId\".to_string(), Value::String(sqm_id.to_string()));\n        } else {\n            println!(\"{} 'telemetry' field is not an object.\", \"[ERROR]\".color(RED));\n            return false; // Or attempt to restore original_content\n        }\n    } else {\n        // This case should ideally be covered by the creation logic above.\n        println!(\"{} Failed to access or create 'telemetry' object.\", \"[ERROR]\".color(RED));\n        return false; // Or attempt to restore original_content\n    }\n    \n    match serde_json::to_string_pretty(&config) { // Using pretty for readability, PowerShell does compact\n        Ok(updated_json) => {\n            match fs::write(storage_file_path, updated_json.as_bytes()) { // .as_bytes() for UTF-8\n                Ok(_) => {\n                    println!(\"{} Configuration file updated successfully at {:?}\", \"[INFO]\".color(GREEN), storage_file_path);\n                    true\n                }\n                Err(e) => {\n                    println!(\"{} Failed to write updated configuration to {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n                    // Attempt to restore original content\n                    if fs::write(storage_file_path, original_content.as_bytes()).is_err() {\n                        println!(\"{} CRITICAL: Failed to restore original content to {:?} after write error.\", \"[ERROR]\".color(RED), storage_file_path);\n                    }\n                    false\n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to serialize updated configuration to JSON: {}\", \"[ERROR]\".color(RED), e);\n            // Attempt to restore original content if we had changed it in memory (not the case here with direct write path)\n            // No need to restore file if serialization failed before writing.\n            false\n        }\n    }\n}\n", "middle_code": "fn update_machine_guid(backup_dir: &Path) -> bool {\n    println!(\"{} Updating MachineGuid in registry...\", \"[INFO]\".color(GREEN));\n    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);\n    let reg_path = \"SOFTWARE\\\\Microsoft\\\\Cryptography\";\n    let reg_key_name = \"MachineGuid\";\n    let full_reg_key_path_for_export = \"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Cryptography\";\n    let crypto_key = match hklm.open_subkey_with_flags(reg_path, KEY_READ | KEY_WRITE) {\n        Ok(key) => key,\n        Err(e) => {\n            println!(\"{} Failed to open registry key '{}': {}. Ensure you have admin rights.\", \"[ERROR]\".color(RED), reg_path, e);\n            return false;\n        }\n    };\n    let current_guid_val: Result<String, _> = crypto_key.get_value(reg_key_name);\n    let original_guid = match current_guid_val {\n        Ok(guid) => {\n            println!(\"{} Current registry value:\", \"[INFO]\".color(GREEN));\n            println!(\"  {}\", full_reg_key_path_for_export);\n            println!(\"    {}    REG_SZ    {}\", reg_key_name, guid);\n            guid\n        }\n        Err(e) => {\n            println!(\"{} Unable to get current {}: {}. This might indicate a problem or the value might not exist.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            String::new() \n        }\n    };\n    if !backup_dir.exists() {\n        if let Err(e) = fs::create_dir_all(backup_dir) {\n            println!(\"{} Failed to create backup directory for registry backup: {}. Proceeding without registry backup.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n    let backup_file_name = format!(\"MachineGuid_{}.reg\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n    let backup_file_path = backup_dir.join(&backup_file_name);\n    let backup_command_str = format!(\"reg.exe export \\\"{}\\\" \\\"{}\\\" /y\", full_reg_key_path_for_export, backup_file_path.display());\n    println!(\"{} Attempting to backup registry key to: {:?}\", \"[INFO]\".color(GREEN), backup_file_path);\n    match Command::new(\"cmd\").args(&[\"/C\", &backup_command_str]).status() {\n        Ok(status) if status.success() => {\n            println!(\"{} Registry key backed up successfully.\", \"[INFO]\".color(GREEN));\n        }\n        Ok(status) => {\n            println!(\"{} Registry backup command finished with status: {}. Check permissions or if reg.exe is available.\", \"[WARNING]\".color(YELLOW), status);\n        }\n        Err(e) => {\n            println!(\"{} Failed to execute registry backup command: {}. Proceeding with caution.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n    let new_guid = Uuid::new_v4().to_string();\n    match crypto_key.set_value(reg_key_name, &new_guid) {\n        Ok(_) => {\n            println!(\"{} Registry value {} set to: {}\", \"[INFO]\".color(GREEN), reg_key_name, new_guid);\n            let verify_guid: Result<String, _> = crypto_key.get_value(reg_key_name);\n            match verify_guid {\n                Ok(val) if val == new_guid => {\n                    println!(\"{} Registry update verified successfully.\", \"[INFO]\".color(GREEN));\n                    println!(\"  {}\", full_reg_key_path_for_export);\n                    println!(\"    {}    REG_SZ    {}\", reg_key_name, new_guid);\n                    true\n                }\n                Ok(val) => {\n                    println!(\"{} Registry verification failed: Updated value ({}) does not match expected value ({}).\", \"[ERROR]\".color(RED), val, new_guid);\n                    false \n                }\n                Err(e) => {\n                    println!(\"{} Failed to verify registry update: {}.\", \"[ERROR]\".color(RED), e);\n                    false \n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to set registry value {}: {}.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            if !original_guid.is_empty() && backup_file_path.exists() {\n                println!(\"{} Attempting to restore registry from backup: {:?}\", \"[YELLOW]\".color(YELLOW), backup_file_path);\n                let restore_command_str = format!(\"reg.exe import \\\"{}\\\"\", backup_file_path.display());\n                match Command::new(\"cmd\").args(&[\"/C\", &restore_command_str]).status() {\n                    Ok(status) if status.success() => println!(\"{} Registry restored successfully from backup.\", \"[INFO]\".color(GREEN)),\n                    Ok(status) => println!(\"{} Registry restore command failed with status: {}. Manual restore may be needed from {:?}\", \"[ERROR]\".color(RED), status, backup_file_path),\n                    Err(re) => println!(\"{} Failed to execute registry restore command: {}. Manual restore needed from {:?}\", \"[ERROR]\".color(RED), re, backup_file_path),\n                }\n            }\n            false\n        }\n    }\n}", "code_description": null, "fill_type": "FUNCTION_TYPE", "language_type": "rust", "sub_task_type": null}, "context_code": [], "task_instance_info": {"created_time": "2025-08-21 01:31:56", "created_task_model": "DeepSeek-R1", "function_skeleton": "fn update_machine_guid (backup_dir: &Path) -> bool {}", "code_description": "This code segment functions to: Modify system-level configuration settings by generating and applying new unique identifiers while creating backups of original values and verifying successful implementation of changes."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```rust\n[TASK_BEGIN]\n#[cfg(target_os = \"windows\")]\nfn update_machine_guid(backup_dir: &Path) -> bool {\n    use winreg::enums::*;\n    use winreg::RegKey;\n    use std::fs;\n    use chrono::Local;\n\n    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);\n    let subkey = \"SOFTWARE\\\\Microsoft\\\\Cryptography\";\n    \n    // Open registry key with read/write access\n    let key = match hklm.open_subkey_with_flags(subkey, KEY_READ | KEY_WRITE) {\n        Ok(k) => k,\n        Err(e) => {\n            println!(\"{} Failed to open registry key: {}\", \"[ERROR]\".color(RED), e);\n            return false;\n        }\n    };\n\n    // Read current MachineGuid\n    let current_guid: String = match key.get_value(\"MachineGuid\") {\n        Ok(v) => v,\n        Err(e) => {\n            println!(\"{} Failed to read MachineGuid: {}\", \"[ERROR]\".color(RED), e);\n            return false;\n        }\n    };\n\n    // Create backup file\n    let backup_filename = format!(\"MachineGuid_backup_{}.reg\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n    let backup_path = backup_dir.join(backup_filename);\n    \n    if let Err(e) = fs::write(&backup_path, format!(\"Windows Registry Editor Version 5.00\\n\\n[HKEY_LOCAL_MACHINE\\\\{}\\\\Microsoft\\\\Cryptography]\\n\\\"MachineGuid\\\"=\\\"{}\\\"\", subkey, current_guid)) {\n        println!(\"{} Failed to create backup file: {}\", \"[ERROR]\".color(RED), e);\n        return false;\n    }\n    println!(\"{} Backup created: {:?}\", \"[INFO]\".color(GREEN), backup_path);\n\n    // Generate new GUID (32 chars uppercase without hyphens)\n    let new_guid = Uuid::new_v4().to_string().to_uppercase().replace(\"-\", \"\");\n\n    // Write new value to registry\n    match key.set_value(\"MachineGuid\", &new_guid) {\n        Ok(_) => {\n            println!(\"{} MachineGuid updated successfully\", \"[INFO]\".color(GREEN));\n            println!(\"{} Old value: {}\", \"[DEBUG]\".color(BLUE), current_guid);\n            println!(\"{} New value: {}\", \"[DEBUG]\".color(BLUE), new_guid);\n            true\n        }\n        Err(e) => {\n            println!(\"{} Failed to update MachineGuid: {}\", \"[ERROR]\".color(RED), e);\n            false\n        }\n    }\n}\n[TASK_END]", "inference_time": "2025-08-21 01-32-33"}, "editdistance_info": {"edit_distance": 25.8621, "calculate_time": "2025-08-21 01:32:33", "true_code_clean": "fn update_machine_guid(backup_dir: &Path) -> bool {\n    println!(\"{} Updating MachineGuid in registry...\", \"[INFO]\".color(GREEN));\n    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);\n    let reg_path = \"SOFTWARE\\\\Microsoft\\\\Cryptography\";\n    let reg_key_name = \"MachineGuid\";\n    let full_reg_key_path_for_export = \"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Cryptography\";\n    let crypto_key = match hklm.open_subkey_with_flags(reg_path, KEY_READ | KEY_WRITE) {\n        Ok(key) => key,\n        Err(e) => {\n            println!(\"{} Failed to open registry key '{}': {}. Ensure you have admin rights.\", \"[ERROR]\".color(RED), reg_path, e);\n            return false;\n        }\n    };\n    let current_guid_val: Result<String, _> = crypto_key.get_value(reg_key_name);\n    let original_guid = match current_guid_val {\n        Ok(guid) => {\n            println!(\"{} Current registry value:\", \"[INFO]\".color(GREEN));\n            println!(\"  {}\", full_reg_key_path_for_export);\n            println!(\"    {}    REG_SZ    {}\", reg_key_name, guid);\n            guid\n        }\n        Err(e) => {\n            println!(\"{} Unable to get current {}: {}. This might indicate a problem or the value might not exist.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            String::new() \n        }\n    };\n    if !backup_dir.exists() {\n        if let Err(e) = fs::create_dir_all(backup_dir) {\n            println!(\"{} Failed to create backup directory for registry backup: {}. Proceeding without registry backup.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n    let backup_file_name = format!(\"MachineGuid_{}.reg\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n    let backup_file_path = backup_dir.join(&backup_file_name);\n    let backup_command_str = format!(\"reg.exe export \\\"{}\\\" \\\"{}\\\" /y\", full_reg_key_path_for_export, backup_file_path.display());\n    println!(\"{} Attempting to backup registry key to: {:?}\", \"[INFO]\".color(GREEN), backup_file_path);\n    match Command::new(\"cmd\").args(&[\"/C\", &backup_command_str]).status() {\n        Ok(status) if status.success() => {\n            println!(\"{} Registry key backed up successfully.\", \"[INFO]\".color(GREEN));\n        }\n        Ok(status) => {\n            println!(\"{} Registry backup command finished with status: {}. Check permissions or if reg.exe is available.\", \"[WARNING]\".color(YELLOW), status);\n        }\n        Err(e) => {\n            println!(\"{} Failed to execute registry backup command: {}. Proceeding with caution.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n    let new_guid = Uuid::new_v4().to_string();\n    match crypto_key.set_value(reg_key_name, &new_guid) {\n        Ok(_) => {\n            println!(\"{} Registry value {} set to: {}\", \"[INFO]\".color(GREEN), reg_key_name, new_guid);\n            let verify_guid: Result<String, _> = crypto_key.get_value(reg_key_name);\n            match verify_guid {\n                Ok(val) if val == new_guid => {\n                    println!(\"{} Registry update verified successfully.\", \"[INFO]\".color(GREEN));\n                    println!(\"  {}\", full_reg_key_path_for_export);\n                    println!(\"    {}    REG_SZ    {}\", reg_key_name, new_guid);\n                    true\n                }\n                Ok(val) => {\n                    println!(\"{} Registry verification failed: Updated value ({}) does not match expected value ({}).\", \"[ERROR]\".color(RED), val, new_guid);\n                    false \n                }\n                Err(e) => {\n                    println!(\"{} Failed to verify registry update: {}.\", \"[ERROR]\".color(RED), e);\n                    false \n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to set registry value {}: {}.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            if !original_guid.is_empty() && backup_file_path.exists() {\n                println!(\"{} Attempting to restore registry from backup: {:?}\", \"[YELLOW]\".color(YELLOW), backup_file_path);\n                let restore_command_str = format!(\"reg.exe import \\\"{}\\\"\", backup_file_path.display());\n                match Command::new(\"cmd\").args(&[\"/C\", &restore_command_str]).status() {\n                    Ok(status) if status.success() => println!(\"{} Registry restored successfully from backup.\", \"[INFO]\".color(GREEN)),\n                    Ok(status) => println!(\"{} Registry restore command failed with status: {}. Manual restore may be needed from {:?}\", \"[ERROR]\".color(RED), status, backup_file_path),\n                    Err(re) => println!(\"{} Failed to execute registry restore command: {}. Manual restore needed from {:?}\", \"[ERROR]\".color(RED), re, backup_file_path),\n                }\n            }\n            false\n        }\n    }\n}", "predict_code_clean": "#[cfg(target_os = \"windows\")]\nfn update_machine_guid(backup_dir: &Path) -> bool {\n    use winreg::enums::*;\n    use winreg::RegKey;\n    use std::fs;\n    use chrono::Local;\n    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);\n    let subkey = \"SOFTWARE\\\\Microsoft\\\\Cryptography\";\n    let key = match hklm.open_subkey_with_flags(subkey, KEY_READ | KEY_WRITE) {\n        Ok(k) => k,\n        Err(e) => {\n            println!(\"{} Failed to open registry key: {}\", \"[ERROR]\".color(RED), e);\n            return false;\n        }\n    };\n    let current_guid: String = match key.get_value(\"MachineGuid\") {\n        Ok(v) => v,\n        Err(e) => {\n            println!(\"{} Failed to read MachineGuid: {}\", \"[ERROR]\".color(RED), e);\n            return false;\n        }\n    };\n    let backup_filename = format!(\"MachineGuid_backup_{}.reg\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n    let backup_path = backup_dir.join(backup_filename);\n    if let Err(e) = fs::write(&backup_path, format!(\"Windows Registry Editor Version 5.00\\n\\n[HKEY_LOCAL_MACHINE\\\\{}\\\\Microsoft\\\\Cryptography]\\n\\\"MachineGuid\\\"=\\\"{}\\\"\", subkey, current_guid)) {\n        println!(\"{} Failed to create backup file: {}\", \"[ERROR]\".color(RED), e);\n        return false;\n    }\n    println!(\"{} Backup created: {:?}\", \"[INFO]\".color(GREEN), backup_path);\n    let new_guid = Uuid::new_v4().to_string().to_uppercase().replace(\"-\", \"\");\n    match key.set_value(\"MachineGuid\", &new_guid) {\n        Ok(_) => {\n            println!(\"{} MachineGuid updated successfully\", \"[INFO]\".color(GREEN));\n            println!(\"{} Old value: {}\", \"[DEBUG]\".color(BLUE), current_guid);\n            println!(\"{} New value: {}\", \"[DEBUG]\".color(BLUE), new_guid);\n            true\n        }\n        Err(e) => {\n            println!(\"{} Failed to update MachineGuid: {}\", \"[ERROR]\".color(RED), e);\n            false\n        }\n    }\n}"}}
{"repo_name": "cursor-free-everyday", "file_name": "/cursor-free-everyday/reset_machine.rs", "inference_info": {"prefix_code": "use colored::*;\nuse directories::{BaseDirs, UserDirs};\nuse is_elevated::is_elevated;\nuse serde::{Deserialize, Serialize};\nuse serde_json::Value;\nuse std::collections::HashMap;\nuse std::env;\nuse std::fs;\nuse std::io::{self, Write};\nuse std::path::{Path, PathBuf};\nuse std::process::{Command, Stdio};\nuse sysinfo::{System};\nuse uuid::Uuid;\nuse winreg::enums::*;\nuse winreg::RegKey;\nuse chrono::Local;\nuse rand::{thread_rng, Rng, distributions::Alphanumeric};\n\n// Color definitions (approximated from PowerShell)\nconst RED: &str = \"red\";\nconst GREEN: &str = \"green\";\nconst YELLOW: &str = \"yellow\";\nconst BLUE: &str = \"blue\";\n// const NC: &str = \"clear\"; // `colored` crate handles reset implicitly or via `.normal()`\n\n// Max retries and wait time for process termination\nconst MAX_RETRIES: u32 = 5;\nconst WAIT_TIME_SECONDS: u64 = 1;\n\n// Configuration file paths\nfn get_storage_file_path() -> Option<PathBuf> {\n    if let Some(base_dirs) = BaseDirs::new() {\n        let app_data_dir = base_dirs.config_dir(); // Typically %APPDATA% or ~/.config\n        Some(app_data_dir.join(\"Cursor\").join(\"User\").join(\"globalStorage\").join(\"storage.json\"))\n    } else {\n        None\n    }\n}\n\nfn get_backup_dir_path() -> Option<PathBuf> {\n    if let Some(base_dirs) = BaseDirs::new() {\n        let app_data_dir = base_dirs.config_dir();\n        Some(app_data_dir.join(\"Cursor\").join(\"User\").join(\"globalStorage\").join(\"backups\"))\n    } else {\n        None\n    }\n}\n\nfn get_cursor_package_path() -> Option<PathBuf> {\n    if let Some(user_dirs) = BaseDirs::new() {\n        let local_app_data_dir = user_dirs.data_local_dir();\n        let primary_path = local_app_data_dir.join(\"Programs\").join(\"cursor\").join(\"resources\").join(\"app\").join(\"package.json\");\n        if primary_path.exists() {\n            return Some(primary_path);\n        }\n        let alt_path = local_app_data_dir.join(\"cursor\").join(\"resources\").join(\"app\").join(\"package.json\");\n        if alt_path.exists() {\n            return Some(alt_path);\n        }\n    }\n    None\n}\n\nfn get_cursor_updater_path() -> Option<PathBuf> {\n    if let Some(user_dirs) = BaseDirs::new() {\n        let local_app_data_dir = user_dirs.data_local_dir();\n        Some(local_app_data_dir.join(\"cursor-updater\"))\n    } else {\n        None\n    }\n}\n\n\nfn press_enter_to_exit(exit_code: i32) {\n    print!(\"Press Enter to exit...\");\n    io::stdout().flush().unwrap();\n    let mut buffer = String::new();\n    io::stdin().read_line(&mut buffer).unwrap();\n    std::process::exit(exit_code);\n}\n\nfn main() {\n    // Set output encoding to UTF-8 (Rust strings are UTF-8 by default, console might need setup on Windows)\n    // On Windows, `chcp 65001` might be needed in the terminal before running for full UTF-8 display.\n    // The script itself cannot reliably change the parent console's encoding.\n\n    // Check administrator privileges\n    if !is_elevated() {\n        println!(\"{}\", \"[ERROR] Please run this script as administrator\".color(RED));\n        println!(\"Right-click the executable and select 'Run as administrator'\");\n        press_enter_to_exit(1);\n    }\n\n    // Display Logo\n    // Using simple print for now, can be enhanced\n    Command::new(\"cmd\").args(&[\"/c\", \"cls\"]).status().unwrap(); // Clear screen on Windows\n\n    println!(\"{}\", r#\"\n    ██████╗██╗   ██╗██████╗ ███████╗ ██████╗ ██████╗ \n   ██╔════╝██║   ██║██╔══██╗██╔════╝██╔═══██╗██╔══██╗\n   ██║     ██║   ██║██████╔╝███████╗██║   ██║██████╔╝\n   ██║     ██║   ██║██╔══██╗╚════██║██║   ██║██╔══██╗\n   ╚██████╗╚██████╔╝██║  ██║███████║╚██████╔╝██║  ██║\n    ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═╝  ╚═╝\n\n\"#.bright_cyan());\n    println!(\"{}\", \"================================\".color(BLUE));\n    println!(\"   {}\", \"Cursor Device ID Modifier Tool\".color(GREEN));\n    println!(\"  {}\", \"Cursor ID Reset Tool - Community Edition\".color(YELLOW));\n    println!(\"  {}\", \"Free tool for Cursor device ID management\".color(YELLOW));\n    println!(\"  {}\", \"[IMPORTANT] This is a free community tool\".color(YELLOW));\n    println!(\"{}\", \"================================\".color(BLUE));\n    println!(\"  {}\", \"QQ群: 951642519 (交流/下载纯免费自动账号切换工具)\".color(YELLOW));\n    println!(\"\");\n\n    // Get and display Cursor version\n    let cursor_version = get_cursor_version();\n    match &cursor_version {\n        Some(version) => println!(\"{} Current Cursor version: v{}\", \"[INFO]\".color(GREEN), version),\n        None => {\n            println!(\"{} Unable to detect Cursor version\", \"[WARNING]\".color(YELLOW));\n            println!(\"{} Please ensure Cursor is properly installed\", \"[TIP]\".color(YELLOW));\n        }\n    }\n    println!(\"\");\n\n    println!(\"{} Latest 0.45.x (supported)\", \"[IMPORTANT NOTE]\".color(YELLOW));\n    println!(\"\");\n\n    // Check and close Cursor processes\n    println!(\"{} Checking Cursor processes...\", \"[INFO]\".color(GREEN));\n    close_cursor_process(\"Cursor\");\n    close_cursor_process(\"cursor\");\n    println!(\"\");\n\n    let storage_file_path = match get_storage_file_path() {\n        Some(path) => path,\n        None => {\n            println!(\"{}\", \"[ERROR] Could not determine APPDATA path for storage file.\".color(RED));\n            press_enter_to_exit(1);\n            unreachable!(); // press_enter_to_exit exits\n        }\n    };\n    // println!(\"Storage file path: {:?}\", storage_file_path);\n\n    let backup_dir_path = match get_backup_dir_path() {\n        Some(path) => path,\n        None => {\n            println!(\"{}\", \"[ERROR] Could not determine APPDATA path for backup directory.\".color(RED));\n            press_enter_to_exit(1);\n            unreachable!();\n        }\n    };\n    // println!(\"Backup dir path: {:?}\", backup_dir_path);\n\n    // Create backup directory\n    if !backup_dir_path.exists() {\n        match fs::create_dir_all(&backup_dir_path) {\n            Ok(_) => println!(\"{} Created backup directory at {:?}\", \"[INFO]\".color(GREEN), backup_dir_path),\n            Err(e) => {\n                println!(\"{} Failed to create backup directory at {:?}: {}\", \"[ERROR]\".color(RED), backup_dir_path, e);\n                press_enter_to_exit(1);\n            }\n        }\n    }\n\n    // Backup existing configuration\n    if storage_file_path.exists() {\n        println!(\"{} Backing up configuration file...\", \"[INFO]\".color(GREEN));\n        let backup_name = format!(\"storage.json.backup_{}\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n        let backup_file_path = backup_dir_path.join(backup_name);\n        match fs::copy(&storage_file_path, &backup_file_path) {\n            Ok(_) => println!(\"{} Configuration backed up to {:?}\", \"[INFO]\".color(GREEN), backup_file_path),\n            Err(e) => {\n                println!(\"{} Failed to backup configuration file to {:?}: {}\", \"[ERROR]\".color(RED), backup_file_path, e);\n                // Decide if this is a fatal error or a warning\n            }\n        }\n    } else {\n        println!(\"{} No existing configuration file found at {:?} to back up.\", \"[INFO]\".color(GREEN), storage_file_path);\n    }\n    println!(\"\");\n\n    // Generate new IDs\n    println!(\"{} Generating new IDs...\", \"[INFO]\".color(GREEN));\n    let mac_machine_id = new_standard_machine_id();\n    let uuid_str = Uuid::new_v4().to_string();\n    let prefix_hex = \"auth0|user_\".as_bytes().iter().map(|b| format!(\"{:02x}\", b)).collect::<String>();\n    let random_part = get_random_hex(32);\n    let machine_id = format!(\"{}{}\", prefix_hex, random_part);\n    let sqm_id = format!(\"{{{}}}\", Uuid::new_v4().to_string().to_uppercase());\n\n    // println!(\"Generated MAC_MACHINE_ID: {}\", mac_machine_id);\n    // println!(\"Generated UUID_STR: {}\", uuid_str);\n    // println!(\"Generated MACHINE_ID: {}\", machine_id);\n    // println!(\"Generated SQM_ID: {}\", sqm_id);\n    // println!(\"\");\n\n    // Update MachineGuid in registry\n    let mut machine_guid_updated = false;\n    if cfg!(target_os = \"windows\") { // Only run on Windows\n        machine_guid_updated = update_machine_guid(&backup_dir_path);\n    } else {\n        println!(\"{} Skipping MachineGuid update (not on Windows)\", \"[INFO]\".color(YELLOW));\n    }\n\n    // Create or update configuration file\n    println!(\"{} Updating configuration...\", \"[INFO]\".color(GREEN));\n    let storage_update_successful = update_storage_file(\n        &storage_file_path,\n        &machine_id,\n        &mac_machine_id,\n        &uuid_str, // This was $UUID in PowerShell, which corresponds to devDeviceId\n        &sqm_id\n    );\n\n    if storage_update_successful {\n        println!(\"{} Configuration updated successfully.\", \"[INFO]\".color(GREEN));\n        // Display results\n        println!(\"\");\n        println!(\"{} Configuration updated details:\", \"[INFO]\".color(GREEN));\n        println!(\"{} machineId: {}\", \"[DEBUG]\".color(BLUE), machine_id);\n        println!(\"{} macMachineId: {}\", \"[DEBUG]\".color(BLUE), mac_machine_id);\n        println!(\"{} devDeviceId: {}\", \"[DEBUG]\".color(BLUE), uuid_str);\n        println!(\"{} sqmId: {}\", \"[DEBUG]\".color(BLUE), sqm_id);\n    } else {\n        println!(\"{} Main operation failed to update storage file.\", \"[ERROR]\".color(RED));\n        // The PS script has an alternative method here, which is complex.\n        // For now, we'll just indicate failure.\n        press_enter_to_exit(1);\n    }\n    println!(\"\");\n\n    // Display file tree structure\n    println!(\"{} File structure:\", \"[INFO]\".color(GREEN));\n    if let Some(user_dirs) = UserDirs::new() {\n        // %APPDATA%\\Cursor\\User is not directly available via UserDirs or BaseDirs in a cross-platform way for this specific structure.\n        // We'll construct it based on APPDATA which UserDirs doesn't directly give, BaseDirs::config_dir() is the closest.\n        if let Some(base_dirs) = BaseDirs::new() {\n             let app_data_dir_equivalent = base_dirs.config_dir(); // This is platform specific, e.g. %APPDATA% on Windows\n             println!(\"{}\", app_data_dir_equivalent.join(\"Cursor\").join(\"User\").display().to_string().color(BLUE));\n        }\n    } else {\n        println!(\"{} Could not determine APPDATA path for display.\", \"[WARNING]\".color(YELLOW));\n    }\n    println!(\"├── globalStorage\");\n    println!(\"│   ├── storage.json (modified)\");\n    println!(\"│   └── backups\");\n\n    // List backup files\n    match fs::read_dir(&backup_dir_path) {\n        Ok(entries) => {\n            let mut backup_files_found = false;\n            for entry in entries {\n                if let Ok(entry) = entry {\n                    if entry.path().is_file() {\n                        println!(\"│       └── {}\", entry.file_name().to_string_lossy());\n                        backup_files_found = true;\n                    }\n                }\n            }\n            if !backup_files_found {\n                println!(\"│       └── (empty)\");\n            }\n        }\n        Err(e) => {\n            println!(\"│       └── (Error reading backups: {})\", e);\n        }\n    }\n    println!(\"\");\n\n    // Display completion message\n    println!(\"{}\", \"================================\".color(GREEN));\n    println!(\"  {}\", \"Cursor ID Reset Tool - Community Edition\".color(YELLOW));\n    println!(\"{}\", \"================================\".color(GREEN));\n    println!(\"\");\n    println!(\"{} Please restart Cursor to apply new configuration\", \"[INFO]\".color(GREEN));\n    println!(\"\");\n\n    press_enter_to_exit(0);\n}\n\nfn get_random_hex(length: usize) -> String {\n    thread_rng()\n        .sample_iter(&Alphanumeric)\n        .take(length)\n        .map(char::from)\n        .collect::<String>()\n        .to_lowercase() // PowerShell version produces lowercase hex\n}\n\nfn new_standard_machine_id() -> String {\n    // Template: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\n    // y is one of 8, 9, a, b\n    let mut rng = thread_rng();\n    let mut id = String::with_capacity(36);\n    for (i, char_template) in \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".chars().enumerate() {\n        if char_template == '-' || char_template == '4' {\n            id.push(char_template);\n        } else if char_template == 'x' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(0..16)));\n        } else if char_template == 'y' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(8..12))); // 8, 9, a, b\n        }\n    }\n    id\n}\n\n#[derive(Deserialize)]\nstruct PackageJson {\n    version: String,\n}\n\nfn get_cursor_version() -> Option<String> {\n    if let Some(package_path) = get_cursor_package_path() {\n        if package_path.exists() {\n            match fs::read_to_string(&package_path) {\n                Ok(contents) => match serde_json::from_str::<PackageJson>(&contents) {\n                    Ok(json) => Some(json.version),\n                    Err(e) => {\n                        println!(\"{} Failed to parse package.json: {}\", \"[ERROR]\".color(RED), e);\n                        None\n                    }\n                },\n                Err(e) => {\n                    println!(\"{} Failed to read package.json at {:?}: {}\", \"[ERROR]\".color(RED), package_path, e);\n                    None\n                }\n            }\n        } else {\n            println!(\"{} package.json not found at {:?}\", \"[WARNING]\".color(YELLOW), package_path);\n            None\n        }\n    } else {\n        println!(\"{} Could not determine path to Cursor's package.json\", \"[WARNING]\".color(YELLOW));\n        None\n    }\n}\n\nfn close_cursor_process(process_name: &str) {\n    let mut sys = System::new_all();\n    sys.refresh_processes();\n\n    let processes_to_kill: Vec<_> = sys\n        .processes()\n        .values()\n        .filter(|p| p.name().eq_ignore_ascii_case(process_name))\n        .collect();\n\n    if !processes_to_kill.is_empty() {\n        println!(\"{} Found {} running\", \"[WARNING]\".color(YELLOW), process_name);\n        for p in &processes_to_kill {\n            println!(\"  PID: {}, Name: {}, Path: {:?}\", p.pid(), p.name(), p.exe());\n        }\n\n        println!(\"{} Attempting to close {}...\", \"[WARNING]\".color(YELLOW), process_name);\n        for p in processes_to_kill {\n            if !p.kill() { // kill() sends SIGKILL by default on Unix, TerminateProcess on Windows\n                println!(\"{} Failed to send termination signal to {} (PID: {}). Trying to wait...\", \"[ERROR]\".color(RED), process_name, p.pid());\n            }\n        }\n\n        let mut retry_count = 0;\n        loop {\n            sys.refresh_processes();\n            let still_running: Vec<_> = sys\n                .processes()\n                .values()\n                .filter(|p| p.name().eq_ignore_ascii_case(process_name))\n                .collect();\n\n            if still_running.is_empty() {\n                break;\n            }\n\n            retry_count += 1;\n            if retry_count >= MAX_RETRIES {\n                println!(\"{} Unable to close {} after {} attempts\", \"[ERROR]\".color(RED), process_name, MAX_RETRIES);\n                for p in still_running {\n                     println!(\"  Still running - PID: {}, Name: {}, Path: {:?}\", p.pid(), p.name(), p.exe());\n                }\n                println!(\"{} Please close the process manually and try again\", \"[ERROR]\".color(RED));\n                press_enter_to_exit(1);\n            }\n\n            println!(\"{} Waiting for process to close, attempt {}/{}...\", \"[WARNING]\".color(YELLOW), retry_count, MAX_RETRIES);\n            std::thread::sleep(std::time::Duration::from_secs(WAIT_TIME_SECONDS));\n        }\n        println!(\"{} {} successfully closed\", \"[INFO]\".color(GREEN), process_name);\n    }\n}\n\n#[cfg(target_os = \"windows\")]\nfn update_machine_guid(backup_dir: &Path) -> bool {\n    println!(\"{} Updating MachineGuid in registry...\", \"[INFO]\".color(GREEN));\n    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);\n    let reg_path = \"SOFTWARE\\\\Microsoft\\\\Cryptography\";\n    let reg_key_name = \"MachineGuid\";\n    let full_reg_key_path_for_export = \"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Cryptography\";\n\n    let crypto_key = match hklm.open_subkey_with_flags(reg_path, KEY_READ | KEY_WRITE) {\n        Ok(key) => key,\n        Err(e) => {\n            println!(\"{} Failed to open registry key '{}': {}. Ensure you have admin rights.\", \"[ERROR]\".color(RED), reg_path, e);\n            return false;\n        }\n    };\n\n    let current_guid_val: Result<String, _> = crypto_key.get_value(reg_key_name);\n    let original_guid = match current_guid_val {\n        Ok(guid) => {\n            println!(\"{} Current registry value:\", \"[INFO]\".color(GREEN));\n            println!(\"  {}\", full_reg_key_path_for_export);\n            println!(\"    {}    REG_SZ    {}\", reg_key_name, guid);\n            guid\n        }\n        Err(e) => {\n            println!(\"{} Unable to get current {}: {}. This might indicate a problem or the value might not exist.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            // Proceeding to set a new one if it doesn't exist, or fail if it's a permission issue.\n            String::new() // Or handle as a more critical error if needed.\n        }\n    };\n\n    if !backup_dir.exists() {\n        if let Err(e) = fs::create_dir_all(backup_dir) {\n            println!(\"{} Failed to create backup directory for registry backup: {}. Proceeding without registry backup.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n\n    let backup_file_name = format!(\"MachineGuid_{}.reg\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n    let backup_file_path = backup_dir.join(&backup_file_name);\n    let backup_command_str = format!(\"reg.exe export \\\"{}\\\" \\\"{}\\\" /y\", full_reg_key_path_for_export, backup_file_path.display());\n    \n    println!(\"{} Attempting to backup registry key to: {:?}\", \"[INFO]\".color(GREEN), backup_file_path);\n    match Command::new(\"cmd\").args(&[\"/C\", &backup_command_str]).status() {\n        Ok(status) if status.success() => {\n            println!(\"{} Registry key backed up successfully.\", \"[INFO]\".color(GREEN));\n        }\n        Ok(status) => {\n            println!(\"{} Registry backup command finished with status: {}. Check permissions or if reg.exe is available.\", \"[WARNING]\".color(YELLOW), status);\n        }\n        Err(e) => {\n            println!(\"{} Failed to execute registry backup command: {}. Proceeding with caution.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n\n    let new_guid = Uuid::new_v4().to_string();\n    match crypto_key.set_value(reg_key_name, &new_guid) {\n        Ok(_) => {\n            println!(\"{} Registry value {} set to: {}\", \"[INFO]\".color(GREEN), reg_key_name, new_guid);\n            // Verification\n            let verify_guid: Result<String, _> = crypto_key.get_value(reg_key_name);\n            match verify_guid {\n                Ok(val) if val == new_guid => {\n                    println!(\"{} Registry update verified successfully.\", \"[INFO]\".color(GREEN));\n                    println!(\"  {}\", full_reg_key_path_for_export);\n                    println!(\"    {}    REG_SZ    {}\", reg_key_name, new_guid);\n                    true\n                }\n                Ok(val) => {\n                    println!(\"{} Registry verification failed: Updated value ({}) does not match expected value ({}).\", \"[ERROR]\".color(RED), val, new_guid);\n                    // Attempt restore\n                    false // Placeholder for restore logic\n                }\n                Err(e) => {\n                    println!(\"{} Failed to verify registry update: {}.\", \"[ERROR]\".color(RED), e);\n                    false // Placeholder for restore logic\n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to set registry value {}: {}.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            // Attempt restore if original_guid was present and backup_file_path exists\n            if !original_guid.is_empty() && backup_file_path.exists() {\n                println!(\"{} Attempting to restore registry from backup: {:?}\", \"[YELLOW]\".color(YELLOW), backup_file_path);\n                let restore_command_str = format!(\"reg.exe import \\\"{}\\\"\", backup_file_path.display());\n                match Command::new(\"cmd\").args(&[\"/C\", &restore_command_str]).status() {\n                    Ok(status) if status.success() => println!(\"{} Registry restored successfully from backup.\", \"[INFO]\".color(GREEN)),\n                    Ok(status) => println!(\"{} Registry restore command failed with status: {}. Manual restore may be needed from {:?}\", \"[ERROR]\".color(RED), status, backup_file_path),\n                    Err(re) => println!(\"{} Failed to execute registry restore command: {}. Manual restore needed from {:?}\", \"[ERROR]\".color(RED), re, backup_file_path),\n                }\n            }\n            false\n        }\n    }\n}\n\n", "suffix_code": "\n", "middle_code": "fn update_storage_file(\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {\n    if !storage_file_path.exists() {\n        println!(\"{} Configuration file not found: {:?}\", \"[ERROR]\".color(RED), storage_file_path);\n        println!(\"{} Please install and run Cursor once before using this script\", \"[TIP]\".color(YELLOW));\n        return false;\n    }\n    let original_content = match fs::read_to_string(storage_file_path) {\n        Ok(content) => content,\n        Err(e) => {\n            println!(\"{} Failed to read configuration file {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n            return false;\n        }\n    };\n    let mut config: Value = match serde_json::from_str(&original_content) {\n        Ok(json_value) => json_value,\n        Err(e) => {\n            println!(\"{} Failed to parse configuration file JSON: {}\", \"[ERROR]\".color(RED), e);\n            return false;\n        }\n    };\n    if !config.get(\"telemetry\").map_or(false, |v| v.is_object()) {\n        if config.as_object_mut().is_some() { \n            config[\"telemetry\"] = serde_json::json!({});\n        } else {\n            println!(\"{} Configuration root is not a JSON object. Cannot set telemetry.\", \"[ERROR]\".color(RED));\n            return false;\n        }\n    }\n    if let Some(telemetry) = config.get_mut(\"telemetry\") {\n        if let Some(telemetry_obj) = telemetry.as_object_mut() {\n            telemetry_obj.insert(\"machineId\".to_string(), Value::String(machine_id.to_string()));\n            telemetry_obj.insert(\"macMachineId\".to_string(), Value::String(mac_machine_id.to_string()));\n            telemetry_obj.insert(\"devDeviceId\".to_string(), Value::String(dev_device_id.to_string()));\n            telemetry_obj.insert(\"sqmId\".to_string(), Value::String(sqm_id.to_string()));\n        } else {\n            println!(\"{} 'telemetry' field is not an object.\", \"[ERROR]\".color(RED));\n            return false; \n        }\n    } else {\n        println!(\"{} Failed to access or create 'telemetry' object.\", \"[ERROR]\".color(RED));\n        return false; \n    }\n    match serde_json::to_string_pretty(&config) { \n        Ok(updated_json) => {\n            match fs::write(storage_file_path, updated_json.as_bytes()) { \n                Ok(_) => {\n                    println!(\"{} Configuration file updated successfully at {:?}\", \"[INFO]\".color(GREEN), storage_file_path);\n                    true\n                }\n                Err(e) => {\n                    println!(\"{} Failed to write updated configuration to {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n                    if fs::write(storage_file_path, original_content.as_bytes()).is_err() {\n                        println!(\"{} CRITICAL: Failed to restore original content to {:?} after write error.\", \"[ERROR]\".color(RED), storage_file_path);\n                    }\n                    false\n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to serialize updated configuration to JSON: {}\", \"[ERROR]\".color(RED), e);\n            false\n        }\n    }\n}", "code_description": null, "fill_type": "FUNCTION_TYPE", "language_type": "rust", "sub_task_type": null}, "context_code": [], "task_instance_info": {"created_time": "2025-08-21 01:31:56", "created_task_model": "DeepSeek-R1", "function_skeleton": "fn update_storage_file (\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {}", "code_description": "This code segment functions to: Modify configuration data by updating telemetry-related identifiers in a structured data file and ensure integrity through error handling and backup restoration mechanisms."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```rust\n[TASK_BEGIN]\nfn update_storage_file(\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {\n    // Read existing data or create new empty object\n    let mut data: Value = if storage_file_path.exists() {\n        match fs::read_to_string(storage_file_path) {\n            Ok(contents) => match serde_json::from_str(&contents) {\n                Ok(v) => v,\n                Err(e) => {\n                    println!(\"{} Failed to parse storage.json: {}\", \"[ERROR]\".color(RED), e);\n                    return false;\n                }\n            },\n            Err(e) => {\n                println!(\"{} Failed to read storage.json: {}\", \"[ERROR]\".color(RED), e);\n                return false;\n            }\n        }\n    } else {\n        serde_json::json!({})\n    };\n\n    // Update values in JSON structure\n    if let Some(obj) = data.as_object_mut() {\n        obj.insert(\"machineId\".to_string(), Value::String(machine_id.to_string()));\n        obj.insert(\"macMachineId\".to_string(), Value::String(mac_machine_id.to_string()));\n        obj.insert(\"devDeviceId\".to_string(), Value::String(dev_device_id.to_string()));\n        obj.insert(\"sqmId\".to_string(), Value::String(sqm_id.to_string()));\n    } else {\n        println!(\"{} Existing storage.json has invalid format\", \"[ERROR]\".color(RED));\n        return false;\n    }\n\n    // Write updated data back to file\n    match fs::write(\n        storage_file_path,\n        serde_json::to_string_pretty(&data).expect(\"Should serialize valid JSON\")\n    ) {\n        Ok(_) => true,\n        Err(e) => {\n            println!(\"{} Failed to write storage.json: {}\", \"[ERROR]\".color(RED), e);\n            false\n        }\n    }\n}\n[TASK_END]\n```", "inference_time": "2025-08-21 01-32-37"}, "editdistance_info": {"edit_distance": 38.1974, "calculate_time": "2025-08-21 01:32:37", "true_code_clean": "fn update_storage_file(\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {\n    if !storage_file_path.exists() {\n        println!(\"{} Configuration file not found: {:?}\", \"[ERROR]\".color(RED), storage_file_path);\n        println!(\"{} Please install and run Cursor once before using this script\", \"[TIP]\".color(YELLOW));\n        return false;\n    }\n    let original_content = match fs::read_to_string(storage_file_path) {\n        Ok(content) => content,\n        Err(e) => {\n            println!(\"{} Failed to read configuration file {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n            return false;\n        }\n    };\n    let mut config: Value = match serde_json::from_str(&original_content) {\n        Ok(json_value) => json_value,\n        Err(e) => {\n            println!(\"{} Failed to parse configuration file JSON: {}\", \"[ERROR]\".color(RED), e);\n            return false;\n        }\n    };\n    if !config.get(\"telemetry\").map_or(false, |v| v.is_object()) {\n        if config.as_object_mut().is_some() { \n            config[\"telemetry\"] = serde_json::json!({});\n        } else {\n            println!(\"{} Configuration root is not a JSON object. Cannot set telemetry.\", \"[ERROR]\".color(RED));\n            return false;\n        }\n    }\n    if let Some(telemetry) = config.get_mut(\"telemetry\") {\n        if let Some(telemetry_obj) = telemetry.as_object_mut() {\n            telemetry_obj.insert(\"machineId\".to_string(), Value::String(machine_id.to_string()));\n            telemetry_obj.insert(\"macMachineId\".to_string(), Value::String(mac_machine_id.to_string()));\n            telemetry_obj.insert(\"devDeviceId\".to_string(), Value::String(dev_device_id.to_string()));\n            telemetry_obj.insert(\"sqmId\".to_string(), Value::String(sqm_id.to_string()));\n        } else {\n            println!(\"{} 'telemetry' field is not an object.\", \"[ERROR]\".color(RED));\n            return false; \n        }\n    } else {\n        println!(\"{} Failed to access or create 'telemetry' object.\", \"[ERROR]\".color(RED));\n        return false; \n    }\n    match serde_json::to_string_pretty(&config) { \n        Ok(updated_json) => {\n            match fs::write(storage_file_path, updated_json.as_bytes()) { \n                Ok(_) => {\n                    println!(\"{} Configuration file updated successfully at {:?}\", \"[INFO]\".color(GREEN), storage_file_path);\n                    true\n                }\n                Err(e) => {\n                    println!(\"{} Failed to write updated configuration to {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n                    if fs::write(storage_file_path, original_content.as_bytes()).is_err() {\n                        println!(\"{} CRITICAL: Failed to restore original content to {:?} after write error.\", \"[ERROR]\".color(RED), storage_file_path);\n                    }\n                    false\n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to serialize updated configuration to JSON: {}\", \"[ERROR]\".color(RED), e);\n            false\n        }\n    }\n}", "predict_code_clean": "fn update_storage_file(\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {\n    let mut data: Value = if storage_file_path.exists() {\n        match fs::read_to_string(storage_file_path) {\n            Ok(contents) => match serde_json::from_str(&contents) {\n                Ok(v) => v,\n                Err(e) => {\n                    println!(\"{} Failed to parse storage.json: {}\", \"[ERROR]\".color(RED), e);\n                    return false;\n                }\n            },\n            Err(e) => {\n                println!(\"{} Failed to read storage.json: {}\", \"[ERROR]\".color(RED), e);\n                return false;\n            }\n        }\n    } else {\n        serde_json::json!({})\n    };\n    if let Some(obj) = data.as_object_mut() {\n        obj.insert(\"machineId\".to_string(), Value::String(machine_id.to_string()));\n        obj.insert(\"macMachineId\".to_string(), Value::String(mac_machine_id.to_string()));\n        obj.insert(\"devDeviceId\".to_string(), Value::String(dev_device_id.to_string()));\n        obj.insert(\"sqmId\".to_string(), Value::String(sqm_id.to_string()));\n    } else {\n        println!(\"{} Existing storage.json has invalid format\", \"[ERROR]\".color(RED));\n        return false;\n    }\n    match fs::write(\n        storage_file_path,\n        serde_json::to_string_pretty(&data).expect(\"Should serialize valid JSON\")\n    ) {\n        Ok(_) => true,\n        Err(e) => {\n            println!(\"{} Failed to write storage.json: {}\", \"[ERROR]\".color(RED), e);\n            false\n        }\n    }\n}"}}
{"repo_name": "cursor-free-everyday", "file_name": "/cursor-free-everyday/reset_machine.rs", "inference_info": {"prefix_code": "use colored::*;\nuse directories::{BaseDirs, UserDirs};\nuse is_elevated::is_elevated;\nuse serde::{Deserialize, Serialize};\nuse serde_json::Value;\nuse std::collections::HashMap;\nuse std::env;\nuse std::fs;\nuse std::io::{self, Write};\nuse std::path::{Path, PathBuf};\nuse std::process::{Command, Stdio};\nuse sysinfo::{System};\nuse uuid::Uuid;\nuse winreg::enums::*;\nuse winreg::RegKey;\nuse chrono::Local;\nuse rand::{thread_rng, Rng, distributions::Alphanumeric};\n\n// Color definitions (approximated from PowerShell)\nconst RED: &str = \"red\";\nconst GREEN: &str = \"green\";\nconst YELLOW: &str = \"yellow\";\nconst BLUE: &str = \"blue\";\n// const NC: &str = \"clear\"; // `colored` crate handles reset implicitly or via `.normal()`\n\n// Max retries and wait time for process termination\nconst MAX_RETRIES: u32 = 5;\nconst WAIT_TIME_SECONDS: u64 = 1;\n\n// Configuration file paths\nfn get_storage_file_path() -> Option<PathBuf> {\n    if let Some(base_dirs) = BaseDirs::new() {\n        let app_data_dir = base_dirs.config_dir(); // Typically %APPDATA% or ~/.config\n        Some(app_data_dir.join(\"Cursor\").join(\"User\").join(\"globalStorage\").join(\"storage.json\"))\n    } else {\n        None\n    }\n}\n\nfn get_backup_dir_path() -> Option<PathBuf> {\n    if let Some(base_dirs) = BaseDirs::new() {\n        let app_data_dir = base_dirs.config_dir();\n        Some(app_data_dir.join(\"Cursor\").join(\"User\").join(\"globalStorage\").join(\"backups\"))\n    } else {\n        None\n    }\n}\n\nfn get_cursor_package_path() -> Option<PathBuf> {\n    if let Some(user_dirs) = BaseDirs::new() {\n        let local_app_data_dir = user_dirs.data_local_dir();\n        let primary_path = local_app_data_dir.join(\"Programs\").join(\"cursor\").join(\"resources\").join(\"app\").join(\"package.json\");\n        if primary_path.exists() {\n            return Some(primary_path);\n        }\n        let alt_path = local_app_data_dir.join(\"cursor\").join(\"resources\").join(\"app\").join(\"package.json\");\n        if alt_path.exists() {\n            return Some(alt_path);\n        }\n    }\n    None\n}\n\nfn get_cursor_updater_path() -> Option<PathBuf> {\n    if let Some(user_dirs) = BaseDirs::new() {\n        let local_app_data_dir = user_dirs.data_local_dir();\n        Some(local_app_data_dir.join(\"cursor-updater\"))\n    } else {\n        None\n    }\n}\n\n\nfn press_enter_to_exit(exit_code: i32) {\n    print!(\"Press Enter to exit...\");\n    io::stdout().flush().unwrap();\n    let mut buffer = String::new();\n    io::stdin().read_line(&mut buffer).unwrap();\n    std::process::exit(exit_code);\n}\n\nfn main() {\n    // Set output encoding to UTF-8 (Rust strings are UTF-8 by default, console might need setup on Windows)\n    // On Windows, `chcp 65001` might be needed in the terminal before running for full UTF-8 display.\n    // The script itself cannot reliably change the parent console's encoding.\n\n    // Check administrator privileges\n    if !is_elevated() {\n        println!(\"{}\", \"[ERROR] Please run this script as administrator\".color(RED));\n        println!(\"Right-click the executable and select 'Run as administrator'\");\n        press_enter_to_exit(1);\n    }\n\n    // Display Logo\n    // Using simple print for now, can be enhanced\n    Command::new(\"cmd\").args(&[\"/c\", \"cls\"]).status().unwrap(); // Clear screen on Windows\n\n    println!(\"{}\", r#\"\n    ██████╗██╗   ██╗██████╗ ███████╗ ██████╗ ██████╗ \n   ██╔════╝██║   ██║██╔══██╗██╔════╝██╔═══██╗██╔══██╗\n   ██║     ██║   ██║██████╔╝███████╗██║   ██║██████╔╝\n   ██║     ██║   ██║██╔══██╗╚════██║██║   ██║██╔══██╗\n   ╚██████╗╚██████╔╝██║  ██║███████║╚██████╔╝██║  ██║\n    ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═╝  ╚═╝\n\n\"#.bright_cyan());\n    println!(\"{}\", \"================================\".color(BLUE));\n    println!(\"   {}\", \"Cursor Device ID Modifier Tool\".color(GREEN));\n    println!(\"  {}\", \"Cursor ID Reset Tool - Community Edition\".color(YELLOW));\n    println!(\"  {}\", \"Free tool for Cursor device ID management\".color(YELLOW));\n    println!(\"  {}\", \"[IMPORTANT] This is a free community tool\".color(YELLOW));\n    println!(\"{}\", \"================================\".color(BLUE));\n    println!(\"  {}\", \"QQ群: 951642519 (交流/下载纯免费自动账号切换工具)\".color(YELLOW));\n    println!(\"\");\n\n    // Get and display Cursor version\n    let cursor_version = get_cursor_version();\n    match &cursor_version {\n        Some(version) => println!(\"{} Current Cursor version: v{}\", \"[INFO]\".color(GREEN), version),\n        None => {\n            println!(\"{} Unable to detect Cursor version\", \"[WARNING]\".color(YELLOW));\n            println!(\"{} Please ensure Cursor is properly installed\", \"[TIP]\".color(YELLOW));\n        }\n    }\n    println!(\"\");\n\n    println!(\"{} Latest 0.45.x (supported)\", \"[IMPORTANT NOTE]\".color(YELLOW));\n    println!(\"\");\n\n    // Check and close Cursor processes\n    println!(\"{} Checking Cursor processes...\", \"[INFO]\".color(GREEN));\n    close_cursor_process(\"Cursor\");\n    close_cursor_process(\"cursor\");\n    println!(\"\");\n\n    let storage_file_path = match get_storage_file_path() {\n        Some(path) => path,\n        None => {\n            println!(\"{}\", \"[ERROR] Could not determine APPDATA path for storage file.\".color(RED));\n            press_enter_to_exit(1);\n            unreachable!(); // press_enter_to_exit exits\n        }\n    };\n    // println!(\"Storage file path: {:?}\", storage_file_path);\n\n    let backup_dir_path = match get_backup_dir_path() {\n        Some(path) => path,\n        None => {\n            println!(\"{}\", \"[ERROR] Could not determine APPDATA path for backup directory.\".color(RED));\n            press_enter_to_exit(1);\n            unreachable!();\n        }\n    };\n    // println!(\"Backup dir path: {:?}\", backup_dir_path);\n\n    // Create backup directory\n    if !backup_dir_path.exists() {\n        match fs::create_dir_all(&backup_dir_path) {\n            Ok(_) => println!(\"{} Created backup directory at {:?}\", \"[INFO]\".color(GREEN), backup_dir_path),\n            Err(e) => {\n                println!(\"{} Failed to create backup directory at {:?}: {}\", \"[ERROR]\".color(RED), backup_dir_path, e);\n                press_enter_to_exit(1);\n            }\n        }\n    }\n\n    // Backup existing configuration\n    if storage_file_path.exists() {\n        println!(\"{} Backing up configuration file...\", \"[INFO]\".color(GREEN));\n        let backup_name = format!(\"storage.json.backup_{}\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n        let backup_file_path = backup_dir_path.join(backup_name);\n        match fs::copy(&storage_file_path, &backup_file_path) {\n            Ok(_) => println!(\"{} Configuration backed up to {:?}\", \"[INFO]\".color(GREEN), backup_file_path),\n            Err(e) => {\n                println!(\"{} Failed to backup configuration file to {:?}: {}\", \"[ERROR]\".color(RED), backup_file_path, e);\n                // Decide if this is a fatal error or a warning\n            }\n        }\n    } else {\n        println!(\"{} No existing configuration file found at {:?} to back up.\", \"[INFO]\".color(GREEN), storage_file_path);\n    }\n    println!(\"\");\n\n    // Generate new IDs\n    println!(\"{} Generating new IDs...\", \"[INFO]\".color(GREEN));\n    let mac_machine_id = new_standard_machine_id();\n    let uuid_str = Uuid::new_v4().to_string();\n    let prefix_hex = \"auth0|user_\".as_bytes().iter().map(|b| format!(\"{:02x}\", b)).collect::<String>();\n    let random_part = get_random_hex(32);\n    let machine_id = format!(\"{}{}\", prefix_hex, random_part);\n    let sqm_id = format!(\"{{{}}}\", Uuid::new_v4().to_string().to_uppercase());\n\n    // println!(\"Generated MAC_MACHINE_ID: {}\", mac_machine_id);\n    // println!(\"Generated UUID_STR: {}\", uuid_str);\n    // println!(\"Generated MACHINE_ID: {}\", machine_id);\n    // println!(\"Generated SQM_ID: {}\", sqm_id);\n    // println!(\"\");\n\n    // Update MachineGuid in registry\n    let mut machine_guid_updated = false;\n    if cfg!(target_os = \"windows\") { // Only run on Windows\n        machine_guid_updated = update_machine_guid(&backup_dir_path);\n    } else {\n        println!(\"{} Skipping MachineGuid update (not on Windows)\", \"[INFO]\".color(YELLOW));\n    }\n\n    // Create or update configuration file\n    println!(\"{} Updating configuration...\", \"[INFO]\".color(GREEN));\n    let storage_update_successful = update_storage_file(\n        &storage_file_path,\n        &machine_id,\n        &mac_machine_id,\n        &uuid_str, // This was $UUID in PowerShell, which corresponds to devDeviceId\n        &sqm_id\n    );\n\n    if storage_update_successful {\n        println!(\"{} Configuration updated successfully.\", \"[INFO]\".color(GREEN));\n        // Display results\n        println!(\"\");\n        println!(\"{} Configuration updated details:\", \"[INFO]\".color(GREEN));\n        println!(\"{} machineId: {}\", \"[DEBUG]\".color(BLUE), machine_id);\n        println!(\"{} macMachineId: {}\", \"[DEBUG]\".color(BLUE), mac_machine_id);\n        println!(\"{} devDeviceId: {}\", \"[DEBUG]\".color(BLUE), uuid_str);\n        println!(\"{} sqmId: {}\", \"[DEBUG]\".color(BLUE), sqm_id);\n    } else {\n        println!(\"{} Main operation failed to update storage file.\", \"[ERROR]\".color(RED));\n        // The PS script has an alternative method here, which is complex.\n        // For now, we'll just indicate failure.\n        press_enter_to_exit(1);\n    }\n    println!(\"\");\n\n    // Display file tree structure\n    println!(\"{} File structure:\", \"[INFO]\".color(GREEN));\n    if let Some(user_dirs) = UserDirs::new() {\n        // %APPDATA%\\Cursor\\User is not directly available via UserDirs or BaseDirs in a cross-platform way for this specific structure.\n        // We'll construct it based on APPDATA which UserDirs doesn't directly give, BaseDirs::config_dir() is the closest.\n        if let Some(base_dirs) = BaseDirs::new() {\n             let app_data_dir_equivalent = base_dirs.config_dir(); // This is platform specific, e.g. %APPDATA% on Windows\n             println!(\"{}\", app_data_dir_equivalent.join(\"Cursor\").join(\"User\").display().to_string().color(BLUE));\n        }\n    } else {\n        println!(\"{} Could not determine APPDATA path for display.\", \"[WARNING]\".color(YELLOW));\n    }\n    println!(\"├── globalStorage\");\n    println!(\"│   ├── storage.json (modified)\");\n    println!(\"│   └── backups\");\n\n    // List backup files\n    match fs::read_dir(&backup_dir_path) {\n        Ok(entries) => {\n            let mut backup_files_found = false;\n            for entry in entries {\n                if let Ok(entry) = entry {\n                    if entry.path().is_file() {\n                        println!(\"│       └── {}\", entry.file_name().to_string_lossy());\n                        backup_files_found = true;\n                    }\n                }\n            }\n            if !backup_files_found {\n                println!(\"│       └── (empty)\");\n            }\n        }\n        Err(e) => {\n            println!(\"│       └── (Error reading backups: {})\", e);\n        }\n    }\n    println!(\"\");\n\n    // Display completion message\n    println!(\"{}\", \"================================\".color(GREEN));\n    println!(\"  {}\", \"Cursor ID Reset Tool - Community Edition\".color(YELLOW));\n    println!(\"{}\", \"================================\".color(GREEN));\n    println!(\"\");\n    println!(\"{} Please restart Cursor to apply new configuration\", \"[INFO]\".color(GREEN));\n    println!(\"\");\n\n    press_enter_to_exit(0);\n}\n\nfn get_random_hex(length: usize) -> String {\n    thread_rng()\n        .sample_iter(&Alphanumeric)\n        .take(length)\n        .map(char::from)\n        .collect::<String>()\n        .to_lowercase() // PowerShell version produces lowercase hex\n}\n\n", "suffix_code": "\n\n#[derive(Deserialize)]\nstruct PackageJson {\n    version: String,\n}\n\nfn get_cursor_version() -> Option<String> {\n    if let Some(package_path) = get_cursor_package_path() {\n        if package_path.exists() {\n            match fs::read_to_string(&package_path) {\n                Ok(contents) => match serde_json::from_str::<PackageJson>(&contents) {\n                    Ok(json) => Some(json.version),\n                    Err(e) => {\n                        println!(\"{} Failed to parse package.json: {}\", \"[ERROR]\".color(RED), e);\n                        None\n                    }\n                },\n                Err(e) => {\n                    println!(\"{} Failed to read package.json at {:?}: {}\", \"[ERROR]\".color(RED), package_path, e);\n                    None\n                }\n            }\n        } else {\n            println!(\"{} package.json not found at {:?}\", \"[WARNING]\".color(YELLOW), package_path);\n            None\n        }\n    } else {\n        println!(\"{} Could not determine path to Cursor's package.json\", \"[WARNING]\".color(YELLOW));\n        None\n    }\n}\n\nfn close_cursor_process(process_name: &str) {\n    let mut sys = System::new_all();\n    sys.refresh_processes();\n\n    let processes_to_kill: Vec<_> = sys\n        .processes()\n        .values()\n        .filter(|p| p.name().eq_ignore_ascii_case(process_name))\n        .collect();\n\n    if !processes_to_kill.is_empty() {\n        println!(\"{} Found {} running\", \"[WARNING]\".color(YELLOW), process_name);\n        for p in &processes_to_kill {\n            println!(\"  PID: {}, Name: {}, Path: {:?}\", p.pid(), p.name(), p.exe());\n        }\n\n        println!(\"{} Attempting to close {}...\", \"[WARNING]\".color(YELLOW), process_name);\n        for p in processes_to_kill {\n            if !p.kill() { // kill() sends SIGKILL by default on Unix, TerminateProcess on Windows\n                println!(\"{} Failed to send termination signal to {} (PID: {}). Trying to wait...\", \"[ERROR]\".color(RED), process_name, p.pid());\n            }\n        }\n\n        let mut retry_count = 0;\n        loop {\n            sys.refresh_processes();\n            let still_running: Vec<_> = sys\n                .processes()\n                .values()\n                .filter(|p| p.name().eq_ignore_ascii_case(process_name))\n                .collect();\n\n            if still_running.is_empty() {\n                break;\n            }\n\n            retry_count += 1;\n            if retry_count >= MAX_RETRIES {\n                println!(\"{} Unable to close {} after {} attempts\", \"[ERROR]\".color(RED), process_name, MAX_RETRIES);\n                for p in still_running {\n                     println!(\"  Still running - PID: {}, Name: {}, Path: {:?}\", p.pid(), p.name(), p.exe());\n                }\n                println!(\"{} Please close the process manually and try again\", \"[ERROR]\".color(RED));\n                press_enter_to_exit(1);\n            }\n\n            println!(\"{} Waiting for process to close, attempt {}/{}...\", \"[WARNING]\".color(YELLOW), retry_count, MAX_RETRIES);\n            std::thread::sleep(std::time::Duration::from_secs(WAIT_TIME_SECONDS));\n        }\n        println!(\"{} {} successfully closed\", \"[INFO]\".color(GREEN), process_name);\n    }\n}\n\n#[cfg(target_os = \"windows\")]\nfn update_machine_guid(backup_dir: &Path) -> bool {\n    println!(\"{} Updating MachineGuid in registry...\", \"[INFO]\".color(GREEN));\n    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);\n    let reg_path = \"SOFTWARE\\\\Microsoft\\\\Cryptography\";\n    let reg_key_name = \"MachineGuid\";\n    let full_reg_key_path_for_export = \"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Cryptography\";\n\n    let crypto_key = match hklm.open_subkey_with_flags(reg_path, KEY_READ | KEY_WRITE) {\n        Ok(key) => key,\n        Err(e) => {\n            println!(\"{} Failed to open registry key '{}': {}. Ensure you have admin rights.\", \"[ERROR]\".color(RED), reg_path, e);\n            return false;\n        }\n    };\n\n    let current_guid_val: Result<String, _> = crypto_key.get_value(reg_key_name);\n    let original_guid = match current_guid_val {\n        Ok(guid) => {\n            println!(\"{} Current registry value:\", \"[INFO]\".color(GREEN));\n            println!(\"  {}\", full_reg_key_path_for_export);\n            println!(\"    {}    REG_SZ    {}\", reg_key_name, guid);\n            guid\n        }\n        Err(e) => {\n            println!(\"{} Unable to get current {}: {}. This might indicate a problem or the value might not exist.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            // Proceeding to set a new one if it doesn't exist, or fail if it's a permission issue.\n            String::new() // Or handle as a more critical error if needed.\n        }\n    };\n\n    if !backup_dir.exists() {\n        if let Err(e) = fs::create_dir_all(backup_dir) {\n            println!(\"{} Failed to create backup directory for registry backup: {}. Proceeding without registry backup.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n\n    let backup_file_name = format!(\"MachineGuid_{}.reg\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n    let backup_file_path = backup_dir.join(&backup_file_name);\n    let backup_command_str = format!(\"reg.exe export \\\"{}\\\" \\\"{}\\\" /y\", full_reg_key_path_for_export, backup_file_path.display());\n    \n    println!(\"{} Attempting to backup registry key to: {:?}\", \"[INFO]\".color(GREEN), backup_file_path);\n    match Command::new(\"cmd\").args(&[\"/C\", &backup_command_str]).status() {\n        Ok(status) if status.success() => {\n            println!(\"{} Registry key backed up successfully.\", \"[INFO]\".color(GREEN));\n        }\n        Ok(status) => {\n            println!(\"{} Registry backup command finished with status: {}. Check permissions or if reg.exe is available.\", \"[WARNING]\".color(YELLOW), status);\n        }\n        Err(e) => {\n            println!(\"{} Failed to execute registry backup command: {}. Proceeding with caution.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n\n    let new_guid = Uuid::new_v4().to_string();\n    match crypto_key.set_value(reg_key_name, &new_guid) {\n        Ok(_) => {\n            println!(\"{} Registry value {} set to: {}\", \"[INFO]\".color(GREEN), reg_key_name, new_guid);\n            // Verification\n            let verify_guid: Result<String, _> = crypto_key.get_value(reg_key_name);\n            match verify_guid {\n                Ok(val) if val == new_guid => {\n                    println!(\"{} Registry update verified successfully.\", \"[INFO]\".color(GREEN));\n                    println!(\"  {}\", full_reg_key_path_for_export);\n                    println!(\"    {}    REG_SZ    {}\", reg_key_name, new_guid);\n                    true\n                }\n                Ok(val) => {\n                    println!(\"{} Registry verification failed: Updated value ({}) does not match expected value ({}).\", \"[ERROR]\".color(RED), val, new_guid);\n                    // Attempt restore\n                    false // Placeholder for restore logic\n                }\n                Err(e) => {\n                    println!(\"{} Failed to verify registry update: {}.\", \"[ERROR]\".color(RED), e);\n                    false // Placeholder for restore logic\n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to set registry value {}: {}.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            // Attempt restore if original_guid was present and backup_file_path exists\n            if !original_guid.is_empty() && backup_file_path.exists() {\n                println!(\"{} Attempting to restore registry from backup: {:?}\", \"[YELLOW]\".color(YELLOW), backup_file_path);\n                let restore_command_str = format!(\"reg.exe import \\\"{}\\\"\", backup_file_path.display());\n                match Command::new(\"cmd\").args(&[\"/C\", &restore_command_str]).status() {\n                    Ok(status) if status.success() => println!(\"{} Registry restored successfully from backup.\", \"[INFO]\".color(GREEN)),\n                    Ok(status) => println!(\"{} Registry restore command failed with status: {}. Manual restore may be needed from {:?}\", \"[ERROR]\".color(RED), status, backup_file_path),\n                    Err(re) => println!(\"{} Failed to execute registry restore command: {}. Manual restore needed from {:?}\", \"[ERROR]\".color(RED), re, backup_file_path),\n                }\n            }\n            false\n        }\n    }\n}\n\nfn update_storage_file(\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {\n    if !storage_file_path.exists() {\n        println!(\"{} Configuration file not found: {:?}\", \"[ERROR]\".color(RED), storage_file_path);\n        println!(\"{} Please install and run Cursor once before using this script\", \"[TIP]\".color(YELLOW));\n        return false;\n    }\n\n    let original_content = match fs::read_to_string(storage_file_path) {\n        Ok(content) => content,\n        Err(e) => {\n            println!(\"{} Failed to read configuration file {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n            return false;\n        }\n    };\n\n    let mut config: Value = match serde_json::from_str(&original_content) {\n        Ok(json_value) => json_value,\n        Err(e) => {\n            println!(\"{} Failed to parse configuration file JSON: {}\", \"[ERROR]\".color(RED), e);\n            // Attempt to restore original content is not applicable here as we haven't written yet\n            return false;\n        }\n    };\n\n    // Ensure the path to telemetry values exists or create it\n    // serde_json::Value uses `pointer_mut` for this kind of access.\n    // Example: /telemetry/machineId\n    // We need to ensure `config[\"telemetry\"]` is an object.\n    if !config.get(\"telemetry\").map_or(false, |v| v.is_object()) {\n        if config.as_object_mut().is_some() { // Check if config itself is an object\n            config[\"telemetry\"] = serde_json::json!({});\n        } else {\n            println!(\"{} Configuration root is not a JSON object. Cannot set telemetry.\", \"[ERROR]\".color(RED));\n            return false;\n        }\n    }\n    \n    // Update specific values\n    // Using .get_mut(\"telemetry\") and then working with the resulting Option<&mut Value>\n    if let Some(telemetry) = config.get_mut(\"telemetry\") {\n        if let Some(telemetry_obj) = telemetry.as_object_mut() {\n            telemetry_obj.insert(\"machineId\".to_string(), Value::String(machine_id.to_string()));\n            telemetry_obj.insert(\"macMachineId\".to_string(), Value::String(mac_machine_id.to_string()));\n            telemetry_obj.insert(\"devDeviceId\".to_string(), Value::String(dev_device_id.to_string()));\n            telemetry_obj.insert(\"sqmId\".to_string(), Value::String(sqm_id.to_string()));\n        } else {\n            println!(\"{} 'telemetry' field is not an object.\", \"[ERROR]\".color(RED));\n            return false; // Or attempt to restore original_content\n        }\n    } else {\n        // This case should ideally be covered by the creation logic above.\n        println!(\"{} Failed to access or create 'telemetry' object.\", \"[ERROR]\".color(RED));\n        return false; // Or attempt to restore original_content\n    }\n    \n    match serde_json::to_string_pretty(&config) { // Using pretty for readability, PowerShell does compact\n        Ok(updated_json) => {\n            match fs::write(storage_file_path, updated_json.as_bytes()) { // .as_bytes() for UTF-8\n                Ok(_) => {\n                    println!(\"{} Configuration file updated successfully at {:?}\", \"[INFO]\".color(GREEN), storage_file_path);\n                    true\n                }\n                Err(e) => {\n                    println!(\"{} Failed to write updated configuration to {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n                    // Attempt to restore original content\n                    if fs::write(storage_file_path, original_content.as_bytes()).is_err() {\n                        println!(\"{} CRITICAL: Failed to restore original content to {:?} after write error.\", \"[ERROR]\".color(RED), storage_file_path);\n                    }\n                    false\n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to serialize updated configuration to JSON: {}\", \"[ERROR]\".color(RED), e);\n            // Attempt to restore original content if we had changed it in memory (not the case here with direct write path)\n            // No need to restore file if serialization failed before writing.\n            false\n        }\n    }\n}\n", "middle_code": "fn new_standard_machine_id() -> String {\n    let mut rng = thread_rng();\n    let mut id = String::with_capacity(36);\n    for (i, char_template) in \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".chars().enumerate() {\n        if char_template == '-' || char_template == '4' {\n            id.push(char_template);\n        } else if char_template == 'x' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(0..16)));\n        } else if char_template == 'y' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(8..12))); \n        }\n    }\n    id\n}", "code_description": null, "fill_type": "FUNCTION_TYPE", "language_type": "rust", "sub_task_type": null}, "context_code": [], "task_instance_info": {"created_time": "2025-08-21 01:32:38", "created_task_model": "DeepSeek-R1", "function_skeleton": "fn new_standard_machine_id () -> String {}", "code_description": "This code segment functions to: Generate a standardized unique identifier using a predefined format with specific sections containing randomized hexadecimal values and fixed version indicators."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```rust\n[TASK_BEGIN]\nfn new_standard_machine_id() -> String {\n    let uuid = Uuid::new_v4();\n    uuid.as_bytes()[..8]\n        .iter()\n        .map(|b| format!(\"{:02x}\", b))\n        .collect()\n}\n[TASK_END]\n```", "inference_time": "2025-08-21 01-32-50"}, "editdistance_info": {"edit_distance": 15.7534, "calculate_time": "2025-08-21 01:32:50", "true_code_clean": "fn new_standard_machine_id() -> String {\n    let mut rng = thread_rng();\n    let mut id = String::with_capacity(36);\n    for (i, char_template) in \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".chars().enumerate() {\n        if char_template == '-' || char_template == '4' {\n            id.push(char_template);\n        } else if char_template == 'x' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(0..16)));\n        } else if char_template == 'y' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(8..12))); \n        }\n    }\n    id\n}", "predict_code_clean": "fn new_standard_machine_id() -> String {\n    let uuid = Uuid::new_v4();\n    uuid.as_bytes()[..8]\n        .iter()\n        .map(|b| format!(\"{:02x}\", b))\n        .collect()\n}"}}
{"repo_name": "cursor-free-everyday", "file_name": "/cursor-free-everyday/reset_machine.rs", "inference_info": {"prefix_code": "use colored::*;\nuse directories::{BaseDirs, UserDirs};\nuse is_elevated::is_elevated;\nuse serde::{Deserialize, Serialize};\nuse serde_json::Value;\nuse std::collections::HashMap;\nuse std::env;\nuse std::fs;\nuse std::io::{self, Write};\nuse std::path::{Path, PathBuf};\nuse std::process::{Command, Stdio};\nuse sysinfo::{System};\nuse uuid::Uuid;\nuse winreg::enums::*;\nuse winreg::RegKey;\nuse chrono::Local;\nuse rand::{thread_rng, Rng, distributions::Alphanumeric};\n\n// Color definitions (approximated from PowerShell)\nconst RED: &str = \"red\";\nconst GREEN: &str = \"green\";\nconst YELLOW: &str = \"yellow\";\nconst BLUE: &str = \"blue\";\n// const NC: &str = \"clear\"; // `colored` crate handles reset implicitly or via `.normal()`\n\n// Max retries and wait time for process termination\nconst MAX_RETRIES: u32 = 5;\nconst WAIT_TIME_SECONDS: u64 = 1;\n\n// Configuration file paths\nfn get_storage_file_path() -> Option<PathBuf> {\n    if let Some(base_dirs) = BaseDirs::new() {\n        let app_data_dir = base_dirs.config_dir(); // Typically %APPDATA% or ~/.config\n        Some(app_data_dir.join(\"Cursor\").join(\"User\").join(\"globalStorage\").join(\"storage.json\"))\n    } else {\n        None\n    }\n}\n\nfn get_backup_dir_path() -> Option<PathBuf> {\n    if let Some(base_dirs) = BaseDirs::new() {\n        let app_data_dir = base_dirs.config_dir();\n        Some(app_data_dir.join(\"Cursor\").join(\"User\").join(\"globalStorage\").join(\"backups\"))\n    } else {\n        None\n    }\n}\n\nfn get_cursor_package_path() -> Option<PathBuf> {\n    if let Some(user_dirs) = BaseDirs::new() {\n        let local_app_data_dir = user_dirs.data_local_dir();\n        let primary_path = local_app_data_dir.join(\"Programs\").join(\"cursor\").join(\"resources\").join(\"app\").join(\"package.json\");\n        if primary_path.exists() {\n            return Some(primary_path);\n        }\n        let alt_path = local_app_data_dir.join(\"cursor\").join(\"resources\").join(\"app\").join(\"package.json\");\n        if alt_path.exists() {\n            return Some(alt_path);\n        }\n    }\n    None\n}\n\nfn get_cursor_updater_path() -> Option<PathBuf> {\n    if let Some(user_dirs) = BaseDirs::new() {\n        let local_app_data_dir = user_dirs.data_local_dir();\n        Some(local_app_data_dir.join(\"cursor-updater\"))\n    } else {\n        None\n    }\n}\n\n\nfn press_enter_to_exit(exit_code: i32) {\n    print!(\"Press Enter to exit...\");\n    io::stdout().flush().unwrap();\n    let mut buffer = String::new();\n    io::stdin().read_line(&mut buffer).unwrap();\n    std::process::exit(exit_code);\n}\n\nfn main() {\n    // Set output encoding to UTF-8 (Rust strings are UTF-8 by default, console might need setup on Windows)\n    // On Windows, `chcp 65001` might be needed in the terminal before running for full UTF-8 display.\n    // The script itself cannot reliably change the parent console's encoding.\n\n    // Check administrator privileges\n    if !is_elevated() {\n        println!(\"{}\", \"[ERROR] Please run this script as administrator\".color(RED));\n        println!(\"Right-click the executable and select 'Run as administrator'\");\n        press_enter_to_exit(1);\n    }\n\n    // Display Logo\n    // Using simple print for now, can be enhanced\n    Command::new(\"cmd\").args(&[\"/c\", \"cls\"]).status().unwrap(); // Clear screen on Windows\n\n    println!(\"{}\", r#\"\n    ██████╗██╗   ██╗██████╗ ███████╗ ██████╗ ██████╗ \n   ██╔════╝██║   ██║██╔══██╗██╔════╝██╔═══██╗██╔══██╗\n   ██║     ██║   ██║██████╔╝███████╗██║   ██║██████╔╝\n   ██║     ██║   ██║██╔══██╗╚════██║██║   ██║██╔══██╗\n   ╚██████╗╚██████╔╝██║  ██║███████║╚██████╔╝██║  ██║\n    ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═╝  ╚═╝\n\n\"#.bright_cyan());\n    println!(\"{}\", \"================================\".color(BLUE));\n    println!(\"   {}\", \"Cursor Device ID Modifier Tool\".color(GREEN));\n    println!(\"  {}\", \"Cursor ID Reset Tool - Community Edition\".color(YELLOW));\n    println!(\"  {}\", \"Free tool for Cursor device ID management\".color(YELLOW));\n    println!(\"  {}\", \"[IMPORTANT] This is a free community tool\".color(YELLOW));\n    println!(\"{}\", \"================================\".color(BLUE));\n    println!(\"  {}\", \"QQ群: 951642519 (交流/下载纯免费自动账号切换工具)\".color(YELLOW));\n    println!(\"\");\n\n    // Get and display Cursor version\n    let cursor_version = get_cursor_version();\n    match &cursor_version {\n        Some(version) => println!(\"{} Current Cursor version: v{}\", \"[INFO]\".color(GREEN), version),\n        None => {\n            println!(\"{} Unable to detect Cursor version\", \"[WARNING]\".color(YELLOW));\n            println!(\"{} Please ensure Cursor is properly installed\", \"[TIP]\".color(YELLOW));\n        }\n    }\n    println!(\"\");\n\n    println!(\"{} Latest 0.45.x (supported)\", \"[IMPORTANT NOTE]\".color(YELLOW));\n    println!(\"\");\n\n    // Check and close Cursor processes\n    println!(\"{} Checking Cursor processes...\", \"[INFO]\".color(GREEN));\n    close_cursor_process(\"Cursor\");\n    close_cursor_process(\"cursor\");\n    println!(\"\");\n\n    let storage_file_path = match get_storage_file_path() {\n        Some(path) => path,\n        None => {\n            println!(\"{}\", \"[ERROR] Could not determine APPDATA path for storage file.\".color(RED));\n            press_enter_to_exit(1);\n            unreachable!(); // press_enter_to_exit exits\n        }\n    };\n    // println!(\"Storage file path: {:?}\", storage_file_path);\n\n    let backup_dir_path = match get_backup_dir_path() {\n        Some(path) => path,\n        None => {\n            println!(\"{}\", \"[ERROR] Could not determine APPDATA path for backup directory.\".color(RED));\n            press_enter_to_exit(1);\n            unreachable!();\n        }\n    };\n    // println!(\"Backup dir path: {:?}\", backup_dir_path);\n\n    // Create backup directory\n    if !backup_dir_path.exists() {\n        match fs::create_dir_all(&backup_dir_path) {\n            Ok(_) => println!(\"{} Created backup directory at {:?}\", \"[INFO]\".color(GREEN), backup_dir_path),\n            Err(e) => {\n                println!(\"{} Failed to create backup directory at {:?}: {}\", \"[ERROR]\".color(RED), backup_dir_path, e);\n                press_enter_to_exit(1);\n            }\n        }\n    }\n\n    // Backup existing configuration\n    if storage_file_path.exists() {\n        println!(\"{} Backing up configuration file...\", \"[INFO]\".color(GREEN));\n        let backup_name = format!(\"storage.json.backup_{}\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n        let backup_file_path = backup_dir_path.join(backup_name);\n        match fs::copy(&storage_file_path, &backup_file_path) {\n            Ok(_) => println!(\"{} Configuration backed up to {:?}\", \"[INFO]\".color(GREEN), backup_file_path),\n            Err(e) => {\n                println!(\"{} Failed to backup configuration file to {:?}: {}\", \"[ERROR]\".color(RED), backup_file_path, e);\n                // Decide if this is a fatal error or a warning\n            }\n        }\n    } else {\n        println!(\"{} No existing configuration file found at {:?} to back up.\", \"[INFO]\".color(GREEN), storage_file_path);\n    }\n    println!(\"\");\n\n    // Generate new IDs\n    println!(\"{} Generating new IDs...\", \"[INFO]\".color(GREEN));\n    let mac_machine_id = new_standard_machine_id();\n    let uuid_str = Uuid::new_v4().to_string();\n    let prefix_hex = \"auth0|user_\".as_bytes().iter().map(|b| format!(\"{:02x}\", b)).collect::<String>();\n    let random_part = get_random_hex(32);\n    let machine_id = format!(\"{}{}\", prefix_hex, random_part);\n    let sqm_id = format!(\"{{{}}}\", Uuid::new_v4().to_string().to_uppercase());\n\n    // println!(\"Generated MAC_MACHINE_ID: {}\", mac_machine_id);\n    // println!(\"Generated UUID_STR: {}\", uuid_str);\n    // println!(\"Generated MACHINE_ID: {}\", machine_id);\n    // println!(\"Generated SQM_ID: {}\", sqm_id);\n    // println!(\"\");\n\n    // Update MachineGuid in registry\n    let mut machine_guid_updated = false;\n    if cfg!(target_os = \"windows\") { // Only run on Windows\n        machine_guid_updated = update_machine_guid(&backup_dir_path);\n    } else {\n        println!(\"{} Skipping MachineGuid update (not on Windows)\", \"[INFO]\".color(YELLOW));\n    }\n\n    // Create or update configuration file\n    println!(\"{} Updating configuration...\", \"[INFO]\".color(GREEN));\n    let storage_update_successful = update_storage_file(\n        &storage_file_path,\n        &machine_id,\n        &mac_machine_id,\n        &uuid_str, // This was $UUID in PowerShell, which corresponds to devDeviceId\n        &sqm_id\n    );\n\n    if storage_update_successful {\n        println!(\"{} Configuration updated successfully.\", \"[INFO]\".color(GREEN));\n        // Display results\n        println!(\"\");\n        println!(\"{} Configuration updated details:\", \"[INFO]\".color(GREEN));\n        println!(\"{} machineId: {}\", \"[DEBUG]\".color(BLUE), machine_id);\n        println!(\"{} macMachineId: {}\", \"[DEBUG]\".color(BLUE), mac_machine_id);\n        println!(\"{} devDeviceId: {}\", \"[DEBUG]\".color(BLUE), uuid_str);\n        println!(\"{} sqmId: {}\", \"[DEBUG]\".color(BLUE), sqm_id);\n    } else {\n        println!(\"{} Main operation failed to update storage file.\", \"[ERROR]\".color(RED));\n        // The PS script has an alternative method here, which is complex.\n        // For now, we'll just indicate failure.\n        press_enter_to_exit(1);\n    }\n    println!(\"\");\n\n    // Display file tree structure\n    println!(\"{} File structure:\", \"[INFO]\".color(GREEN));\n    if let Some(user_dirs) = UserDirs::new() {\n        // %APPDATA%\\Cursor\\User is not directly available via UserDirs or BaseDirs in a cross-platform way for this specific structure.\n        // We'll construct it based on APPDATA which UserDirs doesn't directly give, BaseDirs::config_dir() is the closest.\n        if let Some(base_dirs) = BaseDirs::new() {\n             let app_data_dir_equivalent = base_dirs.config_dir(); // This is platform specific, e.g. %APPDATA% on Windows\n             println!(\"{}\", app_data_dir_equivalent.join(\"Cursor\").join(\"User\").display().to_string().color(BLUE));\n        }\n    } else {\n        println!(\"{} Could not determine APPDATA path for display.\", \"[WARNING]\".color(YELLOW));\n    }\n    println!(\"├── globalStorage\");\n    println!(\"│   ├── storage.json (modified)\");\n    println!(\"│   └── backups\");\n\n    // List backup files\n    match fs::read_dir(&backup_dir_path) {\n        Ok(entries) => {\n            let mut backup_files_found = false;\n            for entry in entries {\n                if let Ok(entry) = entry {\n                    if entry.path().is_file() {\n                        println!(\"│       └── {}\", entry.file_name().to_string_lossy());\n                        backup_files_found = true;\n                    }\n                }\n            }\n            if !backup_files_found {\n                println!(\"│       └── (empty)\");\n            }\n        }\n        Err(e) => {\n            println!(\"│       └── (Error reading backups: {})\", e);\n        }\n    }\n    println!(\"\");\n\n    // Display completion message\n    println!(\"{}\", \"================================\".color(GREEN));\n    println!(\"  {}\", \"Cursor ID Reset Tool - Community Edition\".color(YELLOW));\n    println!(\"{}\", \"================================\".color(GREEN));\n    println!(\"\");\n    println!(\"{} Please restart Cursor to apply new configuration\", \"[INFO]\".color(GREEN));\n    println!(\"\");\n\n    press_enter_to_exit(0);\n}\n\nfn get_random_hex(length: usize) -> String {\n    thread_rng()\n        .sample_iter(&Alphanumeric)\n        .take(length)\n        .map(char::from)\n        .collect::<String>()\n        .to_lowercase() // PowerShell version produces lowercase hex\n}\n\nfn new_standard_machine_id() -> String {\n    // Template: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\n    // y is one of 8, 9, a, b\n    let mut rng = thread_rng();\n    let mut id = String::with_capacity(36);\n    for (i, char_template) in \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".chars().enumerate() {\n        if char_template == '-' || char_template == '4' {\n            id.push(char_template);\n        } else if char_template == 'x' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(0..16)));\n        } else if char_template == 'y' {\n            id.push_str(&format!(\"{:x}\", rng.gen_range(8..12))); // 8, 9, a, b\n        }\n    }\n    id\n}\n\n#[derive(Deserialize)]\nstruct PackageJson {\n    version: String,\n}\n\nfn get_cursor_version() -> Option<String> {\n    if let Some(package_path) = get_cursor_package_path() {\n        if package_path.exists() {\n            match fs::read_to_string(&package_path) {\n                Ok(contents) => match serde_json::from_str::<PackageJson>(&contents) {\n                    Ok(json) => Some(json.version),\n                    Err(e) => {\n                        println!(\"{} Failed to parse package.json: {}\", \"[ERROR]\".color(RED), e);\n                        None\n                    }\n                },\n                Err(e) => {\n                    println!(\"{} Failed to read package.json at {:?}: {}\", \"[ERROR]\".color(RED), package_path, e);\n                    None\n                }\n            }\n        } else {\n            println!(\"{} package.json not found at {:?}\", \"[WARNING]\".color(YELLOW), package_path);\n            None\n        }\n    } else {\n        println!(\"{} Could not determine path to Cursor's package.json\", \"[WARNING]\".color(YELLOW));\n        None\n    }\n}\n\nfn close_cursor_process(process_name: &str) {\n    let mut sys = System::new_all();\n    sys.refresh_processes();\n\n    let processes_to_kill: Vec<_> = sys\n        .processes()\n        .values()\n        .filter(|p| p.name().eq_ignore_ascii_case(process_name))\n        .collect();\n\n    if !processes_to_kill.is_empty() {\n        println!(\"{} Found {} running\", \"[WARNING]\".color(YELLOW), process_name);\n        for p in &processes_to_kill {\n            println!(\"  PID: {}, Name: {}, Path: {:?}\", p.pid(), p.name(), p.exe());\n        }\n\n        println!(\"{} Attempting to close {}...\", \"[WARNING]\".color(YELLOW), process_name);\n        for p in processes_to_kill {\n            if !p.kill() { // kill() sends SIGKILL by default on Unix, TerminateProcess on Windows\n                println!(\"{} Failed to send termination signal to {} (PID: {}). Trying to wait...\", \"[ERROR]\".color(RED), process_name, p.pid());\n            }\n        }\n\n        let mut retry_count = 0;\n        loop {\n            sys.refresh_processes();\n            let still_running: Vec<_> = sys\n                .processes()\n                .values()\n                .filter(|p| p.name().eq_ignore_ascii_case(process_name))\n                .collect();\n\n            if still_running.is_empty() {\n                break;\n            }\n\n            retry_count += 1;\n            if retry_count >= MAX_RETRIES {\n                println!(\"{} Unable to close {} after {} attempts\", \"[ERROR]\".color(RED), process_name, MAX_RETRIES);\n                for p in still_running {\n                     println!(\"  Still running - PID: {}, Name: {}, Path: {:?}\", p.pid(), p.name(), p.exe());\n                }\n                println!(\"{} Please close the process manually and try again\", \"[ERROR]\".color(RED));\n                press_enter_to_exit(1);\n            }\n\n            println!(\"{} Waiting for process to close, attempt {}/{}...\", \"[WARNING]\".color(YELLOW), retry_count, MAX_RETRIES);\n            std::thread::sleep(std::time::Duration::from_secs(WAIT_TIME_SECONDS));\n        }\n        println!(\"{} {} successfully closed\", \"[INFO]\".color(GREEN), process_name);\n    }\n}\n\n#[cfg(target_os = \"windows\")]\nfn update_machine_guid(backup_dir: &Path) -> bool {\n    println!(\"{} Updating MachineGuid in registry...\", \"[INFO]\".color(GREEN));\n    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);\n    let reg_path = \"SOFTWARE\\\\Microsoft\\\\Cryptography\";\n    let reg_key_name = \"MachineGuid\";\n    let full_reg_key_path_for_export = \"HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Cryptography\";\n\n    let crypto_key = match hklm.open_subkey_with_flags(reg_path, KEY_READ | KEY_WRITE) {\n        Ok(key) => key,\n        Err(e) => {\n            println!(\"{} Failed to open registry key '{}': {}. Ensure you have admin rights.\", \"[ERROR]\".color(RED), reg_path, e);\n            return false;\n        }\n    };\n\n    let current_guid_val: Result<String, _> = crypto_key.get_value(reg_key_name);\n    let original_guid = match current_guid_val {\n        Ok(guid) => {\n            println!(\"{} Current registry value:\", \"[INFO]\".color(GREEN));\n            println!(\"  {}\", full_reg_key_path_for_export);\n            println!(\"    {}    REG_SZ    {}\", reg_key_name, guid);\n            guid\n        }\n        Err(e) => {\n            println!(\"{} Unable to get current {}: {}. This might indicate a problem or the value might not exist.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            // Proceeding to set a new one if it doesn't exist, or fail if it's a permission issue.\n            String::new() // Or handle as a more critical error if needed.\n        }\n    };\n\n    if !backup_dir.exists() {\n        if let Err(e) = fs::create_dir_all(backup_dir) {\n            println!(\"{} Failed to create backup directory for registry backup: {}. Proceeding without registry backup.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n\n    let backup_file_name = format!(\"MachineGuid_{}.reg\", Local::now().format(\"%Y%m%d_%H%M%S\"));\n    let backup_file_path = backup_dir.join(&backup_file_name);\n    let backup_command_str = format!(\"reg.exe export \\\"{}\\\" \\\"{}\\\" /y\", full_reg_key_path_for_export, backup_file_path.display());\n    \n    println!(\"{} Attempting to backup registry key to: {:?}\", \"[INFO]\".color(GREEN), backup_file_path);\n    match Command::new(\"cmd\").args(&[\"/C\", &backup_command_str]).status() {\n        Ok(status) if status.success() => {\n            println!(\"{} Registry key backed up successfully.\", \"[INFO]\".color(GREEN));\n        }\n        Ok(status) => {\n            println!(\"{} Registry backup command finished with status: {}. Check permissions or if reg.exe is available.\", \"[WARNING]\".color(YELLOW), status);\n        }\n        Err(e) => {\n            println!(\"{} Failed to execute registry backup command: {}. Proceeding with caution.\", \"[WARNING]\".color(YELLOW), e);\n        }\n    }\n\n    let new_guid = Uuid::new_v4().to_string();\n    match crypto_key.set_value(reg_key_name, &new_guid) {\n        Ok(_) => {\n            println!(\"{} Registry value {} set to: {}\", \"[INFO]\".color(GREEN), reg_key_name, new_guid);\n            // Verification\n            let verify_guid: Result<String, _> = crypto_key.get_value(reg_key_name);\n            match verify_guid {\n                Ok(val) if val == new_guid => {\n                    println!(\"{} Registry update verified successfully.\", \"[INFO]\".color(GREEN));\n                    println!(\"  {}\", full_reg_key_path_for_export);\n                    println!(\"    {}    REG_SZ    {}\", reg_key_name, new_guid);\n                    true\n                }\n                Ok(val) => {\n                    println!(\"{} Registry verification failed: Updated value ({}) does not match expected value ({}).\", \"[ERROR]\".color(RED), val, new_guid);\n                    // Attempt restore\n                    false // Placeholder for restore logic\n                }\n                Err(e) => {\n                    println!(\"{} Failed to verify registry update: {}.\", \"[ERROR]\".color(RED), e);\n                    false // Placeholder for restore logic\n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to set registry value {}: {}.\", \"[ERROR]\".color(RED), reg_key_name, e);\n            // Attempt restore if original_guid was present and backup_file_path exists\n            if !original_guid.is_empty() && backup_file_path.exists() {\n                println!(\"{} Attempting to restore registry from backup: {:?}\", \"[YELLOW]\".color(YELLOW), backup_file_path);\n                let restore_command_str = format!(\"reg.exe import \\\"{}\\\"\", backup_file_path.display());\n                match Command::new(\"cmd\").args(&[\"/C\", &restore_command_str]).status() {\n                    Ok(status) if status.success() => println!(\"{} Registry restored successfully from backup.\", \"[INFO]\".color(GREEN)),\n                    Ok(status) => println!(\"{} Registry restore command failed with status: {}. Manual restore may be needed from {:?}\", \"[ERROR]\".color(RED), status, backup_file_path),\n                    Err(re) => println!(\"{} Failed to execute registry restore command: {}. Manual restore needed from {:?}\", \"[ERROR]\".color(RED), re, backup_file_path),\n                }\n            }\n            false\n        }\n    }\n}\n\n", "suffix_code": "\n", "middle_code": "fn update_storage_file(\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {\n    if !storage_file_path.exists() {\n        println!(\"{} Configuration file not found: {:?}\", \"[ERROR]\".color(RED), storage_file_path);\n        println!(\"{} Please install and run Cursor once before using this script\", \"[TIP]\".color(YELLOW));\n        return false;\n    }\n    let original_content = match fs::read_to_string(storage_file_path) {\n        Ok(content) => content,\n        Err(e) => {\n            println!(\"{} Failed to read configuration file {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n            return false;\n        }\n    };\n    let mut config: Value = match serde_json::from_str(&original_content) {\n        Ok(json_value) => json_value,\n        Err(e) => {\n            println!(\"{} Failed to parse configuration file JSON: {}\", \"[ERROR]\".color(RED), e);\n            return false;\n        }\n    };\n    if !config.get(\"telemetry\").map_or(false, |v| v.is_object()) {\n        if config.as_object_mut().is_some() { \n            config[\"telemetry\"] = serde_json::json!({});\n        } else {\n            println!(\"{} Configuration root is not a JSON object. Cannot set telemetry.\", \"[ERROR]\".color(RED));\n            return false;\n        }\n    }\n    if let Some(telemetry) = config.get_mut(\"telemetry\") {\n        if let Some(telemetry_obj) = telemetry.as_object_mut() {\n            telemetry_obj.insert(\"machineId\".to_string(), Value::String(machine_id.to_string()));\n            telemetry_obj.insert(\"macMachineId\".to_string(), Value::String(mac_machine_id.to_string()));\n            telemetry_obj.insert(\"devDeviceId\".to_string(), Value::String(dev_device_id.to_string()));\n            telemetry_obj.insert(\"sqmId\".to_string(), Value::String(sqm_id.to_string()));\n        } else {\n            println!(\"{} 'telemetry' field is not an object.\", \"[ERROR]\".color(RED));\n            return false; \n        }\n    } else {\n        println!(\"{} Failed to access or create 'telemetry' object.\", \"[ERROR]\".color(RED));\n        return false; \n    }\n    match serde_json::to_string_pretty(&config) { \n        Ok(updated_json) => {\n            match fs::write(storage_file_path, updated_json.as_bytes()) { \n                Ok(_) => {\n                    println!(\"{} Configuration file updated successfully at {:?}\", \"[INFO]\".color(GREEN), storage_file_path);\n                    true\n                }\n                Err(e) => {\n                    println!(\"{} Failed to write updated configuration to {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n                    if fs::write(storage_file_path, original_content.as_bytes()).is_err() {\n                        println!(\"{} CRITICAL: Failed to restore original content to {:?} after write error.\", \"[ERROR]\".color(RED), storage_file_path);\n                    }\n                    false\n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to serialize updated configuration to JSON: {}\", \"[ERROR]\".color(RED), e);\n            false\n        }\n    }\n}", "code_description": null, "fill_type": "FUNCTION_TYPE", "language_type": "rust", "sub_task_type": null}, "context_code": [], "task_instance_info": {"created_time": "2025-08-21 01:32:19", "created_task_model": "DeepSeek-R1", "function_skeleton": "fn update_storage_file (\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {}", "code_description": "This code segment functions to: Modify structured configuration data by updating specific identifier fields within a nested object hierarchy, ensuring data integrity through error handling and backup restoration mechanisms during file operations."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```rust\n[TASK_BEGIN]\nfn update_storage_file(\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {\n    // Read existing data or create new object\n    let mut data = if storage_file_path.exists() {\n        match fs::read_to_string(storage_file_path) {\n            Ok(contents) => match serde_json::from_str(&contents) {\n                Ok(v) => v,\n                Err(e) => {\n                    println!(\"{} Failed to parse existing storage.json: {}\", \"[ERROR]\".color(RED), e);\n                    Value::Object(serde_json::Map::new())\n                }\n            },\n            Err(e) => {\n                println!(\"{} Failed to read storage file: {}\", \"[ERROR]\".color(RED), e);\n                return false;\n            }\n        }\n    } else {\n        Value::Object(serde_json::Map::new())\n    };\n\n    // Convert to mutable object\n    if let Value::Object(ref mut obj) = data {\n        // Update top-level fields\n        obj.insert(\"machineId\".to_string(), Value::String(machine_id.to_string()));\n        obj.insert(\"macMachineId\".to_string(), Value::String(mac_machine_id.to_string()));\n        obj.insert(\"sqmId\".to_string(), Value::String(sqm_id.to_string()));\n\n        // Update device structure\n        let device_entry = obj.entry(\"device\").or_insert_with(|| Value::Object(serde_json::Map::new()));\n        if let Value::Object(ref mut device_obj) = device_entry {\n            device_obj.insert(\"id\".to_string(), Value::String(dev_device_id.to_string()));\n\n            // Update telemetry substructure\n            let telemetry_entry = device_obj.entry(\"telemetry\").or_insert_with(|| Value::Object(serde_json::Map::new()));\n            if let Value::Object(ref mut telemetry_obj) = telemetry_entry {\n                telemetry_obj.insert(\"sqmUserId\".to_string(), Value::String(sqm_id.to_string()));\n            }\n        }\n\n        // Create parent directories if needed\n        if let Some(parent) = storage_file_path.parent() {\n            if let Err(e) = fs::create_dir_all(parent) {\n                println!(\"{} Failed to create storage directory: {}\", \"[ERROR]\".color(RED), e);\n                return false;\n            }\n        }\n\n        // Write updated data\n        match fs::File::create(storage_file_path) {\n            Ok(file) => match serde_json::to_writer_pretty(file, &data) {\n                Ok(_) => true,\n                Err(e) => {\n                    println!(\"{} Failed to write storage file: {}\", \"[ERROR]\".color(RED), e);\n                    false\n                }\n            },\n            Err(e) => {\n                println!(\"{} Failed to create storage file: {}\", \"[ERROR]\".color(RED), e);\n                false\n            }\n        }\n    } else {\n        println!(\"{} Invalid JSON structure - expected root object\", \"[ERROR]\".color(RED));\n        false\n    }\n}\n[TASK_END]\n```", "inference_time": "2025-08-21 01-33-09"}, "editdistance_info": {"edit_distance": 32.618, "calculate_time": "2025-08-21 01:33:09", "true_code_clean": "fn update_storage_file(\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {\n    if !storage_file_path.exists() {\n        println!(\"{} Configuration file not found: {:?}\", \"[ERROR]\".color(RED), storage_file_path);\n        println!(\"{} Please install and run Cursor once before using this script\", \"[TIP]\".color(YELLOW));\n        return false;\n    }\n    let original_content = match fs::read_to_string(storage_file_path) {\n        Ok(content) => content,\n        Err(e) => {\n            println!(\"{} Failed to read configuration file {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n            return false;\n        }\n    };\n    let mut config: Value = match serde_json::from_str(&original_content) {\n        Ok(json_value) => json_value,\n        Err(e) => {\n            println!(\"{} Failed to parse configuration file JSON: {}\", \"[ERROR]\".color(RED), e);\n            return false;\n        }\n    };\n    if !config.get(\"telemetry\").map_or(false, |v| v.is_object()) {\n        if config.as_object_mut().is_some() { \n            config[\"telemetry\"] = serde_json::json!({});\n        } else {\n            println!(\"{} Configuration root is not a JSON object. Cannot set telemetry.\", \"[ERROR]\".color(RED));\n            return false;\n        }\n    }\n    if let Some(telemetry) = config.get_mut(\"telemetry\") {\n        if let Some(telemetry_obj) = telemetry.as_object_mut() {\n            telemetry_obj.insert(\"machineId\".to_string(), Value::String(machine_id.to_string()));\n            telemetry_obj.insert(\"macMachineId\".to_string(), Value::String(mac_machine_id.to_string()));\n            telemetry_obj.insert(\"devDeviceId\".to_string(), Value::String(dev_device_id.to_string()));\n            telemetry_obj.insert(\"sqmId\".to_string(), Value::String(sqm_id.to_string()));\n        } else {\n            println!(\"{} 'telemetry' field is not an object.\", \"[ERROR]\".color(RED));\n            return false; \n        }\n    } else {\n        println!(\"{} Failed to access or create 'telemetry' object.\", \"[ERROR]\".color(RED));\n        return false; \n    }\n    match serde_json::to_string_pretty(&config) { \n        Ok(updated_json) => {\n            match fs::write(storage_file_path, updated_json.as_bytes()) { \n                Ok(_) => {\n                    println!(\"{} Configuration file updated successfully at {:?}\", \"[INFO]\".color(GREEN), storage_file_path);\n                    true\n                }\n                Err(e) => {\n                    println!(\"{} Failed to write updated configuration to {:?}: {}\", \"[ERROR]\".color(RED), storage_file_path, e);\n                    if fs::write(storage_file_path, original_content.as_bytes()).is_err() {\n                        println!(\"{} CRITICAL: Failed to restore original content to {:?} after write error.\", \"[ERROR]\".color(RED), storage_file_path);\n                    }\n                    false\n                }\n            }\n        }\n        Err(e) => {\n            println!(\"{} Failed to serialize updated configuration to JSON: {}\", \"[ERROR]\".color(RED), e);\n            false\n        }\n    }\n}", "predict_code_clean": "fn update_storage_file(\n    storage_file_path: &Path,\n    machine_id: &str,\n    mac_machine_id: &str,\n    dev_device_id: &str,\n    sqm_id: &str,\n) -> bool {\n    let mut data = if storage_file_path.exists() {\n        match fs::read_to_string(storage_file_path) {\n            Ok(contents) => match serde_json::from_str(&contents) {\n                Ok(v) => v,\n                Err(e) => {\n                    println!(\"{} Failed to parse existing storage.json: {}\", \"[ERROR]\".color(RED), e);\n                    Value::Object(serde_json::Map::new())\n                }\n            },\n            Err(e) => {\n                println!(\"{} Failed to read storage file: {}\", \"[ERROR]\".color(RED), e);\n                return false;\n            }\n        }\n    } else {\n        Value::Object(serde_json::Map::new())\n    };\n    if let Value::Object(ref mut obj) = data {\n        obj.insert(\"machineId\".to_string(), Value::String(machine_id.to_string()));\n        obj.insert(\"macMachineId\".to_string(), Value::String(mac_machine_id.to_string()));\n        obj.insert(\"sqmId\".to_string(), Value::String(sqm_id.to_string()));\n        let device_entry = obj.entry(\"device\").or_insert_with(|| Value::Object(serde_json::Map::new()));\n        if let Value::Object(ref mut device_obj) = device_entry {\n            device_obj.insert(\"id\".to_string(), Value::String(dev_device_id.to_string()));\n            let telemetry_entry = device_obj.entry(\"telemetry\").or_insert_with(|| Value::Object(serde_json::Map::new()));\n            if let Value::Object(ref mut telemetry_obj) = telemetry_entry {\n                telemetry_obj.insert(\"sqmUserId\".to_string(), Value::String(sqm_id.to_string()));\n            }\n        }\n        if let Some(parent) = storage_file_path.parent() {\n            if let Err(e) = fs::create_dir_all(parent) {\n                println!(\"{} Failed to create storage directory: {}\", \"[ERROR]\".color(RED), e);\n                return false;\n            }\n        }\n        match fs::File::create(storage_file_path) {\n            Ok(file) => match serde_json::to_writer_pretty(file, &data) {\n                Ok(_) => true,\n                Err(e) => {\n                    println!(\"{} Failed to write storage file: {}\", \"[ERROR]\".color(RED), e);\n                    false\n                }\n            },\n            Err(e) => {\n                println!(\"{} Failed to create storage file: {}\", \"[ERROR]\".color(RED), e);\n                false\n            }\n        }\n    } else {\n        println!(\"{} Invalid JSON structure - expected root object\", \"[ERROR]\".color(RED));\n        false\n    }\n}"}}