refactor(cdp): share local event names with schema generation

This commit is contained in:
ldm0
2026-11-14 00:44:58 +08:00
committed by Donough Liu
parent e75131a947
commit 046811f7b9
8 changed files with 270 additions and 126 deletions
+210
View File
@@ -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] = <Self as strum::VariantNames>::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"
);
}
}
+4 -2
View File
@@ -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,
};
-115
View File
@@ -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;
+25
View File
@@ -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)
+12 -4
View File
@@ -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())
});
}
}
+1 -1
View File
@@ -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};
+2
View File
@@ -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"));
+16 -4
View File
@@ -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 {