Upload fastsearch-tauri/src-tauri/src/main.rs

fastsearch-tauri/src-tauri/src/main.rs

@@ -0,0 +1,477 @@
+// Prevents additional console window on Windows in release
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use std::sync::Arc;
+use parking_lot::RwLock;
+use crossbeam_channel::unbounded;
+use once_cell::sync::Lazy;
+use tauri::{Manager, SystemTray, SystemTrayEvent, SystemTrayMenu, SystemTrayMenuItem, CustomMenuItem, WindowBuilder, WindowUrl, WindowEvent, PhysicalPosition};
+use serde::{Serialize, Deserialize};
+
+use fastsearch_core::index::store::IndexStore;
+use fastsearch_core::index::search::search;
+use fastsearch_core::mft::reader::MftReader;
+use fastsearch_core::mft::watcher::UsnWatcher;
+use fastsearch_core::mft::types::{IndexEvent, JournalCheckpoint};
+use fastsearch_core::utils::drives::get_ntfs_drives;
+
+// ── Global state ───────────────────────────────────────────────────
+static INDEX: Lazy<Arc<RwLock<IndexStore>>> = Lazy::new(|| {
+    Arc::new(RwLock::new(IndexStore::new()))
+});
+
+static LIVE_CHECKPOINTS: Lazy<Arc<parking_lot::Mutex<Vec<JournalCheckpoint>>>> = Lazy::new(|| {
+    Arc::new(parking_lot::Mutex::new(Vec::new()))
+});
+
+static EXCLUDED_DIRS: Lazy<Arc<RwLock<Vec<String>>>> = Lazy::new(|| {
+    Arc::new(RwLock::new(load_exclusions()))
+});
+
+// ── Search response types ─────────────────────────────────────────
+#[derive(Serialize, Clone)]
+struct SearchResponse {
+    results: Vec<SearchItem>,
+    elapsed_ms: f64,
+    total_indexed: usize,
+}
+
+#[derive(Serialize, Clone)]
+struct SearchItem {
+    name: String,
+    path: String,
+    is_dir: bool,
+    rank: u8,
+}
+
+#[derive(Deserialize)]
+struct SearchRequest {
+    query: String,
+    #[serde(default)]
+    limit: usize,
+    #[serde(default)]
+    case_sensitive: bool,
+}
+
+// ── Tauri Commands ─────────────────────────────────────────────────
+#[tauri::command]
+fn cmd_search(request: SearchRequest) -> SearchResponse {
+    let store = INDEX.read();
+    let excluded = EXCLUDED_DIRS.read();
+    let limit = if request.limit == 0 { 50 } else { request.limit };
+
+    let start = std::time::Instant::now();
+    let raw = search(&store, &request.query, limit * 2, request.case_sensitive, &excluded);
+    let elapsed = start.elapsed();
+
+    let results: Vec<SearchItem> = raw.into_iter()
+        .take(limit)
+        .map(|r| SearchItem {
+            name: r.name,
+            path: r.full_path.to_string_lossy().to_string(),
+            is_dir: r.is_dir,
+            rank: r.rank,
+        })
+        .collect();
+
+    SearchResponse {
+        results,
+        elapsed_ms: elapsed.as_secs_f64() * 1000.0,
+        total_indexed: store.len(),
+    }
+}
+
+#[tauri::command]
+fn cmd_get_stats() -> serde_json::Value {
+    let store = INDEX.read();
+    serde_json::json!({
+        "total_indexed": store.len(),
+        "checkpoints": store.checkpoints.len(),
+    })
+}
+
+#[tauri::command]
+fn cmd_rescan() {
+    let cache_path = std::env::temp_dir().join("fastseek_cache.bin");
+    let _ = std::fs::remove_file(&cache_path);
+}
+
+#[tauri::command]
+fn cmd_toggle_window(window: tauri::Window) {
+    toggle_window(&window);
+}
+
+#[tauri::command]
+fn cmd_open_file(path: String) {
+    let _ = std::process::Command::new("explorer")
+        .arg("/select,")
+        .arg(&path)
+        .spawn();
+}
+
+#[tauri::command]
+fn cmd_open_folder(path: String) {
+    let _ = std::process::Command::new("explorer")
+        .arg(&path)
+        .spawn();
+}
+
+#[tauri::command]
+fn cmd_add_exclusion(path: String) {
+    let mut excluded = EXCLUDED_DIRS.write();
+    let path = path.to_lowercase();
+    let path = if path.ends_with('\\') || path.ends_with('/') {
+        path
+    } else {
+        format!("{}\\", path)
+    };
+    if !excluded.contains(&path) {
+        excluded.push(path.clone());
+        save_exclusions(&excluded);
+    }
+}
+
+#[tauri::command]
+fn cmd_remove_exclusion(path: String) {
+    let mut excluded = EXCLUDED_DIRS.write();
+    let path = path.to_lowercase();
+    excluded.retain(|d| d != &path);
+    save_exclusions(&excluded);
+}
+
+#[tauri::command]
+fn cmd_get_exclusions() -> Vec<String> {
+    EXCLUDED_DIRS.read().clone()
+}
+
+// ── Window helpers ───────────────────────────────────────────────
+fn toggle_window(window: &tauri::Window) {
+    if window.is_visible().unwrap_or(false) {
+        let _ = window.hide();
+    } else {
+        if let Some(monitor) = window.primary_monitor().unwrap_or(None) {
+            let size = monitor.size();
+            let win_size = window.outer_size().unwrap_or(tauri::PhysicalSize::new(800, 520));
+            let x = (size.width as i32 - win_size.width as i32) / 2;
+            let y = (size.height as i32 - win_size.height as i32) / 3;
+            let _ = window.set_position(PhysicalPosition::new(x, y));
+        }
+        let _ = window.show();
+        let _ = window.set_focus();
+    }
+}
+
+fn show_window(window: &tauri::Window) {
+    if !window.is_visible().unwrap_or(false) {
+        let _ = window.show();
+        let _ = window.set_focus();
+    }
+}
+
+// ── Config helpers ───────────────────────────────────────────────
+fn config_dir() -> std::path::PathBuf {
+    let dir = std::env::var("APPDATA")
+        .map(std::path::PathBuf::from)
+        .unwrap_or_else(|_| std::env::temp_dir())
+        .join("fastseek");
+    let _ = std::fs::create_dir_all(&dir);
+    dir
+}
+
+fn load_exclusions() -> Vec<String> {
+    let path = config_dir().join("exclusions.txt");
+    std::fs::read_to_string(&path)
+        .unwrap_or_default()
+        .lines()
+        .map(|l| l.trim().to_lowercase())
+        .filter(|l| !l.is_empty())
+        .collect()
+}
+
+fn save_exclusions(dirs: &[String]) {
+    let path = config_dir().join("exclusions.txt");
+    let content = dirs.join("\n");
+    let _ = std::fs::write(&path, content);
+}
+
+// ── Index initialization (background thread) ──────────────────
+fn init_index() {
+    std::thread::spawn(|| {
+        let drives = get_ntfs_drives();
+        if drives.is_empty() {
+            eprintln!("No NTFS drives found. Run as Administrator.");
+            return;
+        }
+
+        let (tx, rx) = unbounded();
+        let cache_path = std::env::temp_dir().join("fastseek_cache.bin");
+
+        // Try loading from cache
+        let cache_loaded = if cache_path.exists() {
+            match std::fs::read(&cache_path) {
+                Ok(compressed) => {
+                    match lz4_flex::decompress_size_prepended(&compressed) {
+                        Ok(bytes) => {
+                            match bincode::deserialize::<fastsearch_core::index::store::CacheData>(&bytes) {
+                                Ok(cache) => {
+                                    let checkpoints = cache.checkpoints.clone();
+                                    *INDEX.write() = IndexStore::from_cache(cache);
+
+                                    // Delta catch-up
+                                    if !checkpoints.is_empty() {
+                                        let (delta_tx, delta_rx) = unbounded::<IndexEvent>();
+                                        let mut journal_ok = true;
+
+                                        for drive in &drives {
+                                            let cp = checkpoints.iter()
+                                                .find(|c| c.drive_letter == drive.letter);
+
+                                            if let Some(cp) = cp {
+                                                match UsnWatcher::new_from(drive, delta_tx.clone(), Some(cp)) {
+                                                    Ok(mut watcher) => {
+                                                        watcher.drain();
+                                                        let new_cp = watcher.checkpoint();
+                                                        let mut store = INDEX.write();
+                                                        store.checkpoints.retain(|c| c.drive_letter != drive.letter);
+                                                        store.checkpoints.push(new_cp);
+                                                    }
+                                                    Err(_) => {
+                                                        let _ = std::fs::remove_file(&cache_path);
+                                                        journal_ok = false;
+                                                        break;
+                                                    }
+                                                }
+                                            } else {
+                                                let _ = std::fs::remove_file(&cache_path);
+                                                journal_ok = false;
+                                                break;
+                                            }
+                                        }
+
+                                        drop(delta_tx);
+
+                                        if journal_ok {
+                                            let mut store = INDEX.write();
+                                            for event in delta_rx {
+                                                match event {
+                                                    IndexEvent::Created(r) => store.insert(r),
+                                                    IndexEvent::Deleted(id) => store.remove(id),
+                                                    IndexEvent::Renamed { old_ref, new_record } => store.rename(old_ref, new_record),
+                                                    IndexEvent::Moved { file_ref, new_parent_ref, name, kind } => {
+                                                        store.apply_move(file_ref, new_parent_ref, name, kind);
+                                                    }
+                                                }
+                                            }
+                                            true
+                                        } else {
+                                            false
+                                        }
+                                    } else {
+                                        true
+                                    }
+                                }
+                                Err(_) => false
+                            }
+                        }
+                        Err(_) => false
+                    }
+                }
+                Err(_) => false
+            }
+        } else {
+            false
+        };
+
+        // Full MFT scan if no cache
+        if !cache_loaded {
+            {
+                let mut store = INDEX.write();
+                for drive in &drives {
+                    let (dummy_tx, _) = unbounded::<IndexEvent>();
+                    if let Ok(w) = UsnWatcher::new(drive, dummy_tx) {
+                        store.checkpoints.push(w.checkpoint());
+                    }
+                }
+            }
+
+            let index_clone = Arc::clone(&INDEX);
+            let drives_clone = drives.clone();
+
+            for drive in &drives_clone {
+                let reader = match MftReader::open(drive) {
+                    Ok(r) => r,
+                    Err(_) => continue,
+                };
+
+                let scan = match reader.scan_direct() {
+                    Some(s) => s,
+                    None => reader.scan(),
+                };
+
+                let mut store = index_clone.write();
+                store.populate_from_scan(scan, &drive.root);
+            }
+
+            {
+                let mut store = index_clone.write();
+                store.finalize();
+
+                let cache = store.to_cache();
+                if let Ok(bytes) = bincode::serialize(&cache) {
+                    let compressed = lz4_flex::compress_prepend_size(&bytes);
+                    let _ = std::fs::write(&cache_path, &compressed);
+                }
+            }
+        }
+
+        // Start USN watchers for live updates
+        let live_cps = Arc::clone(&LIVE_CHECKPOINTS);
+        for drive in &drives {
+            let tx_clone = tx.clone();
+            let drive_clone = drive.clone();
+            let cps = Arc::clone(&live_cps);
+            std::thread::spawn(move || {
+                if let Ok(mut watcher) = UsnWatcher::new(&drive_clone, tx_clone) {
+                    watcher.run_shared(cps);
+                }
+            });
+        }
+
+        // Apply live updates
+        let index_live = Arc::clone(&INDEX);
+        std::thread::spawn(move || {
+            for event in rx {
+                let mut store = index_live.write();
+                match event {
+                    IndexEvent::Created(r) => store.insert(r),
+                    IndexEvent::Deleted(id) => store.remove(id),
+                    IndexEvent::Renamed { old_ref, new_record } => store.rename(old_ref, new_record),
+                    IndexEvent::Moved { file_ref, new_parent_ref, name, kind } => {
+                        store.apply_move(file_ref, new_parent_ref, name, kind);
+                    }
+                }
+            }
+        });
+    });
+}
+
+// ── Hotkey listener (Win+Space) ──────────────────────────────────
+fn setup_hotkey_listener(app_handle: tauri::AppHandle) {
+    std::thread::spawn(move || {
+        use rdev::{listen, EventType, Key};
+        
+        let mut win_pressed = false;
+
+        let callback = move |event: rdev::Event| {
+            match event.event_type {
+                EventType::KeyPress(Key::MetaLeft) | EventType::KeyPress(Key::MetaRight) => {
+                    win_pressed = true;
+                }
+                EventType::KeyRelease(Key::MetaLeft) | EventType::KeyRelease(Key::MetaRight) => {
+                    win_pressed = false;
+                }
+                EventType::KeyPress(Key::Space) => {
+                    if win_pressed {
+                        if let Some(window) = app_handle.get_window("main") {
+                            let _ = window.emit("toggle-search", "");
+                        }
+                    }
+                }
+                _ => {}
+            }
+        };
+
+        if let Err(e) = listen(callback) {
+            eprintln!("Hotkey listener error: {:?}", e);
+        }
+    });
+}
+
+// ── Main ───────────────────────────────────────────────────────────
+fn main() {
+    let tray_menu = SystemTrayMenu::new()
+        .add_item(CustomMenuItem::new("show", "Show"))
+        .add_native_item(SystemTrayMenuItem::Separator)
+        .add_item(CustomMenuItem::new("quit", "Quit"));
+
+    let system_tray = SystemTray::new().with_menu(tray_menu);
+
+    tauri::Builder::default()
+        .setup(|app| {
+            init_index();
+
+            let app_handle = app.handle();
+            setup_hotkey_listener(app_handle.clone());
+
+            let window = WindowBuilder::new(
+                app,
+                "main",
+                WindowUrl::App("index.html".into())
+            )
+            .title("FastSeek")
+            .inner_size(800.0, 520.0)
+            .decorations(false)
+            .transparent(true)
+            .always_on_top(true)
+            .skip_taskbar(true)
+            .visible(false)
+            .build()?;
+
+            // Center window initially
+            if let Some(monitor) = window.primary_monitor()? {
+                let size = monitor.size();
+                let win_size = window.outer_size()?;
+                let x = (size.width as i32 - win_size.width as i32) / 2;
+                let y = (size.height as i32 - win_size.height as i32) / 3;
+                window.set_position(PhysicalPosition::new(x, y))?;
+            }
+
+            Ok(())
+        })
+        .system_tray(system_tray)
+        .on_system_tray_event(|app, event| {
+            match event {
+                SystemTrayEvent::LeftClick { .. } => {
+                    if let Some(window) = app.get_window("main") {
+                        toggle_window(&window);
+                    }
+                }
+                SystemTrayEvent::MenuItemClick { id, .. } => {
+                    match id.as_str() {
+                        "show" => {
+                            if let Some(window) = app.get_window("main") {
+                                show_window(&window);
+                            }
+                        }
+                        "quit" => {
+                            std::process::exit(0);
+                        }
+                        _ => {}
+                    }
+                }
+                _ => {}
+            }
+        })
+        .on_window_event(|event| {
+            match event.event() {
+                WindowEvent::Focused(false) => {
+                    // Optional: hide on blur (click outside)
+                    // event.window().hide().ok();
+                }
+                _ => {}
+            }
+        })
+        .invoke_handler(tauri::generate_handler![
+            cmd_search,
+            cmd_get_stats,
+            cmd_rescan,
+            cmd_toggle_window,
+            cmd_open_file,
+            cmd_open_folder,
+            cmd_add_exclusion,
+            cmd_remove_exclusion,
+            cmd_get_exclusions
+        ])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}