mod app_state; mod commands; mod deep_link; mod events; mod huddle; mod managed_agents; mod media_proxy; #[cfg(feature = "mesh-llm")] mod mesh_llm; mod migration; #[cfg(test)] mod model_tests; mod models; pub mod nostr_convert; mod prevent_sleep; mod ptt_shortcut; mod relay; mod secret_store; mod shutdown; mod templates; mod util; #[cfg(not(feature = "mesh-llm"))] mod mesh_llm_stubs; #[cfg(not(feature = "mesh-llm"))] use mesh_llm_stubs::*; use app_state::{build_app_state, resolve_persisted_identity, AppState}; use commands::*; use deep_link::handle_deep_link_url; use huddle::audio_output::{ get_audio_output_device, list_audio_output_devices, set_audio_output_device, }; use huddle::{ add_agent_to_huddle, check_pipeline_hotstart, confirm_huddle_active, download_voice_models, end_huddle, get_huddle_agent_pubkeys, get_huddle_state, get_model_status, get_voice_input_mode, join_huddle, leave_huddle, push_audio_pcm, set_huddle_transcription_enabled, set_tts_enabled, set_voice_input_mode, speak_agent_message, start_huddle, start_stt_pipeline, }; use managed_agents::{ backfill_persona_snapshots, ensure_nest, restore_managed_agents_on_launch, try_regenerate_nest, }; use shutdown::shutdown_managed_agents; use std::sync::{ atomic::{AtomicBool, Ordering}, Arc, }; use tauri::{Emitter, Manager, RunEvent}; use tauri_plugin_window_state::StateFlags; #[tauri::command] fn perform_sidebar_default_haptic() { #[cfg(target_os = "macos")] { use objc2_app_kit::{ NSHapticFeedbackManager, NSHapticFeedbackPattern, NSHapticFeedbackPerformanceTime, NSHapticFeedbackPerformer, }; NSHapticFeedbackManager::defaultPerformer().performFeedbackPattern_performanceTime( NSHapticFeedbackPattern::Alignment, NSHapticFeedbackPerformanceTime::Now, ); } } #[cfg_attr(mobile, tauri::mobile_entry_point)] pub fn run() { let builder = tauri::Builder::default() .plugin(tauri_plugin_single_instance::init(|app, argv, _cwd| { // Focus the existing window when a duplicate instance launches. if let Some(w) = app.get_webview_window("main") { let _ = w.set_focus(); } // Forward any deep link URLs from the duplicate launch. for arg in &argv { if arg.starts_with("buzz://") { handle_deep_link_url(app, arg); } } })) .plugin(tauri_plugin_deep_link::init()) .plugin(tauri_plugin_notification::init()) .plugin(tauri_plugin_opener::init()) .plugin( tauri_plugin_window_state::Builder::default() // The main window should always launch edge-to-edge in the // available desktop area. Do not let stale saved geometry or // fullscreen state override the maximized launch config. .with_state_flags( StateFlags::all() & !(StateFlags::VISIBLE | StateFlags::POSITION | StateFlags::SIZE | StateFlags::MAXIMIZED | StateFlags::FULLSCREEN), ) .build(), ) .plugin(tauri_plugin_websocket::init()) .plugin(tauri_plugin_dialog::init()) .plugin(tauri_plugin_process::init()); // The global-shortcut plugin is omitted from test builds: linking it into // the lib-test binary makes it fail to load on Windows // (STATUS_ENTRYPOINT_NOT_FOUND) before any test runs. #[cfg(not(test))] let builder = builder.plugin({ use tauri_plugin_global_shortcut::ShortcutState; // Generation counter for the release delay task. Incremented on // every press — a delayed release only fires if the generation // hasn't changed (i.e. no new press happened during the delay). // This prevents press→release→press within 200 ms from having // the first release clobber the second press. let ptt_press_gen = Arc::new(std::sync::atomic::AtomicU64::new(0)); tauri_plugin_global_shortcut::Builder::new() .with_handler(move |app, _shortcut, event| { let state = match app.try_state::() { Some(s) => s, None => return, }; // Only act if a huddle is active and mode is PTT. let (is_ptt_mode, is_active) = match state.huddle_state.lock() { Ok(hs) => ( hs.voice_input_mode == huddle::VoiceInputMode::PushToTalk, matches!( hs.phase, huddle::HuddlePhase::Connected | huddle::HuddlePhase::Active ), ), Err(_) => return, }; if !is_ptt_mode || !is_active { return; } match event.state { ShortcutState::Pressed => { // Bump generation — invalidates any pending release delay. ptt_press_gen.fetch_add(1, std::sync::atomic::Ordering::Release); if let Ok(hs) = state.huddle_state.lock() { hs.ptt_active .store(true, std::sync::atomic::Ordering::Release); // Only cancel TTS if it's actually playing — avoids // a stale cancel flag that drops the next queued message. if hs.tts_active.load(std::sync::atomic::Ordering::Acquire) { hs.tts_cancel .store(true, std::sync::atomic::Ordering::Release); } } // Emit ptt-state=true to the frontend. // The React side plays the press audio cue on this event // (Web Audio API via HuddleContext). Rust-side rodio audio // was considered but rejected: the rodio OutputStream must // outlive the handler and sharing it across the shortcut // closure adds lifecycle complexity for marginal gain. // The React implementation is sufficient and simpler. let _ = app.emit("ptt-state", true); } ShortcutState::Released => { // Capture generation at release time. let gen_at_release = ptt_press_gen.load(std::sync::atomic::Ordering::Acquire); let gen_arc = Arc::clone(&ptt_press_gen); let app_handle = app.clone(); // 200 ms release delay — captures the tail of the utterance. // Only applies if no new press happened during the delay. tauri::async_runtime::spawn(async move { tokio::time::sleep(std::time::Duration::from_millis(200)).await; // Check generation — if it changed, a new press arrived. if gen_arc.load(std::sync::atomic::Ordering::Acquire) != gen_at_release { return; // Superseded by a new press. } if let Some(state) = app_handle.try_state::() { if let Ok(hs) = state.huddle_state.lock() { hs.ptt_active .store(false, std::sync::atomic::Ordering::Release); } } // Emit ptt-state=false — React plays the release audio cue. let _ = app_handle.emit("ptt-state", false); }); } } }) .build() }); // Only register the updater in release builds that were compiled with a // real updater configuration. Local unsigned builds omit that config and // should still launch for debugging. #[cfg(buzz_updater_enabled)] let builder = if cfg!(debug_assertions) { builder } else { builder.plugin(tauri_plugin_updater::Builder::new().build()) }; #[cfg(not(buzz_updater_enabled))] let builder = builder; let shutdown_started = Arc::new(AtomicBool::new(false)); let restore_shutdown_started = Arc::clone(&shutdown_started); let app = builder .register_asynchronous_uri_scheme_protocol("buzz-media", |ctx, request, responder| { let app = ctx.app_handle().clone(); tauri::async_runtime::spawn(async move { let response = media_proxy::handle_buzz_media(&app, &request).await; responder.respond(response); }); }) .manage(build_app_state()) .manage(commands::pairing::PairingHandle::new()) .setup(move |app| { let app_handle = app.handle().clone(); let shutdown_started = Arc::clone(&restore_shutdown_started); // Run all pre-identity data migrations before state loads from disk. migration::run_boot_migrations(&app_handle); // Resolve persisted identity key (env var → file → generate+save). // This is fatal — the app should not start with an ephemeral identity // that will be lost on restart, as that silently breaks channel // memberships, DMs, and relay identity. let state = app_handle.state::(); resolve_persisted_identity(&app_handle, &state) .map_err(|e| -> Box { e.into() })?; // Sync team-dir edits and reconcile persona/team events. Needs the // resolved owner keys, so it runs after identity resolution. let owner_keys = state .keys .lock() .map(|k| k.clone()) .map_err(|e| -> Box { e.to_string().into() })?; migration::run_event_sync(&app_handle, &owner_keys); // Backfill the pinned persona snapshot for any pre-existing agent // that predates the record-authoritative-spawn cutover (persona_id // set but no source_version). Must run before // restore_managed_agents_on_launch so no agent spawns from an empty // snapshot. Synchronous and best-effort — a failure here must not // block launch, but a missing persona is logged loudly inside. if let Err(e) = backfill_persona_snapshots(&app_handle) { eprintln!("buzz-desktop: persona-snapshot backfill failed: {e}"); } // Store the AppHandle so huddle commands can emit `huddle-state-changed` // events via `huddle::emit_huddle_state` without threading the handle // through every call site. if let Ok(mut guard) = state.app_handle.lock() { *guard = Some(app_handle.clone()); } // Bring up the runtime-owned relay-mesh call-me-now listener now, // before any saved agent restore can request a connection. Its // lifetime is tied to the runtime, not a UI mount — this is what // closes the cold-launch hole-punch race. #[cfg(feature = "mesh-llm")] { let mesh_app = app_handle.clone(); tauri::async_runtime::spawn(async move { crate::mesh_llm::spawn_listener(mesh_app).await; }); } // Start the localhost media streaming proxy. Uses the shared HTTP // client so WARP tunnelling applies. The port is stored in AppState // and exposed to the frontend via the `get_media_proxy_port` command. let proxy_client = state.http_client.clone(); let proxy_handle = app_handle.clone(); tauri::async_runtime::spawn(async move { let port = media_proxy::spawn_media_proxy(proxy_client, proxy_handle.clone()).await; let state = proxy_handle.state::(); state .media_proxy_port .store(port, std::sync::atomic::Ordering::Relaxed); }); // Create the Buzz nest (~/.buzz) before agents are restored, // so default_agent_workdir() resolves to the nest directory. // Non-fatal: agents fall back to $HOME if nest creation fails. if let Err(error) = ensure_nest() { eprintln!("buzz-desktop: failed to create nest: {error}"); } // Resolve the REPOS symlink from the persisted repos_dir BEFORE // agents are restored below, and decide whether restore is safe. // The frontend's apply_workspace runs only after React mounts — // later than the async agent restore — so without this an agent // could clone into the empty real REPOS dir, and once REPOS is // non-empty ensure_repos_symlink refuses forever. resolve_repos_at_boot // fails closed: if a repos_dir was configured but its symlink could // not be resolved (transiently unavailable external volume), it // returns false so we skip restore this launch rather than let an // agent clone into the wrong REPOS. See managed_agents::repos. let restore_agents = match managed_agents::nest_dir() { Some(nest) => managed_agents::resolve_repos_at_boot(&nest), None => true, }; // Carry the agent's knowledge from the legacy nest (~/.sprout) into // the live nest (~/.buzz) after it exists. Must run after // ensure_nest() so the destination is present. Non-fatal. // On a real migration, emit a one-time hint so the user can delete // the now-inert ~/.sprout; the frontend dedupes the toast. if migration::migrate_legacy_nest() { let _ = app_handle.emit("legacy-nest-migrated", ()); } // Create/update the local CLI symlink pointing to the // bundled CLI binary. Non-fatal: agents find CLI via PATH. if let Ok(exe) = std::env::current_exe() { if let Some(parent) = exe.parent() { if let Err(error) = managed_agents::ensure_cli_symlink(parent) { eprintln!("buzz-desktop: failed to create CLI symlink: {error}"); } } } try_regenerate_nest(&app_handle); if let Some(mgr) = huddle::models::global_model_manager() { mgr.start_stt_download(state.http_client.clone()); mgr.start_tts_download(state.http_client.clone()); } // Handle deep link URLs received while the app is running (macOS) // and on cold start. The single-instance plugin handles forwarding // from duplicate launches on Windows/Linux. #[cfg(desktop)] { use tauri_plugin_deep_link::DeepLinkExt; let dl_handle = app.handle().clone(); app.deep_link().on_open_url(move |event| { for url in event.urls() { handle_deep_link_url(&dl_handle, url.as_str()); } }); } // Keep launch-time agent restoration off the synchronous setup path // so the frontend can mount and reveal the window promptly. Gated on // the boot-time repos symlink result (see restore_agents above): // skip when a configured repos_dir could not be resolved, so no // agent clones into a REPOS that isn't the user's target. if restore_agents { tauri::async_runtime::spawn(async move { if let Err(error) = restore_managed_agents_on_launch(&app_handle, shutdown_started.as_ref()) .await { eprintln!("buzz-desktop: failed to restore managed agents: {error}"); } }); } // Periodic sweep: reap orphaned agents from dead instances every 60s. // Catches agents that escaped both the Justfile trap and boot-time // reaping (e.g. a `just staging` Ctrl+C leak that only gets collected // by a different instance's periodic sweep). let sweep_handle = app.handle().clone(); tauri::async_runtime::spawn(async move { use std::collections::HashSet; use std::time::Duration; use tauri::Manager; let instance_id = managed_agents::current_instance_id(&sweep_handle); let state = sweep_handle.state::(); // Two-tick grace: only reap same-instance orphans seen on two // consecutive sweeps. Prevents killing a legitimately-starting // agent that spawned between the skip-list snapshot and the scan. let mut prev_orphans: HashSet = HashSet::new(); loop { tokio::time::sleep(Duration::from_secs(60)).await; // Collect PIDs of our own live agents to avoid killing them. let skip_pids: Vec = state .managed_agent_processes .lock() .map(|runtimes| runtimes.values().map(|rt| rt.child.id()).collect()) .unwrap_or_default(); let prev = prev_orphans.clone(); let inst = instance_id.clone(); // Run the blocking syscall work off the async executor. let new_orphans = tauri::async_runtime::spawn_blocking(move || { let orphans = managed_agents::sweep_system_agent_processes_with_grace( &inst, &skip_pids, &prev, ); managed_agents::reap_dead_instance_agents(&inst, &skip_pids); orphans }) .await .unwrap_or_default(); prev_orphans = new_orphans; } }); // Drain events the retention store flagged `pending_sync` (UI // create/edit, delete tombstones, launch reconcile) to the relay. // One loop is the sole publisher for persona, team, and managed- // agent writers; a relay-unreachable tick leaves rows pending for // the next sweep. let flush_handle = app.handle().clone(); tauri::async_runtime::spawn(async move { use std::time::Duration; use tauri::Manager; let Ok(db_path) = managed_agents::managed_agents_base_dir(&flush_handle) .map(|d| d.join("retention.db")) else { eprintln!("buzz-desktop: event-flush: cannot resolve retention db path"); return; }; loop { let state = flush_handle.state::(); if let Err(e) = managed_agents::persona_events::flush_pending_events(&db_path, &state).await { eprintln!("buzz-desktop: event-flush: {e}"); } tokio::time::sleep(Duration::from_secs(30)).await; } }); Ok(()) }) .invoke_handler(tauri::generate_handler![ get_identity, get_nsec, import_identity, get_profile, update_profile, get_user_profile, get_users_batch, get_user_notes, search_users, get_presence, get_default_relay_url, get_legacy_workspace_storage, is_shared_identity, get_relay_ws_url, get_relay_http_url, get_media_proxy_port, fetch_link_preview_title, discover_acp_providers, install_acp_runtime, discover_managed_agent_prereqs, sign_event, decrypt_observer_event, build_observer_control_event, create_auth_event, nip44_encrypt_to_self, nip44_decrypt_from_self, get_channels, create_channel, open_dm, hide_dm, get_channel_details, get_channel_members, update_channel, set_channel_topic, set_channel_purpose, archive_channel, unarchive_channel, delete_channel, add_channel_members, remove_channel_member, change_channel_member_role, join_channel, leave_channel, get_canvas, set_canvas, get_feed, search_messages, send_channel_message, send_managed_agent_channel_message, get_forum_posts, get_forum_thread, edit_message, delete_message, add_reaction, remove_reaction, get_event, show_native_notification, upload_media, pick_and_upload_media, upload_media_bytes, download_image, download_file, list_relay_members, get_my_relay_membership, add_relay_member, remove_relay_member, change_relay_member_role, archive_identity, unarchive_identity, list_archived_identities, resolve_oa_owner, list_relay_agents, list_managed_agents, create_managed_agent, start_managed_agent, stop_managed_agent, set_managed_agent_start_on_app_launch, delete_managed_agent, get_managed_agent_log, get_agent_models, discover_agent_models, get_agent_config_surface, put_agent_session_config, mesh_availability, mesh_start_node, mesh_ensure_client_node, mesh_prepare_relay_mesh_client, mesh_dial_endpoint_addr, mesh_status_report_payload, mesh_stop_node, mesh_node_status, mesh_installed_models, mesh_agent_preset, update_managed_agent, discover_backend_providers, probe_backend_provider, list_personas, create_persona, update_persona, delete_persona, set_persona_active, reconcile_inbound_persona_event, list_channel_templates, create_channel_template, update_channel_template, delete_channel_template, duplicate_channel_template, list_teams, create_team, update_team, delete_team, install_team_from_directory, sync_team_directory, pick_team_directory, export_team_to_json, parse_team_file, parse_persona_files, export_persona_to_json, get_channel_workflows, get_workflow, create_workflow, update_workflow, delete_workflow, get_workflow_runs, get_run_approvals, trigger_workflow, grant_approval, deny_approval, publish_note, get_contact_list, set_contact_list, get_notes_timeline, get_global_notes, get_note, get_note_reactions, get_liked_notes, start_huddle, join_huddle, leave_huddle, end_huddle, get_huddle_state, push_audio_pcm, start_stt_pipeline, set_huddle_transcription_enabled, download_voice_models, get_model_status, set_tts_enabled, speak_agent_message, add_agent_to_huddle, check_pipeline_hotstart, confirm_huddle_active, perform_sidebar_default_haptic, get_huddle_agent_pubkeys, set_voice_input_mode, get_voice_input_mode, list_audio_output_devices, set_audio_output_device, get_audio_output_device, start_pairing, confirm_pairing_sas, cancel_pairing, apply_workspace, validate_repos_dir, get_active_workspace, set_prevent_sleep_active, get_agent_memory, relay_reconnect_hook, ]) .build(tauri::generate_context!()) .expect("error while building tauri application"); let shutdown_done = Arc::new(AtomicBool::new(false)); // Agent cleanup on SIGINT (Ctrl+C), SIGTERM, and SIGHUP (terminal close). // The ctrlc crate with the "termination" feature covers all three signals // and runs the handler on a dedicated thread (safe for mutex operations). // `shutdown_done` prevents double-execution with the RunEvent handler. // `process::exit(0)` intentionally skips Drop impls to avoid re-entrant // locking in destructors during signal teardown. #[cfg(unix)] { let signal_app = app.handle().clone(); let signal_shutdown_done = Arc::clone(&shutdown_done); let signal_shutdown_started = Arc::clone(&shutdown_started); if let Err(e) = ctrlc::set_handler(move || { signal_shutdown_started.store(true, Ordering::SeqCst); if !signal_shutdown_done.swap(true, Ordering::SeqCst) { let _ = shutdown_managed_agents(&signal_app); } std::process::exit(0); }) { eprintln!("buzz-desktop: failed to register signal handler: {e}"); } } let run_shutdown_done = Arc::clone(&shutdown_done); app.run(move |app_handle, event| match event { RunEvent::ExitRequested { .. } | RunEvent::Exit => { shutdown_started.store(true, Ordering::SeqCst); if !run_shutdown_done.swap(true, Ordering::SeqCst) { prevent_sleep::release(&app_handle.state::().prevent_sleep); if let Err(error) = shutdown_managed_agents(app_handle) { eprintln!("buzz-desktop: failed to stop managed agents: {error}"); } } } _ => {} }); }