entracte_lib/

lib.rs

mod audio;
mod camera;
mod chores_store;
pub mod cli;
mod config;
mod diagnostics;
mod dnd;
mod hooks;
mod ipc;
mod license_redact;
mod media;
mod notifications;
mod pause_store;
mod platform;
mod plugin_store;
mod plugins;
mod proc;
mod proc_match;
mod renderer_log;
mod scheduler;
mod screen_time_store;
mod secure_io;
mod stats;
pub mod supporter;
#[cfg(test)]
mod test_support;
mod tray;
mod updater;
mod video;
mod window;

use scheduler::Scheduler;
use tauri::{Manager, WindowEvent};
use tauri_plugin_autostart::MacosLauncher;
use tauri_plugin_log::{Target, TargetKind};

pub fn should_hide_on_close(window_label: &str) -> bool {
    window_label == "main"
}

/// Extract the executable path an autostart LaunchAgent will launch — the
/// first `<string>` inside its `ProgramArguments` array.
#[cfg(any(target_os = "macos", test))]
fn launch_agent_program_path(plist: &str) -> Option<String> {
    let after_key = plist.split("ProgramArguments").nth(1)?;
    let open = after_key.find("<string>")? + "<string>".len();
    let rest = &after_key[open..];
    let close = rest.find("</string>")?;
    Some(rest[..close].trim().to_string())
}

/// True when an existing autostart LaunchAgent points at a different
/// executable than the running one. The `auto-launch` crate's
/// `is_enabled()` only checks that the plist exists — never that its path
/// is current — and it keys the plist by product name, so a plist written
/// by another build sharing that name (e.g. a dev binary) silently keeps
/// launching the wrong executable. Detecting the mismatch lets us rewrite it.
#[cfg(any(target_os = "macos", test))]
fn autostart_agent_is_stale(plist: &str, current_exe: &str) -> bool {
    launch_agent_program_path(plist).is_some_and(|p| p != current_exe)
}

/// True when the running executable lives inside a Cargo build tree
/// (`.../target/debug/...` or `.../target/release/...`). Such a binary is a
/// transient dev or CI build, never an installed app, so it must not claim
/// the autostart LaunchAgent. Without this guard a locally-built bundle that
/// repoints autostart to itself hijacks it from the installed app and
/// re-asserts every login — the user then keeps launching the stale build
/// (e.g. the pre-fix invisible overlay of #196/#226) instead of the release
/// they installed.
#[cfg(any(target_os = "macos", test))]
fn is_dev_build_path(exe: &str) -> bool {
    exe.contains("/target/debug/") || exe.contains("/target/release/")
}

/// Repoint the autostart LaunchAgent at the running executable when it was
/// written by a different build. Only the path decisions carry logic
/// ([`autostart_agent_is_stale`], [`is_dev_build_path`]); the rest is
/// filesystem/plugin glue.
#[cfg(target_os = "macos")]
fn repoint_stale_autostart_agent(app: &tauri::App) {
    use tauri_plugin_autostart::ManagerExt;
    let manager = app.autolaunch();
    if !manager.is_enabled().unwrap_or(false) {
        return;
    }
    let Ok(home) = app.path().home_dir() else {
        return;
    };
    let plist = home
        .join("Library/LaunchAgents")
        .join(format!("{}.plist", app.package_info().name));
    let Ok(contents) = std::fs::read_to_string(&plist) else {
        return;
    };
    let Ok(exe) = std::env::current_exe().and_then(|p| p.canonicalize()) else {
        return;
    };
    let exe = exe.display().to_string();
    // A build running from a Cargo target tree is never the installed app, so
    // leave autostart alone: a locally-built bundle that claimed it would
    // hijack the LaunchAgent from the real install and re-assert every login.
    // The installed app repoints correctly when it next runs.
    if is_dev_build_path(&exe) {
        log::debug!("autostart: running from a build tree; leaving the LaunchAgent untouched");
        return;
    }
    if autostart_agent_is_stale(&contents, &exe) {
        log::warn!(
            "autostart: LaunchAgent points at a stale executable; repointing to current binary"
        );
        let _ = manager.disable();
        if let Err(e) = manager.enable() {
            log::warn!("autostart: failed to repoint LaunchAgent: {e}");
        }
    }
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    let log_level = if cfg!(debug_assertions) {
        log::LevelFilter::Debug
    } else {
        log::LevelFilter::Info
    };

    let mut log_targets = vec![Target::new(TargetKind::LogDir {
        file_name: Some("entracte".to_string()),
    })];
    if cfg!(debug_assertions) {
        log_targets.push(Target::new(TargetKind::Stdout));
        log_targets.push(Target::new(TargetKind::Stderr));
    }

    let logger = tauri_plugin_log::Builder::new()
        .targets(log_targets)
        .level(log_level)
        .max_file_size(1024 * 1024)
        .rotation_strategy(tauri_plugin_log::RotationStrategy::KeepSome(5))
        .build();

    tauri::Builder::default()
        .on_window_event(|window, event| {
            if let WindowEvent::CloseRequested { api, .. } = event {
                if should_hide_on_close(window.label()) {
                    api.prevent_close();
                    let _ = window.hide();
                }
            }
        })
        .plugin(tauri_plugin_single_instance::init(|app, argv, _cwd| {
            handle_cli_argv(app, argv);
        }))
        .plugin(logger)
        .plugin(tauri_plugin_opener::init())
        .plugin(tauri_plugin_dialog::init())
        .plugin(tauri_plugin_notification::init())
        .plugin(tauri_plugin_updater::Builder::new().build())
        .plugin(tauri_plugin_autostart::init(
            MacosLauncher::LaunchAgent,
            None,
        ))
        .plugin(tauri_plugin_global_shortcut::Builder::new().build())
        .invoke_handler(tauri::generate_handler![
            scheduler::get_settings,
            scheduler::update_settings,
            scheduler::get_onboarding_completed,
            scheduler::complete_onboarding,
            scheduler::set_hooks,
            scheduler::test_hook,
            scheduler::pause,
            scheduler::resume,
            scheduler::export_backup_to_path,
            scheduler::import_backup_from_path,
            scheduler::import_content_pack,
            scheduler::export_content_pack,
            scheduler::install_plugin,
            scheduler::uninstall_plugin,
            scheduler::list_plugins,
            scheduler::get_pause_info,
            scheduler::end_break,
            scheduler::trigger_test_break,
            scheduler::notify_overlay_rendered,
            scheduler::postpone_break,
            scheduler::skip_next_break,
            scheduler::get_postpone_state,
            scheduler::get_last_break_info,
            scheduler::resume_last_break,
            scheduler::start_long_break_now,
            scheduler::get_break_stats,
            scheduler::get_current_break,
            scheduler::get_routines,
            scheduler::reset_break_stats,
            scheduler::get_stats_digest,
            scheduler::export_stats_csv,
            scheduler::clear_event_log,
            scheduler::get_idle_secs,
            scheduler::get_screen_time,
            scheduler::get_chores,
            scheduler::set_chores,
            scheduler::list_profiles,
            scheduler::get_active_profile,
            scheduler::set_active_profile,
            scheduler::create_profile,
            scheduler::duplicate_profile,
            scheduler::rename_profile,
            scheduler::delete_profile,
            scheduler::reorder_profiles,
            scheduler::reset_profile_to_defaults,
            updater::check_for_update,
            diagnostics::build_diagnostics_report,
            platform::get_platform,
            platform::get_arch,
            platform::get_platform_capabilities,
            platform::get_locale,
            window::close_pause_window,
            renderer_log::report_renderer_error,
            audio::play_sound,
            audio::play_custom_sound,
            audio::start_ambient,
            audio::start_custom_ambient,
            audio::preview_ambient,
            audio::preview_custom_ambient,
            audio::stop_ambient,
            audio::stop_all_sounds,
            get_supporter_status,
            verify_supporter_key,
            remove_supporter,
        ])
        .setup(|app| {
            #[cfg(target_os = "macos")]
            {
                app.set_activation_policy(tauri::ActivationPolicy::Accessory);
                repoint_stale_autostart_agent(app);
            }

            notifications::ensure_permission_requested(app.handle());

            let config_dir = app
                .path()
                .app_config_dir()
                .expect("app_config_dir resolves");
            let _ = secure_io::ensure_user_only_dir(&config_dir);
            let config_path = config_dir.join("settings.json");
            let pause_path = config_dir.join("pause.json");
            let data_dir = app
                .path()
                .app_data_dir()
                .unwrap_or_else(|_| config_dir.clone());
            let _ = secure_io::ensure_user_only_dir(&data_dir);
            if let Ok(log_dir) = app.path().app_log_dir() {
                let _ = secure_io::ensure_user_only_dir(&log_dir);
                let _ = secure_io::tighten_existing_files_in_dir(&log_dir);
                // The log plugin rotates files asynchronously with the
                // process umask, so a startup-only tighten misses every
                // rotation that happens after boot. Re-tighten once a
                // minute for the process lifetime.
                secure_io::spawn_periodic_dir_tighten(log_dir, std::time::Duration::from_secs(60));
            }
            let events_path = data_dir.join("events.jsonl");
            let _ = secure_io::tighten_existing_file(&events_path);
            let screen_time_path = data_dir.join("screen_time.json");
            let chores_path = data_dir.join("chores.json");
            // `stats::append_one` only sets mode at file creation, so
            // a file recreated through migration / `cp` / restore
            // would otherwise keep the process umask until next
            // restart. Sweep the data dir at the same cadence as
            // log_dir so events.jsonl, screen_time.json, and
            // supporter.json converge back to 0o600 in-process.
            secure_io::spawn_periodic_dir_tighten(
                data_dir.clone(),
                std::time::Duration::from_secs(60),
            );

            let scheduler = Scheduler::new(
                config_path,
                pause_path,
                events_path,
                screen_time_path,
                chores_path,
            );
            // Snapshot the loaded settings before `spawn` so the run loop
            // can't be holding the lock — used to register global hotkeys
            // once the app is up.
            let initial_settings = scheduler.settings.try_lock().map(|s| s.clone()).ok();
            scheduler.spawn(app.handle().clone());
            app.manage(scheduler);

            if let Some(settings) = initial_settings {
                scheduler::apply_hotkeys(app.handle(), &settings);
                // Opt-in: silently check for a newer build once at launch and
                // post a non-intrusive notification if one is available (#238).
                updater::spawn_startup_check(app.handle().clone(), &settings);
            }

            app.manage(audio::AudioPlayer::spawn());

            let supporter_path = supporter::file_path(&data_dir);
            app.manage(SupporterAppState {
                path: supporter_path.clone(),
                client: reqwest::Client::new(),
            });
            spawn_supporter_revalidation(supporter_path);

            tray::setup(app.handle())?;

            if let Err(e) = ipc::start_server(app.handle().clone(), data_dir.clone()) {
                log::warn!("ipc: failed to start server: {e}");
            }

            diagnostics::log_startup_banner(app.handle());
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

fn handle_cli_argv(app: &tauri::AppHandle, argv: Vec<String>) {
    window::show_main_window(app);
    if argv.len() > 1 {
        log::debug!(
            "cli: single-instance second invocation received args {:?} \
             — these route via the local TCP IPC channel, not single-instance forwarding",
            &argv[1..]
        );
    }
}

pub struct SupporterAppState {
    pub path: std::path::PathBuf,
    pub client: reqwest::Client,
}

fn spawn_supporter_revalidation(path: std::path::PathBuf) {
    tauri::async_runtime::spawn(async move {
        let client = reqwest::Client::new();
        loop {
            let Some(record) = supporter::load(&path) else {
                tokio::time::sleep(std::time::Duration::from_secs(60 * 60 * 24)).await;
                continue;
            };
            if supporter::needs_remote_revalidation(&record, chrono::Utc::now()) {
                match supporter::validate_remote(&client, &record.license_key, &record.instance_id)
                    .await
                {
                    Ok(true) => {
                        let mut updated = record.clone();
                        updated.last_validated_at = chrono::Utc::now();
                        if let Err(e) = supporter::save(&path, &updated) {
                            log::warn!("supporter: failed to persist validation timestamp: {e}");
                        }
                    }
                    Ok(false) => {
                        log::warn!("supporter: license no longer valid, removing local record");
                        let _ = supporter::delete(&path);
                    }
                    Err(e) => {
                        log::warn!("supporter: validate request failed: {e}");
                    }
                }
            }
            tokio::time::sleep(std::time::Duration::from_secs(60 * 60 * 24)).await;
        }
    });
}

#[tauri::command]
async fn get_supporter_status(
    state: tauri::State<'_, SupporterAppState>,
) -> Result<supporter::SupporterStatus, String> {
    let record = supporter::load(&state.path);
    Ok(supporter::SupporterStatus::from_record(
        record.as_ref(),
        chrono::Utc::now(),
    ))
}

#[tauri::command]
async fn verify_supporter_key(
    state: tauri::State<'_, SupporterAppState>,
    license_key: String,
) -> Result<supporter::SupporterStatus, String> {
    let host = sysinfo::System::host_name().unwrap_or_else(|| "entracte-machine".to_string());
    let instance_name = format!("entracte-{host}");
    let now = chrono::Utc::now();
    let record = supporter::activate_with(
        &state.path,
        &state.client,
        &license_key,
        &instance_name,
        now,
    )
    .await?;
    Ok(supporter::SupporterStatus::from_record(Some(&record), now))
}

#[tauri::command]
async fn remove_supporter(
    state: tauri::State<'_, SupporterAppState>,
) -> Result<supporter::SupporterStatus, String> {
    supporter::delete(&state.path).map_err(|e| e.to_string())?;
    Ok(supporter::SupporterStatus::from_record(
        None,
        chrono::Utc::now(),
    ))
}

#[cfg(test)]
mod tests {
    use super::should_hide_on_close;

    #[test]
    fn main_window_hides_on_close() {
        assert!(should_hide_on_close("main"));
    }

    #[test]
    fn overlay_windows_destroy_on_close() {
        assert!(!should_hide_on_close("overlay-0"));
        assert!(!should_hide_on_close("overlay-1"));
        assert!(!should_hide_on_close("overlay-7"));
    }

    #[test]
    fn unknown_labels_destroy_on_close() {
        assert!(!should_hide_on_close(""));
        assert!(!should_hide_on_close("Main"));
        assert!(!should_hide_on_close("main "));
        assert!(!should_hide_on_close(" main"));
        assert!(!should_hide_on_close("settings"));
        assert!(!should_hide_on_close("preferences"));
    }

    const EXE: &str = "/Applications/Entracte.app/Contents/MacOS/entracte";

    fn plist_for(program: &str) -> String {
        format!(
            "<?xml version=\"1.0\"?>\n<plist version=\"1.0\"><dict>\
             <key>Label</key><string>Entracte</string>\
             <key>ProgramArguments</key><array><string>{program}</string></array>\
             <key>RunAtLoad</key><true/></dict></plist>"
        )
    }

    #[test]
    fn program_path_extracts_first_argument() {
        assert_eq!(
            super::launch_agent_program_path(&plist_for(EXE)).as_deref(),
            Some(EXE)
        );
    }

    #[test]
    fn program_path_is_none_without_program_arguments() {
        assert_eq!(super::launch_agent_program_path("<plist></plist>"), None);
    }

    #[test]
    fn agent_is_stale_when_path_differs() {
        let plist = plist_for("/Users/dev/workspace/breakly/target/debug/entracte");
        assert!(super::autostart_agent_is_stale(&plist, EXE));
    }

    #[test]
    fn agent_is_not_stale_when_path_matches() {
        assert!(!super::autostart_agent_is_stale(&plist_for(EXE), EXE));
    }

    #[test]
    fn agent_is_not_stale_without_program_arguments() {
        assert!(!super::autostart_agent_is_stale("<plist/>", EXE));
    }

    #[test]
    fn dev_build_path_detects_cargo_target_tree() {
        assert!(super::is_dev_build_path(
            "/Users/dev/workspace/entracte/src-tauri/target/release/bundle/macos/\
             Entracte.app/Contents/MacOS/entracte"
        ));
        assert!(super::is_dev_build_path(
            "/Users/dev/entracte/src-tauri/target/debug/entracte"
        ));
    }

    #[test]
    fn dev_build_path_false_for_installed_app() {
        assert!(!super::is_dev_build_path(EXE));
        assert!(!super::is_dev_build_path(
            "/Users/me/Applications/Entracte.app/Contents/MacOS/entracte"
        ));
    }
}