25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
mod background_backup;
mod commands;
mod data_dir;
pub use background_backup::run_if_requested as run_backup_worker_if_requested;
mod db;
#[cfg(target_os = "macos")]
mod macos_app_delegate;
#[cfg(target_os = "macos")]
mod macos_escape_guard;
mod migration_gate;
mod models;
mod plugin_ui_protocol;
#[cfg(any(target_os = "windows", test))]
mod startup_messages;
#[cfg(any(target_os = "windows", test))]
mod startup_recovery;
#[cfg(all(not(target_os = "windows"), not(test)))]
#[path = "startup_recovery_noop.rs"]
mod startup_recovery;
#[cfg(any(target_os = "windows", test))]
mod webview2_legacy_css;
#[cfg(target_os = "windows")]
mod webview2_preflight;
#[cfg(any(target_os = "windows", test))]
mod webview2_recovery;
mod window_geometry;
mod window_state_guard;
#[cfg(target_os = "windows")]
mod windows_appcompat;
#[cfg(not(target_os = "windows"))]
#[path = "windows_appcompat_noop.rs"]
mod windows_appcompat;
#[cfg(any(target_os = "windows", test))]
mod windows_appcompat_state;
use commands::connection::AppState;
use dbx_core::persistence::secret_codec::SecretKeyPolicy;
use dbx_core::sql_dialect::dialect_loader::{register_core_dialects, DialectPluginLoader, DialectRegistry};
use dbx_core::sql_dialect::hot_reload::DialectHotReload;
use dbx_core::storage::{maybe_import_user_data_db, DesktopIconTheme, DesktopSettings, Storage};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
#[cfg(target_os = "macos")]
use tauri::menu::Menu;
#[cfg(target_os = "macos")]
use tauri::menu::{AboutMetadata, MenuItem, PredefinedMenuItem, Submenu};
use tauri::webview::PageLoadEvent;
use tauri::RunEvent;
use tauri::{
menu::MenuBuilder,
tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
};
use tauri::{Emitter, Manager};
#[cfg(target_os = "macos")]
use tauri_plugin_clipboard_manager::ClipboardExt;
#[cfg(any(windows, target_os = "linux"))]
use tauri_plugin_deep_link::DeepLinkExt;
use tauri_plugin_opener::OpenerExt;
const DESKTOP_TRAY_ID: &str = "main-tray";
const APP_CLOSE_REQUESTED_EVENT: &str = "dbx-app-close-requested";
#[cfg(target_os = "macos")]
const APP_MENU_QUIT_ID: &str = "app-menu-quit";
#[cfg(target_os = "macos")]
const APP_MENU_COPY_SUPPORT_INFO_ID: &str = "app-menu-copy-support-info";
#[cfg(target_os = "macos")]
const APP_MENU_CLOSE_TAB_ID: &str = "app-menu-close-tab";
#[cfg(target_os = "macos")]
const APP_CLOSE_ACTIVE_TAB_EVENT: &str = "dbx-close-active-tab";
pub struct CloseBehaviorState {
confirmed_exit: AtomicBool,
frontend_ready: AtomicBool,
}
impl CloseBehaviorState {
fn new() -> Self {
Self { confirmed_exit: AtomicBool::new(false), frontend_ready: AtomicBool::new(false) }
}
pub(crate) fn allow_next_exit(&self) {
self.confirmed_exit.store(true, Ordering::Relaxed);
}
fn take_confirmed_exit(&self) -> bool {
self.confirmed_exit.swap(false, Ordering::Relaxed)
}
pub(crate) fn set_frontend_ready(&self, ready: bool) {
self.frontend_ready.store(ready, Ordering::Release);
}
fn is_frontend_ready(&self) -> bool {
self.frontend_ready.load(Ordering::Acquire)
}
}
/// UI language pushed from the frontend i18n layer; native menus follow it and
/// fall back to the OS locale until the first `set_app_locale` call arrives.
pub struct AppLocaleState {
locale: std::sync::Mutex<Option<String>>,
}
impl AppLocaleState {
fn new() -> Self {
Self { locale: std::sync::Mutex::new(None) }
}
pub(crate) fn set(&self, locale: String) {
*self.locale.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = Some(locale);
}
fn get(&self) -> String {
self.locale
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.clone()
.unwrap_or_else(|| sys_locale::get_locale().unwrap_or_default())
}
}
#[cfg(target_os = "macos")]
const MACOS_TRAY_ICON: tauri::image::Image<'_> = tauri::include_image!("icons/tray-macos-template.png");
#[cfg(target_os = "macos")]
const ABOUT_APP_ICON: tauri::image::Image<'_> = tauri::include_image!("icons/icon.png");
#[cfg(not(target_os = "macos"))]
const BLACK_APP_ICON: tauri::image::Image<'_> = tauri::include_image!("icons/icon-black.png");
#[cfg(target_os = "macos")]
const MACOS_DEFAULT_APP_ICON: &[u8] = include_bytes!("../icons/icon.icns");
#[cfg(target_os = "macos")]
const MACOS_DARK_APP_ICON: &[u8] = include_bytes!("../icons/icon-macos-dark.icns");
pub(crate) fn apply_debug_log_level(debug_logging_enabled: bool) {
log::set_max_level(if debug_logging_enabled { log::LevelFilter::Debug } else { log::LevelFilter::Off });
}
fn should_hide_window_on_close(target_os: &str) -> bool {
matches!(target_os, "macos" | "windows")
}
/// How long to keep the app off-screen after hiding it and before the process
/// exits, so WindowServer has removed the window before WKWebView teardown.
#[cfg(target_os = "macos")]
pub(crate) const EXIT_HIDE_GRACE_MS: u64 = 250;
/// On macOS, tearing down WKWebView while the window is still on screen can
/// paint the window red for a frame before the process exits, so the app is
/// hidden first. Windows and Linux keep their existing exit behavior.
fn should_hide_window_before_exit(target_os: &str) -> bool {
target_os == "macos"
}
fn should_setup_desktop_tray(target_os: &str, show_tray_icon: bool, linux_appindicator_available: bool) -> bool {
show_tray_icon
&& (matches!(target_os, "macos" | "windows") || (target_os == "linux" && linux_appindicator_available))
}
fn should_enable_single_instance(debug_build: bool) -> bool {
!debug_build
}
fn startup_data_dir_mode(mode: &data_dir::DataDirMode) -> &'static str {
match mode {
data_dir::DataDirMode::Default => "default",
data_dir::DataDirMode::EnvOverride => "env_override",
data_dir::DataDirMode::Portable { .. } => "portable",
}
}
#[cfg(target_os = "macos")]
fn development_dock_badge_label(debug_build: bool) -> Option<&'static str> {
debug_build.then_some("DEV")
}
#[cfg(target_os = "linux")]
fn linux_appindicator_available() -> bool {
const APPINDICATOR_LIBRARIES: &[&str] = &["libayatana-appindicator3.so.1", "libappindicator3.so.1"];
APPINDICATOR_LIBRARIES.iter().any(|library| {
// tray-icon loads AppIndicator dynamically and panics when neither ABI is
// installed, so probe the same libraries before entering that code path.
unsafe { libloading::Library::new(library).is_ok() }
})
}
/// Without a compositing manager (XFCE with compositing off, i3, openbox, ...) a transparent
/// window renders black where it should be see-through.
#[cfg(target_os = "linux")]
pub(crate) fn linux_compositing_available() -> bool {
gtk::gdk::Screen::default().is_some_and(|screen| screen.is_composited())
}
/// Desktops where the floating frame is enabled automatically. Driver/WebKitGTK combinations
/// can still cause flickering on GNOME, so the saved setting can disable this default.
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn linux_desktop_supports_floating_frame(current_desktop: Option<&std::ffi::OsStr>) -> bool {
current_desktop
.map(|value| value.to_string_lossy().split(':').any(|name| name.eq_ignore_ascii_case("GNOME")))
.unwrap_or(false)
}
/// `DBX_LINUX_FLOATING_FRAME=1|0` overrides the saved preference; otherwise the frame is only used on
/// GNOME running as a native Wayland client. GNOME on X11 ("GNOME on Xorg") keeps the opaque
/// window: there the transparent WebKitGTK window stays see-through and only repaints the regions
/// that get damaged (e.g. under the mouse).
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn should_enable_linux_floating_frame(
compositing: bool,
native_wayland: bool,
override_value: Option<&std::ffi::OsStr>,
current_desktop: Option<&std::ffi::OsStr>,
enabled: bool,
) -> bool {
if !compositing {
return false;
}
match override_value.and_then(|value| value.to_str()) {
Some("1") => true,
Some("0") => false,
_ => enabled && native_wayland && linux_desktop_supports_floating_frame(current_desktop),
}
}
/// The Linux config declares the main window with `create: false` so its transparency can
/// depend at runtime on the desktop, the Wayland/X11 session and whether a compositor is available.
#[cfg(target_os = "linux")]
fn create_linux_main_window(app: &tauri::App, floating_frame_enabled: bool) -> tauri::Result<()> {
let Some(config) = app.config().app.windows.iter().find(|window| window.label == "main").cloned() else {
return Ok(());
};
let compositing = linux_compositing_available();
let native_wayland = linux_uses_native_wayland(
std::env::var_os("WAYLAND_DISPLAY").as_deref(),
std::env::var_os("XDG_SESSION_TYPE").as_deref(),
std::env::var_os("GDK_BACKEND").as_deref(),
);
let override_value = std::env::var_os("DBX_LINUX_FLOATING_FRAME");
let current_desktop = std::env::var_os("XDG_CURRENT_DESKTOP");
let floating_frame = should_enable_linux_floating_frame(
compositing,
native_wayland,
override_value.as_deref(),
current_desktop.as_deref(),
floating_frame_enabled,
);
log::info!(
"[WINDOW] Linux main window compositing={compositing}; native_wayland={native_wayland}; floating_frame={floating_frame}"
);
let mut builder = tauri::WebviewWindowBuilder::from_config(app.handle(), &config)?.transparent(floating_frame);
if floating_frame {
// Read by index.html before first paint to draw the rounded, shadowed frame.
builder = builder.initialization_script("window.__DBX_LINUX_FLOATING__ = true;");
}
builder.build()?;
Ok(())
}
#[cfg(not(target_os = "linux"))]
fn linux_appindicator_available() -> bool {
false
}
#[cfg(test)]
fn uses_application_level_icon(target_os: &str) -> bool {
target_os == "macos"
}
fn should_show_main_window_after_setup() -> bool {
true
}
fn should_show_main_window_before_setup_tasks() -> bool {
true
}
fn append_startup_probe(message: impl AsRef<str>) {
startup_recovery::record(message);
}
pub(crate) fn clear_startup_probe_after_frontend_ready(main_window_visible: bool) {
startup_recovery::mark_frontend_ready(main_window_visible);
}
fn should_confirm_app_exit_request(target_os: &str, exit_code: Option<i32>, confirmed_exit: bool) -> bool {
should_hide_window_on_close(target_os) && exit_code != Some(tauri::RESTART_EXIT_CODE) && !confirmed_exit
}
fn should_fallback_to_native_quit(target: &str, frontend_ready: bool) -> bool {
target == "quit" && !frontend_ready
}
fn native_window_decorations_override(target_os: &str) -> Option<bool> {
match target_os {
"windows" | "linux" => Some(false),
_ => None,
}
}
#[cfg(target_os = "macos")]
fn build_app_menu<R: tauri::Runtime>(app_handle: &tauri::AppHandle<R>) -> tauri::Result<Menu<R>> {
let pkg_info = app_handle.package_info();
let app_name = pkg_info.name.clone();
let about_metadata = AboutMetadata {
name: Some(app_name.clone()),
version: Some(pkg_info.version.to_string()),
copyright: Some(commands::support_info::format_support_info_for_native_about()),
icon: Some(ABOUT_APP_ICON),
..Default::default()
};
let copy_support_info_item = MenuItem::with_id(
app_handle,
APP_MENU_COPY_SUPPORT_INFO_ID,
app_menu_copy_support_info_label(¤t_app_locale(app_handle)),
true,
None::<&str>,
)?;
let quit_item = MenuItem::with_id(
app_handle,
APP_MENU_QUIT_ID,
app_menu_quit_label(¤t_app_locale(app_handle), &app_name),
true,
Some("Cmd+Q"),
)?;
let close_tab_item = MenuItem::with_id(
app_handle,
APP_MENU_CLOSE_TAB_ID,
app_menu_close_tab_label(¤t_app_locale(app_handle)),
true,
Some("Cmd+W"),
)?;
Menu::with_items(
app_handle,
&[
&Submenu::with_items(
app_handle,
app_name,
true,
&[
&PredefinedMenuItem::about(app_handle, None, Some(about_metadata))?,
©_support_info_item,
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::services(app_handle, None)?,
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::hide(app_handle, None)?,
&PredefinedMenuItem::hide_others(app_handle, None)?,
&PredefinedMenuItem::separator(app_handle)?,
&quit_item,
],
)?,
&Submenu::with_items(app_handle, "File", true, &[&close_tab_item])?,
&Submenu::with_items(
app_handle,
"Edit",
true,
&[
&PredefinedMenuItem::undo(app_handle, None)?,
&PredefinedMenuItem::redo(app_handle, None)?,
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::cut(app_handle, None)?,
&PredefinedMenuItem::copy(app_handle, None)?,
&PredefinedMenuItem::paste(app_handle, None)?,
&PredefinedMenuItem::select_all(app_handle, None)?,
],
)?,
&Submenu::with_items(app_handle, "View", true, &[&PredefinedMenuItem::fullscreen(app_handle, None)?])?,
&Submenu::with_items(
app_handle,
"Window",
true,
&[&PredefinedMenuItem::minimize(app_handle, None)?, &PredefinedMenuItem::maximize(app_handle, None)?],
)?,
&Submenu::with_items(app_handle, "Help", true, &[])?,
],
)
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum LinuxNvidiaDriver {
None,
Nouveau,
Proprietary,
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
#[derive(Clone, Debug, Eq, PartialEq)]
struct LinuxDrmRenderDevice {
device_file: std::path::PathBuf,
driver: Option<String>,
boot_vga: bool,
pci_id: Option<(u16, u16)>,
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct LinuxDmabufRendererPciQuirk {
vendor_id: u16,
device_id: u16,
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
const LINUX_DMABUF_RENDERER_PCI_QUIRKS: &[LinuxDmabufRendererPciQuirk] = &[LinuxDmabufRendererPciQuirk {
// Strix Halo can stop presenting new WebKitGTK DMABuf frames while the
// WebView remains interactive on native Wayland.
vendor_id: 0x1002,
device_id: 0x1586,
}];
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn linux_nvidia_driver_from_state(
proprietary_control_exists: bool,
proprietary_proc_exists: bool,
render_driver: Option<&str>,
prime_render_offload: bool,
) -> LinuxNvidiaDriver {
// On hybrid laptops the proprietary module is loaded for the dGPU while the
// integrated GPU (i915/xe/amdgpu) drives the display and WebKit's renderer.
// Applying the NVIDIA workarounds there needlessly disables DMABuf and drops
// WebKitGTK to the slow shared-memory path (laggy scrolling everywhere).
let renders_on_nvidia =
prime_render_offload || render_driver.is_none_or(|driver| driver.eq_ignore_ascii_case("nvidia"));
if (proprietary_control_exists || proprietary_proc_exists) && renders_on_nvidia {
LinuxNvidiaDriver::Proprietary
} else if render_driver.is_some_and(|driver| driver.eq_ignore_ascii_case("nouveau")) {
LinuxNvidiaDriver::Nouveau
} else {
LinuxNvidiaDriver::None
}
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn linux_selected_drm_render_device<'a>(
explicit_device_file: Option<&std::path::Path>,
devices: &'a [LinuxDrmRenderDevice],
) -> Option<&'a LinuxDrmRenderDevice> {
if let Some(explicit_device_file) = explicit_device_file {
// WebKit gives this environment override precedence over EGL/DRM discovery.
return devices.iter().find(|device| device.device_file.as_path() == explicit_device_file);
}
// Before WebKit initializes EGL, boot_vga is the best available default-display signal.
// The sorted first render node mirrors WebKit's final DRM-device fallback.
devices.iter().find(|device| device.boot_vga).or_else(|| devices.first())
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn linux_pci_id_from_sysfs_value(value: &str) -> Option<u16> {
let value = value.trim();
let value = value.strip_prefix("0x").or_else(|| value.strip_prefix("0X")).unwrap_or(value);
(!value.is_empty()).then(|| u16::from_str_radix(value, 16).ok()).flatten()
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn linux_drm_render_devices_from_paths(
sys_class_drm: &std::path::Path,
dev_dri: &std::path::Path,
) -> Vec<LinuxDrmRenderDevice> {
let Ok(entries) = std::fs::read_dir(sys_class_drm) else {
return Vec::new();
};
let mut devices = entries
.filter_map(Result::ok)
.filter_map(|entry| {
let node_name = entry.file_name();
let node_name = node_name.to_str()?;
let render_index = node_name.strip_prefix("renderD")?;
if render_index.is_empty() || !render_index.bytes().all(|byte| byte.is_ascii_digit()) {
return None;
}
let device_file = dev_dri.join(node_name);
if std::fs::OpenOptions::new().read(true).write(true).open(&device_file).is_err() {
return None;
}
let device_path = entry.path().join("device");
let driver = std::fs::read_link(device_path.join("driver"))
.ok()
.and_then(|path| path.file_name().and_then(std::ffi::OsStr::to_str).map(str::to_ascii_lowercase));
let boot_vga = std::fs::read_to_string(device_path.join("boot_vga")).is_ok_and(|value| value.trim() == "1");
let vendor_id = std::fs::read_to_string(device_path.join("vendor"))
.ok()
.and_then(|value| linux_pci_id_from_sysfs_value(&value));
let device_id = std::fs::read_to_string(device_path.join("device"))
.ok()
.and_then(|value| linux_pci_id_from_sysfs_value(&value));
Some(LinuxDrmRenderDevice { device_file, driver, boot_vga, pci_id: vendor_id.zip(device_id) })
})
.collect::<Vec<_>>();
devices.sort_by(|left, right| left.device_file.cmp(&right.device_file));
devices
}
#[cfg(target_os = "linux")]
fn linux_drm_render_devices() -> Vec<LinuxDrmRenderDevice> {
linux_drm_render_devices_from_paths(std::path::Path::new("/sys/class/drm"), std::path::Path::new("/dev/dri"))
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
const LINUX_SOFTWARE_ONLY_DRM_DRIVERS: &[&str] = &[
"virtio-pci", // QEMU/KVM virtio-gpu: 2D dumb-buffer only, GL falls back to llvmpipe
"virtio_gpu", // virtio-gpu on virtio-mmio/platform buses
"qxl", // QEMU/SPICE 2D display adapter
"bochs", // QEMU/BOCHS VGA (2D only)
"cirrus", // legacy Cirrus VGA (2D only)
"vmwgfx", // VMware SVGA
"vboxvideo", // VirtualBox graphics
"xen", // Xen virtual GPU
"udl", // DisplayLink 2D framebuffer
"mgag200", // Matrox server BMC
"ast", // ASPEED server BMC
"hibmc", // Huawei HiBMC server BMC
];
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn linux_drm_driver_is_software_only(driver: Option<&str>) -> bool {
// 2D-only/virtual drivers leave GL rendering to llvmpipe, where WebKitGTK's
// DMABuf compositing drives the gallivm LLVM JIT that can fail to
// materialize compositing shaders (blank window on GPU-less VMs).
driver.is_none_or(|driver| LINUX_SOFTWARE_ONLY_DRM_DRIVERS.contains(&driver))
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn linux_selected_device_has_dmabuf_quirk(
selected_device: Option<&LinuxDrmRenderDevice>,
uses_native_wayland: bool,
) -> bool {
uses_native_wayland
&& selected_device.is_some_and(|device| {
let Some((vendor_id, device_id)) = device.pci_id else {
return false;
};
LINUX_DMABUF_RENDERER_PCI_QUIRKS
.iter()
.any(|quirk| vendor_id == quirk.vendor_id && device_id == quirk.device_id)
})
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn linux_webkit_rendering_workarounds(
driver: LinuxNvidiaDriver,
has_hardware_render_device: bool,
selected_device: Option<&LinuxDrmRenderDevice>,
uses_native_wayland: bool,
) -> &'static [(&'static str, &'static str)] {
match driver {
LinuxNvidiaDriver::Proprietary => {
// NVIDIA's proprietary driver needs both DMABuf and explicit-sync
// workarounds to avoid blank windows and compositor failures.
&[("WEBKIT_DISABLE_DMABUF_RENDERER", "1"), ("__NV_DISABLE_EXPLICIT_SYNC", "1")]
}
LinuxNvidiaDriver::Nouveau => {
// WebKitGTK's DMABuf renderer can produce a fully black WebView on
// Nouveau while the DOM remains interactive.
&[("WEBKIT_DISABLE_DMABUF_RENDERER", "1")]
}
LinuxNvidiaDriver::None if !has_hardware_render_device => {
// No hardware render device means Mesa can only render through
// llvmpipe. WebKitGTK's DMABuf compositing then drives llvmpipe's
// gallivm LLVM JIT, which can fail to materialize the compositing
// shaders (blank/white window on GPU-less VMs and servers), so
// disable the DMABuf renderer there as well.
&[("WEBKIT_DISABLE_DMABUF_RENDERER", "1")]
}
LinuxNvidiaDriver::None if linux_selected_device_has_dmabuf_quirk(selected_device, uses_native_wayland) => {
&[("WEBKIT_DISABLE_DMABUF_RENDERER", "1")]
}
LinuxNvidiaDriver::None => {
// AMD / Intel and other Mesa drivers keep DMABuf enabled to avoid
// unnecessary CPU usage and UI lag on Wayland.
&[]
}
}
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn linux_webkit_environment_override<'a>(
existing_value: Option<&std::ffi::OsStr>,
workaround_value: &'a str,
) -> Option<&'a str> {
existing_value.is_none().then_some(workaround_value)
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn linux_appimage_requires_dmabuf_workaround(appimage: Option<&std::ffi::OsStr>) -> bool {
appimage.is_some_and(|value| !value.is_empty())
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
fn linux_uses_native_wayland(
wayland_display: Option<&std::ffi::OsStr>,
session_type: Option<&std::ffi::OsStr>,
gdk_backend: Option<&std::ffi::OsStr>,
) -> bool {
let has_wayland_display = wayland_display.is_some_and(|value| !value.is_empty());
let is_wayland_session =
session_type.and_then(std::ffi::OsStr::to_str).is_some_and(|value| value.eq_ignore_ascii_case("wayland"));
if !has_wayland_display || !is_wayland_session {
return false;
}
gdk_backend.is_none_or(|backends| {
backends
.to_string_lossy()
.split(',')
.next()
.is_some_and(|backend| backend.trim().eq_ignore_ascii_case("wayland"))
})
}
#[cfg(target_os = "linux")]
fn apply_linux_webkit_rendering_workarounds() {
let render_devices = linux_drm_render_devices();
let appimage = std::env::var_os("APPIMAGE");
let explicit_device_file = std::env::var_os("WEBKIT_WEB_RENDER_DEVICE_FILE")
.filter(|path| !path.is_empty())
.map(std::path::PathBuf::from)
// Resolve stable /dev/dri/by-path links to the renderD* node used by sysfs.
.map(|path| std::fs::canonicalize(&path).unwrap_or(path));
let selected_device = linux_selected_drm_render_device(explicit_device_file.as_deref(), &render_devices);
let nvidia_driver = linux_nvidia_driver_from_state(
std::path::Path::new("/dev/nvidiactl").exists(),
std::path::Path::new("/proc/driver/nvidia/version").exists(),
selected_device.and_then(|device| device.driver.as_deref()),
std::env::var_os("__NV_PRIME_RENDER_OFFLOAD").is_some_and(|value| value == "1"),
);
let has_hardware_render_device =
render_devices.iter().any(|device| !linux_drm_driver_is_software_only(device.driver.as_deref()));
let uses_native_wayland = linux_uses_native_wayland(
std::env::var_os("WAYLAND_DISPLAY").as_deref(),
std::env::var_os("XDG_SESSION_TYPE").as_deref(),
std::env::var_os("GDK_BACKEND").as_deref(),
);
// AppImages bundle WebKitGTK/GTK but use the host EGL/GL stack. On some
// combinations, WebKit's DMABUF initialization aborts the WebProcess
// before it can fall back to software rendering. Keep this opt-out
// user-overridable and use the stable shared-memory renderer instead.
if linux_appimage_requires_dmabuf_workaround(appimage.as_deref())
&& linux_webkit_environment_override(std::env::var_os("WEBKIT_DISABLE_DMABUF_RENDERER").as_deref(), "1")
.is_some()
{
std::env::set_var("WEBKIT_DISABLE_DMABUF_RENDERER", "1");
}
for (key, value) in linux_webkit_rendering_workarounds(
nvidia_driver,
has_hardware_render_device,
selected_device,
uses_native_wayland,
) {
if let Some(value) = linux_webkit_environment_override(std::env::var_os(key).as_deref(), value) {
std::env::set_var(key, value);
}
}
}
/// Brings the main window to the foreground, reporting whether it ended up visible.
///
/// The individual calls used to be discarded with `let _ =`, which made a failed
/// reveal completely silent. That matters on macOS: an instance that has lost its
/// WindowServer connection stays alive and idle but can no longer present a window
/// or a tray icon, and the single-instance guard keeps handing later launches to it,
/// so the app looks like it simply does not start. Logging here is what makes that
/// state diagnosable at all.
fn show_main_window<R: tauri::Runtime>(app: &tauri::AppHandle<R>) -> bool {
let Some(window) = app.get_webview_window("main") else {
eprintln!("[WINDOW] show_main_window: no \"main\" webview window to reveal");
startup_recovery::record("show_main_window: main webview window is missing");
return false;
};
if let Err(err) = window.show() {
eprintln!("[WINDOW] show_main_window: show() failed: {err}");
startup_recovery::record(format!("show_main_window: show() failed: {err}"));
}
if let Err(err) = window.unminimize() {
eprintln!("[WINDOW] show_main_window: unminimize() failed: {err}");
startup_recovery::record(format!("show_main_window: unminimize() failed: {err}"));
}
if let Err(err) = window.set_focus() {
eprintln!("[WINDOW] show_main_window: set_focus() failed: {err}");
startup_recovery::record(format!("show_main_window: set_focus() failed: {err}"));
}
match window.is_visible() {
Ok(visible) => visible,
Err(err) => {
eprintln!("[WINDOW] show_main_window: is_visible() failed: {err}");
startup_recovery::record(format!("show_main_window: is_visible() failed: {err}"));
false
}
}
}
fn main_window_probe_state<R: tauri::Runtime>(app: &tauri::AppHandle<R>) -> String {
let Some(window) = app.get_webview_window("main") else {
return "main_window=missing".to_string();
};
format!(
"main_window visible={:?} minimized={:?} maximized={:?} fullscreen={:?} position={:?} size={:?}",
window.is_visible(),
window.is_minimized(),
window.is_maximized(),
window.is_fullscreen(),
window.outer_position(),
window.outer_size()
)
}
fn prepare_main_window_for_display<R: tauri::Runtime>(app: &tauri::AppHandle<R>) {
if let Some(decorations) = native_window_decorations_override(std::env::consts::OS) {
if let Some(window) = app.get_webview_window("main") {
let _ = window.set_decorations(decorations);
}
}
window_state_guard::enforce_main_window_bounds(app);
}
fn clear_main_webview_focus<R: tauri::Runtime>(app: &tauri::AppHandle<R>) {
if let Some(window) = app.get_webview_window("main") {
let _ = window.eval(
r#"
(() => {
const active = document.activeElement;
if (active instanceof HTMLElement) active.blur();
if (document.body) {
if (!document.body.hasAttribute("tabindex")) {
document.body.setAttribute("tabindex", "-1");
}
document.body.focus({ preventScroll: true });
}
})();
"#,
);
}
}
pub(crate) fn hide_main_window_for_close<R: tauri::Runtime>(app: &tauri::AppHandle<R>, window: &tauri::Window<R>) {
clear_main_webview_focus(app);
#[cfg(target_os = "macos")]
{
if window.is_fullscreen().unwrap_or(false) {
let app = app.clone();
let window = window.clone();
let _ = window.set_fullscreen(false);
tauri::async_runtime::spawn(async move {
for _ in 0..40 {
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
if !window.is_fullscreen().unwrap_or(false) {
tokio::time::sleep(std::time::Duration::from_millis(600)).await;
let app_to_hide = app.clone();
let window_to_hide = window.clone();
let _ = app.run_on_main_thread(move || {
let _ = window_to_hide.hide();
let _ = app_to_hide.hide();
});
return;
}
}
let app_to_hide = app.clone();
let window_to_hide = window.clone();
let _ = app.run_on_main_thread(move || {
let _ = window_to_hide.hide();
let _ = app_to_hide.hide();
});
});
return;
}
}
let _ = window.hide();
}
pub(crate) fn request_app_close<R: tauri::Runtime>(app: &tauri::AppHandle<R>, target: &str) {
let frontend_ready = app.try_state::<CloseBehaviorState>().is_some_and(|state| state.is_frontend_ready());
if should_fallback_to_native_quit(target, frontend_ready) {
// A missing WebView2 runtime can prevent the frontend listener from ever
// loading. Only the explicit tray Quit fallback bypasses the prompt.
if let Some(state) = app.try_state::<CloseBehaviorState>() {
state.allow_next_exit();
}
app.exit(0);
return;
}
show_main_window(app);
// The prompt only resolves to a quit after the user answers, by which
// point the window may already be hidden. Record its visible frame now;
// `complete_app_close` and the dock/menu quit keep this capture unless the
// window has meanwhile moved.
window_state_guard::remember_main_window_geometry(app);
let _ = app.emit(APP_CLOSE_REQUESTED_EVENT, target);
}
fn register_deep_link_state<R: tauri::Runtime>(builder: tauri::Builder<R>) -> tauri::Builder<R> {
// macOS can deliver Opened before setup, so its queue must already exist.
builder.manage(commands::deep_link::DeepLinkOpenState::default())
}
fn open_connection_deep_links<R: tauri::Runtime>(app: &tauri::AppHandle<R>, links: Vec<String>) {
if links.is_empty() {
return;
}
let should_emit = app
.try_state::<commands::deep_link::DeepLinkOpenState>()
.is_none_or(|state| state.route_connection_links(links.clone()));
if should_emit {
let _ = app.emit("dbx-open-connection-links", links);
}
show_main_window(app);
}
fn open_ai_config_deep_links(app: &tauri::AppHandle, links: Vec<String>) {
if links.is_empty() {
return;
}
let should_emit = app
.try_state::<commands::deep_link::DeepLinkOpenState>()
.is_none_or(|state| state.route_ai_config_links(links.clone()));
if should_emit {
let _ = app.emit("dbx-open-ai-config-links", links);
}
show_main_window(app);
}
fn open_plugin_install_deep_links(app: &tauri::AppHandle, links: Vec<String>) {
if links.is_empty() {
return;
}
let should_emit = app
.try_state::<commands::deep_link::DeepLinkOpenState>()
.is_none_or(|state| state.route_plugin_install_links(links.clone()));
if should_emit {
let _ = app.emit("dbx-open-plugin-install-links", links);
}
show_main_window(app);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum LocaleFamily {
Azerbaijani,
English,
Thai,
SimplifiedChinese,
TraditionalChinese,
Japanese,
Korean,
Spanish,
Indonesian,
Italian,
Portuguese,
Polish,
Russian,
Turkish,
}
// Mirrors the frontend language mapping in apps/desktop/src/i18n/index.ts
// (localeFromLanguageTag) so native menus agree with the UI language.
fn locale_family(locale: &str) -> LocaleFamily {
let normalized = locale.replace('_', "-").to_ascii_lowercase();
let is_language = |language: &str| normalized == language || normalized.starts_with(&format!("{language}-"));
if is_language("zh") {
if normalized.contains("hant")
|| normalized.starts_with("zh-tw")
|| normalized.starts_with("zh-hk")
|| normalized.starts_with("zh-mo")
{
LocaleFamily::TraditionalChinese
} else {
LocaleFamily::SimplifiedChinese
}
} else if is_language("ja") {
LocaleFamily::Japanese
} else if is_language("th") {
LocaleFamily::Thai
} else if is_language("ko") {
LocaleFamily::Korean
} else if is_language("az") {
LocaleFamily::Azerbaijani
} else if is_language("es") {
LocaleFamily::Spanish
} else if is_language("id") {
LocaleFamily::Indonesian
} else if is_language("tr") {
LocaleFamily::Turkish
} else if is_language("it") {
LocaleFamily::Italian
} else if is_language("pt") {
LocaleFamily::Portuguese
} else if is_language("pl") {
LocaleFamily::Polish
} else if is_language("ru") {
LocaleFamily::Russian
} else {
LocaleFamily::English
}
}
fn tray_menu_labels_for_locale(locale: &str) -> (&'static str, &'static str) {
match locale_family(locale) {
LocaleFamily::SimplifiedChinese => ("显示 DBX", "退出 DBX"),
LocaleFamily::TraditionalChinese => ("顯示 DBX", "退出 DBX"),
LocaleFamily::Thai => ("แสดง DBX", "ออกจาก DBX"),
LocaleFamily::Japanese => ("DBXを表示", "DBXを終了"),
LocaleFamily::Korean => ("DBX 표시", "DBX 종료"),
LocaleFamily::Azerbaijani => ("DBX-i göstər", "DBX-dən çıx"),
LocaleFamily::Spanish => ("Mostrar DBX", "Salir de DBX"),
LocaleFamily::Indonesian => ("Tampilkan DBX", "Keluar dari DBX"),
LocaleFamily::Italian => ("Mostra DBX", "Esci da DBX"),
LocaleFamily::Turkish => ("DBX'i Göster", "DBX'ten Çık"),
LocaleFamily::Portuguese => ("Mostrar DBX", "Sair do DBX"),
LocaleFamily::Russian => ("Показать DBX", "Выйти из DBX"),
LocaleFamily::Polish => ("Pokaż DBX", "Zakończ DBX"),
LocaleFamily::English => ("Show DBX", "Quit DBX"),
}
}
// Matches the frontend supportInfoCopy translations in apps/desktop/src/i18n/locales/*.ts.
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
fn app_menu_copy_support_info_label(locale: &str) -> &'static str {
match locale_family(locale) {
LocaleFamily::SimplifiedChinese => "复制支持信息",
LocaleFamily::TraditionalChinese => "複製支援資訊",
LocaleFamily::Thai => "คัดลอกข้อมูลสำหรับขอความช่วยเหลือ",
LocaleFamily::Japanese => "サポート情報をコピー",
LocaleFamily::Korean => "지원 정보 복사",
LocaleFamily::Azerbaijani => "Dəstək məlumatlarını kopyala",
LocaleFamily::Spanish => "Copiar información",
LocaleFamily::Indonesian => "Salin Info Dukungan",
LocaleFamily::Italian => "Copia informazioni",
LocaleFamily::Turkish => "Destek bilgilerini kopyala",
LocaleFamily::Portuguese => "Copiar informações",
LocaleFamily::Russian => "Копировать сведения о поддержке",
LocaleFamily::Polish => "Kopiuj informacje o pomocy technicznej",
LocaleFamily::English => "Copy Support Info",
}
}
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
fn app_menu_close_tab_label(locale: &str) -> &'static str {
match locale_family(locale) {
LocaleFamily::SimplifiedChinese => "关闭标签页",
LocaleFamily::TraditionalChinese => "關閉分頁",
LocaleFamily::Thai => "ปิดแท็บ",
LocaleFamily::Japanese => "タブを閉じる",
LocaleFamily::Korean => "탭 닫기",
LocaleFamily::Azerbaijani => "Vərəqi bağla",
LocaleFamily::Spanish => "Cerrar pestaña",
LocaleFamily::Indonesian => "Tutup Tab",
LocaleFamily::Italian => "Chiudi scheda",
LocaleFamily::Turkish => "Sekmeyi kapat",
LocaleFamily::Portuguese => "Fechar aba",
LocaleFamily::Russian => "Закрыть вкладку",
LocaleFamily::Polish => "Zamknij kartę",
LocaleFamily::English => "Close Tab",
}
}
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
fn app_menu_quit_label(locale: &str, app_name: &str) -> String {
match locale_family(locale) {
LocaleFamily::SimplifiedChinese | LocaleFamily::TraditionalChinese => format!("退出 {app_name}"),
LocaleFamily::Thai => format!("ออกจาก {app_name}"),
LocaleFamily::Japanese => format!("{app_name}を終了"),
LocaleFamily::Korean => format!("{app_name} 종료"),
LocaleFamily::Azerbaijani => format!("{app_name}-dən çıx"),
LocaleFamily::Spanish => format!("Salir de {app_name}"),
LocaleFamily::Indonesian => format!("Keluar dari {app_name}"),
LocaleFamily::Italian => format!("Esci da {app_name}"),
LocaleFamily::Turkish => format!("{app_name} Uygulamasından Çık"),
LocaleFamily::Portuguese => format!("Sair do {app_name}"),
LocaleFamily::Russian => format!("Выйти из {app_name}"),
LocaleFamily::Polish => format!("Zakończ {app_name}"),
LocaleFamily::English => format!("Quit {app_name}"),
}
}
fn current_app_locale<R: tauri::Runtime, M: Manager<R>>(manager: &M) -> String {
match manager.try_state::<AppLocaleState>() {
Some(state) => state.get(),
None => sys_locale::get_locale().unwrap_or_default(),
}
}
fn build_tray_menu<R: tauri::Runtime, M: Manager<R>>(manager: &M) -> tauri::Result<tauri::menu::Menu<R>> {
let (show_label, quit_label) = tray_menu_labels_for_locale(¤t_app_locale(manager));
MenuBuilder::new(manager).text("show", show_label).separator().text("quit", quit_label).build()
}
/// Rebuilds the tray menu (and the macOS app menu) so native labels follow the
/// UI language after the frontend reports a locale change.
pub(crate) fn refresh_native_menus(app: &tauri::AppHandle) -> tauri::Result<()> {
if let Some(tray) = app.tray_by_id(DESKTOP_TRAY_ID) {
tray.set_menu(Some(build_tray_menu(app)?))?;
}
#[cfg(target_os = "macos")]
{
let _ = app.set_menu(build_app_menu(app)?)?;
}
Ok(())
}
#[cfg_attr(not(any(target_os = "macos", target_os = "windows")), allow(dead_code))]
fn setup_desktop_tray<R: tauri::Runtime, M: Manager<R>>(
manager: &M,
_icon_theme: DesktopIconTheme,
) -> tauri::Result<()> {
let menu = build_tray_menu(manager)?;
let mut tray =
TrayIconBuilder::<R>::with_id(DESKTOP_TRAY_ID).tooltip("DBX").menu(&menu).show_menu_on_left_click(false);
#[cfg(target_os = "macos")]
{
tray = tray.icon(MACOS_TRAY_ICON).icon_as_template(true);
}
#[cfg(target_os = "windows")]
{
let icon = match _icon_theme {
DesktopIconTheme::Default => manager.app_handle().default_window_icon().cloned(),
DesktopIconTheme::Black => Some(BLACK_APP_ICON),
};
if let Some(icon) = icon {
tray = tray.icon(icon);
}
}
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
{
if let Some(icon) = manager.app_handle().default_window_icon().cloned() {
tray = tray.icon(icon);
}
}
tray.on_menu_event(|app, event| {
if event.id() == "show" {
show_main_window(app);
} else if event.id() == "quit" {
request_app_close(app, "quit");
}
})
.on_tray_icon_event(|tray, event| match event {
TrayIconEvent::Click { button: MouseButton::Left, button_state: MouseButtonState::Up, .. }
| TrayIconEvent::DoubleClick { button: MouseButton::Left, .. } => {
show_main_window(tray.app_handle());
}
_ => {}
})
.build(manager)?;
Ok(())
}
#[cfg(target_os = "macos")]
fn apply_macos_app_icon_theme(
app: &tauri::AppHandle,
icon_theme: DesktopIconTheme,
persist_bundle_icon: bool,
) -> tauri::Result<()> {
use objc2::{AllocAnyThread, MainThreadMarker};
use objc2_app_kit::{NSApplication, NSImage, NSWorkspace, NSWorkspaceIconCreationOptions};
use objc2_foundation::{NSBundle, NSData, NSString};
let icon_bytes = match icon_theme {
DesktopIconTheme::Default => MACOS_DEFAULT_APP_ICON,
DesktopIconTheme::Black => MACOS_DARK_APP_ICON,
};
app.run_on_main_thread(move || {
// macOS has no per-window icon. Update NSApplication so the Dock and
// app switcher reflect the selected theme immediately.
let marker = unsafe { MainThreadMarker::new_unchecked() };
let application = NSApplication::sharedApplication(marker);
let workspace = NSWorkspace::sharedWorkspace();
let app_bundle_path = NSBundle::mainBundle().bundlePath();
let data = NSData::with_bytes(icon_bytes);
if let Some(icon) = NSImage::initWithData(NSImage::alloc(), &data) {
unsafe { application.setApplicationIconImage(Some(&icon)) };
// NSApplication only changes the icon for this process lifetime.
// Persist the selected icon on the app bundle so Finder and the
// Dock keep showing it after DBX exits. A nil image removes the
// custom icon and restores the bundle's packaged default.
if persist_bundle_icon {
let persistent_icon = match icon_theme {
DesktopIconTheme::Default => None,
DesktopIconTheme::Black => Some(&*icon),
};
if app_bundle_path.hasSuffix(&NSString::from_str(".app"))
&& !workspace.setIcon_forFile_options(
persistent_icon,
&app_bundle_path,
NSWorkspaceIconCreationOptions::empty(),
)
{
log::warn!("Failed to persist the selected macOS app icon; the app bundle may not be writable");
}
}
} else {
log::warn!("Failed to decode the selected macOS application icon");
}
})
}
#[cfg(target_os = "macos")]
fn apply_macos_development_dock_badge(app: &tauri::AppHandle) -> tauri::Result<()> {
use objc2::MainThreadMarker;
use objc2_app_kit::NSApplication;
use objc2_foundation::NSString;
let badge_label = development_dock_badge_label(cfg!(debug_assertions));
app.run_on_main_thread(move || {
let marker = unsafe { MainThreadMarker::new_unchecked() };
let application = NSApplication::sharedApplication(marker);
let badge_label = badge_label.map(NSString::from_str);
application.dockTile().setBadgeLabel(badge_label.as_deref());
})
}
pub(crate) fn apply_desktop_icon_theme(app: &tauri::AppHandle, icon_theme: DesktopIconTheme) -> tauri::Result<()> {
#[cfg(target_os = "macos")]
{
apply_macos_app_icon_theme(app, icon_theme, true)
}
#[cfg(not(target_os = "macos"))]
if let Some(window) = app.get_webview_window("main") {
match icon_theme {
DesktopIconTheme::Default => {
if let Some(icon) = app.default_window_icon().cloned() {
window.set_icon(icon)?;
}
}
DesktopIconTheme::Black => window.set_icon(BLACK_APP_ICON)?,
}
}
#[cfg(not(target_os = "macos"))]
Ok(())
}
fn apply_desktop_tray_icon_theme(app: &tauri::AppHandle, _icon_theme: DesktopIconTheme) -> tauri::Result<()> {
if let Some(_tray) = app.tray_by_id(DESKTOP_TRAY_ID) {
#[cfg(target_os = "windows")]
{
let icon = match _icon_theme {
DesktopIconTheme::Default => app.default_window_icon().cloned(),
DesktopIconTheme::Black => Some(BLACK_APP_ICON),
};
_tray.set_icon(icon)?;
}
#[cfg(target_os = "linux")]
{
let icon = match _icon_theme {
DesktopIconTheme::Default => app.default_window_icon().cloned(),
DesktopIconTheme::Black => Some(BLACK_APP_ICON),
};
_tray.set_icon(icon)?;
}
#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
{
let _ = (_tray, _icon_theme);
}
}
Ok(())
}
pub(crate) fn apply_desktop_settings(app: &tauri::AppHandle, desktop_settings: &DesktopSettings) -> tauri::Result<()> {
apply_debug_log_level(desktop_settings.debug_logging_enabled);
apply_desktop_icon_theme(app, desktop_settings.icon_theme)?;
if should_setup_desktop_tray(std::env::consts::OS, desktop_settings.show_tray_icon, linux_appindicator_available())
{
if let Some(tray) = app.tray_by_id(DESKTOP_TRAY_ID) {
tray.set_visible(desktop_settings.show_tray_icon)?;
apply_desktop_tray_icon_theme(app, desktop_settings.icon_theme)?;
} else if desktop_settings.show_tray_icon {
setup_desktop_tray(app, desktop_settings.icon_theme)?;
}
}
Ok(())
}
async fn shutdown_runtime_resources(app_handle: &tauri::AppHandle) {
if let Some(backups) = app_handle.try_state::<background_backup::BackgroundBackup>() {
backups.shutdown().await;
}
if let Some(server) = app_handle.try_state::<commands::redis_pubsub_server::PubSubServerState>() {
server.shutdown(Duration::from_secs(1)).await;
}
if let Some(state) = app_handle.try_state::<Arc<AppState>>() {
state.shutdown(Duration::from_secs(3)).await;
}
}
fn run_shutdown_on_dedicated_thread(shutdown: impl FnOnce() + Send + 'static) -> Result<(), String> {
std::thread::Builder::new()
.name("dbx-runtime-shutdown".into())
.spawn(shutdown)
.map_err(|error| format!("failed to start runtime shutdown: {error}"))?
.join()
.map_err(|_| "runtime shutdown thread panicked".to_string())
}
pub(crate) fn cleanup_before_updater_forced_exit(app_handle: &tauri::AppHandle) {
let shutdown_app = app_handle.clone();
if let Err(error) = run_shutdown_on_dedicated_thread(move || {
tauri::async_runtime::block_on(shutdown_runtime_resources(&shutdown_app));
}) {
log::warn!("Failed to shut down DBX runtime resources before updater exit: {error}");
}
app_handle.cleanup_before_exit();
}
#[cfg(test)]
#[allow(clippy::items_after_test_module)]
mod tests {
use super::{
app_menu_close_tab_label, app_menu_copy_support_info_label, app_menu_quit_label,
linux_appimage_requires_dmabuf_workaround, linux_drm_driver_is_software_only,
linux_drm_render_devices_from_paths, linux_nvidia_driver_from_state, linux_pci_id_from_sysfs_value,
linux_selected_drm_render_device, linux_uses_native_wayland, linux_webkit_environment_override,
linux_webkit_rendering_workarounds, native_window_decorations_override, run_shutdown_on_dedicated_thread,
should_confirm_app_exit_request, should_enable_linux_floating_frame, should_enable_single_instance,
should_fallback_to_native_quit, should_hide_window_before_exit, should_hide_window_on_close,
should_setup_desktop_tray, should_show_main_window_after_setup, should_show_main_window_before_setup_tasks,
startup_data_dir_mode, tray_menu_labels_for_locale, uses_application_level_icon, LinuxDrmRenderDevice,
LinuxNvidiaDriver,
};
use crate::data_dir::DataDirMode;
use std::ffi::OsStr;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
#[test]
#[cfg(desktop)]
fn deep_links_received_before_setup_survive_until_frontend_ready() {
use crate::commands::deep_link::{pending_open_connection_links, DeepLinkOpenState};
use std::sync::atomic::{AtomicBool, Ordering};
use tauri::test::{mock_builder, mock_context, noop_assets};
use tauri::{Listener, Manager};
let setup_ran = Arc::new(AtomicBool::new(false));
let setup_observed = setup_ran.clone();
// Use the production registration path, not a test-only manage call.
let mut app = super::register_deep_link_state(mock_builder())
.setup(move |_| {
setup_observed.store(true, Ordering::SeqCst);
Ok(())
})
.build(mock_context(noop_assets()))
.unwrap();
assert!(!setup_ran.load(Ordering::SeqCst));
assert!(app.try_state::<DeepLinkOpenState>().is_some());
let emitted = Arc::new(Mutex::new(Vec::<Vec<String>>::new()));
let observed = emitted.clone();
app.listen("dbx-open-connection-links", move |event| {
observed.lock().unwrap().push(serde_json::from_str(event.payload()).unwrap());
});
let first = "dbx://connection/new?type=mysql&one_time=true".to_string();
let second = "dbx://connection/new?type=postgres&one_time=false".to_string();
super::open_connection_deep_links(app.handle(), vec![first.clone()]);
super::open_connection_deep_links(app.handle(), vec![first.clone(), second.clone()]);
assert!(emitted.lock().unwrap().is_empty());
// Tauri runs setup here even though MockRuntime's iteration is a no-op.
// A single iteration avoids the busy-loop the deprecation warns about.
#[allow(deprecated)]
app.run_iteration(|_, _| {});
assert!(setup_ran.load(Ordering::SeqCst));
assert!(emitted.lock().unwrap().is_empty());
assert_eq!(pending_open_connection_links(app.state()), vec![first, second]);
assert!(pending_open_connection_links(app.state()).is_empty());
let warm = "dbx://connection/new?type=mysql&host=localhost".to_string();
super::open_connection_deep_links(app.handle(), vec![warm.clone()]);
assert_eq!(*emitted.lock().unwrap(), vec![vec![warm]]);
assert!(pending_open_connection_links(app.state()).is_empty());
}
#[test]
fn forced_exit_shutdown_waits_for_a_dedicated_cleanup_thread() {
let caller = std::thread::current().id();
let cleanup_thread = Arc::new(Mutex::new(None));
let observed_thread = cleanup_thread.clone();
run_shutdown_on_dedicated_thread(move || {
*observed_thread.lock().unwrap() = Some(std::thread::current().id());
})
.unwrap();
let cleanup_thread = cleanup_thread.lock().unwrap().expect("cleanup thread id");
assert_ne!(cleanup_thread, caller);
}
#[test]
fn linux_floating_frame_is_enabled_by_default_on_gnome_wayland_only() {
for desktop in ["GNOME", "ubuntu:GNOME", "gnome", "GNOME-Classic:GNOME"] {
assert!(should_enable_linux_floating_frame(true, true, None, Some(OsStr::new(desktop)), true), "{desktop}");
}
for desktop in ["KDE", "XFCE", "X-Cinnamon", "sway", "", "GNOMEISH"] {
assert!(
!should_enable_linux_floating_frame(true, true, None, Some(OsStr::new(desktop)), true),
"{desktop}"
);
}
assert!(!should_enable_linux_floating_frame(true, true, None, None, true));
}
#[test]
fn linux_floating_frame_is_disabled_by_default_on_gnome_x11() {
for desktop in ["GNOME", "ubuntu:GNOME", "GNOME-Classic:GNOME"] {
assert!(
!should_enable_linux_floating_frame(true, false, None, Some(OsStr::new(desktop)), true),
"{desktop}"
);
}
assert!(should_enable_linux_floating_frame(
true,
false,
Some(OsStr::new("1")),
Some(OsStr::new("GNOME")),
true
));
}
#[test]
fn linux_floating_frame_override_wins_over_desktop() {
assert!(should_enable_linux_floating_frame(true, true, Some(OsStr::new("1")), Some(OsStr::new("KDE")), true));
assert!(!should_enable_linux_floating_frame(
true,
true,
Some(OsStr::new("0")),
Some(OsStr::new("GNOME")),
true
));
for value in ["", "true", "auto", "01"] {
assert!(should_enable_linux_floating_frame(
true,
true,
Some(OsStr::new(value)),
Some(OsStr::new("GNOME")),
true
));
assert!(!should_enable_linux_floating_frame(
true,
true,
Some(OsStr::new(value)),
Some(OsStr::new("KDE")),
true
));
}
}
#[test]
fn linux_floating_frame_requires_compositing() {
assert!(!should_enable_linux_floating_frame(
false,
true,
Some(OsStr::new("1")),
Some(OsStr::new("GNOME")),
true
));
assert!(!should_enable_linux_floating_frame(false, true, None, Some(OsStr::new("GNOME")), true));
}
#[test]
fn linux_floating_frame_setting_can_disable_gnome_default() {
let desktop = Some(OsStr::new("GNOME"));
assert!(!should_enable_linux_floating_frame(true, true, None, desktop, false));
assert!(!should_enable_linux_floating_frame(true, true, Some(OsStr::new("auto")), desktop, false));
assert!(should_enable_linux_floating_frame(true, true, Some(OsStr::new("1")), desktop, false));
assert!(!should_enable_linux_floating_frame(true, true, Some(OsStr::new("0")), desktop, true));
assert!(!should_enable_linux_floating_frame(true, false, None, desktop, true));
assert!(!should_enable_linux_floating_frame(false, true, Some(OsStr::new("1")), desktop, false));
}
#[test]
fn tray_menu_labels_follow_locale() {
assert_eq!(tray_menu_labels_for_locale("zh-CN"), ("显示 DBX", "退出 DBX"));
assert_eq!(tray_menu_labels_for_locale("zh_CN"), ("显示 DBX", "退出 DBX"));
assert_eq!(tray_menu_labels_for_locale("zh-Hans-CN"), ("显示 DBX", "退出 DBX"));
assert_eq!(tray_menu_labels_for_locale("zh"), ("显示 DBX", "退出 DBX"));
assert_eq!(tray_menu_labels_for_locale("zh-TW"), ("顯示 DBX", "退出 DBX"));
assert_eq!(tray_menu_labels_for_locale("zh-Hant-HK"), ("顯示 DBX", "退出 DBX"));
assert_eq!(tray_menu_labels_for_locale("zh-MO"), ("顯示 DBX", "退出 DBX"));
assert_eq!(tray_menu_labels_for_locale("ja-JP"), ("DBXを表示", "DBXを終了"));
assert_eq!(tray_menu_labels_for_locale("th-TH"), ("แสดง DBX", "ออกจาก DBX"));
assert_eq!(tray_menu_labels_for_locale("th_TH"), ("แสดง DBX", "ออกจาก DBX"));
assert_eq!(tray_menu_labels_for_locale("ko-KR"), ("DBX 표시", "DBX 종료"));
assert_eq!(tray_menu_labels_for_locale("az-AZ"), ("DBX-i göstər", "DBX-dən çıx"));
assert_eq!(tray_menu_labels_for_locale("es-ES"), ("Mostrar DBX", "Salir de DBX"));
assert_eq!(tray_menu_labels_for_locale("id-ID"), ("Tampilkan DBX", "Keluar dari DBX"));
assert_eq!(tray_menu_labels_for_locale("it-IT"), ("Mostra DBX", "Esci da DBX"));
assert_eq!(tray_menu_labels_for_locale("pt-BR"), ("Mostrar DBX", "Sair do DBX"));
assert_eq!(tray_menu_labels_for_locale("tr-TR"), ("DBX'i Göster", "DBX'ten Çık"));
assert_eq!(tray_menu_labels_for_locale("ru-RU"), ("Показать DBX", "Выйти из DBX"));
assert_eq!(tray_menu_labels_for_locale("pl-PL"), ("Pokaż DBX", "Zakończ DBX"));
assert_eq!(tray_menu_labels_for_locale("pl_PL"), ("Pokaż DBX", "Zakończ DBX"));
assert_eq!(tray_menu_labels_for_locale("en-US"), ("Show DBX", "Quit DBX"));
// Unknown and empty locales fall back to English; "ita" must not match "it".
assert_eq!(tray_menu_labels_for_locale("ita"), ("Show DBX", "Quit DBX"));
assert_eq!(tray_menu_labels_for_locale(""), ("Show DBX", "Quit DBX"));
}
#[test]
fn app_menu_labels_follow_locale() {
assert_eq!(app_menu_quit_label("zh-CN", "DBX"), "退出 DBX");
assert_eq!(app_menu_quit_label("zh-TW", "DBX"), "退出 DBX");
assert_eq!(app_menu_quit_label("ja-JP", "DBX"), "DBXを終了");
assert_eq!(app_menu_quit_label("th-TH", "DBX"), "ออกจาก DBX");
assert_eq!(app_menu_quit_label("th_TH", "DBX"), "ออกจาก DBX");
assert_eq!(app_menu_quit_label("ko-KR", "DBX"), "DBX 종료");
assert_eq!(app_menu_quit_label("tr-TR", "DBX"), "DBX Uygulamasından Çık");
assert_eq!(app_menu_quit_label("ru-RU", "DBX"), "Выйти из DBX");
assert_eq!(app_menu_quit_label("az-AZ", "DBX"), "DBX-dən çıx");
assert_eq!(app_menu_quit_label("id-ID", "DBX"), "Keluar dari DBX");
assert_eq!(app_menu_quit_label("en-US", "DBX"), "Quit DBX");
assert_eq!(app_menu_quit_label("", "DBX"), "Quit DBX");
assert_eq!(app_menu_copy_support_info_label("zh-CN"), "复制支持信息");
assert_eq!(app_menu_copy_support_info_label("zh-TW"), "複製支援資訊");
assert_eq!(app_menu_copy_support_info_label("th-TH"), "คัดลอกข้อมูลสำหรับขอความช่วยเหลือ");
assert_eq!(app_menu_copy_support_info_label("ko-KR"), "지원 정보 복사");
assert_eq!(app_menu_copy_support_info_label("tr-TR"), "Destek bilgilerini kopyala");
assert_eq!(app_menu_copy_support_info_label("ru-RU"), "Копировать сведения о поддержке");
assert_eq!(app_menu_copy_support_info_label("az-AZ"), "Dəstək məlumatlarını kopyala");
assert_eq!(app_menu_copy_support_info_label("id-ID"), "Salin Info Dukungan");
assert_eq!(app_menu_copy_support_info_label("en-US"), "Copy Support Info");
assert_eq!(app_menu_close_tab_label("zh-CN"), "关闭标签页");
assert_eq!(app_menu_close_tab_label("zh-TW"), "關閉分頁");
assert_eq!(app_menu_close_tab_label("ja-JP"), "タブを閉じる");
assert_eq!(app_menu_close_tab_label("th-TH"), "ปิดแท็บ");
assert_eq!(app_menu_close_tab_label("en-US"), "Close Tab");
}
#[test]
fn hides_window_on_close_for_windows_and_macos() {
assert!(should_hide_window_on_close("windows"));
assert!(should_hide_window_on_close("macos"));
}
#[test]
fn does_not_hide_window_on_close_for_other_platforms() {
assert!(!should_hide_window_on_close("linux"));
}
#[test]
fn hides_window_before_exit_only_on_macos() {
assert!(should_hide_window_before_exit("macos"));
assert!(!should_hide_window_before_exit("windows"));
assert!(!should_hide_window_before_exit("linux"));
}
#[test]
fn sets_up_desktop_tray_for_windows_macos_and_linux() {
assert!(should_setup_desktop_tray("windows", true, false));
assert!(should_setup_desktop_tray("macos", true, false));
assert!(should_setup_desktop_tray("linux", true, true));
assert!(!should_setup_desktop_tray("linux", true, false));
assert!(!should_setup_desktop_tray("windows", false, true));
assert!(!should_setup_desktop_tray("macos", false, true));
assert!(!should_setup_desktop_tray("linux", false, true));
}
#[test]
fn keeps_single_instance_for_release_builds_only() {
assert!(!should_enable_single_instance(true));
assert!(should_enable_single_instance(false));
}
#[test]
fn startup_data_dir_diagnostics_never_include_paths() {
let private_path = PathBuf::from(r"C:\Users\private-user\DBXData");
assert_eq!(startup_data_dir_mode(&DataDirMode::Default), "default");
assert_eq!(startup_data_dir_mode(&DataDirMode::EnvOverride), "env_override");
let label = startup_data_dir_mode(&DataDirMode::Portable { exe_dir: private_path });
assert_eq!(label, "portable");
assert!(!label.contains("private-user"));
}
#[cfg(target_os = "macos")]
#[test]
fn labels_debug_builds_in_the_macos_dock() {
assert_eq!(super::development_dock_badge_label(true), Some("DEV"));
assert_eq!(super::development_dock_badge_label(false), None);
}
#[cfg(target_os = "macos")]
#[test]
fn macos_tray_icon_remains_a_system_template() {
// Menu bar template images are intentionally independent from the app
// icon theme so macOS can recolor them for light and dark menu bars.
assert_eq!(super::MACOS_TRAY_ICON.width(), 36);
assert_eq!(super::MACOS_TRAY_ICON.height(), 36);
}
#[cfg(target_os = "macos")]
#[test]
fn macos_icon_themes_use_packaged_dock_assets() {
use objc2::AllocAnyThread;
use objc2_app_kit::NSImage;
use objc2_foundation::NSData;
assert!(super::MACOS_DEFAULT_APP_ICON.starts_with(b"icns"));
assert!(super::MACOS_DARK_APP_ICON.starts_with(b"icns"));
for bytes in [super::MACOS_DEFAULT_APP_ICON, super::MACOS_DARK_APP_ICON] {
let data = NSData::with_bytes(bytes);
assert!(NSImage::initWithData(NSImage::alloc(), &data).is_some());
}
}
#[test]
fn macos_icon_theme_targets_the_application_instead_of_a_window() {
assert!(uses_application_level_icon("macos"));
assert!(!uses_application_level_icon("windows"));
assert!(!uses_application_level_icon("linux"));
}
#[test]
fn shows_main_window_after_regular_startup_setup() {
assert!(should_show_main_window_after_setup());
}
#[test]
fn shows_main_window_while_startup_setup_continues() {
assert!(should_show_main_window_before_setup_tasks());
}
#[test]
fn only_user_requested_app_exit_needs_frontend_confirmation() {
assert!(should_confirm_app_exit_request("windows", None, false));
assert!(should_confirm_app_exit_request("macos", Some(0), false));
assert!(!should_confirm_app_exit_request("windows", Some(0), true));
assert!(!should_confirm_app_exit_request("windows", Some(tauri::RESTART_EXIT_CODE), false));
assert!(!should_confirm_app_exit_request("linux", Some(0), false));
}
#[test]
fn only_quit_uses_native_fallback_before_frontend_ready() {
assert!(should_fallback_to_native_quit("quit", false));
assert!(!should_fallback_to_native_quit("quit", true));
assert!(!should_fallback_to_native_quit("settings", false));
}
#[test]
fn overrides_native_window_decorations_for_desktop_platforms() {
assert_eq!(native_window_decorations_override("windows"), Some(false));
assert_eq!(native_window_decorations_override("linux"), Some(false));
assert_eq!(native_window_decorations_override("macos"), None);
}
#[test]
fn classifies_linux_nvidia_driver_from_selected_renderer() {
assert_eq!(linux_nvidia_driver_from_state(true, false, None, false), LinuxNvidiaDriver::Proprietary);
assert_eq!(linux_nvidia_driver_from_state(false, true, None, false), LinuxNvidiaDriver::Proprietary);
assert_eq!(linux_nvidia_driver_from_state(true, false, Some("nouveau"), false), LinuxNvidiaDriver::Nouveau);
assert_eq!(linux_nvidia_driver_from_state(false, false, Some("nouveau"), false), LinuxNvidiaDriver::Nouveau);
assert_eq!(linux_nvidia_driver_from_state(false, false, Some("i915"), false), LinuxNvidiaDriver::None);
assert_eq!(linux_nvidia_driver_from_state(false, false, Some("amdgpu"), false), LinuxNvidiaDriver::None);
assert_eq!(linux_nvidia_driver_from_state(false, false, None, false), LinuxNvidiaDriver::None);
assert_eq!(linux_nvidia_driver_from_state(true, true, Some("nvidia"), false), LinuxNvidiaDriver::Proprietary);
// Hybrid laptops: the iGPU renders, so the proprietary dGPU module must not disable DMABuf.
assert_eq!(linux_nvidia_driver_from_state(true, true, Some("i915"), false), LinuxNvidiaDriver::None);
assert_eq!(linux_nvidia_driver_from_state(true, true, Some("xe"), false), LinuxNvidiaDriver::None);
assert_eq!(linux_nvidia_driver_from_state(true, true, Some("amdgpu"), false), LinuxNvidiaDriver::None);
assert_eq!(linux_nvidia_driver_from_state(true, true, Some("i915"), true), LinuxNvidiaDriver::Proprietary);
}
fn drm_render_device(path: &str, driver: &str, boot_vga: bool) -> LinuxDrmRenderDevice {
LinuxDrmRenderDevice {
device_file: PathBuf::from(path),
driver: Some(driver.to_string()),
boot_vga,
pci_id: None,
}
}
fn drm_pci_render_device(
path: &str,
driver: &str,
boot_vga: bool,
vendor_id: u16,
device_id: u16,
) -> LinuxDrmRenderDevice {
LinuxDrmRenderDevice {
device_file: PathBuf::from(path),
driver: Some(driver.to_string()),
boot_vga,
pci_id: Some((vendor_id, device_id)),
}
}
#[test]
fn discovers_only_usable_linux_drm_render_device_files() {
let root = std::env::temp_dir().join(format!("dbx-drm-render-devices-{}", uuid::Uuid::new_v4()));
let sys_class_drm = root.join("sys/class/drm");
let dev_dri = root.join("dev/dri");
std::fs::create_dir_all(sys_class_drm.join("renderD128/device")).unwrap();
std::fs::create_dir_all(sys_class_drm.join("renderD129/device")).unwrap();
std::fs::create_dir_all(&dev_dri).unwrap();
assert!(linux_drm_render_devices_from_paths(&sys_class_drm, &dev_dri).is_empty());
std::fs::write(dev_dri.join("renderD129"), []).unwrap();
std::fs::write(sys_class_drm.join("renderD129/device/vendor"), "0x1002\n").unwrap();
std::fs::write(sys_class_drm.join("renderD129/device/device"), "0x1586\n").unwrap();
let devices = linux_drm_render_devices_from_paths(&sys_class_drm, &dev_dri);
assert_eq!(devices.len(), 1);
assert_eq!(devices[0].device_file, dev_dri.join("renderD129"));
assert_eq!(devices[0].pci_id, Some((0x1002, 0x1586)));
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn parses_linux_drm_pci_ids_without_accepting_malformed_values() {
assert_eq!(linux_pci_id_from_sysfs_value("0x1002\n"), Some(0x1002));
assert_eq!(linux_pci_id_from_sysfs_value("0X1586"), Some(0x1586));
assert_eq!(linux_pci_id_from_sysfs_value("8086"), Some(0x8086));
assert_eq!(linux_pci_id_from_sysfs_value(""), None);
assert_eq!(linux_pci_id_from_sysfs_value("0x"), None);
assert_eq!(linux_pci_id_from_sysfs_value("0x10000"), None);
assert_eq!(linux_pci_id_from_sysfs_value("not-a-device"), None);
let root = std::env::temp_dir().join(format!("dbx-drm-pci-ids-{}", uuid::Uuid::new_v4()));
let sys_class_drm = root.join("sys/class/drm");
let dev_dri = root.join("dev/dri");
for node in ["renderD128", "renderD129"] {
std::fs::create_dir_all(sys_class_drm.join(node).join("device")).unwrap();
std::fs::create_dir_all(&dev_dri).unwrap();
std::fs::write(dev_dri.join(node), []).unwrap();
}
std::fs::write(sys_class_drm.join("renderD128/device/vendor"), "malformed").unwrap();
std::fs::write(sys_class_drm.join("renderD128/device/device"), "0x1586").unwrap();
std::fs::write(sys_class_drm.join("renderD129/device/vendor"), "0x1002").unwrap();
let devices = linux_drm_render_devices_from_paths(&sys_class_drm, &dev_dri);
assert_eq!(devices.len(), 2);
assert_eq!(devices[0].pci_id, None);
assert_eq!(devices[1].pci_id, None);
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn keeps_linux_dmabuf_when_nouveau_is_loaded_but_not_the_default_renderer() {
let devices = [
drm_render_device("/dev/dri/renderD128", "i915", true),
drm_render_device("/dev/dri/renderD129", "nouveau", false),
];
let selected = linux_selected_drm_render_device(None, &devices).unwrap();
assert_eq!(selected.driver.as_deref(), Some("i915"));
assert_eq!(
linux_nvidia_driver_from_state(false, false, selected.driver.as_deref(), false),
LinuxNvidiaDriver::None
);
}
#[test]
fn honors_explicit_webkit_linux_render_device_on_hybrid_gpus() {
let devices = [
drm_render_device("/dev/dri/renderD128", "i915", true),
drm_render_device("/dev/dri/renderD129", "nouveau", false),
];
let selected = linux_selected_drm_render_device(Some(Path::new("/dev/dri/renderD129")), &devices).unwrap();
assert_eq!(selected.driver.as_deref(), Some("nouveau"));
assert_eq!(
linux_nvidia_driver_from_state(false, false, selected.driver.as_deref(), false),
LinuxNvidiaDriver::Nouveau
);
let devices = [
drm_render_device("/dev/dri/renderD128", "i915", false),
drm_render_device("/dev/dri/renderD129", "nouveau", true),
];
let selected = linux_selected_drm_render_device(Some(Path::new("/dev/dri/renderD128")), &devices).unwrap();
assert_eq!(selected.driver.as_deref(), Some("i915"));
assert_eq!(
linux_nvidia_driver_from_state(false, false, selected.driver.as_deref(), false),
LinuxNvidiaDriver::None
);
}
#[test]
fn uses_nouveau_workaround_for_the_default_linux_renderer() {
let devices = [
drm_render_device("/dev/dri/renderD128", "amdgpu", false),
drm_render_device("/dev/dri/renderD129", "nouveau", true),
];
let selected = linux_selected_drm_render_device(None, &devices).unwrap();
assert_eq!(selected.driver.as_deref(), Some("nouveau"));
assert_eq!(
linux_nvidia_driver_from_state(false, false, selected.driver.as_deref(), false),
LinuxNvidiaDriver::Nouveau
);
}
#[test]
fn applies_driver_specific_linux_webkit_rendering_workarounds() {
assert_eq!(
linux_webkit_rendering_workarounds(LinuxNvidiaDriver::Proprietary, true, None, false),
&[("WEBKIT_DISABLE_DMABUF_RENDERER", "1"), ("__NV_DISABLE_EXPLICIT_SYNC", "1")]
);
assert_eq!(
linux_webkit_rendering_workarounds(LinuxNvidiaDriver::Nouveau, true, None, false),
&[("WEBKIT_DISABLE_DMABUF_RENDERER", "1")]
);
assert_eq!(linux_webkit_rendering_workarounds(LinuxNvidiaDriver::None, true, None, false), &[]);
// Without any hardware render device (GPU-less VM / server) Mesa falls
// back to llvmpipe, whose DMABuf compositing path can crash the WebKit
// process.
assert_eq!(
linux_webkit_rendering_workarounds(LinuxNvidiaDriver::None, false, None, false),
&[("WEBKIT_DISABLE_DMABUF_RENDERER", "1")]
);
}
#[test]
fn enables_appimage_dmabuf_workaround_only_for_real_appimage_values() {
assert!(linux_appimage_requires_dmabuf_workaround(Some(OsStr::new("/opt/DBX.AppImage"))));
assert!(!linux_appimage_requires_dmabuf_workaround(Some(OsStr::new(""))));
assert!(!linux_appimage_requires_dmabuf_workaround(None));
}
#[test]
fn disables_linux_webkit_dmabuf_only_for_strix_halo_on_native_wayland() {
let strix_halo = drm_pci_render_device("/dev/dri/renderD128", "amdgpu", true, 0x1002, 0x1586);
let mut strix_halo_without_driver = strix_halo.clone();
strix_halo_without_driver.driver = None;
let adjacent_amd = drm_pci_render_device("/dev/dri/renderD128", "amdgpu", true, 0x1002, 0x1587);
let native_wayland =
linux_uses_native_wayland(Some(OsStr::new("wayland-0")), Some(OsStr::new("wayland")), None);
assert!(native_wayland);
assert_eq!(
linux_webkit_rendering_workarounds(LinuxNvidiaDriver::None, true, Some(&strix_halo), native_wayland),
&[("WEBKIT_DISABLE_DMABUF_RENDERER", "1")]
);
assert_eq!(
linux_webkit_rendering_workarounds(
LinuxNvidiaDriver::None,
true,
Some(&strix_halo_without_driver),
native_wayland,
),
&[("WEBKIT_DISABLE_DMABUF_RENDERER", "1")]
);
assert_eq!(
linux_webkit_rendering_workarounds(LinuxNvidiaDriver::None, true, Some(&adjacent_amd), native_wayland),
&[]
);
for native_wayland in [
linux_uses_native_wayland(
Some(OsStr::new("wayland-0")),
Some(OsStr::new("wayland")),
Some(OsStr::new("x11")),
),
linux_uses_native_wayland(None, Some(OsStr::new("wayland")), None),
linux_uses_native_wayland(Some(OsStr::new("wayland-0")), None, None),
linux_uses_native_wayland(Some(OsStr::new("wayland-0")), Some(OsStr::new("x11")), None),
] {
assert!(!native_wayland);
assert_eq!(
linux_webkit_rendering_workarounds(LinuxNvidiaDriver::None, true, Some(&strix_halo), native_wayland),
&[]
);
}
}
#[test]
fn linux_webkit_strix_quirk_follows_the_selected_hybrid_render_node() {
let devices = [
drm_pci_render_device("/dev/dri/renderD128", "i915", true, 0x8086, 0x46a6),
drm_pci_render_device("/dev/dri/renderD129", "amdgpu", false, 0x1002, 0x1586),
];
let default_device = linux_selected_drm_render_device(None, &devices).unwrap();
assert_eq!(linux_webkit_rendering_workarounds(LinuxNvidiaDriver::None, true, Some(default_device), true), &[]);
let explicit_device = linux_selected_drm_render_device(Some(Path::new("/dev/dri/renderD129")), &devices);
assert_eq!(
linux_webkit_rendering_workarounds(LinuxNvidiaDriver::None, true, explicit_device, true),
&[("WEBKIT_DISABLE_DMABUF_RENDERER", "1")]
);
let unmatched_device = linux_selected_drm_render_device(Some(Path::new("/dev/dri/renderD130")), &devices);
assert!(unmatched_device.is_none());
assert_eq!(linux_webkit_rendering_workarounds(LinuxNvidiaDriver::None, true, unmatched_device, true), &[]);
}
#[test]
fn linux_webkit_quirk_respects_explicit_gdk_backend() {
let display = Some(OsStr::new("wayland-0"));
let session = Some(OsStr::new("wayland"));
assert!(linux_uses_native_wayland(display, session, None));
assert!(linux_uses_native_wayland(display, session, Some(OsStr::new("wayland"))));
assert!(!linux_uses_native_wayland(display, session, Some(OsStr::new("x11,wayland,*"))));
}
#[test]
fn linux_webkit_workarounds_preserve_user_environment_values() {
assert_eq!(linux_webkit_environment_override(None, "1"), Some("1"));
for value in [OsStr::new(""), OsStr::new("0"), OsStr::new("1")] {
assert_eq!(linux_webkit_environment_override(Some(value), "1"), None);
}
}
#[test]
fn treats_virtual_and_2d_drm_drivers_as_software_rendering() {
assert!(linux_drm_driver_is_software_only(Some("virtio-pci")));
assert!(linux_drm_driver_is_software_only(Some("virtio_gpu")));
assert!(linux_drm_driver_is_software_only(Some("qxl")));
assert!(linux_drm_driver_is_software_only(Some("bochs")));
assert!(linux_drm_driver_is_software_only(None));
assert!(!linux_drm_driver_is_software_only(Some("amdgpu")));
assert!(!linux_drm_driver_is_software_only(Some("i915")));
assert!(!linux_drm_driver_is_software_only(Some("nouveau")));
}
}
fn route_external_commands(
main_handler: impl Fn(tauri::ipc::Invoke<tauri::Wry>) -> bool + Send + Sync + 'static,
) -> impl Fn(tauri::ipc::Invoke<tauri::Wry>) -> bool + Send + Sync + 'static {
dbx_tauri_consul::route(dbx_tauri_schema::route(main_handler))
}
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
// WebView2 warm-up child mode: when a compatibility profile asks for a
// preflight, the parent re-launches this executable with
// DBX_WEBVIEW2_PREFLIGHT_CHILD=1. The child only creates and releases a
// WebView2 environment (forcing AV products to scan/trust msedgewebview2.exe)
// and exits before any Tauri/window setup. Doing this in a separate process
// isolates a hanging environment creation from the real startup attempt.
#[cfg(target_os = "windows")]
if webview2_preflight::run_child_if_requested() {
return;
}
// Metadata/completion command chains nest very large async futures and can
// exhaust tokio's default 2 MiB worker stack, which aborts the process with
// STATUS_STACK_OVERFLOW. Share the roomier stack the backup worker and Web
// server runtimes use as well.
let runtime = dbx_core::scheduled_backup::worker_runtime().expect("Failed to build tokio runtime");
let runtime_handle = runtime.handle().clone();
let _runtime = Box::leak(Box::new(runtime));
tauri::async_runtime::set(runtime_handle);
startup_recovery::initialize();
rustls::crypto::aws_lc_rs::default_provider().install_default().expect("Failed to install rustls crypto provider");
append_startup_probe("runtime prerequisites configured");
// Record the WebView2 / security-software environment before any window is
// created. This is the first thing to look at when a startup recovery chain
// fails: it distinguishes a missing/hooked WebView2 runtime from an AV
// product that blocks the child browser process.
#[cfg(target_os = "windows")]
let webview2_runtime_health = webview2_preflight::runtime_health();
#[cfg(target_os = "windows")]
append_startup_probe(format!("webview2 runtime_health={}", webview2_runtime_health.as_str()));
#[cfg(target_os = "windows")]
{
// Collect WebView2/AV diagnostics on a worker thread with a hard deadline:
// on machines where a security product hooks the WebView2 loader (the very
// machines this diagnostics targets) the version query must never be able
// to delay the real startup path. A timed-out worker is abandoned and dies
// with the process.
let (diagnostics_tx, diagnostics_rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let diagnostics = webview2_preflight::collect_diagnostics();
let _ = diagnostics_tx.send(webview2_preflight::format_diagnostics(&diagnostics));
});
match diagnostics_rx.recv_timeout(std::time::Duration::from_secs(3)) {
Ok(lines) => {
for line in lines {
append_startup_probe(line);
}
}
Err(_) => append_startup_probe("webview2 diagnostics timed out after 3s; continuing startup"),
}
}
// A missing/damaged WebView2 runtime is the #1 cause of "the window never
// appears" on enterprise Windows machines, and it used to be misdiagnosed as a
// security product blocking WebView2 (the compatibility ladder then retried for
// minutes). Detect it before Tauri tries to create the window and show one
// clear, actionable message instead.
#[cfg(target_os = "windows")]
{
// Diagnostic escape hatch: a user who wants the AV compatibility ladder to
// run even though the WebView2 runtime is missing/damaged can force it.
// This makes no difference on a healthy runtime but lets support reproduce
// "try everything" behaviour on a broken machine.
let force_compat_on_broken_runtime =
std::env::var_os("DBX_TRY_COMPAT_ON_BROKEN_WEBVIEW2").is_some_and(|value| value == "1");
match webview2_runtime_health {
webview2_preflight::WebView2RuntimeHealth::Missing if !force_compat_on_broken_runtime => {
startup_recovery::handle_missing_webview2_runtime();
return;
}
webview2_preflight::WebView2RuntimeHealth::RegisteredButDamaged if !force_compat_on_broken_runtime => {
startup_recovery::handle_damaged_webview2_runtime(
webview2_preflight::collect_diagnostics().runtime_version.as_deref(),
);
return;
}
_ => {}
}
}
// Profile-specific pre-Tauri work (scan delay, WebView2 warm-up preflight).
// This must run before `Builder::default().build()` because wry reads the
// WebView2 environment variables during window creation.
startup_recovery::run_profile_pre_tauri_hooks();
#[cfg(target_os = "linux")]
apply_linux_webkit_rendering_workarounds();
let startup_begin = Instant::now();
let builder = register_deep_link_state(tauri::Builder::default())
.plugin(tauri_plugin_deep_link::init())
.plugin(tauri_plugin_clipboard_manager::init())
.plugin(tauri_plugin_dialog::init())
.plugin(tauri_plugin_fs::init())
// Plugin workbench sandbox documents lazy-load their code-split chunks
// through this scheme; see plugin_ui_protocol.rs.
.register_asynchronous_uri_scheme_protocol(plugin_ui_protocol::PLUGIN_UI_SCHEME, plugin_ui_protocol::handle);
let builder = if should_enable_single_instance(cfg!(debug_assertions)) {
builder.plugin(tauri_plugin_single_instance::init(|app, args, cwd| {
let app_open_requested = args.iter().any(|arg| commands::deep_link::is_app_open_deep_link(arg));
let links = commands::deep_link::connection_deep_links_from_args(args.clone());
open_connection_deep_links(app, links);
let ai_config_links = commands::deep_link::ai_config_deep_links_from_args(args.clone());
open_ai_config_deep_links(app, ai_config_links);
let plugin_install_links = commands::deep_link::plugin_install_deep_links_from_args(args.clone());
open_plugin_install_deep_links(app, plugin_install_links);
let paths = commands::external_sql::sql_file_paths_from_args(args.clone(), std::path::Path::new(&cwd));
if !paths.is_empty() {
if let Some(state) = app.try_state::<commands::external_sql::ExternalSqlOpenState>() {
state.push(paths.clone());
}
let _ = app.emit("dbx-open-sql-files", paths);
}
let db_paths = commands::external_db::db_file_paths_from_args(args, std::path::Path::new(&cwd));
if !db_paths.is_empty() {
if let Some(state) = app.try_state::<commands::external_db::ExternalDbOpenState>() {
state.push(db_paths.clone());
}
let _ = app.emit("dbx-open-db-files", db_paths);
}
// This runs inside the *existing* instance: a second launch has already
// handed over its arguments and exited. If we cannot reveal a window here
// the user is left with no feedback whatsoever - the app they clicked
// simply vanished - so make the reason recoverable from the logs.
if !show_main_window(app) {
eprintln!(
"[WINDOW] single-instance handoff could not reveal the main window; app_open_requested={app_open_requested}; {}",
main_window_probe_state(app)
);
}
}))
} else {
builder
};
let builder = builder
.plugin(tauri_plugin_opener::init())
.plugin(tauri_plugin_shell::init())
.plugin(tauri_plugin_updater::Builder::new().build())
.plugin(
tauri_plugin_window_state::Builder::default()
.with_state_flags(window_state_guard::persisted_main_window_state_flags())
// The main window's geometry is restored by `window_state_guard`
// in logical units; the plugin's physical restore is the bug in
// issue #13168.
.skip_initial_state("main")
.build(),
);
// macOS app menu (Cmd+Q / Dock Quit). Skip on Linux/Windows so an empty menu bar
// is not installed where there was none before.
#[cfg(target_os = "macos")]
let builder = builder.menu(build_app_menu).on_menu_event(|app, event| {
if event.id() == APP_MENU_QUIT_ID {
request_app_close(app, "quit");
} else if event.id() == APP_MENU_COPY_SUPPORT_INFO_ID {
if let Err(err) = app.clipboard().write_text(commands::support_info::format_support_info_for_clipboard()) {
log::warn!("Failed to copy support info from app menu: {err}");
}
} else if event.id() == APP_MENU_CLOSE_TAB_ID {
let _ = app.emit(APP_CLOSE_ACTIVE_TAB_EVENT, ());
}
});
builder
.manage(CloseBehaviorState::new())
.manage(commands::plugin_file::PluginFileState::new())
.manage(commands::plugin_media::PluginMediaState::new())
.manage(commands::plugin_storage::PluginUiStorageState::new())
.manage(AppLocaleState::new())
.on_page_load(|webview, payload| {
if payload.event() == PageLoadEvent::Started {
if let Some(state) = webview.app_handle().try_state::<CloseBehaviorState>() {
state.set_frontend_ready(false);
}
}
})
.setup(move |app| {
let setup_start = Instant::now();
eprintln!("[STARTUP] plugins registered in {:?}", startup_begin.elapsed());
append_startup_probe(format!("setup entered after {:?}", startup_begin.elapsed()));
#[cfg(not(target_os = "linux"))]
{
window_state_guard::restore_main_window_state(app.handle());
if should_show_main_window_before_setup_tasks() {
prepare_main_window_for_display(app.handle());
show_main_window(app.handle());
append_startup_probe(format!(
"early main window show requested; {}",
main_window_probe_state(app.handle())
));
startup_recovery::report_window_visibility_probe(startup_recovery::probe_main_window_visible(
app.handle(),
));
}
}
append_startup_probe("resolving app data dir");
let default_data_dir =
app.path().app_data_dir().map_err(|e| e.to_string()).expect("Failed to resolve app data dir");
let data_dir_resolution = data_dir::resolve_data_dir_with_mode(default_data_dir);
let data_dir = data_dir_resolution.data_dir.clone();
let portable_mode = data_dir_resolution.is_portable_mode();
std::fs::create_dir_all(&data_dir).expect("Failed to create data dir");
let data_dir_mode = startup_data_dir_mode(&data_dir_resolution.mode);
append_startup_probe(format!("data dir ready mode={data_dir_mode}"));
let alternative_data_dir = data_dir::alternative_data_dir(&data_dir_resolution);
match maybe_import_user_data_db(&data_dir, alternative_data_dir.as_deref()) {
Ok(result) => eprintln!("[STARTUP] data db fallback import: {result:?}"),
Err(err) => eprintln!("[STARTUP] data db fallback import failed: {err}"),
}
let db_path = data_dir.join("dbx.db");
// Failure logs from previous runs are kept only within their retention
// limits; prune once at startup so a killed process cannot leave the
// directory growing forever.
commands::sql_file::prune_desktop_sql_file_failure_logs(&data_dir);
let t = Instant::now();
append_startup_probe(format!("opening storage file=dbx.db data_dir_mode={data_dir_mode}"));
let storage = tauri::async_runtime::block_on(async {
let mut s = Storage::open_unmigrated(&db_path).await.expect("Failed to open storage");
if portable_mode {
s = s.with_secret_key_policy(SecretKeyPolicy::ManagedDataDir);
match s.prepare_portable_secret_key().await {
Ok(true) => append_startup_probe("portable key copied from the platform credential store"),
Ok(false) => {}
Err(error) => {
log::warn!("[STARTUP] portable key preparation failed: {error}");
append_startup_probe(format!("portable key preparation failed: {error}"));
}
}
}
eprintln!("[STARTUP] Storage::open in {:?}", t.elapsed());
append_startup_probe(format!("storage opened in {:?}", t.elapsed()));
let t2 = Instant::now();
eprintln!("[STARTUP] migration wizard deferred in {:?}", t2.elapsed());
append_startup_probe(format!("migration deferred to security wizard in {:?}", t2.elapsed()));
s
});
let migration_ready = tauri::async_runtime::block_on(storage.inspect_data_migration())
.map(|status| status.is_ready())
.unwrap_or(false);
let migration_gate = Arc::new(migration_gate::MigrationGate::new(migration_ready));
app.manage(migration_gate.clone());
let desktop_settings = tauri::async_runtime::block_on(storage.load_desktop_settings()).unwrap_or_default();
#[cfg(target_os = "linux")]
{
// Transparency must be chosen before creating the native window. Read the saved
// preference first so a disabled frame is never briefly shown during startup.
create_linux_main_window(app, desktop_settings.linux_floating_frame_enabled)?;
window_state_guard::restore_main_window_state(app.handle());
if should_show_main_window_before_setup_tasks() {
prepare_main_window_for_display(app.handle());
show_main_window(app.handle());
append_startup_probe(format!(
"early main window show requested; {}",
main_window_probe_state(app.handle())
));
}
}
app.handle().plugin(
tauri_plugin_log::Builder::default()
.timezone_strategy(tauri_plugin_log::TimezoneStrategy::UseLocal)
.format(|out, message, record| {
out.finish(format_args!(
"[{}][{}][{}] {}",
chrono::Local::now().format("%Y-%m-%d][%H:%M:%S%.3f"),
record.level(),
record.target(),
message
));
})
.level(log::LevelFilter::Debug)
.build(),
)?;
apply_debug_log_level(desktop_settings.debug_logging_enabled);
eprintln!("[STARTUP] storage ready in {:?}", t.elapsed());
append_startup_probe(format!("storage ready in {:?}", t.elapsed()));
// Initialize core dialect registry and load external plugin dialects
let dialect_init_start = Instant::now();
register_core_dialects();
let registry = DialectRegistry::global();
let plugin_dirs = vec![data_dir.join("plugins").join("dialects")];
let load_result = DialectPluginLoader::scan_and_load(registry, &plugin_dirs);
eprintln!(
"[STARTUP] dialect plugins loaded: {} success, {} errors, {} skipped in {:?}",
load_result.loaded.len(),
load_result.errors.len(),
load_result.skipped.len(),
dialect_init_start.elapsed()
);
append_startup_probe(format!(
"dialect plugins loaded: {} success, {} errors, {} skipped in {:?}",
load_result.loaded.len(),
load_result.errors.len(),
load_result.skipped.len(),
dialect_init_start.elapsed()
));
// Start dialect YAML hot-reload watcher
let watch_dirs = plugin_dirs.clone();
tauri::async_runtime::spawn(async move {
if let Err(e) = DialectHotReload::run_forever(watch_dirs, DialectRegistry::global()).await {
log::error!("[STARTUP] dialect hot-reload watcher exited: {e}");
}
});
eprintln!("[STARTUP] dialect hot-reload watcher started");
let default_agent_dir = data_dir_resolution.uses_custom_data_dir().then(|| data_dir.join("agents"));
let (plugin_dir, agent_dir) = commands::app_settings::resolve_driver_store_dirs_from_settings(
&desktop_settings,
&data_dir,
default_agent_dir,
);
let state = if let Some(agent_dir) = agent_dir {
AppState::new_with_plugin_and_agent_dir_and_app_version(
storage,
plugin_dir,
agent_dir,
env!("CARGO_PKG_VERSION"),
)
} else {
AppState::new_with_plugin_dir_and_app_version(storage, plugin_dir, env!("CARGO_PKG_VERSION"))
};
dbx_core::db::sqlite_worker::enable_sqlite_ssh_runtime(env!("CARGO_PKG_VERSION"));
state.set_duckdb_worker_process_isolation_enabled(desktop_settings.duckdb_worker_process_isolation);
state.set_duckdb_worker_max_processes(desktop_settings.duckdb_worker_max_processes);
state.set_honor_fixed_ssh_local_ports(true);
let oidc_app_handle = app.handle().clone();
state.set_mongo_oidc_browser_opener(Arc::new(move |url| {
oidc_app_handle
.opener()
.open_url(url, None::<&str>)
.map_err(|err| format!("Failed to open the system browser: {err}"))
}));
let sf_app_handle = app.handle().clone();
state.set_salesforce_browser_opener(Arc::new(move |url| {
sf_app_handle
.opener()
.open_url(url, None::<&str>)
.map_err(|err| format!("Failed to open the system browser: {err}"))
}));
let state = Arc::new(state);
app.manage(state.clone());
commands::plugins::install_plugin_event_bridge(app.handle(), state.clone());
commands::connection::install_connection_liveness_bridge(app.handle(), state.clone());
commands::connection::install_connection_idle_closed_bridge(app.handle(), state.clone());
let app_identifier = app.config().identifier.clone();
let backups = tauri::async_runtime::block_on(async {
background_backup::BackgroundBackup::new(state.clone(), data_dir.clone(), app_identifier)
});
match backups {
Ok(backups) => {
if let Err(error) = backups.resume() {
log::error!("[database-backup] background registration failed: {error}");
}
app.manage(backups);
}
Err(error) => log::error!("[database-backup] worker startup failed: {error}"),
}
let mcp_http_server = Arc::new(commands::mcp_http_server::McpHttpServerState::new(data_dir.clone()));
app.manage(mcp_http_server.clone());
let mcp_http_state = state.clone();
let mcp_gate = migration_gate.clone();
tauri::async_runtime::spawn(async move {
mcp_gate.wait().await;
commands::mcp_http_server::start_if_enabled(mcp_http_state, mcp_http_server).await;
});
app.manage(commands::redis_pubsub_server::start_pubsub_server(state.clone()));
app.manage(commands::saved_sql::SavedSqlStorageState { data_dir: data_dir.clone() });
app.manage(commands::external_sql::ExternalSqlOpenState::default());
app.manage(commands::external_db::ExternalDbOpenState::default());
app.manage(commands::update::PendingUpdateState::default());
app.manage(commands::ssh_prompt::SshPromptState::new());
commands::ssh_prompt::install_ssh_prompt_bridge(app.handle());
commands::ssh_prompt::install_ssh_notice_bridge(app.handle());
#[cfg(target_os = "macos")]
macos_app_delegate::install_dock_quit_handler(app.handle());
#[cfg(target_os = "macos")]
macos_escape_guard::install_escape_fullscreen_guard();
#[cfg(target_os = "windows")]
webview2_recovery::install(app.handle());
let startup_args: Vec<String> = std::env::args().skip(1).collect();
let startup_links = commands::deep_link::connection_deep_links_from_args(&startup_args);
open_connection_deep_links(app.handle(), startup_links);
let startup_ai_config_links = commands::deep_link::ai_config_deep_links_from_args(&startup_args);
open_ai_config_deep_links(app.handle(), startup_ai_config_links);
let startup_plugin_install_links = commands::deep_link::plugin_install_deep_links_from_args(&startup_args);
open_plugin_install_deep_links(app.handle(), startup_plugin_install_links);
let app_handle = app.handle().clone();
#[cfg(target_os = "windows")]
tauri::async_runtime::spawn_blocking(commands::mcp::cleanup_mcp_installation_temp_files);
tauri::async_runtime::spawn(async move {
migration_gate.wait().await;
commands::mcp_bridge::start(app_handle, state, data_dir);
});
eprintln!("[STARTUP] setup complete in {:?} (total {:?})", setup_start.elapsed(), startup_begin.elapsed());
append_startup_probe(format!(
"setup tasks complete in {:?} total {:?}",
setup_start.elapsed(),
startup_begin.elapsed()
));
prepare_main_window_for_display(app.handle());
if should_setup_desktop_tray(
std::env::consts::OS,
desktop_settings.show_tray_icon,
linux_appindicator_available(),
) {
setup_desktop_tray(app, desktop_settings.icon_theme)?;
}
apply_desktop_icon_theme(app.handle(), desktop_settings.icon_theme)?;
#[cfg(target_os = "macos")]
apply_macos_development_dock_badge(app.handle())?;
if should_show_main_window_after_setup() {
show_main_window(app.handle());
append_startup_probe(format!(
"final main window show requested; {}",
main_window_probe_state(app.handle())
));
startup_recovery::report_window_visibility_probe(startup_recovery::probe_main_window_visible(
app.handle(),
));
}
#[cfg(any(windows, target_os = "linux"))]
let _ = app.deep_link().register_all();
append_startup_probe("setup finished");
Ok(())
})
.on_window_event(|window, event| {
// Anchor the plugin-file drop consent on the Rust side: paths are
// registered for the webview that physically received the drop,
// and plugin_file_open_dropped consumes them there. Folders are
// granted as themselves and expand to their contained files at
// open time. Renderer-side drop events stay display-only; they
// cannot mint file access.
if let tauri::WindowEvent::DragDrop(tauri::DragDropEvent::Drop { paths, .. }) = event {
let dropped: Vec<String> = paths
.iter()
.filter(|path| path.is_file() || path.is_dir())
.map(|path| path.to_string_lossy().into_owned())
.collect();
if !dropped.is_empty() {
if let Some(state) = window.try_state::<commands::plugin_file::PluginFileState>() {
state.register_dropped_paths(window.label(), dropped);
}
}
return;
}
if let tauri::WindowEvent::Destroyed = event {
// A webview that no longer exists must not leave drop grants
// behind for a future renderer to claim.
if let Some(state) = window.try_state::<commands::plugin_file::PluginFileState>() {
state.clear_dropped_paths(window.label());
}
if let Some(tab_id) = window.label().strip_prefix("detached-tab-") {
let _ = window.emit("dbx:detached-tab-lost", serde_json::json!({ "tabId": tab_id }));
}
return;
}
if let tauri::WindowEvent::CloseRequested { api, .. } = event {
// Floating plugin widgets (label prefix shared with the frontend's
// floatingWindowLabel) close like ordinary windows. Hiding them to
// the tray would keep their plugin instance — audio included —
// running invisibly, and the app-wide close prompt belongs to the
// main shell, not to a widget the user dismissed.
if window.label().starts_with("plugin-floating-") {
return;
}
if let Some(tab_id) = window.label().strip_prefix("detached-tab-") {
if commands::app_settings::take_approved_detached_window_close(window.label()) {
return;
}
api.prevent_close();
// Broadcast with the tabId payload: JS listeners registered
// with the default `listen()` target receive events emitted
// to any window, so the frontend must filter by tabId.
let _ = window.emit("dbx:detached-tab-close-requested", serde_json::json!({ "tabId": tab_id }));
return;
}
if !should_hide_window_on_close(std::env::consts::OS) {
return;
}
let app = window.app_handle();
if app.try_state::<CloseBehaviorState>().is_none() {
api.prevent_close();
hide_main_window_for_close(app, window);
return;
}
api.prevent_close();
request_app_close(app, "settings");
}
})
.invoke_handler(migration_gate::guard_handler(route_external_commands(tauri::generate_handler![
commands::ai::ai_complete,
commands::ai::ai_stream,
commands::ai::ai_agent_stream,
commands::ai::ai_cancel_stream,
commands::ai::ai_resolve_tool_approval,
commands::ai::get_ai_plugin_tool_plugins,
commands::ai::set_ai_plugin_tool_plugin_enabled,
commands::ai::preview_plugin_ai_tools,
commands::ai::ai_test_connection,
commands::ai::ai_list_models,
commands::ai::ai_resolve_model_effort,
commands::ai::save_ai_config,
commands::ai::load_ai_config,
commands::ai::save_ai_provider_config,
commands::ai::load_ai_provider_configs,
commands::ai::save_ai_chat_selection,
commands::ai::load_ai_chat_selection,
commands::ai::save_ai_conversation,
commands::ai::load_ai_conversations,
commands::ai::delete_ai_conversation,
commands::ai::save_ai_run,
commands::ai::save_ai_run_state,
commands::ai::load_ai_runs,
commands::ai_multi_config::save_ai_configs,
commands::ai_multi_config::load_ai_configs,
commands::ai_multi_config::set_default_ai_config,
commands::ai_multi_config::save_ai_config_item,
commands::ai_multi_config::delete_ai_config,
commands::cc_switch::load_cc_switch_ai_configs,
commands::cc_switch::load_magpie_ai_configs,
commands::prompt_template::load_prompt_templates,
commands::prompt_template::save_prompt_template,
commands::prompt_template::delete_prompt_template,
commands::prompt_template::get_ai_global_custom_instructions,
commands::prompt_template::set_ai_global_custom_instructions,
commands::user_skills::list_user_skills,
commands::user_skills::read_user_skills,
commands::app_settings::load_desktop_settings,
commands::app_settings::save_desktop_settings,
commands::app_settings::load_max_agent_turns,
commands::app_settings::save_max_agent_turns,
commands::app_settings::load_history_retention_limit,
commands::app_settings::save_history_retention_limit,
commands::app_settings::load_mcp_history_retention_limit,
commands::app_settings::save_mcp_history_retention_limit,
commands::app_settings::load_max_retries,
commands::app_settings::save_max_retries,
commands::app_settings::load_app_appearance_settings,
commands::app_settings::update_app_appearance_settings,
commands::app_settings::set_app_locale,
commands::app_settings::complete_app_close,
commands::app_settings::mark_frontend_ready,
commands::app_settings::request_app_close_from_window_controls,
commands::window_controls::set_macos_traffic_light_position,
commands::window_controls::get_linux_window_control_icons,
commands::app_settings::set_driver_store_dir,
commands::app_settings::set_plugin_store_dir,
commands::app_settings::set_agent_store_dir,
commands::app_settings::get_driver_store_path,
commands::app_settings::load_pinned_tree_node_ids,
commands::app_settings::save_pinned_tree_node_ids,
commands::app_settings::load_mcp_global_policy,
commands::app_settings::save_mcp_global_policy,
commands::app_settings::load_mcp_tool_catalog,
commands::app_settings::load_mcp_access_policy,
commands::app_settings::reset_invalid_mcp_access_policy,
commands::app_settings::set_mcp_plugin_scope_rule,
commands::app_settings::list_plugin_mcp_views,
commands::app_settings::load_plugin_mcp_view,
commands::app_settings::list_mcp_plugin_scopes,
commands::app_settings::save_plugin_mcp_grant,
commands::mcp_bridge::respond_mcp_sql_approval,
commands::background_image::save_background_image,
commands::background_image::clear_background_image,
commands::background_image::read_background_image,
commands::background_image::check_background_image,
commands::mcp_http_server::load_mcp_http_server_settings,
commands::mcp_http_server::save_mcp_http_server_settings,
commands::mcp_http_server::mcp_http_server_status,
commands::mcp_http_server::rotate_mcp_http_server_token,
commands::app_settings::load_editor_settings,
commands::app_settings::save_editor_settings,
commands::app_settings::load_global_search_settings,
commands::app_settings::save_global_search_settings,
commands::app_settings::load_open_tabs_state,
commands::app_settings::save_open_tabs_state,
commands::app_settings::save_detached_tab_handoff,
commands::app_settings::load_detached_tab_handoff,
commands::app_settings::list_detached_tab_handoffs,
commands::app_settings::delete_detached_tab_handoff,
commands::app_settings::approve_detached_window_close,
commands::app_settings::load_saved_sql_editor_positions,
commands::app_settings::save_saved_sql_editor_positions,
commands::app_settings::load_transfer_task_library,
commands::app_settings::save_transfer_task_library,
commands::app_settings::load_native_debug_logs,
commands::diagnostics::get_process_memory_info,
commands::support_info::get_app_support_info,
commands::cloud_sync::webdav_sync_test,
commands::cloud_sync::migration_status,
commands::cloud_sync::migration_start,
commands::cloud_sync::migration_retry,
commands::cloud_sync::migration_cleanup_backups,
commands::cloud_sync::webdav_password_status,
commands::cloud_sync::save_webdav_saved_password,
commands::cloud_sync::forget_webdav_saved_password,
commands::cloud_sync::webdav_sync_secrets_status,
commands::cloud_sync::save_webdav_sync_secrets_preference,
commands::cloud_sync::forget_webdav_sync_secrets_passphrase,
commands::cloud_sync::webdav_sync_upload,
commands::cloud_sync::webdav_sync_download,
commands::cloud_sync::webdav_sync_inspect,
commands::cloud_sync::cloud_sync_local_catalog,
commands::cloud_sync::snippet_sync_test,
commands::cloud_sync::snippet_token_status,
commands::cloud_sync::save_snippet_saved_token,
commands::cloud_sync::forget_snippet_saved_token,
commands::cloud_sync::snippet_passphrase_status,
commands::cloud_sync::save_snippet_saved_passphrase,
commands::cloud_sync::forget_snippet_saved_passphrase,
commands::cloud_sync::snippet_sync_settings,
commands::cloud_sync::save_snippet_sync_id,
commands::cloud_sync::retry_snippet_legacy_cleanup,
commands::cloud_sync::snippet_sync_upload,
commands::cloud_sync::snippet_sync_download,
commands::cloud_sync::snippet_sync_inspect,
commands::local_backup::local_backup_export,
commands::local_backup::local_backup_inspect,
commands::local_backup::local_backup_import,
commands::connection::test_connection,
commands::connection::test_connection_with_info,
commands::connection::test_ssh_tunnel,
commands::salesforce_oauth::salesforce_oauth_browser_authorize,
commands::salesforce_oauth::salesforce_oauth_device_start,
commands::salesforce_oauth::salesforce_oauth_device_poll,
commands::salesforce_oauth::salesforce_oauth_refresh,
commands::salesforce_oauth::salesforce_oauth_password_login,
commands::salesforce_oauth::salesforce_current_user,
commands::connection::connect_db,
commands::connection::connection_final_proxy_port,
commands::connection::disconnect_db,
commands::connection::close_database_connection,
commands::connection::session_credential_status,
commands::connection::forget_session_credential,
commands::connection::replace_nacos_session_credential,
commands::connection::clear_all_session_credentials,
commands::connection::refresh_connections,
commands::connection::check_connection_health,
commands::connection::connection_is_open,
commands::connection::prewarm_connection,
commands::connection::connection_identifier_quote,
commands::connection::connection_database_info,
commands::connection::save_connection_database_info,
commands::connection::unlock_connection_writes,
commands::connection::lock_connection_writes,
commands::connection::connection_write_unlock_state,
commands::connection::save_connections,
commands::connection::load_connections,
commands::connection::save_sidebar_layout,
commands::connection::load_sidebar_layout,
commands::connection::save_table_vgroups,
commands::connection::load_table_vgroups,
commands::connection::delete_table_vgroups_for_connection,
commands::plugin_file::plugin_file_open_dropped,
commands::plugin_file::plugin_file_pick_files,
commands::plugin_file::plugin_file_save_as,
commands::plugin_file::plugin_file_read,
commands::plugin_file::plugin_file_write,
commands::plugin_file::plugin_file_close,
commands::plugin_media::plugin_media_open,
commands::plugin_media::plugin_media_close,
commands::plugin_storage::plugin_ui_storage_get,
commands::plugin_storage::plugin_ui_storage_set,
commands::plugin_storage::plugin_ui_storage_delete,
commands::plugins::list_plugins,
commands::plugins::list_plugin_trusted_keys,
commands::plugins::save_plugin_trusted_key,
commands::plugins::remove_plugin_trusted_key,
commands::plugins::list_plugin_repositories,
commands::plugins::save_plugin_repository,
commands::plugins::remove_plugin_repository,
commands::plugins::fetch_plugin_marketplace_catalogs,
commands::plugins::install_marketplace_plugin,
commands::plugins::install_plugin_package,
commands::plugins::install_plugin_package_from_url,
commands::plugins::rollback_plugin,
commands::plugins::uninstall_plugin,
commands::plugins::activate_plugin,
commands::plugins::list_active_plugins,
commands::plugins::stop_plugin,
commands::plugins::invoke_plugin,
commands::plugin_download::download_plugin_file,
commands::plugin_download::cancel_plugin_download,
commands::plugins::invoke_plugin_connection_action,
commands::plugins::notify_plugin,
commands::plugins::send_plugin_binary,
commands::plugins::list_plugin_filesystem_entries,
commands::plugins::read_plugin_filesystem_file,
commands::plugins::write_plugin_filesystem_file,
commands::plugins::create_plugin_filesystem_directory,
commands::plugins::delete_plugin_filesystem_entry,
commands::plugins::rename_plugin_filesystem_entry,
commands::plugins::read_plugin_ui_entry,
commands::plugins::read_plugin_asset,
commands::plugins::read_plugin_ui_asset,
commands::plugins::list_jdbc_drivers,
commands::plugins::list_jdbc_maven_bundles,
commands::plugins::list_jdbc_local_bundles,
commands::plugins::import_jdbc_drivers,
commands::plugins::install_jdbc_driver_from_maven,
commands::plugins::install_prestosql_jdbc_driver,
commands::plugins::delete_jdbc_driver,
commands::plugins::delete_jdbc_maven_bundle,
commands::plugins::delete_jdbc_local_bundle,
commands::plugins::jdbc_plugin_status,
commands::plugins::install_jdbc_plugin,
commands::plugins::install_jdbc_plugin_local,
commands::plugins::uninstall_jdbc_plugin,
commands::schema_diff::prepare_schema_diff,
commands::schema_diff::generate_schema_sync_sql,
commands::schema_diff::generate_schema_sync_plan,
commands::dialect_cmd::list_dialect_data_types,
commands::schema_cache::save_schema_cache,
commands::schema_cache::load_schema_cache,
commands::schema_cache::delete_schema_cache_prefix,
commands::tab_runtime_cache::save_tab_runtime_cache,
commands::tab_runtime_cache::load_tab_runtime_cache,
commands::tab_runtime_cache::list_tab_runtime_cache_metadata,
commands::tab_runtime_cache::prune_tab_runtime_cache,
commands::tab_runtime_cache::delete_tab_runtime_cache_owner,
commands::tab_runtime_cache::delete_tab_runtime_cache,
commands::query::execute_query,
commands::pl_debug::pl_debug_bootstrap,
commands::pl_debug::pl_debug_inspect,
commands::pl_debug::pl_debug_compile,
commands::pl_debug::pl_debug_compile_status,
commands::pl_debug::pl_debug_list,
commands::pl_debug::pl_debug_start,
commands::pl_debug::pl_debug_status,
commands::pl_debug::pl_debug_heartbeat,
commands::pl_debug::pl_debug_operation,
commands::pl_debug::pl_debug_operate,
commands::pl_debug::pl_debug_read,
commands::query::execute_conditional_update,
commands::query::execute_multi,
commands::query::cancel_query,
commands::query::cancel_conditional_update,
commands::query::close_query_session,
commands::query::read_large_value_chunk,
commands::query::release_large_value,
commands::query::download_large_value,
commands::query::export_snapshot_result,
commands::query::close_client_connection_session,
commands::query::execute_batch,
commands::query::execute_script,
commands::query::execute_in_transaction,
commands::query::execute_script_with_2pc,
commands::query::begin_manual_transaction,
commands::query::execute_in_manual_transaction,
commands::query::commit_manual_transaction,
commands::query::rollback_manual_transaction,
commands::query::analyze_sql_references,
commands::query::find_statement_at_cursor,
commands::query::prepare_query_pagination_execution_plan,
commands::query::build_sorted_query_sql,
commands::query::build_explain_sql,
commands::query::get_explain_info,
commands::query::get_plugin_plan_capabilities,
commands::query::get_plugin_estimated_plan,
commands::query::query_plugin_data,
commands::query::get_plugin_data_grants,
commands::query::set_plugin_data_grant,
commands::query::build_create_user_sql,
commands::query::build_dropped_file_preview_sql,
commands::query::build_table_select_sql,
commands::query::build_database_search_sql,
commands::query::build_database_search_columns_sql,
commands::query::build_database_search_probe_sql,
commands::query::build_database_structure_search_sql,
commands::query::supports_database_structure_search,
commands::query::build_search_result_where,
commands::query::build_rename_object_sql,
commands::query::build_rename_database_sql,
commands::query::build_rename_database_preflight_sql,
commands::query::build_create_database_sql,
#[cfg(feature = "duckdb-sidecar")]
commands::query::build_duckdb_attach_database_sql,
commands::query::build_sqlite_attach_database_sql,
commands::query::build_drop_object_sql,
commands::query::build_drop_table_sql,
commands::query::build_drop_table_child_object_sql,
commands::query::build_empty_table_sql,
commands::query::build_truncate_table_sql,
commands::query::build_vacuum_table_sql,
commands::query::build_mysql_auto_increment_sql,
commands::query::build_drop_database_sql,
commands::query::build_create_schema_sql,
commands::query::build_update_database_properties_sql,
commands::query::build_drop_schema_sql,
commands::query::build_duplicate_table_structure_sql,
commands::query::build_copy_table_data_sql,
commands::query::build_executable_object_source_statements,
commands::query::validate_oracle_executable_object_source,
commands::query::prepare_oracle_trigger_sql,
commands::query::fingerprint_oracle_routine_object_source,
commands::query::build_executable_object_source_sql,
commands::query::build_editable_object_source,
commands::query::build_routine_rename_object_source_statements,
commands::query::rewrite_oracle_routine_references,
commands::query::rewrite_oracle_table_references,
commands::query::parse_oracle_object_name,
commands::query::build_oracle_view_rename_source,
commands::query::review_oracle_view_rename_source,
commands::query::build_view_ddl_sql,
commands::query::build_table_structure_change_sql,
commands::query::build_table_owner_change_sql,
commands::query::preview_sqlite_table_structure_change,
commands::query::apply_sqlite_table_structure_change,
commands::query::build_create_table_sql,
commands::query::build_create_partitioned_table_sql,
commands::query::build_table_partition_operation_sql,
commands::query::build_single_column_alter_sql,
commands::query::analyze_editable_query_editability,
commands::query::prepare_data_grid_save,
commands::query::extract_data_grid_selection,
commands::query::build_data_grid_copy_update_statements,
commands::query::build_data_grid_copy_insert_statement,
commands::query::build_dml_change_preview_sql,
commands::query::build_data_grid_context_filter_condition,
commands::query::build_data_grid_column_value_filter_condition,
commands::query::build_data_grid_column_values_filter_condition,
commands::query::build_data_grid_column_distinct_values_sql,
commands::query::build_data_grid_count_sql,
commands::query::build_data_grid_conditional_update_sql,
commands::query::build_hive_table_properties_sql,
commands::query::build_export_insert_statements,
commands::query::build_export_sql_insert,
commands::query::build_database_sql_export,
commands::data_compare::prepare_data_compare,
commands::data_compare::prepare_data_compare_from_tables,
commands::data_compare::prepare_data_compare_missing_target,
commands::data_compare::build_data_compare_sync_plan,
commands::sql_file::preview_sql_file,
commands::sql_file::inspect_sql_file_tables,
commands::sql_file::execute_sql_file,
commands::sql_file::execute_sql_files,
commands::sql_file::cancel_sql_file_execution,
commands::sql_file::sql_file_failure_log_info,
commands::sql_file::export_sql_file_failure_log,
commands::sql_file::read_sql_file_failure_log_text,
commands::external_sql::pending_open_sql_files,
commands::external_sql::read_external_sql_file,
commands::external_sql::inspect_external_sql_file,
commands::external_sql::write_external_sql_file,
commands::external_sql::save_external_sql_file,
commands::list_sql_files::list_sql_files_in_folder,
commands::list_sql_files::search_sql_file_contents,
commands::list_sql_files::create_sql_file_in_folder,
commands::list_sql_files::rename_sql_file_in_folder,
commands::list_sql_files::delete_sql_file_in_folder,
commands::list_sql_files::create_sql_folder_in_folder,
commands::list_sql_files::rename_sql_folder_in_folder,
commands::list_sql_files::delete_sql_folder_in_folder,
commands::global_search::global_search,
commands::external_db::pending_open_db_files,
commands::keychain::read_keychain_password,
commands::keychain::read_keychain_passwords,
commands::deep_link::pending_open_connection_links,
commands::deep_link::pending_open_ai_config_links,
commands::deep_link::pending_open_plugin_install_links,
commands::table_import::preview_table_import_file,
commands::table_import::import_table_file,
commands::table_import::cancel_table_import,
commands::mongodb_import_export::preview_mongodb_import_file,
commands::mongodb_import_export::import_mongodb_file,
commands::mongodb_import_export::cancel_mongodb_import,
commands::mongodb_import_export::export_mongodb_query,
commands::mongodb_import_export::cancel_mongodb_export,
commands::mongodb_dump::inspect_mongodb_database_dump,
commands::mongodb_dump::prepare_mongodb_restore_source,
commands::mongodb_dump::release_mongodb_restore_source,
commands::mongodb_dump::dump_mongodb_database,
commands::mongodb_dump::restore_mongodb_database,
commands::mongodb_dump::cancel_mongodb_database_dump,
commands::redis_cmd::redis_list_databases,
commands::redis_cmd::redis_scan_keys,
commands::redis_cmd::redis_scan_keys_batch,
commands::redis_cmd::redis_key_metadata_batch,
commands::redis_cmd::redis_scan_values,
commands::redis_cmd::redis_get_value,
commands::redis_cmd::redis_get_raw_value,
commands::redis_cmd::redis_get_ttl,
commands::redis_cmd::redis_get_stream_entries,
commands::redis_cmd::redis_get_stream_groups,
commands::redis_cmd::redis_get_stream_consumers,
commands::redis_cmd::redis_get_stream_pending,
commands::redis_cmd::redis_set_string,
commands::redis_cmd::redis_delete_key,
commands::redis_cmd::redis_rename_key,
commands::redis_cmd::redis_hash_set,
commands::redis_cmd::redis_hash_del,
commands::redis_cmd::redis_hash_field_update,
commands::redis_cmd::redis_hash_field_set_ttl,
commands::redis_cmd::redis_hash_field_set_expire_at,
commands::redis_cmd::redis_list_push,
commands::redis_cmd::redis_list_set,
commands::redis_cmd::redis_list_remove,
commands::redis_cmd::redis_set_add,
commands::redis_cmd::redis_set_remove,
commands::redis_cmd::redis_zadd,
commands::redis_cmd::redis_zrem,
commands::redis_cmd::redis_zset_update,
commands::redis_cmd::redis_stream_add,
commands::redis_cmd::redis_json_set,
commands::redis_cmd::redis_check_json_module,
commands::redis_cmd::redis_set_ttl,
commands::redis_cmd::redis_set_expire_at,
commands::redis_cmd::redis_set_keys_ttl,
commands::redis_cmd::redis_set_keys_expire_at,
commands::redis_cmd::redis_delete_keys,
commands::redis_cmd::redis_delete_keys_by_pattern,
commands::redis_cmd::redis_flush_db,
commands::redis_cmd::redis_execute_command,
commands::redis_cmd::redis_load_more,
commands::redis_cmd::redis_pubsub_publish,
commands::redis_pubsub_server::redis_pubsub_server_port,
commands::redis_cmd::redis_slowlog_get,
commands::redis_cmd::redis_cluster_master_nodes,
commands::etcd_cmd::etcd_supports_ttl,
commands::etcd_cmd::etcd_list_prefix,
commands::etcd_cmd::etcd_get,
commands::etcd_cmd::etcd_put,
commands::etcd_cmd::etcd_delete,
commands::etcd_cmd::etcd_rename,
commands::etcd_cmd::etcd_history,
commands::etcd_cmd::etcd_status,
commands::etcd_cmd::etcd_preflight,
commands::etcd_cmd::etcd_compact,
commands::etcd_cmd::etcd_defrag,
commands::etcd_cmd::etcd_watch_start,
commands::etcd_cmd::etcd_watch_poll,
commands::etcd_cmd::etcd_watch_stop,
commands::etcd_cmd::etcd_lease_list,
commands::etcd_cmd::etcd_lease_call,
commands::etcd_cmd::etcd_auth_call,
commands::zookeeper_cmd::zookeeper_list_prefix,
commands::zookeeper_cmd::zookeeper_get,
commands::zookeeper_cmd::zookeeper_put,
commands::zookeeper_cmd::zookeeper_delete,
commands::nacos_cmd::nacos_test_connection,
commands::nacos_cmd::nacos_list_namespaces,
commands::nacos_cmd::nacos_sidebar_snapshot,
commands::nacos_cmd::nacos_create_namespace,
commands::nacos_cmd::nacos_update_namespace,
commands::nacos_cmd::nacos_delete_namespace,
commands::nacos_cmd::nacos_list_configs,
commands::nacos_cmd::nacos_get_config,
commands::nacos_cmd::nacos_publish_config,
commands::nacos_cmd::nacos_delete_config,
commands::nacos_cmd::nacos_list_config_history,
commands::nacos_cmd::nacos_get_config_history,
commands::nacos_cmd::nacos_rollback_config,
commands::nacos_cmd::nacos_get_rnacos_console_captcha,
commands::nacos_cmd::nacos_login_rnacos_console,
commands::nacos_cmd::nacos_list_users,
commands::nacos_cmd::nacos_create_user,
commands::nacos_cmd::nacos_update_user,
commands::nacos_cmd::nacos_delete_user,
commands::nacos_cmd::nacos_list_role_bindings,
commands::nacos_cmd::nacos_assign_role,
commands::nacos_cmd::nacos_remove_role,
commands::nacos_cmd::nacos_access_snapshot,
commands::nacos_cmd::nacos_start_access_operation,
commands::nacos_cmd::nacos_get_access_operation,
commands::nacos_cmd::nacos_retry_access_operation,
commands::nacos_cmd::nacos_undo_access_operation,
commands::nacos_cmd::nacos_list_services,
commands::nacos_cmd::nacos_get_service,
commands::nacos_cmd::nacos_create_service,
commands::nacos_cmd::nacos_update_service,
commands::nacos_cmd::nacos_delete_service,
commands::nacos_cmd::nacos_list_instances,
commands::nacos_cmd::nacos_update_instance,
commands::nacos_cmd::nacos_register_instance,
commands::nacos_cmd::nacos_deregister_instance,
commands::nacos_cmd::nacos_get_dashboard,
commands::nacos_cmd::nacos_raw_request,
commands::nacos_cmd::nacos_search_config_content,
commands::nacos_cmd::nacos_cancel_operation,
commands::nacos_cmd::nacos_export_configs,
commands::nacos_cmd::nacos_preview_config_import,
commands::nacos_cmd::nacos_apply_config_import,
commands::nacos_cmd::nacos_preview_config_transfer,
commands::nacos_cmd::nacos_apply_config_transfer,
commands::saved_sql::load_saved_sql_library,
commands::saved_sql::load_saved_sql_files_for_sync,
commands::saved_sql::load_saved_sql_file,
commands::saved_sql::save_saved_sql_folder,
commands::saved_sql::delete_saved_sql_folder,
commands::saved_sql::save_saved_sql_file,
commands::saved_sql::save_default_query_content,
commands::saved_sql::delete_saved_sql_file,
commands::saved_sql::saved_sql_storage_dir,
commands::saved_sql::open_saved_sql_storage_dir,
commands::saved_sql::sync_saved_sql_directory,
commands::shortcut_recording::set_shortcut_recording,
commands::fs_open::reveal_path_in_file_manager,
commands::fs_open::is_sqlite_database_file,
commands::fs_open::delete_database_backup_files,
background_backup::database_backup_command,
background_backup::database_backup_background,
commands::sqlite_backup::backup_sqlite_database,
commands::sqlite_backup::restore_sqlite_database,
commands::mongo_cmd::mongo_list_databases,
commands::mongo_cmd::mongo_list_collections,
commands::vector_cmd::vector_collection_detail,
commands::mongo_cmd::mongo_create_database,
commands::mongo_cmd::mongo_drop_database,
commands::mongo_cmd::mongo_drop_collection,
commands::vector_cmd::vector_drop_database,
commands::vector_cmd::vector_drop_collection,
commands::vector_cmd::vector_rename_collection,
commands::mongo_cmd::mongo_rename_collection,
commands::mongo_cmd::mongo_clone_collection,
commands::docs::docs_collect_snapshot,
commands::docs::docs_collect_snapshot_for_export,
commands::docs::docs_load_annotations,
commands::docs::docs_apply_annotations,
commands::docs::docs_save_annotations,
commands::docs::docs_export_html,
commands::document_cmd::document_list_databases,
commands::document_cmd::document_list_collections,
commands::document_cmd::document_find_documents,
commands::document_cmd::document_count_documents,
commands::document_cmd::dynamodb_describe_table,
commands::document_cmd::elasticsearch_count_documents,
commands::document_cmd::elasticsearch_get_index_metadata,
commands::document_cmd::elasticsearch_delete_all_documents,
commands::document_cmd::document_list_gridfs_buckets,
commands::document_cmd::document_create_gridfs_bucket,
commands::document_cmd::document_delete_gridfs_bucket,
commands::document_cmd::document_list_gridfs_files,
commands::document_cmd::document_download_gridfs_file,
commands::document_cmd::document_upload_gridfs_file,
commands::document_cmd::document_delete_gridfs_file,
commands::mongo_cmd::mongo_find_documents,
commands::mongo_cmd::mongo_parse_shell_command,
commands::mongo_cmd::mongo_find_one,
commands::mongo_cmd::mongo_explain_find,
commands::mongo_cmd::mongo_count_documents,
commands::mongo_cmd::mongo_server_version,
commands::mongo_cmd::mongo_collection_stats,
commands::mongo_cmd::mongo_aggregate_documents,
commands::mongo_cmd::mongo_distinct,
commands::mongo_cmd::mongo_list_index_specs,
commands::mongo_cmd::mongo_create_index,
commands::mongo_cmd::mongo_create_user,
commands::mongo_cmd::mongo_run_command,
commands::mongo_cmd::mongo_drop_indexes,
commands::document_cmd::document_insert_document,
commands::mongo_cmd::mongo_insert_document,
commands::mongo_cmd::mongo_insert_documents,
commands::document_cmd::document_update_document,
commands::mongo_cmd::mongo_update_document,
commands::mongo_cmd::mongo_update_documents,
commands::mongo_cmd::mongo_replace_document,
commands::mongo_cmd::mongo_bulk_write,
commands::document_cmd::document_delete_document,
commands::document_cmd::document_save_meilisearch_batch,
commands::document_cmd::meilisearch_search_documents,
commands::document_cmd::meilisearch_fetch_documents,
commands::document_cmd::meilisearch_get_document,
commands::document_cmd::meilisearch_get_index_settings,
commands::document_cmd::meilisearch_update_index_settings,
commands::document_cmd::meilisearch_get_index_stats,
commands::document_cmd::meilisearch_get_index_overview,
commands::document_cmd::meilisearch_create_index,
commands::document_cmd::meilisearch_delete_index,
commands::document_cmd::meilisearch_delete_all_documents,
commands::document_cmd::meilisearch_get_system_overview,
commands::document_cmd::meilisearch_list_keys,
commands::document_cmd::meilisearch_get_key,
commands::document_cmd::meilisearch_create_key,
commands::document_cmd::meilisearch_update_key,
commands::document_cmd::meilisearch_delete_key,
commands::document_cmd::meilisearch_get_tasks,
commands::document_cmd::meilisearch_get_task,
commands::document_cmd::meilisearch_cancel_tasks,
commands::document_cmd::meilisearch_delete_tasks,
commands::hbase_cmd::hbase_get_table_schema,
commands::hbase_cmd::hbase_scan_rows,
commands::hbase_cmd::hbase_get_row,
commands::hbase_cmd::hbase_put_row,
commands::hbase_cmd::hbase_delete_row,
commands::hbase_cmd::hbase_create_table,
commands::hbase_cmd::hbase_delete_table,
commands::mongo_cmd::mongo_delete_document,
commands::mongo_cmd::mongo_delete_documents,
commands::mongo_cmd::mongo_find_one_and_update,
commands::mongo_cmd::mongo_find_one_and_replace,
commands::mongo_cmd::mongo_find_one_and_delete,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_test_connection,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_tenants,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_get_tenant,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_create_tenant,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_update_tenant,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_delete_tenant,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_namespaces,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_create_namespace,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_delete_namespace,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_get_namespace_policies,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_topics,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_topics_page,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_create_topic,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_delete_topic,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_update_partitions,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_get_topic_stats,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_get_topic_internal_stats,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_exchanges,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_exchanges_page,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_create_exchange,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_delete_exchange,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_bindings,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_bind,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_unbind,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_subscriptions,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_enrich_subscriptions,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_get_kafka_consumer_group_snapshot,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_create_subscription,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_delete_subscription,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_skip_messages,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_reset_cursor,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_clear_backlog,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_get_consumer_group_config,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_alter_consumer_group_config,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_peek_messages,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_expire_messages,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_producers,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_consumers,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_unload_topic,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_client_connections,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_client_channels,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_close_client_connection,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_set_publish_rate,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_set_dispatch_rate,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_set_subscribe_rate,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_set_backlog_quota,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_set_retention,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_get_effective_policies,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_grant_permission,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_revoke_permission,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_permissions,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_users,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_create_user,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_delete_user,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_user_permissions,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_grant_user_permission,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_revoke_user_permission,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_policies,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_set_policy,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_delete_policy,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_get_overview,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_nodes,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_issue_token,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_list_token_records,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_get_backlog,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_get_cluster_info,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_get_topic_route,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_alter_topic_config,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_skip_topic_accumulation,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_view_message,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_query_messages_by_key,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_query_messages_by_topic,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_query_message_trace,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_raw_request,
#[cfg(feature = "mq-admin")]
commands::mq_cmd::mq_send_message,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_get_broker_info,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_subscribe,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_save_topic_config,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_unsubscribe,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_delete_topic_config,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_publish,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_list_topics,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_list_saved_topic_configs,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_get_topic_tree,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_get_messages,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_clear_messages,
#[cfg(feature = "mq-admin")]
commands::mqtt_cmd::mqtt_delete_message,
commands::history::save_history,
commands::history::load_history,
commands::history::search_history,
commands::history::load_history_connection_options,
commands::history::clear_history,
commands::history::clear_history_by_source,
commands::history::cleanup_mcp_history_retention,
commands::history::delete_history_entry,
commands::task_history::load_task_runs,
commands::task_history::load_task_run,
commands::task_history::load_task_run_items,
commands::mcp::check_mcp_server_status,
commands::mcp::check_mcp_keychain_access,
commands::mcp::authorize_mcp_keychain,
commands::mcp::install_mcp_server,
commands::mcp::install_native_mcp_server,
commands::mcp::uninstall_mcp_server,
commands::mcp::uninstall_npm_mcp_server,
commands::app_relaunch::relaunch_app,
commands::update::check_for_updates,
commands::update::fetch_changelog,
commands::update::get_system_proxy_url,
commands::update::get_downloaded_update,
commands::update::discard_downloaded_update,
commands::update::download_update,
commands::update::cancel_update_download,
commands::update::install_downloaded_update,
commands::transfer::start_transfer,
commands::transfer::preview_transfer_ownership,
commands::transfer::cancel_transfer,
commands::database_export::begin_database_backup_snapshot,
commands::database_export::export_database_sql,
commands::database_export::cancel_database_export,
commands::database_export::clear_database_export_cancellation,
commands::database_export::database_export_destination_needs_confirmation,
commands::database_export::record_database_export_destination,
commands::table_export::start_table_export,
commands::table_export::cancel_table_export,
commands::dameng_dump::start_dameng_dump,
commands::dameng_dump::cancel_dameng_dump,
commands::dameng_dump::resolve_dameng_dump_tool,
commands::query_result_export::start_query_result_export,
commands::query_result_export::create_query_result_temp_file,
commands::query_result_export::open_query_result_temp_file,
commands::query_result_export::cancel_query_result_export,
commands::csv_export::export_query_result_csv,
commands::csv_export::export_table_data_csv,
commands::xlsx_export::export_query_result_xlsx,
commands::xlsx_export::export_query_results_xlsx,
commands::text_export::export_query_result_json,
commands::text_export::export_query_result_markdown,
commands::text_export::export_query_result_html,
commands::agents::list_installed_agents,
commands::agents::list_installed_agents_local,
commands::agents::is_agent_installed,
commands::agents::get_driver_store_usage,
commands::agents::clear_driver_download_cache,
commands::agents::get_driver_runtime_summary,
commands::agents::stop_driver_runtime,
commands::agents::restart_driver_runtime,
commands::agents::install_agent,
commands::agents::cancel_agent_install,
commands::agents::upgrade_all_agents,
commands::agents::cancel_agent_upgrade_all,
commands::agents::check_agent_update_blockers,
commands::agents::uninstall_agent,
commands::agents::check_jre_installed,
commands::agents::get_agent_java_runtime_config,
commands::agents::set_agent_java_runtime_config,
commands::agents::uninstall_jre,
commands::agents::reinstall_jre,
commands::agents::invalidate_agent_registry_cache,
commands::agents::import_agents_from_zip,
commands::agents::preview_agent_offline_export,
commands::agents::export_agents_offline,
commands::agents::import_agent_driver_cmd,
commands::agents::import_agent_jar_cmd,
commands::system_fonts::list_system_fonts,
commands::ssh_config::list_ssh_config_hosts,
commands::ssh_keys::list_local_ssh_keys,
commands::ssh_prompt::ssh_prompt_ready,
commands::ssh_prompt::ssh_prompt_not_ready,
commands::ssh_prompt::resolve_ssh_prompt,
commands::tunnel_profiles::load_tunnel_profiles,
commands::tunnel_profiles::save_tunnel_profiles,
commands::tunnel_profiles::test_tunnel_profile,
commands::tunnel_profiles::list_ssh_agent_identities,
])))
.build(tauri::generate_context!())
.inspect(|app| {
append_startup_probe(format!("tauri application built after {:?}", startup_begin.elapsed()));
startup_recovery::start_watchdog(app.handle());
})
.unwrap_or_else(|error| {
append_startup_probe(format!("tauri application build failed: {error}"));
panic!("error while building tauri application: {error}");
})
.run(|app_handle, event| {
startup_recovery::record_run_event();
#[cfg(not(target_os = "macos"))]
let _ = (&app_handle, &event);
if let RunEvent::ExitRequested { code, api, .. } = &event {
let confirmed_exit = app_handle
.try_state::<CloseBehaviorState>()
.map(|state| state.take_confirmed_exit())
.unwrap_or(false);
if should_confirm_app_exit_request(std::env::consts::OS, *code, confirmed_exit) {
api.prevent_exit();
request_app_close(app_handle, "quit");
} else {
// Restart exits and the no-frontend native quit bypass
// `complete_app_close`, so hide the window here too; the
// shutdown below gives WindowServer time to remove it.
if should_hide_window_before_exit(std::env::consts::OS) {
if let Some(window) = app_handle.get_webview_window("main") {
window_state_guard::remember_main_window_geometry(app_handle);
let _ = window.hide();
}
}
tauri::async_runtime::block_on(shutdown_runtime_resources(app_handle));
}
}
#[cfg(target_os = "macos")]
if let RunEvent::Opened { urls } = &event {
if urls.iter().any(|url| commands::deep_link::is_app_open_deep_link(url.as_str())) {
show_main_window(app_handle);
}
let links: Vec<String> = urls
.iter()
.map(|url| url.to_string())
.filter_map(|url| commands::deep_link::connection_deep_link_from_arg(&url))
.collect();
open_connection_deep_links(app_handle, links);
let ai_config_links: Vec<String> = urls
.iter()
.map(|url| url.to_string())
.filter_map(|url| commands::deep_link::ai_config_deep_link_from_arg(&url))
.collect();
open_ai_config_deep_links(app_handle, ai_config_links);
let plugin_install_links: Vec<String> = urls
.iter()
.map(|url| url.to_string())
.filter_map(|url| commands::deep_link::plugin_install_deep_link_from_arg(&url))
.collect();
open_plugin_install_deep_links(app_handle, plugin_install_links);
let paths: Vec<String> = urls
.iter()
.filter_map(|url| url.to_file_path().ok())
.filter(|path| commands::external_sql::is_sql_file_path(path))
.map(|path| path.to_string_lossy().to_string())
.collect();
if !paths.is_empty() {
if let Some(state) = app_handle.try_state::<commands::external_sql::ExternalSqlOpenState>() {
state.push(paths.clone());
}
let _ = app_handle.emit("dbx-open-sql-files", paths);
if let Some(window) = app_handle.get_webview_window("main") {
let _ = window.show();
let _ = window.set_focus();
}
}
let db_paths: Vec<String> = urls
.iter()
.filter_map(|url| url.to_file_path().ok())
.filter(|path| commands::external_db::is_db_file_path(path))
.map(|path| path.to_string_lossy().to_string())
.collect();
if !db_paths.is_empty() {
if let Some(state) = app_handle.try_state::<commands::external_db::ExternalDbOpenState>() {
state.push(db_paths.clone());
}
let _ = app_handle.emit("dbx-open-db-files", db_paths);
if let Some(window) = app_handle.get_webview_window("main") {
let _ = window.show();
let _ = window.set_focus();
}
}
}
#[cfg(target_os = "macos")]
if let RunEvent::Reopen { has_visible_windows, .. } = &event {
if !has_visible_windows && !show_main_window(app_handle) {
// Dock / Finder reopen is the other way back into a hidden
// instance, and it fails silently for the same reason.
eprintln!(
"[WINDOW] reopen could not reveal the main window; {}",
main_window_probe_state(app_handle)
);
}
let app_handle = app_handle.clone();
let migration_gate =
app_handle.try_state::<Arc<migration_gate::MigrationGate>>().map(|state| state.inner().clone());
tauri::async_runtime::spawn(async move {
let Some(migration_gate) = migration_gate else {
return;
};
migration_gate.wait().await;
if let Some(state) = app_handle.try_state::<AppState>() {
state.refresh_connections().await;
}
});
}
if let RunEvent::Resumed = &event {
let app_handle = app_handle.clone();
let migration_gate =
app_handle.try_state::<Arc<migration_gate::MigrationGate>>().map(|state| state.inner().clone());
tauri::async_runtime::spawn(async move {
let Some(migration_gate) = migration_gate else {
return;
};
migration_gate.wait().await;
if let Some(state) = app_handle.try_state::<AppState>() {
state.refresh_connections().await;
}
});
}
});
}