Skip to main content

brows3_lib/
lib.rs

1pub mod commands;
2pub mod credentials;
3pub mod error;
4pub mod s3;
5pub mod transfer;
6
7use commands::{
8    bucket_management, buckets, objects, operations, profiles, transfer as transfer_cmd,
9};
10use s3::S3ClientManager;
11use serde::Serialize;
12use std::sync::Arc;
13use tauri::Manager;
14use tokio::sync::RwLock;
15use transfer::TransferManager;
16
17#[cfg(target_os = "linux")]
18fn configure_linux_webkit_environment() {
19    // WebKitGTK's DMABUF renderer can abort on some Arch/NVIDIA/Wayland systems
20    // with "Could not create default EGL display: EGL_BAD_PARAMETER".
21    if std::env::var_os("WEBKIT_DISABLE_DMABUF_RENDERER").is_none() {
22        std::env::set_var("WEBKIT_DISABLE_DMABUF_RENDERER", "1");
23    }
24}
25
26#[derive(Serialize)]
27struct LogFileInfo {
28    log_file_path: String,
29    log_dir_path: String,
30    panic_log_path: String,
31    panic_log_exists: bool,
32}
33
34#[tauri::command]
35fn get_log_file_info(app: tauri::AppHandle) -> std::result::Result<LogFileInfo, String> {
36    let log_dir = app.path().app_log_dir().map_err(|err| err.to_string())?;
37    let log_file = log_dir.join(format!("{}.log", app.package_info().name));
38    let panic_log = app
39        .path()
40        .app_config_dir()
41        .map_err(|err| err.to_string())?
42        .join("panic.log");
43
44    Ok(LogFileInfo {
45        log_file_path: log_file.to_string_lossy().into_owned(),
46        log_dir_path: log_dir.to_string_lossy().into_owned(),
47        panic_log_exists: panic_log.exists(),
48        panic_log_path: panic_log.to_string_lossy().into_owned(),
49    })
50}
51
52#[cfg_attr(mobile, tauri::mobile_entry_point)]
53pub fn run() {
54    #[cfg(target_os = "linux")]
55    configure_linux_webkit_environment();
56
57    tauri::Builder::default()
58        .plugin(tauri_plugin_shell::init())
59        .plugin(tauri_plugin_dialog::init())
60        .plugin(tauri_plugin_updater::Builder::new().build())
61        .plugin(tauri_plugin_clipboard_manager::init())
62        .manage(Arc::new(RwLock::new(S3ClientManager::new())))
63        .manage(Arc::new(TransferManager::new()))
64        .setup(|app| {
65            // Add native menu on macOS to enable Copy/Paste/Cut/SelectAll/Undo/Redo shortcuts
66            // Add native menu to enable standard shortcuts and window controls
67            {
68                use tauri::menu::{Menu, PredefinedMenuItem, Submenu};
69
70                let handle = app.handle();
71
72                // File Menu (Windows/Linux) or App Menu (macOS)
73                #[cfg(target_os = "macos")]
74                let app_menu = Submenu::with_items(
75                    handle,
76                    "Brows3",
77                    true,
78                    &[
79                        &PredefinedMenuItem::about(handle, None, None)?,
80                        &PredefinedMenuItem::separator(handle)?,
81                        &PredefinedMenuItem::services(handle, None)?,
82                        &PredefinedMenuItem::separator(handle)?,
83                        &PredefinedMenuItem::hide(handle, None)?,
84                        &PredefinedMenuItem::hide_others(handle, None)?,
85                        &PredefinedMenuItem::show_all(handle, None)?,
86                        &PredefinedMenuItem::separator(handle)?,
87                        &PredefinedMenuItem::quit(handle, None)?,
88                    ],
89                )?;
90
91                #[cfg(target_os = "windows")]
92                let file_menu = Submenu::with_items(
93                    handle,
94                    "File",
95                    true,
96                    &[&PredefinedMenuItem::quit(handle, None)?],
97                )?;
98
99                #[cfg(target_os = "linux")]
100                let file_menu = Submenu::with_items(
101                    handle,
102                    "File",
103                    true,
104                    &[&tauri::menu::MenuItem::with_id(
105                        handle,
106                        "quit",
107                        "Quit",
108                        true,
109                        Some("Ctrl+Q"),
110                    )?],
111                )?;
112
113                // Edit Menu (Common)
114                let edit_menu = Submenu::with_items(
115                    handle,
116                    "Edit",
117                    true,
118                    &[
119                        &PredefinedMenuItem::undo(handle, None)?,
120                        &PredefinedMenuItem::redo(handle, None)?,
121                        &PredefinedMenuItem::separator(handle)?,
122                        &PredefinedMenuItem::cut(handle, None)?,
123                        &PredefinedMenuItem::copy(handle, None)?,
124                        &PredefinedMenuItem::paste(handle, None)?,
125                        &PredefinedMenuItem::select_all(handle, None)?,
126                    ],
127                )?;
128
129                // Window Menu (Common)
130                #[cfg(not(target_os = "linux"))]
131                let window_menu = Submenu::with_items(
132                    handle,
133                    "Window",
134                    true,
135                    &[
136                        &PredefinedMenuItem::minimize(handle, None)?,
137                        &PredefinedMenuItem::maximize(handle, None)?,
138                        &PredefinedMenuItem::separator(handle)?,
139                        &PredefinedMenuItem::close_window(handle, None)?,
140                    ],
141                )?;
142
143                #[cfg(target_os = "linux")]
144                let window_menu = Submenu::with_items(
145                    handle,
146                    "Window",
147                    true,
148                    &[
149                        &tauri::menu::MenuItem::with_id(
150                            handle,
151                            "minimize",
152                            "Minimize",
153                            true,
154                            None::<&str>,
155                        )?,
156                        &tauri::menu::MenuItem::with_id(
157                            handle,
158                            "maximize",
159                            "Maximize or Restore",
160                            true,
161                            None::<&str>,
162                        )?,
163                        &PredefinedMenuItem::separator(handle)?,
164                        &tauri::menu::MenuItem::with_id(
165                            handle,
166                            "close",
167                            "Close Window",
168                            true,
169                            Some("Ctrl+W"),
170                        )?,
171                    ],
172                )?;
173
174                #[cfg(target_os = "macos")]
175                let menu = Menu::with_items(handle, &[&app_menu, &edit_menu, &window_menu])?;
176
177                #[cfg(not(target_os = "macos"))]
178                let menu = Menu::with_items(handle, &[&file_menu, &edit_menu, &window_menu])?;
179
180                app.set_menu(menu)?;
181            }
182
183            // Initialize logging for both debug and release builds
184            app.handle().plugin(
185                tauri_plugin_log::Builder::default()
186                    .level(log::LevelFilter::Info)
187                    .build(),
188            )?;
189
190            // Panic Hook for silent crashes
191            let handle = app.handle().clone();
192            std::panic::set_hook(Box::new(move |info| {
193                let location = info
194                    .location()
195                    .map(|location| {
196                        format!(
197                            "{}:{}:{}",
198                            location.file(),
199                            location.line(),
200                            location.column()
201                        )
202                    })
203                    .unwrap_or_else(|| "unknown location".to_string());
204                let msg = format!(
205                    "Panic at {location}: {info:?}\nBacktrace:\n{}",
206                    std::backtrace::Backtrace::force_capture()
207                );
208                log::error!("{}", msg);
209
210                // Also try to write to a file in app data just in case logger is dead
211                if let Ok(path) = handle.path().app_config_dir() {
212                    let _ = std::fs::create_dir_all(&path);
213                    let _ = std::fs::write(path.join("panic.log"), msg);
214                }
215            }));
216
217            let package_info = app.package_info();
218            log::info!(
219                "Brows3 starting up: version={}, platform={}-{}",
220                package_info.version,
221                std::env::consts::OS,
222                std::env::consts::ARCH
223            );
224            if let Ok(log_dir) = app.path().app_log_dir() {
225                log::info!(
226                    "Log file path: {}",
227                    log_dir
228                        .join(format!("{}.log", package_info.name))
229                        .to_string_lossy()
230                );
231            }
232
233            // Initialize credentials manager synchronously before any profile commands can run.
234            let data_dir = credentials::init(app.handle())?;
235            let transfers = app.state::<Arc<TransferManager>>();
236            let journal = data_dir.join("transfers.json");
237            if let Err(error) = tauri::async_runtime::block_on(transfers.configure_journal(journal))
238            {
239                log::error!("Transfer recovery is unavailable: {error}");
240            }
241
242            // Show the main window after initialization to prevent white flash
243            if let Some(window) = app.get_webview_window("main") {
244                let _ = window.show();
245                let _ = window.maximize();
246            }
247
248            Ok(())
249        })
250        .on_menu_event(|_app, _event| {
251            #[cfg(target_os = "linux")]
252            {
253                if _event.id().as_ref() == "quit" {
254                    _app.exit(0);
255                    return;
256                }
257                if let Some(window) = _app.get_webview_window("main") {
258                    let result = match _event.id().as_ref() {
259                        "minimize" => window.minimize(),
260                        "maximize" => window.is_maximized().and_then(|maximized| {
261                            if maximized {
262                                window.unmaximize()
263                            } else {
264                                window.maximize()
265                            }
266                        }),
267                        "close" => window.close(),
268                        _ => Ok(()),
269                    };
270                    if let Err(error) = result {
271                        log::warn!("Window menu action failed: {}", error);
272                    }
273                }
274            }
275        })
276        .invoke_handler(tauri::generate_handler![
277            // Profile management commands
278            profiles::list_profiles,
279            profiles::get_profile,
280            profiles::add_profile,
281            profiles::update_profile,
282            profiles::delete_profile,
283            profiles::set_active_profile,
284            profiles::get_active_profile,
285            profiles::test_connection,
286            profiles::discover_local_profiles,
287            profiles::login_sso,
288            profiles::check_aws_environment,
289            // Bucket commands
290            bucket_management::create_bucket,
291            bucket_management::delete_bucket,
292            bucket_management::get_bucket_policy,
293            bucket_management::put_bucket_policy,
294            buckets::list_buckets,
295            buckets::list_buckets_with_regions,
296            buckets::get_bucket_region,
297            buckets::refresh_s3_client,
298            // Object commands
299            objects::list_objects,
300            objects::search_objects,
301            objects::get_presigned_url,
302            objects::get_object_content,
303            objects::put_object_content,
304            // File operations
305            operations::put_object,
306            operations::get_object,
307            operations::delete_object,
308            operations::copy_object,
309            operations::move_object,
310            operations::delete_objects,
311            operations::get_object_metadata,
312            operations::set_object_content_type,
313            operations::get_object_permissions,
314            operations::set_object_permissions,
315            // Transfer commands
316            transfer_cmd::queue_upload,
317            transfer_cmd::queue_download,
318            transfer_cmd::list_transfers,
319            transfer_cmd::queue_folder_upload,
320            transfer_cmd::queue_folder_download,
321            transfer_cmd::cancel_transfer,
322            transfer_cmd::retry_transfer,
323            transfer_cmd::remove_transfer,
324            transfer_cmd::clear_completed_transfers,
325            transfer_cmd::set_transfer_concurrency,
326            get_log_file_info,
327        ])
328        .run(tauri::generate_context!())
329        .unwrap_or_else(|e| {
330            log::error!("Error while running Tauri application: {}", e);
331            eprintln!("Error while running Tauri application: {}", e);
332        });
333}