Function collect_console

src/commands/console.rs:9–43

(
    client: &mut CdpClient,
    session_id: &str,
    duration_ms: u64,
    type_filter: Vec<String>,
    format: OutputFormat,
)

use crate::result::CommandResult;

pub async fn collect_console(
    client: &mut CdpClient,
    session_id: &str,
    duration_ms: u64,
    type_filter: Vec<String>,
    format: OutputFormat,
) -> Result<CommandResult> {
    let events = if duration_ms == 0 {
        // Drain mode: return accumulated events from the persistent session.
        client.drain_console_events()
    } else if client.persistent_session.is_some() {
        // Live mode, daemon: the persistent session already has Runtime enabled
        // and push_event accumulates its events into console_events. Read for the
        // window so they land in the buffer, then drain the buffer as the single
        // source of truth. Draining also consumes them, so a later drain can't
        // repeat them (read_events_for's own return value would double-count).
        client.read_events_for(duration_ms).await?;
        client.drain_console_events()
    } else {
        // Live mode, direct/fallback: no persistent buffer. Enable Runtime on our
        // own session, collect for the window, disable, and return what we read.
        client
            .send_to_target(session_id, "Runtime.enable", json!({}))
            .await?;
        let events_result = client.read_events_for(duration_ms).await;
        let _ = client
            .send_to_target(session_id, "Runtime.disable", json!({}))
            .await;
        events_result?
    };

    let messages = process_console_events(&events, &type_filter);

    format_console_output(&messages, format)
}

fn process_console_events(
    events: &[serde_json::Value],