From 046811f7b92fccea896eec66a974ff42e9b2c97f Mon Sep 17 00:00:00 2001 From: ldm0 Date: Fri, 13 Nov 2026 18:44:19 +0800 Subject: [PATCH] refactor(cdp): share local event names with schema generation --- moli-protocol-cdp-defs/src/events.rs | 210 +++++++++++++++++++ moli-protocol-cdp-defs/src/lib.rs | 6 +- moli-protocol-cdp-defs/src/support.rs | 115 ---------- moli-protocol-cdp/build.rs | 25 +++ moli-protocol-cdp/build/schema.rs | 16 +- moli-protocol-cdp/src/lib.rs | 2 +- moli-protocol-cdp/src/metadata.rs | 2 + moli-protocol-cdp/tests/protocol_metadata.rs | 20 +- 8 files changed, 270 insertions(+), 126 deletions(-) create mode 100644 moli-protocol-cdp-defs/src/events.rs diff --git a/moli-protocol-cdp-defs/src/events.rs b/moli-protocol-cdp-defs/src/events.rs new file mode 100644 index 00000000000..c29c5820838 --- /dev/null +++ b/moli-protocol-cdp-defs/src/events.rs @@ -0,0 +1,210 @@ +//! Event names generated locally by Moli. V8 notifications are selected from its pinned schema. + +#[derive(Clone, Copy, Debug, Eq, PartialEq, strum::VariantNames, strum::IntoStaticStr)] +pub enum LocalCdpEvent { + #[strum(serialize = "Audits.issueAdded")] + AuditsIssueAdded, + #[strum(serialize = "Browser.downloadProgress")] + BrowserDownloadProgress, + #[strum(serialize = "Browser.downloadWillBegin")] + BrowserDownloadWillBegin, + #[strum(serialize = "CSS.styleSheetAdded")] + CssStyleSheetAdded, + #[strum(serialize = "CSS.styleSheetRemoved")] + CssStyleSheetRemoved, + #[strum(serialize = "Console.messageAdded")] + ConsoleMessageAdded, + #[strum(serialize = "DOM.attributeModified")] + DomAttributeModified, + #[strum(serialize = "DOM.attributeRemoved")] + DomAttributeRemoved, + #[strum(serialize = "DOM.characterDataModified")] + DomCharacterDataModified, + #[strum(serialize = "DOM.childNodeCountUpdated")] + DomChildNodeCountUpdated, + #[strum(serialize = "DOM.childNodeInserted")] + DomChildNodeInserted, + #[strum(serialize = "DOM.childNodeRemoved")] + DomChildNodeRemoved, + #[strum(serialize = "DOM.documentUpdated")] + DomDocumentUpdated, + #[strum(serialize = "DOM.setChildNodes")] + DomSetChildNodes, + #[strum(serialize = "DOMStorage.domStorageItemAdded")] + DomStorageItemAdded, + #[strum(serialize = "DOMStorage.domStorageItemRemoved")] + DomStorageItemRemoved, + #[strum(serialize = "DOMStorage.domStorageItemUpdated")] + DomStorageItemUpdated, + #[strum(serialize = "DOMStorage.domStorageItemsCleared")] + DomStorageItemsCleared, + #[strum(serialize = "Fetch.authRequired")] + FetchAuthRequired, + #[strum(serialize = "Fetch.requestPaused")] + FetchRequestPaused, + #[strum(serialize = "Input.dragIntercepted")] + InputDragIntercepted, + #[strum(serialize = "Inspector.detached")] + InspectorDetached, + #[strum(serialize = "Inspector.targetCrashed")] + InspectorTargetCrashed, + #[strum(serialize = "Inspector.targetReloadedAfterCrash")] + InspectorTargetReloadedAfterCrash, + #[strum(serialize = "Inspector.workerScriptLoaded")] + InspectorWorkerScriptLoaded, + #[strum(serialize = "Log.entryAdded")] + LogEntryAdded, + #[strum(serialize = "Network.dataReceived")] + NetworkDataReceived, + #[strum(serialize = "Network.eventSourceMessageReceived")] + NetworkEventSourceMessageReceived, + #[strum(serialize = "Network.loadingFailed")] + NetworkLoadingFailed, + #[strum(serialize = "Network.loadingFinished")] + NetworkLoadingFinished, + #[strum(serialize = "Network.requestServedFromCache")] + NetworkRequestServedFromCache, + #[strum(serialize = "Network.requestWillBeSent")] + NetworkRequestWillBeSent, + #[strum(serialize = "Network.requestWillBeSentExtraInfo")] + NetworkRequestWillBeSentExtraInfo, + #[strum(serialize = "Network.responseReceived")] + NetworkResponseReceived, + #[strum(serialize = "Network.responseReceivedExtraInfo")] + NetworkResponseReceivedExtraInfo, + #[strum(serialize = "Network.webSocketClosed")] + NetworkWebSocketClosed, + #[strum(serialize = "Network.webSocketCreated")] + NetworkWebSocketCreated, + #[strum(serialize = "Network.webSocketFrameError")] + NetworkWebSocketFrameError, + #[strum(serialize = "Network.webSocketFrameReceived")] + NetworkWebSocketFrameReceived, + #[strum(serialize = "Network.webSocketFrameSent")] + NetworkWebSocketFrameSent, + #[strum(serialize = "Network.webSocketHandshakeResponseReceived")] + NetworkWebSocketHandshakeResponseReceived, + #[strum(serialize = "Network.webSocketWillSendHandshakeRequest")] + NetworkWebSocketWillSendHandshakeRequest, + #[strum(serialize = "Page.documentOpened")] + PageDocumentOpened, + #[strum(serialize = "Page.domContentEventFired")] + PageDomContentEventFired, + #[strum(serialize = "Page.downloadProgress")] + PageDownloadProgress, + #[strum(serialize = "Page.downloadWillBegin")] + PageDownloadWillBegin, + #[strum(serialize = "Page.fileChooserOpened")] + PageFileChooserOpened, + #[strum(serialize = "Page.frameAttached")] + PageFrameAttached, + #[strum(serialize = "Page.frameClearedScheduledNavigation")] + PageFrameClearedScheduledNavigation, + #[strum(serialize = "Page.frameDetached")] + PageFrameDetached, + #[strum(serialize = "Page.frameNavigated")] + PageFrameNavigated, + #[strum(serialize = "Page.frameRequestedNavigation")] + PageFrameRequestedNavigation, + #[strum(serialize = "Page.frameScheduledNavigation")] + PageFrameScheduledNavigation, + #[strum(serialize = "Page.frameStartedLoading")] + PageFrameStartedLoading, + #[strum(serialize = "Page.frameStartedNavigating")] + PageFrameStartedNavigating, + #[strum(serialize = "Page.frameStoppedLoading")] + PageFrameStoppedLoading, + #[strum(serialize = "Page.javascriptDialogClosed")] + PageJavascriptDialogClosed, + #[strum(serialize = "Page.javascriptDialogOpening")] + PageJavascriptDialogOpening, + #[strum(serialize = "Page.lifecycleEvent")] + PageLifecycleEvent, + #[strum(serialize = "Page.loadEventFired")] + PageLoadEventFired, + #[strum(serialize = "Page.navigatedWithinDocument")] + PageNavigatedWithinDocument, + #[strum(serialize = "Page.screencastFrame")] + PageScreencastFrame, + #[strum(serialize = "Page.screencastVisibilityChanged")] + PageScreencastVisibilityChanged, + #[strum(serialize = "Page.windowOpen")] + PageWindowOpen, + #[strum(serialize = "Runtime.bindingCalled")] + RuntimeBindingCalled, + #[strum(serialize = "Runtime.consoleAPICalled")] + RuntimeConsoleApiCalled, + #[strum(serialize = "Runtime.exceptionThrown")] + RuntimeExceptionThrown, + #[strum(serialize = "Runtime.executionContextCreated")] + RuntimeExecutionContextCreated, + #[strum(serialize = "Runtime.executionContextDestroyed")] + RuntimeExecutionContextDestroyed, + #[strum(serialize = "Runtime.executionContextsCleared")] + RuntimeExecutionContextsCleared, + #[strum(serialize = "ServiceWorker.workerErrorReported")] + ServiceWorkerErrorReported, + #[strum(serialize = "ServiceWorker.workerRegistrationUpdated")] + ServiceWorkerRegistrationUpdated, + #[strum(serialize = "ServiceWorker.workerVersionUpdated")] + ServiceWorkerVersionUpdated, + #[strum(serialize = "Target.attachedToTarget")] + TargetAttachedToTarget, + #[strum(serialize = "Target.detachedFromTarget")] + TargetDetachedFromTarget, + #[strum(serialize = "Target.receivedMessageFromTarget")] + TargetReceivedMessageFromTarget, + #[strum(serialize = "Target.targetCrashed")] + TargetCrashed, + #[strum(serialize = "Target.targetCreated")] + TargetCreated, + #[strum(serialize = "Target.targetDestroyed")] + TargetDestroyed, + #[strum(serialize = "Target.targetInfoChanged")] + TargetInfoChanged, + #[strum(serialize = "Tracing.dataCollected")] + TracingDataCollected, + #[strum(serialize = "Tracing.tracingComplete")] + TracingComplete, + #[strum(serialize = "WebMCP.toolInvoked")] + WebMcpToolInvoked, + #[strum(serialize = "WebMCP.toolResponded")] + WebMcpToolResponded, + #[strum(serialize = "WebMCP.toolsAdded")] + WebMcpToolsAdded, + #[strum(serialize = "WebMCP.toolsRemoved")] + WebMcpToolsRemoved, +} + +impl LocalCdpEvent { + pub const METHODS: &'static [&'static str] = ::VARIANTS; + + pub fn method(self) -> &'static str { + self.into() + } +} + +#[cfg(test)] +mod tests { + use super::LocalCdpEvent; + use std::collections::BTreeSet; + + #[test] + fn local_events_have_unique_qualified_wire_names() { + let names: BTreeSet<_> = LocalCdpEvent::METHODS.iter().copied().collect(); + assert_eq!(names.len(), LocalCdpEvent::METHODS.len()); + assert!(names.iter().all(|name| name.split_once('.').is_some())); + assert_eq!( + LocalCdpEvent::RuntimeConsoleApiCalled.method(), + "Runtime.consoleAPICalled" + ); + assert_eq!( + LocalCdpEvent::NetworkWebSocketFrameSent.method(), + "Network.webSocketFrameSent" + ); + assert_eq!( + LocalCdpEvent::TracingComplete.method(), + "Tracing.tracingComplete" + ); + } +} diff --git a/moli-protocol-cdp-defs/src/lib.rs b/moli-protocol-cdp-defs/src/lib.rs index a7ad5df77c0..b18c1875f27 100644 --- a/moli-protocol-cdp-defs/src/lib.rs +++ b/moli-protocol-cdp-defs/src/lib.rs @@ -1,9 +1,11 @@ //! CDP action types and static support catalog shared by dispatch and schema generation. pub mod actions; +mod events; +pub use events::LocalCdpEvent; mod support; pub use support::{ - DomainMembers, FORWARDED_COMMAND_DOMAINS, FORWARDED_EVENT_DOMAINS, IMPLEMENTED_BROWSER_EVENTS, - IMPLEMENTED_COMMANDS, SERVER_COMMANDS, + DomainMembers, FORWARDED_COMMAND_DOMAINS, FORWARDED_EVENT_DOMAINS, IMPLEMENTED_COMMANDS, + SERVER_COMMANDS, }; diff --git a/moli-protocol-cdp-defs/src/support.rs b/moli-protocol-cdp-defs/src/support.rs index 6767b800888..1b6db8d046b 100644 --- a/moli-protocol-cdp-defs/src/support.rs +++ b/moli-protocol-cdp-defs/src/support.rs @@ -45,121 +45,6 @@ pub const FORWARDED_COMMAND_DOMAINS: &[&str] = &["Debugger"]; pub const FORWARDED_EVENT_DOMAINS: &[&str] = &["Console", "Debugger", "HeapProfiler", "Profiler", "Runtime"]; -// Browser events emitted by the protocol owner and renderer agents. V8 events -// are forwarded using the matching upstream JS protocol schema. -pub const IMPLEMENTED_BROWSER_EVENTS: &[DomainMembers] = &[ - ("Audits", &["issueAdded"]), - ("Browser", &["downloadProgress", "downloadWillBegin"]), - ("CSS", &["styleSheetAdded", "styleSheetRemoved"]), - ( - "DOM", - &[ - "attributeModified", - "attributeRemoved", - "characterDataModified", - "childNodeCountUpdated", - "childNodeInserted", - "childNodeRemoved", - "documentUpdated", - "setChildNodes", - ], - ), - ( - "DOMStorage", - &[ - "domStorageItemAdded", - "domStorageItemRemoved", - "domStorageItemUpdated", - "domStorageItemsCleared", - ], - ), - ("Fetch", &["authRequired", "requestPaused"]), - ("Input", &["dragIntercepted"]), - ( - "Inspector", - &[ - "detached", - "targetCrashed", - "targetReloadedAfterCrash", - "workerScriptLoaded", - ], - ), - ("Log", &["entryAdded"]), - ( - "Network", - &[ - "dataReceived", - "eventSourceMessageReceived", - "loadingFailed", - "loadingFinished", - "requestServedFromCache", - "requestWillBeSent", - "requestWillBeSentExtraInfo", - "responseReceived", - "responseReceivedExtraInfo", - "webSocketClosed", - "webSocketCreated", - "webSocketFrameError", - "webSocketFrameReceived", - "webSocketFrameSent", - "webSocketHandshakeResponseReceived", - "webSocketWillSendHandshakeRequest", - ], - ), - ( - "Page", - &[ - "documentOpened", - "domContentEventFired", - "downloadProgress", - "downloadWillBegin", - "fileChooserOpened", - "frameAttached", - "frameClearedScheduledNavigation", - "frameDetached", - "frameNavigated", - "frameRequestedNavigation", - "frameScheduledNavigation", - "frameStartedLoading", - "frameStartedNavigating", - "frameStoppedLoading", - "javascriptDialogClosed", - "javascriptDialogOpening", - "lifecycleEvent", - "loadEventFired", - "navigatedWithinDocument", - "screencastFrame", - "screencastVisibilityChanged", - "windowOpen", - ], - ), - ( - "ServiceWorker", - &[ - "workerErrorReported", - "workerRegistrationUpdated", - "workerVersionUpdated", - ], - ), - ( - "Target", - &[ - "attachedToTarget", - "detachedFromTarget", - "receivedMessageFromTarget", - "targetCrashed", - "targetCreated", - "targetDestroyed", - "targetInfoChanged", - ], - ), - ("Tracing", &["dataCollected", "tracingComplete"]), - ( - "WebMCP", - &["toolInvoked", "toolResponded", "toolsAdded", "toolsRemoved"], - ), -]; - #[cfg(test)] mod implemented_commands_tests { use super::IMPLEMENTED_COMMANDS; diff --git a/moli-protocol-cdp/build.rs b/moli-protocol-cdp/build.rs index 3a544a87d34..ec78d64d90d 100644 --- a/moli-protocol-cdp/build.rs +++ b/moli-protocol-cdp/build.rs @@ -31,6 +31,31 @@ fn main() { schema::prepare_protocol(&mut protocol, &extensions); let compact = serde_json::to_vec(&protocol).expect("serialize compact CDP protocol metadata"); let output = PathBuf::from(env::var_os("OUT_DIR").expect("Cargo build output directory")); + let event_names: Vec<_> = protocol["domains"] + .as_array() + .expect("CDP domains") + .iter() + .flat_map(|domain| { + domain["events"] + .as_array() + .into_iter() + .flatten() + .map(|event| { + serde_json::to_string(&format!( + "{}.{}", + domain["domain"].as_str().expect("domain name"), + event["name"].as_str().expect("event name") + )) + .expect("event name serializes") + }) + }) + .collect(); + assert!(!event_names.is_empty(), "advertised protocol has events"); + let check = format!( + "/// Check an exact event name against this build's discovery schema.\npub fn is_advertised_event(method: &str) -> bool {{ matches!(method, {}) }}\n", + event_names.join(" | ") + ); + fs::write(output.join("cdp-events.rs"), check).expect("write CDP event-name check"); // Keep the input as a build artifact for the byte-for-byte round-trip test. // Only the Brotli resource is embedded in production code. fs::write(output.join("cdp-protocol.json"), &compact) diff --git a/moli-protocol-cdp/build/schema.rs b/moli-protocol-cdp/build/schema.rs index e31eacd53e1..9af4141752b 100644 --- a/moli-protocol-cdp/build/schema.rs +++ b/moli-protocol-cdp/build/schema.rs @@ -1,8 +1,8 @@ use std::collections::BTreeSet; use moli_protocol_cdp_defs::{ - DomainMembers, FORWARDED_COMMAND_DOMAINS, FORWARDED_EVENT_DOMAINS, IMPLEMENTED_BROWSER_EVENTS, - IMPLEMENTED_COMMANDS, SERVER_COMMANDS, + DomainMembers, FORWARDED_COMMAND_DOMAINS, FORWARDED_EVENT_DOMAINS, IMPLEMENTED_COMMANDS, + LocalCdpEvent, SERVER_COMMANDS, }; use serde_json::Value; @@ -38,7 +38,15 @@ pub fn prepare_protocol(protocol: &mut Value, extensions: &Value) { for commands in [IMPLEMENTED_COMMANDS, SERVER_COMMANDS] { validate_supported_definitions(domains, "commands", commands); } - validate_supported_definitions(domains, "events", IMPLEMENTED_BROWSER_EVENTS); + for method in LocalCdpEvent::METHODS { + let (name, event) = method.split_once('.').expect("qualified local event name"); + assert!( + definitions(required_domain(domains, name), "events") + .iter() + .any(|entry| entry["name"] == event), + "missing schema for {method}" + ); + } for (section, forwarded) in [ ("commands", FORWARDED_COMMAND_DOMAINS), ("events", FORWARDED_EVENT_DOMAINS), @@ -65,7 +73,7 @@ pub fn prepare_protocol(protocol: &mut Value, extensions: &Value) { entries.retain(|entry| { let event = entry["name"].as_str().expect("event name"); FORWARDED_EVENT_DOMAINS.contains(&name.as_str()) - || supports(IMPLEMENTED_BROWSER_EVENTS, &name, event) + || LocalCdpEvent::METHODS.contains(&format!("{name}.{event}").as_str()) }); } } diff --git a/moli-protocol-cdp/src/lib.rs b/moli-protocol-cdp/src/lib.rs index 1f4f5dccecf..fa8af24e0f7 100644 --- a/moli-protocol-cdp/src/lib.rs +++ b/moli-protocol-cdp/src/lib.rs @@ -15,7 +15,7 @@ pub use dom::{ backend_node_id_for_snapshot, collect_flattened_node_snapshot, frontend_node_id_for_snapshot, node_snapshot_base_payload, node_snapshot_to_cdp, node_snapshot_to_cdp_with_limit, }; -pub use metadata::{CDP_PROTOCOL_BROTLI, advertised_protocol_json}; +pub use metadata::{CDP_PROTOCOL_BROTLI, advertised_protocol_json, is_advertised_event}; pub use runtime::remote_object_from_json_value; pub use target::{CdpTargetKindWire, CdpTargetType, cdp_target_type_wire_value}; pub use time::{DEFAULT_LOADER_ID, monotonic_timestamp_seconds}; diff --git a/moli-protocol-cdp/src/metadata.rs b/moli-protocol-cdp/src/metadata.rs index 40b9abc4aaf..0bd29bf1894 100644 --- a/moli-protocol-cdp/src/metadata.rs +++ b/moli-protocol-cdp/src/metadata.rs @@ -3,6 +3,8 @@ use std::{ sync::OnceLock, }; +include!(concat!(env!("OUT_DIR"), "/cdp-events.rs")); + /// Final supported CDP schema, validated at build time and Brotli-compressed at quality 11. pub const CDP_PROTOCOL_BROTLI: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/cdp-protocol.json.br")); diff --git a/moli-protocol-cdp/tests/protocol_metadata.rs b/moli-protocol-cdp/tests/protocol_metadata.rs index f68e7046378..a435ba1ff4f 100644 --- a/moli-protocol-cdp/tests/protocol_metadata.rs +++ b/moli-protocol-cdp/tests/protocol_metadata.rs @@ -1,8 +1,8 @@ use std::{collections::BTreeSet, io::Read}; -use moli_protocol_cdp::{CDP_PROTOCOL_BROTLI, advertised_protocol_json}; +use moli_protocol_cdp::{CDP_PROTOCOL_BROTLI, advertised_protocol_json, is_advertised_event}; use moli_protocol_cdp_defs::{ - FORWARDED_EVENT_DOMAINS, IMPLEMENTED_BROWSER_EVENTS, IMPLEMENTED_COMMANDS, SERVER_COMMANDS, + FORWARDED_EVENT_DOMAINS, IMPLEMENTED_COMMANDS, LocalCdpEvent, SERVER_COMMANDS, }; use serde_json::{Value, json}; @@ -263,9 +263,9 @@ fn advertised_events_match_the_browser_catalog_and_v8_forwarding() { let advertised: Value = serde_json::from_str(advertised_protocol_json()).unwrap(); let upstream = upstream_protocol_schema(); let extensions = extensions(); - let mut expected: BTreeSet<_> = IMPLEMENTED_BROWSER_EVENTS + let mut expected: BTreeSet<_> = LocalCdpEvent::METHODS .iter() - .flat_map(|(name, events)| events.iter().map(move |event| format!("{name}.{event}"))) + .map(|method| (*method).to_owned()) .collect(); for source in [&upstream, &extensions] { for domain in source["domains"].as_array().unwrap() { @@ -300,6 +300,18 @@ fn advertised_events_match_the_browser_catalog_and_v8_forwarding() { }) .collect(); assert_eq!(actual, expected); + for method in &actual { + assert!(is_advertised_event(method), "{method}"); + } + for method in [ + "Runtime.someUnknownEvent", + "Runtime.consoleAPICalled.extra", + "Page.LoadEventFired", + "Page.navigate", + "", + ] { + assert!(!is_advertised_event(method), "{method}"); + } } fn domain_mut<'a>(protocol: &'a mut Value, name: &str) -> &'a mut Value {