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 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 {
68 use tauri::menu::{Menu, PredefinedMenuItem, Submenu};
69
70 let handle = app.handle();
71
72 #[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 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 #[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 app.handle().plugin(
185 tauri_plugin_log::Builder::default()
186 .level(log::LevelFilter::Info)
187 .build(),
188 )?;
189
190 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 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 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 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 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_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 objects::list_objects,
300 objects::search_objects,
301 objects::get_presigned_url,
302 objects::get_object_content,
303 objects::put_object_content,
304 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_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}