Merge branch 'installer' into 'master'

UI fixes

See merge request cleanflash/installer!3

.gitignore

@@ -16,8 +16,3 @@ obj
 *.7z
 
 target
-
-macinstaller
-trueinstaller
-build*.sh
-bundle_macos.sh

rust/Cargo.toml

@@ -11,9 +11,6 @@ members = [
 ab_glyph = "0.2"
 sevenz-rust2 = { version = "0.20", default-features = false, features = ["compress", "util"] }
 minifb = "0.28"
-argh = "0.1.19"
-ratatui = "0.30"
-crossterm = "0.29"
 windows-sys = { version = "0.61", features = [
     "Win32_Foundation",
     "Win32_Networking_WinHttp",

rust/crates/clean_flash_common/src/native_host.rs

@@ -9,7 +9,7 @@ use std::path::{Path, PathBuf};
 
 const MANIFEST_NAME: &str = "org.cleanflash.flash_player";
 const FIREFOX_MANIFEST_FILENAME: &str = "clean_flash_firefox.json";
-const CHROME_MANIFEST_FILENAME: &str = "org.cleanflash.flash_player.json";
+const CHROME_MANIFEST_FILENAME: &str = "clean_flash_chrome.json";
 const FIREFOX_ALLOWED_EXTENSION: &str = "flash-player@cleanflash.org";
 const ALLOWED_ORIGIN: &str = "chrome-extension://dcikaadaeajidejkoekdflmfdgeoldcb/";
 

rust/crates/clean_flash_common/src/registry.rs

@@ -1,235 +1,47 @@
-use crate::{system_info, InstallError};
+use crate::{process_utils, system_info, InstallError};
+use std::fs;
+use std::io::Write;
 
-/// Apply registry entries using native Windows registry APIs.
+/// Apply registry contents by writing a .reg file and importing with reg.exe.
-///
-/// The entries are in .reg file format (without the header line).
-/// Supported syntax:
-/// - `[HKEY_xxx\path]` — create/open key
-/// - `[-HKEY_xxx\path]` — delete entire key tree
-/// - `"name"="string_value"` — set REG_SZ value
-/// - `"name"=dword:XXXXXXXX` — set REG_DWORD value
-/// - `"name"=-` — delete a value
-/// - `@="string_value"` — set the default (unnamed) value
 #[cfg(windows)]
 pub fn apply_registry(entries: &[&str]) -> Result<(), InstallError> {
     let combined = entries.join("\n\n");
     let filled = system_info::fill_string(&combined);
-    apply_reg_content(&filled)
-}
-
-#[cfg(windows)]
-fn apply_reg_content(content: &str) -> Result<(), InstallError> {
-    use windows_sys::Win32::System::Registry::{
-        RegCloseKey, RegCreateKeyExW, RegDeleteValueW, RegSetValueExW,
-        KEY_WOW64_64KEY, KEY_WRITE, REG_DWORD, REG_OPTION_NON_VOLATILE, REG_SZ,
-    };
-
-    let mut current_hkey: Option<windows_sys::Win32::System::Registry::HKEY> = None;
-
-    for line in content.lines() {
-        let line = line.trim();
-        if line.is_empty() {
-            continue;
-        }
-
-        // Delete key: [-HKEY_xxx\path]
-        if line.starts_with("[-") && line.ends_with(']') {
-            if let Some(hk) = current_hkey.take() {
-                unsafe { RegCloseKey(hk) };
-            }
-
-            let key_path = &line[2..line.len() - 1];
-            if let Some((root, subkey)) = parse_root_and_subkey(key_path) {
-                delete_key_tree(root, subkey);
-            }
-            continue;
-        }
-
-        // Open/create key: [HKEY_xxx\path]
-        if line.starts_with('[') && line.ends_with(']') {
-            if let Some(hk) = current_hkey.take() {
-                unsafe { RegCloseKey(hk) };
-            }
-
-            let key_path = &line[1..line.len() - 1];
-            if let Some((root, subkey)) = parse_root_and_subkey(key_path) {
-                let subkey_wide: Vec<u16> =
-                    subkey.encode_utf16().chain(std::iter::once(0)).collect();
-                unsafe {
-                    let mut hkey = std::ptr::null_mut();
-                    let mut disposition: u32 = 0;
-                    let result = RegCreateKeyExW(
-                        root,
-                        subkey_wide.as_ptr(),
-                        0,
-                        std::ptr::null(),
-                        REG_OPTION_NON_VOLATILE,
-                        KEY_WRITE | KEY_WOW64_64KEY,
-                        std::ptr::null(),
-                        &mut hkey,
-                        &mut disposition,
-                    );
-                    if result == 0 {
-                        current_hkey = Some(hkey);
-                    }
-                }
-            }
-            continue;
-        }
-
-        // Value operations require an open key.
-        let Some(hkey) = current_hkey else {
-            continue;
-        };
-
-        // Default value: @="value"
-        if let Some(rest) = line.strip_prefix("@=") {
-            if let Some(val) = parse_reg_string(rest) {
-                let val_wide: Vec<u16> =
-                    val.encode_utf16().chain(std::iter::once(0)).collect();
-                unsafe {
-                    RegSetValueExW(
-                        hkey,
-                        std::ptr::null(),
-                        0,
-                        REG_SZ as u32,
-                        val_wide.as_ptr() as *const u8,
-                        (val_wide.len() * 2) as u32,
-                    );
-                }
-            }
-            continue;
-        }
-
-        // Named value: "name"=...
-        if !line.starts_with('"') {
-            continue;
-        }
-
-        let Some((name, value_part)) = parse_name_and_value(line) else {
-            continue;
-        };
-
-        let name_wide: Vec<u16> = name.encode_utf16().chain(std::iter::once(0)).collect();
-
-        // Delete value: "name"=-
-        if value_part == "-" {
-            unsafe {
-                RegDeleteValueW(hkey, name_wide.as_ptr());
-            }
-            continue;
-        }
 
-        // DWORD value: "name"=dword:XXXXXXXX
+    let content = format!("Windows Registry Editor Version 5.00\n\n{}", filled);
-        if let Some(hex_str) = value_part.strip_prefix("dword:") {
+
-            if let Ok(dword_val) = u32::from_str_radix(hex_str, 16) {
+    let temp_dir = std::env::temp_dir();
-                unsafe {
+    // Include the process ID to avoid collisions when two instances run concurrently,
-                    RegSetValueExW(
+    // matching the unique-file guarantee of C#'s Path.GetTempFileName().
-                        hkey,
+    let reg_file = temp_dir.join(format!("cleanflash_reg_{}.tmp", std::process::id()));
-                        name_wide.as_ptr(),
+
-                        0,
+    // Write as UTF-16LE with BOM (Windows .reg format).
-                        REG_DWORD as u32,
+    {
-                        &dword_val as *const u32 as *const u8,
+        let mut f = fs::File::create(&reg_file)
-                        4,
+            .map_err(|e| InstallError::new(format!("Failed to create temp reg file: {}", e)))?;
-                    );
+        let utf16: Vec<u16> = content.encode_utf16().collect();
-                }
+        // BOM
-            }
+        f.write_all(&[0xFF, 0xFE])
-            continue;
+            .map_err(|e| InstallError::new(format!("Failed to write BOM: {}", e)))?;
-        }
+        for word in &utf16 {
-
+            f.write_all(&word.to_le_bytes())
-        // String value: "name"="value"
+                .map_err(|e| InstallError::new(format!("Failed to write reg data: {}", e)))?;
-        if let Some(val) = parse_reg_string(value_part) {
-            let val_wide: Vec<u16> = val.encode_utf16().chain(std::iter::once(0)).collect();
-            unsafe {
-                RegSetValueExW(
-                    hkey,
-                    name_wide.as_ptr(),
-                    0,
-                    REG_SZ as u32,
-                    val_wide.as_ptr() as *const u8,
-                    (val_wide.len() * 2) as u32,
-                );
-            }
-            continue;
         }
     }
 
-    if let Some(hk) = current_hkey {
+    let reg_filename = reg_file.to_string_lossy().to_string();
-        unsafe { RegCloseKey(hk) };
+    let result = process_utils::run_process("reg.exe", &["import", &reg_filename]);
-    }
-
-    Ok(())
-}
-
-/// Parse a root key name and subkey path from a combined string like
-/// `HKEY_LOCAL_MACHINE\Software\Something`.
-#[cfg(windows)]
-fn parse_root_and_subkey(
-    path: &str,
-) -> Option<(windows_sys::Win32::System::Registry::HKEY, &str)> {
-    use windows_sys::Win32::System::Registry::{
-        HKEY_CLASSES_ROOT, HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE, HKEY_USERS,
-    };
-
-    let (root_name, subkey) = path.split_once('\\')?;
-    let root = match root_name {
-        "HKEY_LOCAL_MACHINE" => HKEY_LOCAL_MACHINE,
-        "HKEY_CURRENT_USER" => HKEY_CURRENT_USER,
-        "HKEY_CLASSES_ROOT" => HKEY_CLASSES_ROOT,
-        "HKEY_USERS" => HKEY_USERS,
-        _ => return None,
-    };
-    Some((root, subkey))
-}
-
-/// Delete an entire registry key tree.
-#[cfg(windows)]
-fn delete_key_tree(root: windows_sys::Win32::System::Registry::HKEY, subkey: &str) {
-    use windows_sys::Win32::System::Registry::{
-        RegCloseKey, RegDeleteTreeW, RegOpenKeyExW, KEY_WOW64_64KEY, KEY_WRITE,
-    };
 
-    if let Some((parent, leaf)) = subkey.rsplit_once('\\') {
+    let _ = fs::remove_file(&reg_file);
-        let parent_wide: Vec<u16> = parent.encode_utf16().chain(std::iter::once(0)).collect();
-        let leaf_wide: Vec<u16> = leaf.encode_utf16().chain(std::iter::once(0)).collect();
-        unsafe {
-            let mut hkey = std::ptr::null_mut();
-            let result =
-                RegOpenKeyExW(root, parent_wide.as_ptr(), 0, KEY_WRITE | KEY_WOW64_64KEY, &mut hkey);
-            if result == 0 {
-                RegDeleteTreeW(hkey, leaf_wide.as_ptr());
-                RegCloseKey(hkey);
-            }
-        }
-    } else {
-        let subkey_wide: Vec<u16> = subkey.encode_utf16().chain(std::iter::once(0)).collect();
-        unsafe {
-            RegDeleteTreeW(root, subkey_wide.as_ptr());
-        }
-    }
-}
 
-/// Parse a quoted string value: `"some value"` → `some value`.
+    if !result.is_successful() {
-/// Handles escaped backslashes (`\\` → `\`) inside the string.
+        return Err(InstallError::new(format!(
-#[cfg(windows)]
+            "Failed to apply changes to registry: error code {}\n\n{}",
-fn parse_reg_string(s: &str) -> Option<String> {
+            result.exit_code, result.output
-    let s = s.trim();
+        )));
-    if !s.starts_with('"') || !s.ends_with('"') || s.len() < 2 {
-        return None;
     }
-    let inner = &s[1..s.len() - 1];
-    Some(inner.replace("\\\\", "\\"))
-}
 
-/// Parse `"name"=value` into `(name, value)`.
+    Ok(())
-#[cfg(windows)]
-fn parse_name_and_value(line: &str) -> Option<(String, &str)> {
-    let rest = &line[1..]; // skip opening "
-    let end_quote = rest.find('"')?;
-    let name = &rest[..end_quote];
-    let after_name = &rest[end_quote + 1..]; // skip closing "
-    let value_part = after_name.strip_prefix('=')?;
-    Some((name.to_string(), value_part))
 }
 
 #[cfg(not(windows))]

rust/crates/clean_flash_common/src/uninstaller_linux.rs

@@ -6,6 +6,7 @@ use std::fs;
 /// This removes the native messaging host binary, the Pepper (pp64) files
 /// installed alongside it, and the browser manifests.
 pub fn uninstall(form: &dyn ProgressCallback) -> Result<(), InstallError> {
+    form.update_progress_label("Removing native messaging host...", true);
     native_host::uninstall_native_host(form);
 
     // Remove the entire install directory (host binary + pp64 files).

rust/crates/clean_flash_installer/Cargo.toml

@@ -10,9 +10,6 @@ clean_flash_ui = { path = "../clean_flash_ui" }
 minifb = { workspace = true }
 windows-sys = { workspace = true }
 sevenz-rust2 = { workspace = true }
-argh = { workspace = true }
-ratatui = { workspace = true }
-crossterm = { workspace = true }
 
 [build-dependencies]
 winresource = "0.1"

rust/crates/clean_flash_installer/build.rs

@@ -1,18 +1,4 @@
 fn main() {
-    // On macOS, embed Info.plist into the binary so the OS recognises it as a GUI app.
-    if cfg!(target_os = "macos") {
-        let plist = std::path::Path::new("../../resources/macos/installer-Info.plist");
-        if plist.exists() {
-            println!("cargo:rustc-link-arg=-sectcreate");
-            println!("cargo:rustc-link-arg=__TEXT");
-            println!("cargo:rustc-link-arg=__info_plist");
-            println!(
-                "cargo:rustc-link-arg={}",
-                plist.canonicalize().unwrap().display()
-            );
-        }
-    }
-
     // Set application icon from .ico resource (if present).
     if cfg!(target_os = "windows") {
         let mut res = winresource::WindowsResource::new();

rust/crates/clean_flash_installer/src/cli_args.rs

@@ -1,70 +0,0 @@
-use argh::FromArgs;
-
-/// Clean Flash Player Installer
-///
-/// Install Clean Flash Player with GUI, TUI, or silent mode.
-#[derive(FromArgs)]
-pub struct InstallerArgs {
-    /// use the terminal UI (ratatui) instead of the graphical window
-    #[argh(switch)]
-    pub cli: bool,
-
-    /// run the installation non-interactively (no GUI or TUI)
-    #[argh(switch)]
-    pub install: bool,
-
-    /// suppress all output (only valid with --install)
-    #[argh(switch)]
-    pub silent: bool,
-
-    /// install the Modern Browsers (MV3) native host
-    #[argh(switch)]
-    pub native_host: bool,
-
-    /// install the Pepper API (PPAPI) plugin
-    #[argh(switch)]
-    pub pepper: bool,
-
-    /// install the Netscape API (NPAPI) plugin
-    #[argh(switch)]
-    pub netscape: bool,
-
-    /// install the ActiveX (OCX) plugin
-    #[argh(switch)]
-    pub activex: bool,
-
-    /// install the standalone Flash Player
-    #[argh(switch)]
-    pub player: bool,
-
-    /// create desktop shortcuts for standalone player (requires --player)
-    #[argh(switch)]
-    pub player_desktop: bool,
-
-    /// create start menu shortcuts for standalone player (requires --player)
-    #[argh(switch)]
-    pub player_start_menu: bool,
-
-    /// install the debug version
-    #[argh(switch)]
-    pub debug: bool,
-}
-
-/// The mode in which the application should run.
-pub enum RunMode {
-    Gui,
-    Tui,
-    Silent,
-}
-
-impl InstallerArgs {
-    pub fn determine_mode(&self) -> RunMode {
-        if self.install {
-            RunMode::Silent
-        } else if self.cli {
-            RunMode::Tui
-        } else {
-            RunMode::Gui
-        }
-    }
-}

rust/crates/clean_flash_installer/src/installer_windows.rs

@@ -5,8 +5,6 @@ use clean_flash_common::{
 use std::env;
 use std::fs;
 use std::io::{self, Cursor};
-#[cfg(windows)]
-use std::os::windows::ffi::OsStrExt;
 use std::path::{Path, PathBuf};
 
 /// Metadata for a single installable component.
@@ -48,170 +46,35 @@ pub fn register_activex(filename: &str) -> Result<(), InstallError> {
     Ok(())
 }
 
-/// Create a Windows shortcut (.lnk) using native COM APIs (IShellLinkW + IPersistFile).
+/// Create a Windows shortcut (.lnk) using a PowerShell one-liner.
-#[cfg(windows)]
 fn create_shortcut(
     folder: &Path,
     executable: &Path,
     name: &str,
     description: &str,
 ) -> Result<(), InstallError> {
-    use std::ffi::c_void;
+    let lnk_path = folder.join(format!("{}.lnk", name));
-
+    let exe_str = executable.to_string_lossy();
-    // COM GUIDs.
+    let lnk_str = lnk_path.to_string_lossy();
-    const CLSID_SHELL_LINK: windows_sys::core::GUID =
+
-        windows_sys::core::GUID::from_u128(0x00021401_0000_0000_c000_000000000046);
+    // Use PowerShell to create the shortcut via WScript.Shell COM.
-    const IID_ISHELL_LINK_W: windows_sys::core::GUID =
+    let script = format!(
-        windows_sys::core::GUID::from_u128(0x000214F9_0000_0000_C000_000000000046);
+        "$ws = New-Object -ComObject WScript.Shell; \
-    const IID_IPERSIST_FILE: windows_sys::core::GUID =
+         $s = $ws.CreateShortcut('{}'); \
-        windows_sys::core::GUID::from_u128(0x0000010b_0000_0000_C000_000000000046);
+         $s.TargetPath = '{}'; \
-
+         $s.Description = '{}'; \
-    // IShellLinkW vtable layout — we only need SetPath, SetDescription, SetIconLocation.
+         $s.IconLocation = '{}'; \
-    // Vtable indices (0-based from IUnknown):
+         $s.Save()",
-    //  0: QueryInterface, 1: AddRef, 2: Release,
+        lnk_str, exe_str, description, exe_str
-    //  3: GetPath, 4: GetIDList, 5: SetIDList, 6: GetDescription,
+    );
-    //  7: SetDescription, 8: GetWorkingDirectory, 9: SetWorkingDirectory,
+
-    // 10: GetArguments, 11: SetArguments, 12: GetHotkey, 13: SetHotkey,
+    let result = process_utils::run_process("powershell.exe", &["-NoProfile", "-Command", &script]);
-    // 14: GetShowCmd, 15: SetShowCmd, 16: GetIconLocation, 17: SetIconLocation,
+    if !result.is_successful() {
-    // 18: SetRelativePath, 19: Resolve, 20: SetPath
+        return Err(InstallError::new(format!(
-    const VTBL_SET_DESCRIPTION: usize = 7;
+            "Failed to create shortcut: {}",
-    const VTBL_SET_ICON_LOCATION: usize = 17;
+            result.output
-    const VTBL_SET_PATH: usize = 20;
+        )));
-
-    // IPersistFile vtable layout:
-    //  0: QueryInterface, 1: AddRef, 2: Release,
-    //  3: GetClassID (IPersist),
-    //  4: IsDirty, 5: Load, 6: Save, 7: SaveCompleted, 8: GetCurFile
-    const VTBL_SAVE: usize = 6;
-
-    type ComMethodFn = unsafe extern "system" fn() -> i32;
-
-    unsafe {
-        // Initialize COM (apartment-threaded).
-        let hr = CoInitializeEx(std::ptr::null(), 0x2 /* COINIT_APARTMENTTHREADED */);
-        if hr < 0 {
-            return Err(InstallError::new(format!(
-                "CoInitializeEx failed: 0x{:08X}",
-                hr
-            )));
-        }
-
-        let mut shell_link: *mut c_void = std::ptr::null_mut();
-        let hr = CoCreateInstance(
-            &CLSID_SHELL_LINK,
-            std::ptr::null(),
-            1, // CLSCTX_INPROC_SERVER
-            &IID_ISHELL_LINK_W,
-            &mut shell_link,
-        );
-        if hr < 0 {
-            CoUninitialize();
-            return Err(InstallError::new(format!(
-                "CoCreateInstance for IShellLinkW failed: 0x{:08X}",
-                hr
-            )));
-        }
-
-        // Get the vtable.
-        let vtable = *(shell_link as *const *const *const ComMethodFn);
-
-        // SetPath
-        let exe_wide: Vec<u16> = executable
-            .as_os_str()
-            .encode_wide()
-            .chain(std::iter::once(0))
-            .collect();
-        let set_path: unsafe extern "system" fn(*mut c_void, *const u16) -> i32 =
-            std::mem::transmute(*vtable.add(VTBL_SET_PATH));
-        set_path(shell_link, exe_wide.as_ptr());
-
-        // SetDescription
-        let desc_wide: Vec<u16> = description.encode_utf16().chain(std::iter::once(0)).collect();
-        let set_description: unsafe extern "system" fn(*mut c_void, *const u16) -> i32 =
-            std::mem::transmute(*vtable.add(VTBL_SET_DESCRIPTION));
-        set_description(shell_link, desc_wide.as_ptr());
-
-        // SetIconLocation
-        let set_icon_location: unsafe extern "system" fn(*mut c_void, *const u16, i32) -> i32 =
-            std::mem::transmute(*vtable.add(VTBL_SET_ICON_LOCATION));
-        set_icon_location(shell_link, exe_wide.as_ptr(), 0);
-
-        // QueryInterface for IPersistFile.
-        let query_interface: unsafe extern "system" fn(
-            *mut c_void,
-            *const windows_sys::core::GUID,
-            *mut *mut c_void,
-        ) -> i32 = std::mem::transmute(*vtable.add(0));
-        let mut persist_file: *mut c_void = std::ptr::null_mut();
-        let hr = query_interface(shell_link, &IID_IPERSIST_FILE, &mut persist_file);
-        if hr < 0 {
-            // Release IShellLinkW.
-            let release: unsafe extern "system" fn(*mut c_void) -> u32 =
-                std::mem::transmute(*vtable.add(2));
-            release(shell_link);
-            CoUninitialize();
-            return Err(InstallError::new(format!(
-                "QueryInterface for IPersistFile failed: 0x{:08X}",
-                hr
-            )));
-        }
-
-        // Save the .lnk file.
-        let lnk_path = folder.join(format!("{}.lnk", name));
-        let lnk_wide: Vec<u16> = lnk_path
-            .as_os_str()
-            .encode_wide()
-            .chain(std::iter::once(0))
-            .collect();
-        let pf_vtable = *(persist_file as *const *const *const ComMethodFn);
-        let save: unsafe extern "system" fn(*mut c_void, *const u16, i32) -> i32 =
-            std::mem::transmute(*pf_vtable.add(VTBL_SAVE));
-        let hr = save(persist_file, lnk_wide.as_ptr(), 1 /* TRUE */);
-
-        // Release IPersistFile.
-        let pf_release: unsafe extern "system" fn(*mut c_void) -> u32 =
-            std::mem::transmute(*pf_vtable.add(2));
-        pf_release(persist_file);
-
-        // Release IShellLinkW.
-        let release: unsafe extern "system" fn(*mut c_void) -> u32 =
-            std::mem::transmute(*vtable.add(2));
-        release(shell_link);
-
-        CoUninitialize();
-
-        if hr < 0 {
-            return Err(InstallError::new(format!(
-                "IPersistFile::Save failed: 0x{:08X}",
-                hr
-            )));
-        }
     }
-
-    Ok(())
-}
-
-#[cfg(windows)]
-#[link(name = "ole32")]
-extern "system" {
-    fn CoInitializeEx(pvreserved: *const std::ffi::c_void, dwcoinit: u32) -> i32;
-    fn CoCreateInstance(
-        rclsid: *const windows_sys::core::GUID,
-        punkouter: *const std::ffi::c_void,
-        dwclscontext: u32,
-        riid: *const windows_sys::core::GUID,
-        ppv: *mut *mut std::ffi::c_void,
-    ) -> i32;
-    fn CoUninitialize();
-}
-
-#[cfg(not(windows))]
-fn create_shortcut(
-    _folder: &Path,
-    _executable: &Path,
-    _name: &str,
-    _description: &str,
-) -> Result<(), InstallError> {
     Ok(())
 }
 

rust/crates/clean_flash_installer/src/main.rs

@@ -1,10 +1,7 @@
 #![windows_subsystem = "windows"]
 
-mod cli_args;
 mod install_flags;
 mod install_form;
-mod silent_installer;
-mod tui_installer;
 
 #[cfg(windows)]
 #[path = "installer_windows.rs"]
@@ -14,12 +11,11 @@ mod installer;
 #[path = "installer_linux.rs"]
 mod installer;
 
-use cli_args::{InstallerArgs, RunMode};
 use install_form::{InstallForm, HEIGHT, WIDTH};
 use clean_flash_ui::renderer::Renderer;
 use minifb::{Key, MouseButton, MouseMode, Window, WindowOptions};
 
-fn run_gui() {
+fn main() {
     let title = format!(
         "Clean Flash Player {} Installer",
         clean_flash_common::update_checker::FLASH_VERSION
@@ -68,33 +64,3 @@ fn run_gui() {
             .expect("Failed to update window buffer");
     }
 }
-
-fn main() {
-    let args: InstallerArgs = argh::from_env();
-
-    match args.determine_mode() {
-        RunMode::Silent => {
-            if let Err(e) = silent_installer::run_silent_install(&args) {
-                eprintln!("[!] Fatal error: {}", e);
-                std::process::exit(1);
-            }
-        }
-        RunMode::Tui => {
-            if let Err(e) = tui_installer::run_tui_installer() {
-                eprintln!("[!] TUI error: {}", e);
-                std::process::exit(1);
-            }
-        }
-        RunMode::Gui => {
-            // Try GUI; fall back to TUI if window creation fails.
-            let gui_result = std::panic::catch_unwind(run_gui);
-            if gui_result.is_err() {
-                eprintln!("GUI failed to initialize, falling back to terminal UI...");
-                if let Err(e) = tui_installer::run_tui_installer() {
-                    eprintln!("[!] TUI error: {}", e);
-                    std::process::exit(1);
-                }
-            }
-        }
-    }
-}

rust/crates/clean_flash_installer/src/silent_installer.rs

@@ -1,81 +0,0 @@
-use crate::cli_args::InstallerArgs;
-use crate::install_flags::{self, InstallFlags};
-use crate::installer;
-use clean_flash_common::{uninstaller, redirection, update_checker, ProgressCallback, InstallError};
-
-struct SilentProgressCallback {
-    silent: bool,
-}
-
-impl ProgressCallback for SilentProgressCallback {
-    fn update_progress_label(&self, text: &str, _tick: bool) {
-        if !self.silent {
-            eprintln!("[*] {}", text);
-        }
-    }
-
-    fn tick_progress(&self) {}
-}
-
-pub fn run_silent_install(args: &InstallerArgs) -> Result<(), Box<dyn std::error::Error>> {
-    let version = update_checker::FLASH_VERSION;
-
-    let mut flags = InstallFlags::new();
-    flags.set_conditionally(args.native_host, install_flags::NATIVE_HOST);
-    flags.set_conditionally(args.pepper, install_flags::PEPPER);
-    flags.set_conditionally(args.netscape, install_flags::NETSCAPE);
-    flags.set_conditionally(args.activex, install_flags::ACTIVEX);
-    flags.set_conditionally(args.player, install_flags::PLAYER);
-    flags.set_conditionally(args.player_desktop, install_flags::PLAYER_DESKTOP);
-    flags.set_conditionally(args.player_start_menu, install_flags::PLAYER_START_MENU);
-    flags.set_conditionally(args.debug, install_flags::DEBUG);
-
-    if flags.is_none_set() {
-        if !args.silent {
-            eprintln!("No components selected. Use flags to select what to install:");
-            eprintln!("  --native-host   Modern Browsers (MV3)");
-            eprintln!("  --pepper        Pepper API (PPAPI)");
-            eprintln!("  --netscape      Netscape API (NPAPI)");
-            eprintln!("  --activex       ActiveX (OCX)");
-            eprintln!("  --player        Standalone Flash Player");
-            eprintln!("  --player-desktop    Desktop shortcuts (requires --player)");
-            eprintln!("  --player-start-menu Start Menu shortcuts (requires --player)");
-            eprintln!("  --debug         Debug version");
-            eprintln!("\nExample: clean_flash_installer --install --native-host --pepper");
-        }
-        std::process::exit(1);
-    }
-
-    if !args.silent {
-        eprintln!("Clean Flash Player {} - Installation", version);
-    }
-
-    let callback = SilentProgressCallback {
-        silent: args.silent,
-    };
-
-    let redir = redirection::disable_redirection();
-
-    let result = (|| -> Result<(), InstallError> {
-        uninstaller::uninstall(&callback)?;
-        installer::install(&callback, &mut flags)?;
-        Ok(())
-    })();
-
-    redirection::enable_redirection(redir);
-
-    match result {
-        Ok(()) => {
-            if !args.silent {
-                eprintln!("[+] Installation completed successfully.");
-            }
-            Ok(())
-        }
-        Err(e) => {
-            if !args.silent {
-                eprintln!("[!] Installation failed: {}", e);
-            }
-            std::process::exit(1);
-        }
-    }
-}

rust/crates/clean_flash_installer/src/tui_installer.rs

@@ -1,639 +0,0 @@
-use crate::install_flags::{self, InstallFlags};
-use crate::installer;
-use clean_flash_common::{uninstaller, redirection, update_checker, ProgressCallback, InstallError};
-use crossterm::{
-    event::{self, Event, KeyCode, KeyEventKind},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    execute,
-};
-use ratatui::{
-    prelude::*,
-    widgets::{Block, Borders, Gauge, List, ListItem, Paragraph, Wrap},
-};
-use std::io::{self, stdout};
-use std::sync::{Arc, Mutex};
-
-const FLASH_VERSION: &str = update_checker::FLASH_VERSION;
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum Panel {
-    Disclaimer,
-    Choice,
-    PlayerChoice,
-    DebugChoice,
-    BeforeInstall,
-    Install,
-    Complete,
-    Failure,
-}
-
-struct ProgressState {
-    label: String,
-    value: u32,
-    maximum: u32,
-    done: bool,
-    error: Option<String>,
-}
-
-struct TuiInstallState {
-    panel: Panel,
-    // Disclaimer
-    disclaimer_accepted: bool,
-    // Choice
-    native_host: bool,
-    pepper: bool,
-    netscape: bool,
-    activex: bool,
-    choice_cursor: usize,
-    // Player choice
-    player: bool,
-    player_desktop: bool,
-    player_start_menu: bool,
-    player_cursor: usize,
-    // Debug
-    debug_chosen: bool,
-    // Progress
-    progress: Arc<Mutex<ProgressState>>,
-    // Failure
-    failure_detail: String,
-}
-
-impl TuiInstallState {
-    fn new() -> Self {
-        Self {
-            panel: Panel::Disclaimer,
-            disclaimer_accepted: false,
-            native_host: true,
-            pepper: false,
-            netscape: false,
-            activex: false,
-            choice_cursor: 0,
-            player: false,
-            player_desktop: false,
-            player_start_menu: false,
-            player_cursor: 0,
-            debug_chosen: false,
-            progress: Arc::new(Mutex::new(ProgressState {
-                label: "Preparing...".into(),
-                value: 0,
-                maximum: 10,
-                done: false,
-                error: None,
-            })),
-            failure_detail: String::new(),
-        }
-    }
-
-    fn choice_items(&self) -> Vec<(&str, bool, bool)> {
-        let is_windows = cfg!(target_os = "windows");
-        vec![
-            ("Modern Browsers (MV3) - Chrome/Firefox/Edge", self.native_host, true),
-            ("Pepper API (PPAPI) - Chrome/Opera/Brave", self.pepper, is_windows),
-            ("Netscape API (NPAPI) - Firefox/ESR/Waterfox", self.netscape, is_windows),
-            ("ActiveX (OCX) - IE/Embedded/Desktop", self.activex, is_windows),
-        ]
-    }
-
-    fn player_items(&self) -> Vec<(&str, bool, bool)> {
-        vec![
-            ("Install Standalone Flash Player", self.player, true),
-            ("Create Desktop Shortcuts", self.player_desktop, self.player),
-            ("Create Start Menu Shortcuts", self.player_start_menu, self.player),
-        ]
-    }
-
-    fn toggle_choice(&mut self) {
-        let is_windows = cfg!(target_os = "windows");
-        match self.choice_cursor {
-            0 => self.native_host = !self.native_host,
-            1 if is_windows => self.pepper = !self.pepper,
-            2 if is_windows => self.netscape = !self.netscape,
-            3 if is_windows => self.activex = !self.activex,
-            _ => {}
-        }
-    }
-
-    fn toggle_player(&mut self) {
-        match self.player_cursor {
-            0 => {
-                self.player = !self.player;
-                if !self.player {
-                    self.player_desktop = false;
-                    self.player_start_menu = false;
-                }
-            }
-            1 if self.player => self.player_desktop = !self.player_desktop,
-            2 if self.player => self.player_start_menu = !self.player_start_menu,
-            _ => {}
-        }
-    }
-
-    fn build_flags(&self) -> InstallFlags {
-        let mut flags = InstallFlags::new();
-        flags.set_conditionally(self.native_host, install_flags::NATIVE_HOST);
-        flags.set_conditionally(self.pepper, install_flags::PEPPER);
-        flags.set_conditionally(self.netscape, install_flags::NETSCAPE);
-        flags.set_conditionally(self.activex, install_flags::ACTIVEX);
-        flags.set_conditionally(self.player, install_flags::PLAYER);
-        flags.set_conditionally(self.player_desktop, install_flags::PLAYER_DESKTOP);
-        flags.set_conditionally(self.player_start_menu, install_flags::PLAYER_START_MENU);
-        flags.set_conditionally(self.debug_chosen, install_flags::DEBUG);
-        flags
-    }
-
-    fn start_install(&mut self) {
-        self.panel = Panel::Install;
-        let mut flags = self.build_flags();
-        let max_ticks = flags.get_ticks();
-
-        {
-            let mut state = self.progress.lock().unwrap();
-            state.label = "Preparing...".into();
-            state.value = 0;
-            state.maximum = max_ticks;
-            state.done = false;
-            state.error = None;
-        }
-
-        let progress = Arc::clone(&self.progress);
-        std::thread::spawn(move || {
-            let callback = ThreadProgressCallback {
-                state: Arc::clone(&progress),
-            };
-
-            let redir = redirection::disable_redirection();
-            let result = (|| -> Result<(), InstallError> {
-                uninstaller::uninstall(&callback)?;
-                installer::install(&callback, &mut flags)?;
-                Ok(())
-            })();
-            redirection::enable_redirection(redir);
-
-            let mut state = progress.lock().unwrap();
-            if let Err(e) = result {
-                state.error = Some(e.to_string());
-            }
-            state.done = true;
-        });
-    }
-
-    fn summary_text(&self) -> String {
-        let mut parts = Vec::new();
-        if self.native_host { parts.push("Modern Browsers (via extension)"); }
-        if self.pepper { parts.push("Google Chrome"); }
-        if self.netscape { parts.push("Mozilla Firefox"); }
-        if self.activex { parts.push("Internet Explorer"); }
-        if self.player { parts.push("Standalone Player"); }
-
-        if parts.is_empty() {
-            "You are about to uninstall Clean Flash Player.\n\
-The installer will completely remove all versions of Flash Player."
-                .to_string()
-        } else {
-            format!(
-                "You are about to install Clean Flash Player for:\n  {}\n\n\
-The installer will close browsers running Flash, uninstall previous versions, and install.",
-                parts.join(", ")
-            )
-        }
-    }
-}
-
-struct ThreadProgressCallback {
-    state: Arc<Mutex<ProgressState>>,
-}
-
-impl ProgressCallback for ThreadProgressCallback {
-    fn update_progress_label(&self, text: &str, tick: bool) {
-        let mut state = self.state.lock().unwrap();
-        state.label = text.to_string();
-        if tick {
-            state.value += 1;
-        }
-    }
-
-    fn tick_progress(&self) {
-        let mut state = self.state.lock().unwrap();
-        state.value += 1;
-    }
-}
-
-pub fn run_tui_installer() -> Result<(), Box<dyn std::error::Error>> {
-    enable_raw_mode()?;
-    let mut stdout = stdout();
-    execute!(stdout, EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-
-    let result = run_app(&mut terminal);
-
-    disable_raw_mode()?;
-    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-    terminal.show_cursor()?;
-
-    result
-}
-
-fn run_app(terminal: &mut Terminal<CrosstermBackend<io::Stdout>>) -> Result<(), Box<dyn std::error::Error>> {
-    let mut state = TuiInstallState::new();
-
-    #[cfg(not(target_os = "windows"))]
-    {
-        state.pepper = false;
-        state.netscape = false;
-        state.activex = false;
-    }
-
-    loop {
-        terminal.draw(|f| draw_ui(f, &state))?;
-
-        // While installing, poll both events (with timeout) and progress
-        if state.panel == Panel::Install {
-            // Poll progress
-            {
-                let ps = state.progress.lock().unwrap();
-                if ps.done {
-                    if let Some(ref err) = ps.error {
-                        state.failure_detail = err.clone();
-                        drop(ps);
-                        state.panel = Panel::Failure;
-                    } else {
-                        drop(ps);
-                        state.panel = Panel::Complete;
-                    }
-                    continue;
-                }
-            }
-
-            if event::poll(std::time::Duration::from_millis(100))? {
-                if let Event::Key(key) = event::read()? {
-                    if key.kind == KeyEventKind::Press && (key.code == KeyCode::Char('q') || key.code == KeyCode::Esc) {
-                        break;
-                    }
-                }
-            }
-            continue;
-        }
-
-        if let Event::Key(key) = event::read()? {
-            if key.kind != KeyEventKind::Press {
-                continue;
-            }
-
-            match key.code {
-                KeyCode::Char('q') | KeyCode::Esc => {
-                    match state.panel {
-                        Panel::Install => {} // can't quit during install
-                        _ => break,
-                    }
-                }
-                KeyCode::Enter => {
-                    match state.panel {
-                        Panel::Disclaimer => {
-                            if state.disclaimer_accepted {
-                                state.panel = Panel::Choice;
-                            }
-                        }
-                        Panel::Choice => {
-                            if cfg!(target_os = "windows") {
-                                state.panel = Panel::PlayerChoice;
-                            } else {
-                                state.panel = Panel::BeforeInstall;
-                            }
-                        }
-                        Panel::PlayerChoice => state.panel = Panel::DebugChoice,
-                        Panel::DebugChoice => state.panel = Panel::BeforeInstall,
-                        Panel::BeforeInstall => state.start_install(),
-                        Panel::Complete => break,
-                        Panel::Failure => state.start_install(), // retry
-                        Panel::Install => {} // handled by progress polling above
-                    }
-                }
-                KeyCode::Backspace => {
-                    match state.panel {
-                        Panel::Choice => state.panel = Panel::Disclaimer,
-                        Panel::PlayerChoice => state.panel = Panel::Choice,
-                        Panel::DebugChoice => state.panel = Panel::PlayerChoice,
-                        Panel::BeforeInstall => {
-                            if cfg!(target_os = "windows") {
-                                state.panel = Panel::DebugChoice;
-                            } else {
-                                state.panel = Panel::Choice;
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-                KeyCode::Char(' ') => {
-                    match state.panel {
-                        Panel::Disclaimer => {
-                            state.disclaimer_accepted = !state.disclaimer_accepted;
-                        }
-                        Panel::Choice => state.toggle_choice(),
-                        Panel::PlayerChoice => state.toggle_player(),
-                        Panel::DebugChoice => {
-                            state.debug_chosen = !state.debug_chosen;
-                        }
-                        _ => {}
-                    }
-                }
-                KeyCode::Up => {
-                    match state.panel {
-                        Panel::Choice => {
-                            if state.choice_cursor > 0 {
-                                state.choice_cursor -= 1;
-                            }
-                        }
-                        Panel::PlayerChoice => {
-                            if state.player_cursor > 0 {
-                                state.player_cursor -= 1;
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-                KeyCode::Down => {
-                    match state.panel {
-                        Panel::Choice => {
-                            let max = state.choice_items().len().saturating_sub(1);
-                            if state.choice_cursor < max {
-                                state.choice_cursor += 1;
-                            }
-                        }
-                        Panel::PlayerChoice => {
-                            let max = state.player_items().len().saturating_sub(1);
-                            if state.player_cursor < max {
-                                state.player_cursor += 1;
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-
-    Ok(())
-}
-
-fn draw_ui(f: &mut Frame, state: &TuiInstallState) {
-    let area = f.area();
-
-    // Layout: title area, main panel, footer
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(3),      // title
-            Constraint::Min(5),         // content
-            Constraint::Length(3),      // footer
-        ])
-        .split(area);
-
-    // Title bar
-    let title = format!(
-        " Clean Flash Player {} Installer ",
-        FLASH_VERSION
-    );
-    let title_block = Block::default()
-        .borders(Borders::ALL)
-        .border_style(Style::default().fg(Color::Cyan))
-        .title(title)
-        .title_alignment(Alignment::Center);
-    f.render_widget(title_block, chunks[0]);
-
-    // Content
-    let content_block = Block::default()
-        .borders(Borders::ALL)
-        .border_style(Style::default().fg(Color::DarkGray));
-
-    let inner = content_block.inner(chunks[1]);
-    f.render_widget(content_block, chunks[1]);
-
-    match state.panel {
-        Panel::Disclaimer => draw_disclaimer(f, inner, state),
-        Panel::Choice => draw_choice(f, inner, state),
-        Panel::PlayerChoice => draw_player_choice(f, inner, state),
-        Panel::DebugChoice => draw_debug_choice(f, inner, state),
-        Panel::BeforeInstall => draw_before_install(f, inner, state),
-        Panel::Install => draw_install(f, inner, state),
-        Panel::Complete => draw_complete(f, inner, state),
-        Panel::Failure => draw_failure(f, inner, state),
-    }
-
-    // Footer
-    let footer_text = match state.panel {
-        Panel::Disclaimer => "[Space] Toggle accept  [Enter] Next  [q/Esc] Quit",
-        Panel::Choice => "[↑↓] Move  [Space] Toggle  [Enter] Next  [Backspace] Back  [q] Quit",
-        Panel::PlayerChoice => "[↑↓] Move  [Space] Toggle  [Enter] Next  [Backspace] Back  [q] Quit",
-        Panel::DebugChoice => "[Space] Toggle debug  [Enter] Next  [Backspace] Back  [q] Quit",
-        Panel::BeforeInstall => "[Enter] Install  [Backspace] Back  [q] Quit",
-        Panel::Install => "Installing...",
-        Panel::Complete => "[Enter/q] Quit",
-        Panel::Failure => "[Enter] Retry  [q] Quit",
-    };
-    let footer = Paragraph::new(footer_text)
-        .alignment(Alignment::Center)
-        .block(Block::default().borders(Borders::ALL).border_style(Style::default().fg(Color::DarkGray)));
-    f.render_widget(footer, chunks[2]);
-}
-
-fn draw_disclaimer(f: &mut Frame, area: Rect, state: &TuiInstallState) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Min(3), Constraint::Length(1)])
-        .split(area);
-
-    let text = "I am aware that Adobe Flash Player is no longer supported, nor provided by Adobe Inc.\n\
-Clean Flash Player is a third-party version of Flash Player built from the latest Flash Player \
-version with adware removed.\n\n\
-Adobe is not required by any means to provide support for this version of Flash Player.";
-
-    let paragraph = Paragraph::new(text)
-        .wrap(Wrap { trim: false })
-        .style(Style::default().fg(Color::White));
-    f.render_widget(paragraph, chunks[0]);
-
-    let checkbox = if state.disclaimer_accepted {
-        "[x] I accept the above disclaimer"
-    } else {
-        "[ ] I accept the above disclaimer"
-    };
-    let cb_style = if state.disclaimer_accepted {
-        Style::default().fg(Color::Green)
-    } else {
-        Style::default().fg(Color::Yellow)
-    };
-    let cb = Paragraph::new(checkbox).style(cb_style);
-    f.render_widget(cb, chunks[1]);
-}
-
-fn draw_choice(f: &mut Frame, area: Rect, state: &TuiInstallState) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(2), Constraint::Min(3)])
-        .split(area);
-
-    let header = Paragraph::new("Which browser plugins would you like to install?")
-        .style(Style::default().fg(Color::White).add_modifier(Modifier::BOLD));
-    f.render_widget(header, chunks[0]);
-
-    let items: Vec<ListItem> = state
-        .choice_items()
-        .iter()
-        .enumerate()
-        .map(|(i, (label, checked, enabled))| {
-            let marker = if *checked { "[x]" } else { "[ ]" };
-            let text = format!("{} {}", marker, label);
-            let style = if !enabled {
-                Style::default().fg(Color::DarkGray)
-            } else if i == state.choice_cursor {
-                Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD)
-            } else {
-                Style::default().fg(Color::White)
-            };
-            ListItem::new(text).style(style)
-        })
-        .collect();
-
-    let list = List::new(items);
-    f.render_widget(list, chunks[1]);
-}
-
-fn draw_player_choice(f: &mut Frame, area: Rect, state: &TuiInstallState) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(2), Constraint::Min(3)])
-        .split(area);
-
-    let header = Paragraph::new("Would you like to install the standalone Flash Player?")
-        .style(Style::default().fg(Color::White).add_modifier(Modifier::BOLD));
-    f.render_widget(header, chunks[0]);
-
-    let items: Vec<ListItem> = state
-        .player_items()
-        .iter()
-        .enumerate()
-        .map(|(i, (label, checked, enabled))| {
-            let marker = if *checked { "[x]" } else { "[ ]" };
-            let text = format!("{} {}", marker, label);
-            let style = if !enabled {
-                Style::default().fg(Color::DarkGray)
-            } else if i == state.player_cursor {
-                Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD)
-            } else {
-                Style::default().fg(Color::White)
-            };
-            ListItem::new(text).style(style)
-        })
-        .collect();
-
-    let list = List::new(items);
-    f.render_widget(list, chunks[1]);
-}
-
-fn draw_debug_choice(f: &mut Frame, area: Rect, state: &TuiInstallState) {
-    let text = "Would you like to install the debug version of Clean Flash Player?\n\
-You should only choose the debug version if you are planning to create Flash applications.\n\
-If you are not sure, simply press Enter to continue.";
-
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Min(3), Constraint::Length(1)])
-        .split(area);
-
-    let paragraph = Paragraph::new(text)
-        .wrap(Wrap { trim: false })
-        .style(Style::default().fg(Color::White));
-    f.render_widget(paragraph, chunks[0]);
-
-    let checkbox = if state.debug_chosen {
-        "[x] Install debug version"
-    } else {
-        "[ ] Install debug version"
-    };
-    let cb_style = if state.debug_chosen {
-        Style::default().fg(Color::Yellow)
-    } else {
-        Style::default().fg(Color::White)
-    };
-    let cb = Paragraph::new(checkbox).style(cb_style);
-    f.render_widget(cb, chunks[1]);
-}
-
-fn draw_before_install(f: &mut Frame, area: Rect, state: &TuiInstallState) {
-    let text = state.summary_text();
-    let paragraph = Paragraph::new(text)
-        .wrap(Wrap { trim: false })
-        .style(Style::default().fg(Color::White));
-    f.render_widget(paragraph, area);
-}
-
-fn draw_install(f: &mut Frame, area: Rect, state: &TuiInstallState) {
-    let ps = state.progress.lock().unwrap();
-    let label = ps.label.clone();
-    let ratio = if ps.maximum > 0 {
-        (ps.value as f64 / ps.maximum as f64).min(1.0)
-    } else {
-        0.0
-    };
-    drop(ps);
-
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(2),
-            Constraint::Length(1),
-            Constraint::Length(3),
-            Constraint::Min(0),
-        ])
-        .split(area);
-
-    let header = Paragraph::new("Installation in progress...")
-        .style(Style::default().fg(Color::White).add_modifier(Modifier::BOLD));
-    f.render_widget(header, chunks[0]);
-
-    let status = Paragraph::new(label).style(Style::default().fg(Color::White));
-    f.render_widget(status, chunks[1]);
-
-    let gauge = Gauge::default()
-        .block(Block::default().borders(Borders::ALL))
-        .gauge_style(Style::default().fg(Color::Cyan).bg(Color::DarkGray))
-        .ratio(ratio);
-    f.render_widget(gauge, chunks[2]);
-}
-
-fn draw_complete(f: &mut Frame, area: Rect, _state: &TuiInstallState) {
-    let text = "Clean Flash Player has been successfully installed!\n\n\
-Don't forget, Flash Player is no longer compatible with new browsers.\n\
-For browser recommendations and Flash Player updates, check out Clean Flash Player's website!";
-
-    let paragraph = Paragraph::new(text)
-        .wrap(Wrap { trim: false })
-        .style(Style::default().fg(Color::Green));
-    f.render_widget(paragraph, area);
-}
-
-fn draw_failure(f: &mut Frame, area: Rect, state: &TuiInstallState) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(3), Constraint::Min(2)])
-        .split(area);
-
-    let header = Paragraph::new(
-        "Oops! The installation process has encountered an unexpected problem.\nPress Enter to retry or q to quit.",
-    )
-    .wrap(Wrap { trim: false })
-    .style(Style::default().fg(Color::Red).add_modifier(Modifier::BOLD));
-    f.render_widget(header, chunks[0]);
-
-    let detail_text = if state.failure_detail.len() > 500 {
-        &state.failure_detail[..500]
-    } else {
-        &state.failure_detail
-    };
-    let detail = Paragraph::new(detail_text.to_string())
-        .wrap(Wrap { trim: false })
-        .style(Style::default().fg(Color::White));
-    f.render_widget(detail, chunks[1]);
-}

rust/crates/clean_flash_uninstaller/Cargo.toml

@@ -9,9 +9,6 @@ clean_flash_common = { path = "../clean_flash_common" }
 clean_flash_ui = { path = "../clean_flash_ui" }
 minifb = { workspace = true }
 windows-sys = { workspace = true }
-argh = { workspace = true }
-ratatui = { workspace = true }
-crossterm = { workspace = true }
 
 [build-dependencies]
 winresource = "0.1"

rust/crates/clean_flash_uninstaller/build.rs

@@ -1,18 +1,4 @@
 fn main() {
-    // On macOS, embed Info.plist into the binary so the OS recognises it as a GUI app.
-    if cfg!(target_os = "macos") {
-        let plist = std::path::Path::new("../../resources/macos/uninstaller-Info.plist");
-        if plist.exists() {
-            println!("cargo:rustc-link-arg=-sectcreate");
-            println!("cargo:rustc-link-arg=__TEXT");
-            println!("cargo:rustc-link-arg=__info_plist");
-            println!(
-                "cargo:rustc-link-arg={}",
-                plist.canonicalize().unwrap().display()
-            );
-        }
-    }
-
     if cfg!(target_os = "windows") {
         let mut res = winresource::WindowsResource::new();
         if std::path::Path::new("../../resources/icon.ico").exists() {

rust/crates/clean_flash_uninstaller/src/cli_args.rs

@@ -1,38 +0,0 @@
-use argh::FromArgs;
-
-/// Clean Flash Player Uninstaller
-///
-/// Uninstall Clean Flash Player with GUI, TUI, or silent mode.
-#[derive(FromArgs)]
-pub struct UninstallerArgs {
-    /// use the terminal UI (ratatui) instead of the graphical window
-    #[argh(switch)]
-    pub cli: bool,
-
-    /// run the uninstallation non-interactively (no GUI or TUI)
-    #[argh(switch)]
-    pub uninstall: bool,
-
-    /// suppress all output (only valid with --uninstall)
-    #[argh(switch)]
-    pub silent: bool,
-}
-
-/// The mode in which the application should run.
-pub enum RunMode {
-    Gui,
-    Tui,
-    Silent,
-}
-
-impl UninstallerArgs {
-    pub fn determine_mode(&self) -> RunMode {
-        if self.uninstall {
-            RunMode::Silent
-        } else if self.cli {
-            RunMode::Tui
-        } else {
-            RunMode::Gui
-        }
-    }
-}

rust/crates/clean_flash_uninstaller/src/main.rs

@@ -1,16 +1,12 @@
 #![windows_subsystem = "windows"]
 
-mod cli_args;
-mod silent_uninstaller;
-mod tui_uninstaller;
 mod uninstall_form;
 
-use cli_args::{UninstallerArgs, RunMode};
 use clean_flash_ui::renderer::Renderer;
 use minifb::{Key, MouseButton, MouseMode, Window, WindowOptions};
 use uninstall_form::{UninstallForm, HEIGHT, WIDTH};
 
-fn run_gui() {
+fn main() {
     let title = format!(
         "Clean Flash Player {} Uninstaller",
         clean_flash_common::update_checker::FLASH_VERSION
@@ -55,32 +51,3 @@ fn run_gui() {
             .expect("Failed to update window buffer");
     }
 }
-
-fn main() {
-    let args: UninstallerArgs = argh::from_env();
-
-    match args.determine_mode() {
-        RunMode::Silent => {
-            if let Err(e) = silent_uninstaller::run_silent_uninstall(&args) {
-                eprintln!("[!] Fatal error: {}", e);
-                std::process::exit(1);
-            }
-        }
-        RunMode::Tui => {
-            if let Err(e) = tui_uninstaller::run_tui_uninstaller() {
-                eprintln!("[!] TUI error: {}", e);
-                std::process::exit(1);
-            }
-        }
-        RunMode::Gui => {
-            let gui_result = std::panic::catch_unwind(run_gui);
-            if gui_result.is_err() {
-                eprintln!("GUI failed to initialize, falling back to terminal UI...");
-                if let Err(e) = tui_uninstaller::run_tui_uninstaller() {
-                    eprintln!("[!] TUI error: {}", e);
-                    std::process::exit(1);
-                }
-            }
-        }
-    }
-}

rust/crates/clean_flash_uninstaller/src/silent_uninstaller.rs

@@ -1,47 +0,0 @@
-use crate::cli_args::UninstallerArgs;
-use clean_flash_common::{uninstaller, redirection, update_checker, ProgressCallback, InstallError};
-
-struct SilentProgressCallback {
-    silent: bool,
-}
-
-impl ProgressCallback for SilentProgressCallback {
-    fn update_progress_label(&self, text: &str, _tick: bool) {
-        if !self.silent {
-            eprintln!("[*] {}", text);
-        }
-    }
-
-    fn tick_progress(&self) {}
-}
-
-pub fn run_silent_uninstall(args: &UninstallerArgs) -> Result<(), Box<dyn std::error::Error>> {
-    let version = update_checker::FLASH_VERSION;
-
-    if !args.silent {
-        eprintln!("Clean Flash Player {} - Silent Uninstall", version);
-    }
-
-    let callback = SilentProgressCallback {
-        silent: args.silent,
-    };
-
-    let redir = redirection::disable_redirection();
-    let result: Result<(), InstallError> = uninstaller::uninstall(&callback);
-    redirection::enable_redirection(redir);
-
-    match result {
-        Ok(()) => {
-            if !args.silent {
-                eprintln!("[+] Uninstallation completed successfully.");
-            }
-            Ok(())
-        }
-        Err(e) => {
-            if !args.silent {
-                eprintln!("[!] Uninstallation failed: {}", e);
-            }
-            std::process::exit(1);
-        }
-    }
-}

rust/crates/clean_flash_uninstaller/src/tui_uninstaller.rs

@@ -1,306 +0,0 @@
-use clean_flash_common::{uninstaller, redirection, update_checker, ProgressCallback, InstallError};
-use crossterm::{
-    event::{self, Event, KeyCode, KeyEventKind},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    execute,
-};
-use ratatui::{
-    prelude::*,
-    widgets::{Block, Borders, Gauge, Paragraph, Wrap},
-};
-use std::io::{self, stdout};
-use std::sync::{Arc, Mutex};
-
-const FLASH_VERSION: &str = update_checker::FLASH_VERSION;
-const UNINSTALL_TICKS: u32 = 10;
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum Panel {
-    Confirm,
-    Uninstall,
-    Complete,
-    Failure,
-}
-
-struct ProgressState {
-    label: String,
-    value: u32,
-    maximum: u32,
-    done: bool,
-    error: Option<String>,
-}
-
-struct TuiUninstallState {
-    panel: Panel,
-    progress: Arc<Mutex<ProgressState>>,
-    failure_detail: String,
-}
-
-impl TuiUninstallState {
-    fn new() -> Self {
-        Self {
-            panel: Panel::Confirm,
-            progress: Arc::new(Mutex::new(ProgressState {
-                label: "Preparing...".into(),
-                value: 0,
-                maximum: UNINSTALL_TICKS,
-                done: false,
-                error: None,
-            })),
-            failure_detail: String::new(),
-        }
-    }
-
-    fn start_uninstall(&mut self) {
-        self.panel = Panel::Uninstall;
-
-        {
-            let mut state = self.progress.lock().unwrap();
-            state.label = "Preparing...".into();
-            state.value = 0;
-            state.maximum = UNINSTALL_TICKS;
-            state.done = false;
-            state.error = None;
-        }
-
-        let progress = Arc::clone(&self.progress);
-        std::thread::spawn(move || {
-            let callback = ThreadProgressCallback {
-                state: Arc::clone(&progress),
-            };
-
-            let redir = redirection::disable_redirection();
-            let result: Result<(), InstallError> = uninstaller::uninstall(&callback);
-            redirection::enable_redirection(redir);
-
-            let mut state = progress.lock().unwrap();
-            if let Err(e) = result {
-                state.error = Some(e.to_string());
-            }
-            state.done = true;
-        });
-    }
-}
-
-struct ThreadProgressCallback {
-    state: Arc<Mutex<ProgressState>>,
-}
-
-impl ProgressCallback for ThreadProgressCallback {
-    fn update_progress_label(&self, text: &str, tick: bool) {
-        let mut state = self.state.lock().unwrap();
-        state.label = text.to_string();
-        if tick {
-            state.value += 1;
-        }
-    }
-
-    fn tick_progress(&self) {
-        let mut state = self.state.lock().unwrap();
-        state.value += 1;
-    }
-}
-
-pub fn run_tui_uninstaller() -> Result<(), Box<dyn std::error::Error>> {
-    enable_raw_mode()?;
-    let mut stdout = stdout();
-    execute!(stdout, EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-
-    let result = run_app(&mut terminal);
-
-    disable_raw_mode()?;
-    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-    terminal.show_cursor()?;
-
-    result
-}
-
-fn run_app(terminal: &mut Terminal<CrosstermBackend<io::Stdout>>) -> Result<(), Box<dyn std::error::Error>> {
-    let mut state = TuiUninstallState::new();
-
-    loop {
-        terminal.draw(|f| draw_ui(f, &state))?;
-
-        if state.panel == Panel::Uninstall {
-            // Poll progress
-            {
-                let ps = state.progress.lock().unwrap();
-                if ps.done {
-                    if let Some(ref err) = ps.error {
-                        state.failure_detail = err.clone();
-                        drop(ps);
-                        state.panel = Panel::Failure;
-                    } else {
-                        drop(ps);
-                        state.panel = Panel::Complete;
-                    }
-                    continue;
-                }
-            }
-
-            if event::poll(std::time::Duration::from_millis(100))? {
-                if let Event::Key(key) = event::read()? {
-                    if key.kind == KeyEventKind::Press && (key.code == KeyCode::Char('q') || key.code == KeyCode::Esc) {
-                        break;
-                    }
-                }
-            }
-            continue;
-        }
-
-        if let Event::Key(key) = event::read()? {
-            if key.kind != KeyEventKind::Press {
-                continue;
-            }
-
-            match key.code {
-                KeyCode::Char('q') | KeyCode::Esc => break,
-                KeyCode::Enter => {
-                    match state.panel {
-                        Panel::Confirm => state.start_uninstall(),
-                        Panel::Complete => break,
-                        Panel::Failure => state.start_uninstall(), // retry
-                        _ => {}
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-
-    Ok(())
-}
-
-fn draw_ui(f: &mut Frame, state: &TuiUninstallState) {
-    let area = f.area();
-
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(3),
-            Constraint::Min(5),
-            Constraint::Length(3),
-        ])
-        .split(area);
-
-    // Title
-    let title = format!(
-        " Clean Flash Player {} Uninstaller ",
-        FLASH_VERSION
-    );
-    let title_block = Block::default()
-        .borders(Borders::ALL)
-        .border_style(Style::default().fg(Color::Cyan))
-        .title(title)
-        .title_alignment(Alignment::Center);
-    f.render_widget(title_block, chunks[0]);
-
-    // Content
-    let content_block = Block::default()
-        .borders(Borders::ALL)
-        .border_style(Style::default().fg(Color::DarkGray));
-    let inner = content_block.inner(chunks[1]);
-    f.render_widget(content_block, chunks[1]);
-
-    match state.panel {
-        Panel::Confirm => draw_confirm(f, inner),
-        Panel::Uninstall => draw_uninstall(f, inner, state),
-        Panel::Complete => draw_complete(f, inner),
-        Panel::Failure => draw_failure(f, inner, state),
-    }
-
-    // Footer
-    let footer_text = match state.panel {
-        Panel::Confirm => "[Enter] Uninstall  [q/Esc] Quit",
-        Panel::Uninstall => "Uninstalling...",
-        Panel::Complete => "[Enter/q] Quit",
-        Panel::Failure => "[Enter] Retry  [q] Quit",
-    };
-    let footer = Paragraph::new(footer_text)
-        .alignment(Alignment::Center)
-        .block(Block::default().borders(Borders::ALL).border_style(Style::default().fg(Color::DarkGray)));
-    f.render_widget(footer, chunks[2]);
-}
-
-fn draw_confirm(f: &mut Frame, area: Rect) {
-    let text = "You are about to uninstall Clean Flash Player.\n\
-Please close all browsers, including Google Chrome, Mozilla Firefox and Internet Explorer.\n\n\
-The installer will completely remove all versions of Flash Player from this computer,\n\
-including Clean Flash Player and older versions of Adobe Flash Player.\n\n\
-Press Enter to proceed.";
-
-    let paragraph = Paragraph::new(text)
-        .wrap(Wrap { trim: false })
-        .style(Style::default().fg(Color::White));
-    f.render_widget(paragraph, area);
-}
-
-fn draw_uninstall(f: &mut Frame, area: Rect, state: &TuiUninstallState) {
-    let ps = state.progress.lock().unwrap();
-    let label = ps.label.clone();
-    let ratio = if ps.maximum > 0 {
-        (ps.value as f64 / ps.maximum as f64).min(1.0)
-    } else {
-        0.0
-    };
-    drop(ps);
-
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Length(2),
-            Constraint::Length(1),
-            Constraint::Length(3),
-            Constraint::Min(0),
-        ])
-        .split(area);
-
-    let header = Paragraph::new("Uninstallation in progress...")
-        .style(Style::default().fg(Color::White).add_modifier(Modifier::BOLD));
-    f.render_widget(header, chunks[0]);
-
-    let status = Paragraph::new(label).style(Style::default().fg(Color::White));
-    f.render_widget(status, chunks[1]);
-
-    let gauge = Gauge::default()
-        .block(Block::default().borders(Borders::ALL))
-        .gauge_style(Style::default().fg(Color::Cyan).bg(Color::DarkGray))
-        .ratio(ratio);
-    f.render_widget(gauge, chunks[2]);
-}
-
-fn draw_complete(f: &mut Frame, area: Rect) {
-    let text = "All versions of Flash Player have been successfully uninstalled.\n\n\
-If you ever change your mind, check out Clean Flash Player's website!";
-
-    let paragraph = Paragraph::new(text)
-        .wrap(Wrap { trim: false })
-        .style(Style::default().fg(Color::Green));
-    f.render_widget(paragraph, area);
-}
-
-fn draw_failure(f: &mut Frame, area: Rect, state: &TuiUninstallState) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints([Constraint::Length(3), Constraint::Min(2)])
-        .split(area);
-
-    let header = Paragraph::new(
-        "Oops! The uninstallation process has encountered an unexpected problem.\nPress Enter to retry or q to quit.",
-    )
-    .wrap(Wrap { trim: false })
-    .style(Style::default().fg(Color::Red).add_modifier(Modifier::BOLD));
-    f.render_widget(header, chunks[0]);
-
-    let detail_text = if state.failure_detail.len() > 500 {
-        &state.failure_detail[..500]
-    } else {
-        &state.failure_detail
-    };
-    let detail = Paragraph::new(detail_text.to_string())
-        .wrap(Wrap { trim: false })
-        .style(Style::default().fg(Color::White));
-    f.render_widget(detail, chunks[1]);
-}

rust/resources/macos/installer-Info.plist

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>CFBundleName</key>
-    <string>Clean Flash Installer</string>
-    <key>CFBundleDisplayName</key>
-    <string>Clean Flash Player Installer</string>
-    <key>CFBundleIdentifier</key>
-    <string>com.flashpatch.clean-flash-installer</string>
-    <key>CFBundleVersion</key>
-    <string>34.0.0.330</string>
-    <key>CFBundleShortVersionString</key>
-    <string>34.0.0.330</string>
-    <key>CFBundlePackageType</key>
-    <string>APPL</string>
-    <key>CFBundleExecutable</key>
-    <string>clean_flash_installer</string>
-    <key>NSHighResolutionCapable</key>
-    <true/>
-    <key>LSMinimumSystemVersion</key>
-    <string>10.13</string>
-</dict>
-</plist>

rust/resources/macos/uninstaller-Info.plist

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>CFBundleName</key>
-    <string>Clean Flash Uninstaller</string>
-    <key>CFBundleDisplayName</key>
-    <string>Clean Flash Player Uninstaller</string>
-    <key>CFBundleIdentifier</key>
-    <string>com.flashpatch.clean-flash-uninstaller</string>
-    <key>CFBundleVersion</key>
-    <string>34.0.0.330</string>
-    <key>CFBundleShortVersionString</key>
-    <string>34.0.0.330</string>
-    <key>CFBundlePackageType</key>
-    <string>APPL</string>
-    <key>CFBundleExecutable</key>
-    <string>clean_flash_uninstaller</string>
-    <key>NSHighResolutionCapable</key>
-    <true/>
-    <key>LSMinimumSystemVersion</key>
-    <string>10.13</string>
-</dict>
-</plist>