omni-dev 0.46.0

use std::process;
use std::time::Instant;

use clap::{CommandFactory, Parser};
use omni_dev::request_log::{self, InvocationOutcome, RequestLogContext, Source};
use omni_dev::Cli;

fn main() {
    // Capture argv before clap consumes it, so the invocation record can log the
    // full command line and the resolved subcommand path — and so tracing can be
    // initialized at the right default level for the resolved command *before* any
    // log line is emitted.
    let argv: Vec<String> = std::env::args().collect();
    let command = resolve_command_path(&argv);
    let daemon_run = is_daemon_run(&command);

    // The long-lived `daemon run` defaults to `info` so its lifecycle events reach
    // the log sink; short-lived CLI invocations stay at `warn`. `RUST_LOG` still
    // overrides either. See #1316.
    init_tracing(daemon_run);

    let cli = Cli::parse();

    // Install the per-invocation context up front — crucially *before* the macOS
    // menu-bar handoff below, which `return`s without ever reaching the common
    // path. Otherwise a tray-hosted daemon's `gh`/HTTP records would default to
    // `Source::Cli` instead of `Daemon` (#1387). `daemon run` → Daemon, else Cli;
    // set_global is first-write-wins.
    let source = if daemon_run {
        Source::Daemon
    } else {
        Source::Cli
    };
    request_log::set_global(RequestLogContext {
        invocation_id: request_log::new_id(),
        source,
        mcp_tool: None,
    });

    // The macOS menu-bar daemon needs the GUI event loop on the main thread,
    // which a tokio runtime cannot own. Detect `daemon run` (without
    // `--no-menu`) and hand the main thread to the tray; every other invocation
    // runs the async CLI on a multi-thread runtime exactly as before.
    #[cfg(all(target_os = "macos", feature = "menu-bar"))]
    if let Some(run_config) = cli.menu_bar_run_config() {
        let cfg = match run_config {
            Ok(cfg) => cfg,
            Err(e) => die(&e),
        };
        match omni_dev::daemon::tray::run(cfg) {
            Ok(()) => return,
            Err(e) => die(&e),
        }
    }

    let runtime = match tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()
    {
        Ok(runtime) => runtime,
        Err(e) => {
            eprintln!("Error: failed to start the tokio runtime: {e}");
            process::exit(1);
        }
    };

    // Time the whole command and append one invocation record after it returns.
    // Logging is best-effort and never affects the exit code. (The per-invocation
    // context was installed up front, above, before the menu-bar handoff.)
    let start = Instant::now();
    let result = runtime.block_on(cli.execute());

    let (exit_code, error) = match &result {
        Ok(()) => (0, None),
        Err(e) => (1, Some(format!("{e:#}"))),
    };
    request_log::record_invocation(InvocationOutcome {
        command,
        command_line: argv,
        exit_code,
        error,
        duration: start.elapsed(),
    });

    if let Err(e) = result {
        die(&e);
    }
}

/// Resolves the clap subcommand path (e.g. `["jira","read"]`) by re-deriving
/// matches from argv and walking the subcommand chain. Generic — robust to new
/// subcommands — and returns an empty path if re-parsing fails.
fn resolve_command_path(argv: &[String]) -> Vec<String> {
    let mut path = Vec::new();
    let Ok(matches) = Cli::command().try_get_matches_from(argv) else {
        return path;
    };
    let mut current = &matches;
    while let Some((name, sub)) = current.subcommand() {
        path.push(name.to_string());
        current = sub;
    }
    path
}

/// Whether the resolved command path is `daemon run` (the long-lived daemon).
fn is_daemon_run(command: &[String]) -> bool {
    command.first().map(String::as_str) == Some("daemon")
        && command.get(1).map(String::as_str) == Some("run")
}

/// The default tracing filter for a resolved command when `RUST_LOG` is unset:
/// `info` for the long-lived `daemon run` (so its lifecycle events — start/stop,
/// signals — reach the log sink), `warn` for every short-lived CLI invocation.
fn default_filter(daemon_run: bool) -> &'static str {
    if daemon_run {
        "info"
    } else {
        "warn"
    }
}

/// Initializes the tracing subscriber (stderr, `RUST_LOG`-driven), keeping
/// daemon/debug logs off stdout. The default level when `RUST_LOG` is unset is
/// [`default_filter`]; `RUST_LOG` still overrides it.
fn init_tracing(daemon_run: bool) {
    // Loading through the normal warning loader here would lose its warning:
    // there is no subscriber yet. Emit once after installation instead.
    let (daemon_filter, settings_error) = if daemon_run {
        daemon_filter_from(omni_dev::utils::settings::Settings::load())
    } else {
        (None, None)
    };
    let env_filter = std::env::var("RUST_LOG").ok();
    let (filter, rejected) =
        resolve_filter(daemon_run, env_filter.as_deref(), daemon_filter.as_deref());
    tracing_subscriber::fmt()
        .with_writer(std::io::stderr)
        .with_env_filter(filter)
        .init();
    emit_bootstrap_warnings(&rejected, settings_error.as_deref());
}

/// Splits a bootstrap settings load into the daemon's configured log filter and,
/// when the load failed, the error to report once tracing is installed.
fn daemon_filter_from(
    loaded: anyhow::Result<omni_dev::utils::settings::Settings>,
) -> (Option<String>, Option<String>) {
    match loaded {
        Ok(settings) => (settings.daemon.log_level, None),
        Err(error) => (None, Some(format!("{error:#}"))),
    }
}

/// Reports what could not be said before the subscriber existed: each rejected
/// filter directive, and the settings failure the bootstrap load hit.
fn emit_bootstrap_warnings(rejected: &[&str], settings_error: Option<&str>) {
    for source in rejected {
        tracing::warn!(
            source,
            "invalid tracing directive; using next filter source"
        );
    }
    if let Some(error) = settings_error {
        omni_dev::utils::settings::Settings::warn_bootstrap_failure(error);
    }
}

/// Resolves injected directives without a global subscriber or environment mutation.
fn resolve_filter(
    daemon_run: bool,
    environment: Option<&str>,
    daemon: Option<&str>,
) -> (tracing_subscriber::EnvFilter, Vec<&'static str>) {
    let mut rejected = Vec::new();
    for (source, directive) in [
        ("RUST_LOG", environment),
        ("daemon.log_level", daemon.filter(|_| daemon_run)),
    ] {
        if let Some(directive) = directive {
            match tracing_subscriber::EnvFilter::try_new(directive) {
                Ok(filter) => return (filter, rejected),
                Err(_) => rejected.push(source),
            }
        }
    }
    (
        tracing_subscriber::EnvFilter::new(default_filter(daemon_run)),
        rejected,
    )
}

/// Prints an error and its source chain to stderr, then exits non-zero.
fn die(e: &anyhow::Error) -> ! {
    eprintln!("Error: {e}");
    let mut source = e.source();
    while let Some(err) = source {
        eprintln!("  Caused by: {err}");
        source = err.source();
    }
    process::exit(1);
}

#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
    use super::*;

    fn path(parts: &[&str]) -> Vec<String> {
        parts.iter().map(|s| (*s).to_string()).collect()
    }

    #[test]
    fn is_daemon_run_matches_only_daemon_run() {
        assert!(is_daemon_run(&path(&["daemon", "run"])));
        // Trailing flags after `daemon run` still count (only the path prefix matters).
        assert!(is_daemon_run(&path(&[
            "daemon",
            "run",
            "--socket",
            "/tmp/d.sock"
        ])));
        // Other daemon subcommands are short-lived clients, not the daemon.
        assert!(!is_daemon_run(&path(&["daemon", "status"])));
        assert!(!is_daemon_run(&path(&["daemon", "start"])));
        assert!(!is_daemon_run(&path(&["daemon"])));
        assert!(!is_daemon_run(&path(&["jira", "read"])));
        assert!(!is_daemon_run(&[]));
    }

    #[test]
    fn tracing_filter_precedence_and_fallbacks() {
        for (daemon_run, env, daemon, expected, rejected) in [
            (true, Some("trace"), Some("debug"), "trace", 0),
            (true, None, Some("debug"), "debug", 0),
            (true, None, None, "info", 0),
            (false, None, Some("debug"), "warn", 0),
            (true, Some("["), Some("debug"), "debug", 1),
            (true, None, Some("["), "info", 1),
            (false, Some("["), Some("debug"), "warn", 1),
        ] {
            let (filter, errors) = resolve_filter(daemon_run, env, daemon);
            assert_eq!(filter.to_string(), expected);
            assert_eq!(errors.len(), rejected);
        }
    }

    #[test]
    fn a_failed_bootstrap_settings_load_is_carried_for_later_reporting() {
        let (filter, error) = daemon_filter_from(Err(anyhow::anyhow!("settings.json is broken")));
        assert_eq!(filter, None);
        assert_eq!(error.as_deref(), Some("settings.json is broken"));

        let settings: omni_dev::utils::settings::Settings =
            serde_json::from_str(r#"{"daemon":{"log_level":"debug"}}"#).unwrap();
        assert_eq!(
            daemon_filter_from(Ok(settings)),
            (Some("debug".to_string()), None)
        );
    }

    #[test]
    fn bootstrap_warnings_name_each_rejected_source_and_the_settings_failure() {
        use std::io::{Read, Seek};
        use std::sync::Arc;

        // A temp file is the capture buffer: `&File` is already `Write`, so no
        // custom writer is needed.
        let file = Arc::new(tempfile::tempfile().unwrap());
        let subscriber = tracing_subscriber::fmt()
            .with_max_level(tracing::Level::WARN)
            .with_ansi(false)
            .with_writer(Arc::clone(&file))
            .finish();
        tracing::subscriber::with_default(subscriber, || {
            // Nothing failed, so nothing is said.
            emit_bootstrap_warnings(&[], None);
            assert_eq!(file.metadata().unwrap().len(), 0);

            emit_bootstrap_warnings(
                &["RUST_LOG", "daemon.log_level"],
                Some("main-test bootstrap settings failure"),
            );
        });
        let mut logs = String::new();
        (&*file).rewind().unwrap();
        (&*file).read_to_string(&mut logs).unwrap();
        assert!(logs.contains("invalid tracing directive"), "{logs}");
        assert!(logs.contains("RUST_LOG"), "{logs}");
        assert!(logs.contains("daemon.log_level"), "{logs}");
        assert!(
            logs.contains("main-test bootstrap settings failure"),
            "{logs}"
        );
    }

    #[test]
    fn default_filter_is_info_only_for_daemon_run() {
        assert_eq!(default_filter(true), "info");
        assert_eq!(default_filter(false), "warn");
    }
}