Files
openidea/src-tauri/src/lib.rs
T
qq471754603andqq471754603 6b2bb0bb6a fix(macos): run on Big Sur and Monterey with Safari's staged WebKit (#3534)
When the system WebKit predates Safari 15.4 (macOS 11, and 12 before 12.3) and Safari's update has staged a newer WebKit, main re-execs once with DYLD_FRAMEWORK_PATH pointing at the staged frameworks and clears it again in the second process, so child processes keep the system frameworks. macOS 12.3+ and 13+ keep the system engine without a restart; an unreadable system version also keeps it.

- Entitlements: allow-dyld-environment-variables only; library validation stays on (the staged framework is Apple-signed).
- Bundle and link minimum back to 11.0 so Launch Services opens the app on Big Sur; .cargo/config.toml sets MACOSX_DEPLOYMENT_TARGET as a default a developer can override.
- The staged copy is checked with a stat before the system version is read, so current macOS never spawns defaults at startup.
- Debug builds skip the bindings export when the build checkout is absent.
- Boot error page, install and contributor docs describe the Big Sur case.

Tested by the contributor on macOS 11.7.11 (Safari 16.6.1 staged) and 26.5; by us on macOS 15.7.8 (no re-exec).

Co-authored-by: qq471754603 <23146592+qq471754603@users.noreply.github.com>
2026-11-16 13:25:59 +08:00

412 lines
18 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! OpenIDEA desktop shell: wires the backend crates into Tauri.
//!
//! This crate is glue only. Each `commands/<domain>.rs` is a thin, typed
//! adapter from IPC to a backend crate; no domain logic lives here.
mod application_focus;
mod cli;
mod commands;
#[cfg(debug_assertions)]
mod dev;
mod events;
mod jump_list;
#[cfg(any(target_os = "linux", test))]
mod linux_webkit;
#[cfg(any(target_os = "linux", test))]
mod linux_window_state;
mod logging;
#[cfg(target_os = "macos")]
mod macos;
mod menu;
#[cfg(target_os = "macos")]
mod page_swipe;
mod plugin_web;
#[cfg(target_os = "macos")]
mod relaunch;
mod remote_container;
mod remote_dev;
mod remote_wsl;
mod system_notifications;
mod state;
mod theme_frame;
#[cfg(target_os = "macos")]
mod titlebar;
mod updates;
mod window_groups;
#[cfg(any(windows, test))]
mod window_work_area;
mod window_zoom;
mod windows;
#[cfg(windows)]
mod windows_error_mode;
use parking_lot::Mutex;
use state::AppState;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use tauri::{Emitter, Manager};
use windows::WindowsState;
/// Builds the tauri-specta builder holding every command and exported type.
/// Also used by `export_bindings` (tests) to regenerate `src/bindings.ts`.
pub fn specta_builder() -> tauri_specta::Builder<tauri::Wry> {
commands::builder().typ::<ide_core::IdeEvent>().dangerously_cast_bigints_to_number()
}
pub fn export_bindings(builder: &tauri_specta::Builder<tauri::Wry>) {
let target = Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../src/bindings.ts"));
// Debug builds can end up on machines other than the one that built them
// (packaged test builds). Without the checkout there is nothing to sync,
// and `CARGO_MANIFEST_DIR` points at the build machine anyway.
if !target.parent().is_some_and(Path::is_dir) {
return;
}
// Rewritten only when it changes: every debug launch exports, also a second instance that just
// hands its path over, and a rewrite makes Vite reload the running app's windows.
let fresh = std::env::temp_dir().join(format!("openidea-bindings-{}.ts", std::process::id()));
builder
.export(
specta_typescript::Typescript::default().header("// @ts-nocheck\n/* eslint-disable */\n// Generated by tauri-specta. Do not edit; run `pnpm gen:bindings`."),
&fresh,
)
.expect("failed to export TypeScript bindings");
let text = std::fs::read(&fresh).expect("exported TypeScript bindings");
let _ = std::fs::remove_file(&fresh);
if std::fs::read(target).ok().as_deref() != Some(text.as_slice()) {
std::fs::write(target, text).expect("failed to write TypeScript bindings");
}
}
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
ide_workspace::process::mark_start();
#[cfg(windows)]
windows_error_mode::quiet_error_dialogs();
let context = tauri::generate_context!();
#[cfg(debug_assertions)]
let context = dev::configure(context);
if let Some(project) = ide_mcp::stdio_request(&std::env::args().collect::<Vec<_>>()) {
let app_data = ide_host::data_dirs::data_dir(&context.config().identifier).unwrap_or_default();
std::process::exit(ide_mcp::stdio::run(&ide_mcp::discovery_path(&app_data), project));
}
// The `openidea` command: answer and exit, no UI.
if let Some(code) = cli::run(&context.config().identifier) {
std::process::exit(code);
}
// Before the first window: one taskbar identity for every launch path.
jump_list::set_app_id(&context.config().identifier);
logging::init(&context.config().identifier);
#[cfg(target_os = "linux")]
linux_webkit::configure();
let refresh_shell_path = ide_host::shell_env::inherit_login_shell_path(&context.config().identifier);
// A custom directory from Settings › System Settings › Caches applies here too
// (`OPENIDEA_LOCAL_DATA_DIR` still wins), so tools resolve against the new root.
let local_data_dir = ide_host::data_dirs::startup_local_data_dir(&context.config().identifier);
// Managed LSP/DAP installs; must run before other threads start and before PATH is cached.
match &local_data_dir {
Ok(data) => {
ide_tools::extend_process_path(data);
ide_dap::adapter::set_tools_root(ide_tools::tools_dir(data));
ide_sdk::java::add_jdk_root(&ide_tools::jdk::jdks_dir(data));
}
Err(error) => tracing::error!("{error}"),
}
if let Some(refresh) = refresh_shell_path {
refresh();
}
let builder = specta_builder();
#[cfg(debug_assertions)]
export_bindings(&builder);
let app = tauri::Builder::default().manage(WindowsState::default());
// Single instance first: a second launch focuses this one and opens its path argument.
// Debug builds have a separate identifier per worktree.
let app = app.plugin(tauri_plugin_single_instance::init(windows::on_second_instance));
// Install before window-state restores maximized geometry during window creation.
#[cfg(windows)]
let app = app.plugin(window_work_area::init());
let app = app
.plugin(tauri_plugin_opener::init())
.plugin(tauri_plugin_notification::init())
.plugin(tauri_plugin_dialog::init());
#[cfg(target_os = "linux")]
let app = app.plugin(linux_window_state::plugin());
#[cfg(not(target_os = "linux"))]
let window_state = tauri_plugin_window_state::Builder::default()
.with_state_flags(window_state_flags())
// One remembered geometry per kind of auxiliary window (all projects' settings windows share one).
.map_label(windows::state_key);
// The plugin stores its file in the OS configuration directory; an absolute name follows
// `OPENIDEA_CONFIG_DIR` instead.
#[cfg(not(target_os = "linux"))]
let window_state = match ide_host::data_dirs::config_dir(&context.config().identifier) {
Ok(dir) => window_state.with_filename(dir.join(tauri_plugin_window_state::DEFAULT_FILENAME).to_string_lossy()),
Err(_) => window_state,
};
#[cfg(target_os = "macos")]
let window_state = window_state.with_filter(windows::keeps_window_state);
#[cfg(not(target_os = "linux"))]
let app = app.plugin(window_state.build());
let app = app
// Inert until an endpoint is configured (see `commands::window::app_check_update`).
.plugin(tauri_plugin_updater::Builder::new().build());
// Files of plugins' web views, for their sandboxed frames.
let app = app.register_asynchronous_uri_scheme_protocol(plugin_web::SCHEME, plugin_web::handle);
// E2E automation bridge (Tauri MCP), debug builds only, localhost only.
#[cfg(debug_assertions)]
let app = app.plugin(tauri_plugin_mcp_bridge::Builder::new().bind_address("127.0.0.1").build());
// Paths macOS asked to open (Finder's Open With, the Dock) before setup ran: the first window takes them.
let early_opens: Arc<Mutex<Option<Vec<PathBuf>>>> = Arc::default();
let setup_opens = early_opens.clone();
let typed_invoke = builder.invoke_handler();
// Raw Response is not a JSON/Specta type; keep the binary command out of generated bindings.
let raw_invoke: fn(tauri::ipc::Invoke) -> bool = tauri::generate_handler![commands::fonts::user_font_data];
let invoke = Arc::new(move |request: tauri::ipc::Invoke| {
if request.message.command() == "user_font_data" { raw_invoke(request) } else { typed_invoke(request) }
});
app.invoke_handler(move |request| {
let webview = request.message.webview_ref();
if let Some(state) = webview.try_state::<AppState>() {
let label = AppState::owner_window(webview.label());
let command = request.message.command();
let authorized = match state.remote_dev.get(label) {
Some(connection) => connection.authorize_command(&state.host.trust, command),
None => state.host.authorize_command(webview.label(), command),
};
if let Err(error) = authorized {
request.resolver.reject(error);
return true;
}
}
invoke(request)
})
.setup(move |app| {
builder.mount_events(app);
#[cfg(windows)]
tauri::async_runtime::spawn_blocking(|| {
if let Ok(exe) = tauri::utils::platform::current_exe() {
ide_tools::portable_update::cleanup(&exe);
}
});
// An unusable directory variable stops the start with a message, never a silent fallback.
let identifier = app.config().identifier.clone();
let local_data_dir = local_data_dir.and_then(|dir| {
ide_host::data_dirs::config_dir(&identifier)?;
ide_host::data_dirs::data_dir(&identifier)?;
Ok(dir)
});
let local_data_dir = match local_data_dir {
Ok(dir) => dir,
Err(error) => {
use tauri_plugin_dialog::DialogExt;
let handle = app.handle().clone();
app.dialog()
.message(error)
.title("OpenIDEA")
.kind(tauri_plugin_dialog::MessageDialogKind::Error)
.show(move |_| handle.exit(1));
return Ok(());
}
};
let state = AppState::new(app.handle().clone(), local_data_dir)?;
let windows = app.state::<WindowsState>();
if let Ok(cwd) = std::env::current_dir() {
match windows::cli_launch(&std::env::args().collect::<Vec<_>>(), &cwd) {
Ok(Some(launch)) => windows.set_launch("main", launch),
Ok(None) => {}
Err(error) => windows::report_cli_error(app.handle(), error),
}
}
let menu_state = menu::MenuState::default();
menu::install(app.handle(), &menu_state, &state.recent.list());
app.manage(state);
commands::mcp::apply(&app.state::<AppState>());
#[cfg(windows)]
if let Err(error) = windows::allow_external_launches(app.handle()) {
windows::report_cli_error(app.handle(), error);
}
app.manage(application_focus::ApplicationFocus::default());
system_notifications::init(app.handle());
#[cfg(target_os = "macos")]
macos::intercept_system_quit(app.handle());
#[cfg(target_os = "macos")]
if let Some(mtm) = objc2::MainThreadMarker::new() {
macos::prepare_window_tabbing(mtm);
}
#[cfg(target_os = "macos")]
application_focus::observe(app.handle());
app.manage(menu_state);
cli::serve(app.handle(), &app.config().identifier);
if let Some(paths) = setup_opens.lock().take() {
windows::open_paths_at_launch(app.handle(), paths);
}
app.on_menu_event(on_menu_event);
windows::create_main_window(app.handle())?;
windows::ready_for_cli(app.handle());
jump_list::refresh(app.handle(), app.state::<AppState>().recent.list());
Ok(())
})
.on_window_event(|window, event| match event {
tauri::WindowEvent::CloseRequested { .. } => {
#[cfg(target_os = "linux")]
linux_window_state::save_before_close(window.app_handle());
if let Some(w) = window.try_state::<WindowsState>() {
w.close_requested(window.label());
}
}
tauri::WindowEvent::Focused(true) => {
application_focus::changed(window.app_handle(), true);
if let Some(w) = window.try_state::<WindowsState>() {
w.focused(window.label());
}
}
tauri::WindowEvent::Focused(false) => application_focus::changed(window.app_handle(), false),
tauri::WindowEvent::Moved(_) | tauri::WindowEvent::Resized(_) => {
window_groups::frame_changed(window.app_handle(), window.label());
}
tauri::WindowEvent::Destroyed => {
window_zoom::forget(window.label());
#[cfg(target_os = "macos")]
{
page_swipe::forget(window.label());
titlebar::forget(window);
}
if windows::auxiliary_parent(window.label()).is_none() {
window_groups::destroyed(window.app_handle(), window.label());
windows::close_auxiliary_windows(window.app_handle(), window.label());
if let Some(state) = window.try_state::<AppState>() {
#[cfg(target_os = "macos")]
if let Some(w) = window.try_state::<WindowsState>() {
let settings = ide_host::ops::project::settings(&state.host, window.label());
w.keep_alive.store(settings.general.close_without_welcome, std::sync::atomic::Ordering::SeqCst);
}
state.updates.forget_window(window.label());
state.close_project(window.label());
state.plugins.forget_client(window.label());
}
}
if let Some(w) = window.try_state::<WindowsState>() {
w.forget(window.label());
}
if windows::auxiliary_parent(window.label()).is_none() {
windows::continue_quit(window.app_handle(), Some(window.label()));
}
}
_ => {}
})
.build(context)
.expect("error while running OpenIDEA")
.run(move |app, event| {
#[cfg(target_os = "macos")]
match &event {
tauri::RunEvent::ExitRequested { code: None, api, .. }
if app.state::<WindowsState>().keep_alive.load(std::sync::atomic::Ordering::SeqCst)
&& !app.state::<WindowsState>().quitting() =>
{
api.prevent_exit();
}
tauri::RunEvent::Reopen { has_visible_windows: false, .. }
if windows::project_window_labels(app).is_empty() =>
{
windows::spawn_window(app, None);
}
_ => {}
}
#[cfg(target_os = "macos")]
if let tauri::RunEvent::Opened { urls } = &event {
let paths = windows::opened_paths(urls);
if app.try_state::<AppState>().is_some() {
windows::open_paths(app, paths);
} else {
early_opens.lock().get_or_insert_default().extend(paths);
}
}
#[cfg(not(target_os = "macos"))]
let _ = &early_opens;
if let tauri::RunEvent::Exit = event {
if let Some(state) = app.try_state::<AppState>() {
state.host.stop_processes_on_exit();
commands::mcp::stop(&state);
state.host.clear_workspace_edit_history_on_exit();
state.host.shutdown_notebooks_on_exit();
}
// Cleanup must finish before update/restart replaces this process.
if app.try_state::<WindowsState>().is_some_and(|w| w.restart_requested()) {
#[cfg(target_os = "macos")]
relaunch::restart(&app.env());
#[cfg(not(target_os = "macos"))]
tauri::process::restart(&app.env());
}
}
});
}
#[cfg(not(target_os = "linux"))]
fn window_state_flags() -> tauri_plugin_window_state::StateFlags {
use tauri_plugin_window_state::StateFlags;
#[cfg(target_os = "windows")]
{
// Start at the configured size, centered, instead of restoring geometry after the
// window is visible (Windows briefly showed the default position before that move).
StateFlags::MAXIMIZED | StateFlags::FULLSCREEN
}
#[cfg(not(target_os = "windows"))]
{
StateFlags::SIZE | StateFlags::POSITION | StateFlags::MAXIMIZED | StateFlags::FULLSCREEN
}
}
/// Routes IDE menu items to the focused window's frontend (`executeAction`).
fn on_menu_event(app: &tauri::AppHandle, event: tauri::menu::MenuEvent) {
let id = event.id().as_ref();
menu::restore_check(app, &app.state::<menu::MenuState>(), id);
// A keymap accelerator only draws the shortcut: its key reached the menu because the keymap declined it.
#[cfg(target_os = "macos")]
if !menu::fires_natively(&menu::spec(menu::Os::Mac), id)
&& (macos::handling_key_press() || macos::native_modal_open())
{
return;
}
dispatch_menu_action(app, id);
}
/// Runs menu item `id` as if it were chosen: in the focused window's frontend, or here without one.
pub(crate) fn dispatch_menu_action(app: &tauri::AppHandle, id: &str) {
let Some(route) = menu::route(&menu::spec(menu::Os::current()), id) else { return };
match windows::target_window(app) {
Some(w) => {
// The window to bring back to the front once what the action shows is closed (Settings).
let mut return_to = None;
let label = match windows::menu_destination(w.label(), &route.action) {
windows::MenuDestination::Own => w.label(),
windows::MenuDestination::Parent { label, raise } => {
if raise && let Some(parent) = app.get_webview_window(label) {
windows::focus(&parent);
return_to = Some(w.label());
}
label
}
windows::MenuDestination::Close => {
let _ = w.close();
return;
}
};
let event = menu::MenuEvent { route: &route, return_to };
if let Err(e) = app.emit_to(label, menu::MENU_EVENT, &event) {
tracing::warn!("failed to deliver menu event {id}: {e}");
}
}
// No window left (macOS keeps the menu bar): handle the few that make sense.
None => match route.action.as_str() {
"app.quit" => app.exit(0),
"window.new" | "file.openProject" => windows::spawn_window(app, None),
menu::OPEN_RECENT_ACTION => windows::spawn_window(app, route.arg.map(Into::into)),
_ => {}
},
}
}