mi6_cli/

lib.rs

// CLI crate needs stdout/stderr for user interaction
#![allow(clippy::print_stdout, clippy::print_stderr)]

mod args;
pub mod commands;
pub mod display;
mod error;
mod help;

pub use help::{print_command_help, print_help, print_subcommand_help};

use anyhow::{Context, Result};
use mi6_core::{CodexSessionScanner, Storage, StorageError, TranscriptScanner};

pub use args::{Cli, Commands, IngestCommands, OtelCommands, TuiArgs, UpgradeMethod};
pub use commands::{UpdateInfo, check_for_update};

/// Result of running a CLI command.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RunResult {
    /// Command completed successfully
    Success,
    /// Command requests the process to exit with the given code
    ExitWithCode(i32),
    /// Caller should launch the TUI with the provided arguments
    RunTui(TuiArgs),
}

/// Run the CLI with a storage factory.
///
/// The factory is only called when a command needs storage.
/// Returns `RunResult::RunTui` when the TUI should be launched (caller handles this).
pub fn run<S, F>(cli: Cli, storage_factory: F) -> Result<RunResult>
where
    S: Storage,
    F: FnOnce() -> Result<S, StorageError>,
{
    // Handle TUI mode: either no command or explicit `tui` subcommand
    let command = match cli.command {
        None => return Ok(RunResult::RunTui(cli.tui_args)),
        Some(Commands::Tui(args)) => return Ok(RunResult::RunTui(args)),
        Some(cmd) => cmd,
    };

    match command {
        Commands::Tui(_) => unreachable!("handled above"),

        Commands::Enable {
            frameworks,
            local,
            settings_local,
            print,
            db_only,
            hooks_only,
            otel,
            otel_port,
            no_otel,
        } => {
            let result = commands::run_enable(commands::EnableCliOptions {
                frameworks,
                local,
                settings_local,
                print,
                db_only,
                hooks_only,
                otel,
                otel_port,
                no_otel,
            })?;

            if result.should_init_db
                && let Some(ref db_path) = result.db_path
            {
                let db_existed = db_path.exists();
                let _ = storage_factory().context("failed to initialize storage")?;
                if !db_existed {
                    eprintln!("Database initialized at: {}", db_path.display());
                }
            }

            if !print {
                eprintln!("\nSessions may need to be restarted to use the new configuration.");
            }

            Ok(RunResult::Success)
        }

        Commands::Disable {
            frameworks,
            local,
            settings_local,
            print,
        } => {
            commands::run_disable(commands::DisableOptions {
                frameworks,
                local,
                settings_local,
                print,
            })?;
            Ok(RunResult::Success)
        }

        Commands::Ingest(ingest_cmd) => run_ingest(ingest_cmd, storage_factory),

        Commands::Session {
            session_or_pid,
            machine,
            json,
            fields,
        } => {
            let storage = storage_factory().context("failed to open storage")?;
            commands::run_session(&storage, session_or_pid, machine, json, fields)?;
            Ok(RunResult::Success)
        }

        Commands::Status {
            json,
            verbose,
            check,
        } => {
            commands::run_status_command(json, verbose, check)?;
            Ok(RunResult::Success)
        }

        Commands::Watch {
            session,
            event_type,
            mode,
            framework,
            poll_ms,
        } => {
            let storage = storage_factory().context("failed to open storage")?;
            commands::run_watch(
                &storage,
                commands::WatchOptions {
                    session,
                    event_type,
                    permission_mode: mode,
                    framework,
                    poll_ms,
                },
            )?;
            Ok(RunResult::Success)
        }

        Commands::Cleanup { dry_run } => {
            let storage = storage_factory().context("failed to open storage")?;
            commands::run_cleanup(&storage, dry_run)?;
            Ok(RunResult::Success)
        }

        Commands::Otel(otel_cmd) => run_otel(otel_cmd, storage_factory),

        Commands::Upgrade {
            version,
            yes,
            dry_run,
            method,
            source_path,
        } => {
            commands::run_upgrade(commands::UpgradeOptions {
                version,
                yes,
                dry_run,
                method,
                source_path,
            })?;
            Ok(RunResult::Success)
        }

        Commands::Uninstall {
            yes,
            keep_data,
            dry_run,
        } => {
            commands::run_uninstall(commands::UninstallOptions {
                yes,
                keep_data,
                dry_run,
            })?;
            Ok(RunResult::Success)
        }
    }
}

/// Handle ingest subcommands.
fn run_ingest<S, F>(cmd: IngestCommands, storage_factory: F) -> Result<RunResult>
where
    S: Storage,
    F: FnOnce() -> Result<S, StorageError>,
{
    match cmd {
        IngestCommands::Event {
            event_type,
            json_payload,
            framework,
            ping,
        } => {
            // Handle ping mode: just verify the command can be invoked, then exit
            if ping {
                println!("pong");
                return Ok(RunResult::Success);
            }

            // The event ingest is called by AI assistant hooks during tool execution.
            // It must always exit 0 to avoid blocking the workflow, even if logging fails.
            // Errors are printed to stderr for debugging but don't affect the exit code.
            let result: Result<(), anyhow::Error> = (|| {
                let storage = storage_factory().context("failed to open storage")?;
                let log_result =
                    commands::run_log(&storage, event_type, json_payload, framework.clone())?;

                // Scan transcript file after every hook (if path is available)
                // This is cheap due to incremental position tracking
                if let Some(ref path) = log_result.transcript_path {
                    let scanner = TranscriptScanner::new(&storage, &log_result.machine_id);
                    if let Err(e) = scanner.scan_file(std::path::Path::new(path)) {
                        eprintln!("mi6: warning: failed to scan transcript: {e:#}");
                    }

                    // Backfill initial prompt if the UserPromptSubmit hook didn't fire
                    // (e.g., when Claude is started with an inline prompt like `claude 'prompt'`)
                    if let Err(e) = scanner
                        .backfill_initial_prompt(&log_result.session_id, std::path::Path::new(path))
                    {
                        eprintln!("mi6: warning: failed to backfill initial prompt: {e:#}");
                    }
                }

                // Scan Codex session file after every Codex hook event
                // This fills in token counts, tool calls, and other data that hooks don't provide
                if framework.as_deref() == Some("codex") {
                    let scanner = CodexSessionScanner::new(&storage, &log_result.machine_id);
                    if let Err(e) = scanner.scan_session(&log_result.session_id) {
                        eprintln!("mi6: warning: failed to scan codex session: {e:#}");
                    }
                }

                Ok(())
            })();

            if let Err(e) = result {
                eprintln!("mi6: {:#}", e);
            }
            Ok(RunResult::ExitWithCode(0))
        }

        IngestCommands::Transcript { path } => {
            let storage = storage_factory().context("failed to open storage")?;
            commands::run_scan(&storage, &path)?;
            Ok(RunResult::Success)
        }

        IngestCommands::CodexSession {
            session_or_path,
            file,
        } => {
            let storage = storage_factory().context("failed to open storage")?;
            if file {
                commands::run_codex_session_scan_file(
                    &storage,
                    std::path::Path::new(&session_or_path),
                )?;
            } else {
                commands::run_codex_session_scan_by_id(&storage, &session_or_path)?;
            }
            Ok(RunResult::Success)
        }

        IngestCommands::Otel => {
            let storage = storage_factory().context("failed to open storage")?;
            commands::run_otel_ingest(&storage)?;
            Ok(RunResult::Success)
        }
    }
}

/// Handle otel subcommands.
fn run_otel<S, F>(cmd: OtelCommands, storage_factory: F) -> Result<RunResult>
where
    S: Storage,
    F: FnOnce() -> Result<S, StorageError>,
{
    match cmd {
        OtelCommands::Start { port, mode } => {
            if commands::ensure_running(port, false, mode)? {
                eprintln!("OTel server is running on port {}", port);
            }
            Ok(RunResult::Success)
        }
        OtelCommands::Stop { port } => {
            commands::stop_server(port)?;
            Ok(RunResult::Success)
        }
        OtelCommands::Restart { port, mode } => {
            if commands::ensure_running(port, true, mode)? {
                eprintln!("OTel server restarted on port {}", port);
            }
            Ok(RunResult::Success)
        }
        OtelCommands::Status { port } => {
            commands::get_status(port)?;
            Ok(RunResult::Success)
        }
        OtelCommands::Run { port, mode } => {
            let storage = storage_factory().context("failed to open storage")?;
            commands::run_server(&storage, port, mode)?;
            Ok(RunResult::Success)
        }
    }
}