Method read_events_for

src/cdp.rs:763–811

Collect CDP events for a given duration (milliseconds). Drains any already-buffered events first, then reads from the WebSocket until the timeout expires. Events are also routed through persistent session buffers when active to avoid duplicates.

(&mut self, duration_ms: u64)

    /// until the timeout expires. Events are also routed through persistent
    /// session buffers when active to avoid duplicates.
    pub async fn read_events_for(&mut self, duration_ms: u64) -> Result<Vec<Value>> {
        let mut events: Vec<Value> = self.events.drain(..).collect();
        let deadline = tokio::time::Instant::now() + std::time::Duration::from_millis(duration_ms);

        loop {
            let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
            if remaining.is_zero() {
                break;
            }
            match tokio::time::timeout(remaining, self.read_text()).await {
                Ok(Ok(text)) => {
                    if let Ok(resp) = serde_json::from_str::<Value>(&text) {
                        if let Some(method) = resp.get("method").and_then(|v| v.as_str()) {
                            // Events are routed to persistent session buffers (network_events,
                            // console_events) AND returned in the `events` vector here.
                            //
                            // In direct mode (no persistent session), we avoid pushing
                            // Network/Runtime events to the generic `self.events` buffer.
                            // This prevents them from being stashed and then returned
                            // again in a subsequent drain (double-processing).
                            let is_persistent_event = self
                                .persistent_session
                                .as_deref()
                                .is_some_and(|s| resp["sessionId"].as_str() == Some(s));
                            if is_persistent_event {
                                self.push_event(resp.clone());
                            } else if !method.starts_with("Network.")
                                && !method.starts_with("Runtime.")
                            {
                                self.push_event(resp.clone());
                            }
                            events.push(resp);
                        }
                    }
                }
                // Timeout expired — normal completion path.
                Err(_) => break,
                // read_text() itself failed (socket closed, decode error,
                // etc.) — real transport error. Log it so the user has a
                // signal when the partial result is suspicious, then stop.
                Ok(Err(e)) => {
                    eprintln!("Warning: WebSocket read failed during event collection: {e}");
                    break;
                }
            }
        }

        Ok(events)
    }

    /// Get the current page URL via JavaScript evaluation.
    pub async fn current_url(&mut self, session_id: &str) -> Result<String> {