mirror of
https://github.com/l0ng-ai/openidea.git
synced 2026-11-18 16:08:55 +00:00
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>
412 lines
18 KiB
Rust
412 lines
18 KiB
Rust
//! 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)),
|
||
_ => {}
|
||
},
|
||
}
|
||
}
|