use crate::engines::engine_client::EngineError;
use chromiumoxide::page::Page;
use std::fmt;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum InjectPhase {
BeforeLoad,
AfterLoad,
}
impl fmt::Display for InjectPhase {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
InjectPhase::BeforeLoad => write!(f, "BeforeLoad"),
InjectPhase::AfterLoad => write!(f, "AfterLoad"),
}
}
}
#[derive(Debug, Clone)]
pub struct JsInjector {
before: Vec<String>,
after: Vec<String>,
}
impl JsInjector {
#[must_use]
pub fn stealth() -> Self {
Self {
before: vec![
include_str!("scripts/navigator_overrider.js").to_string(),
include_str!("scripts/webgl_overrider.js").to_string(),
],
after: Vec::new(),
}
}
#[must_use]
pub fn cleanup() -> Self {
Self {
before: Vec::new(),
after: vec![
include_str!("scripts/remove_consent_popups.js").to_string(),
include_str!("scripts/remove_overlay_elements.js").to_string(),
include_str!("scripts/flatten_shadow_dom.js").to_string(),
],
}
}
#[must_use]
pub fn new() -> Self {
Self {
before: Vec::new(),
after: Vec::new(),
}
}
pub fn add_before(&mut self, script: String) -> &mut Self {
self.before.push(script);
self
}
pub fn add_after(&mut self, script: String) -> &mut Self {
self.after.push(script);
self
}
pub fn before_scripts(&self) -> &[String] {
&self.before
}
pub fn after_scripts(&self) -> &[String] {
&self.after
}
pub async fn apply(&self, page: &Page, phase: InjectPhase) -> Result<(), EngineError> {
let scripts = match phase {
InjectPhase::BeforeLoad => &self.before,
InjectPhase::AfterLoad => &self.after,
};
for (idx, script) in scripts.iter().enumerate() {
if let Err(e) = page.evaluate(script.as_str()).await {
return Err(EngineError::BrowserError(format!(
"JS inject failed at phase {} script #{}: {}",
phase,
idx + 1,
e
)));
}
}
Ok(())
}
pub async fn apply_before_document(&self, page: &Page) -> Result<(), EngineError> {
use chromiumoxide::cdp::browser_protocol::page::AddScriptToEvaluateOnNewDocumentParams;
for (idx, script) in self.before.iter().enumerate() {
page.execute(AddScriptToEvaluateOnNewDocumentParams {
source: script.clone(),
world_name: None,
include_command_line_api: None,
run_immediately: None,
})
.await
.map_err(|e| {
EngineError::BrowserError(format!(
"addScriptToEvaluateOnNewDocument failed for script #{}: {}",
idx + 1,
e
))
})?;
}
Ok(())
}
}
impl Default for JsInjector {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn stealth_contains_navigator_overrider_in_before() {
let injector = JsInjector::stealth();
assert_eq!(
injector.before_scripts().len(),
2,
"stealth before must have 2 scripts (navigator + webgl)"
);
let script = &injector.before_scripts()[0];
assert!(
script.contains("navigator") && script.contains("webdriver"),
"stealth before[0] must reference navigator.webdriver: {}",
&script[..script.len().min(80)]
);
}
#[test]
fn stealth_contains_webgl_overrider_in_before() {
let injector = JsInjector::stealth();
assert_eq!(
injector.before_scripts().len(),
2,
"stealth before must have 2 scripts (navigator + webgl)"
);
let script = &injector.before_scripts()[1];
assert!(
script.contains("getParameter"),
"stealth before[1] must hook WebGL getParameter: {}",
&script[..script.len().min(80)]
);
assert!(
script.contains("UNMASKED_VENDOR_WEBGL") && script.contains("UNMASKED_RENDERER_WEBGL"),
"stealth before[1] must override unmasked vendor/renderer"
);
assert!(
script.contains("toDataURL") && script.contains("getImageData"),
"stealth before[1] must add canvas noise via toDataURL/getImageData"
);
assert!(
script.contains("Google Inc. (Intel)") && script.contains("ANGLE (Intel"),
"stealth before[1] must return the faked GPU vendor/renderer strings"
);
assert!(
!script.contains("__crawlrs_stealth_installed =")
&& !script.contains("__crawlrs_stealth_installed="),
"webgl 脚本不得设置 __crawlrs_stealth_installed(由 navigator_overrider 统一管理)"
);
assert!(
script.trim_end().ends_with("})();"),
"webgl script must be an IIFE"
);
}
#[test]
fn stealth_has_empty_after() {
let injector = JsInjector::stealth();
assert!(
injector.after_scripts().is_empty(),
"stealth after must be empty"
);
}
#[test]
fn stealth_source_comment_preserved() {
let injector = JsInjector::stealth();
let script = &injector.before_scripts()[0];
assert!(
script.starts_with("// Source: crawl4ai js_snippet/navigator_overrider.js"),
"stealth script must retain crawl4ai source comment header"
);
}
#[test]
fn cleanup_contains_three_scripts_in_after() {
let injector = JsInjector::cleanup();
assert_eq!(
injector.after_scripts().len(),
3,
"cleanup after must have 3 scripts (consent/overlay/flatten)"
);
}
#[test]
fn cleanup_has_empty_before() {
let injector = JsInjector::cleanup();
assert!(
injector.before_scripts().is_empty(),
"cleanup before must be empty"
);
}
#[test]
fn cleanup_after_scripts_in_expected_order() {
let injector = JsInjector::cleanup();
let scripts = injector.after_scripts();
assert!(
scripts[0].contains("remove_consent_popups"),
"cleanup after[0] must be remove_consent_popups.js"
);
assert!(
scripts[1].contains("remove_overlay_elements"),
"cleanup after[1] must be remove_overlay_elements.js"
);
assert!(
scripts[2].contains("flatten_shadow_dom"),
"cleanup after[2] must be flatten_shadow_dom.js"
);
}
#[test]
fn cleanup_scripts_non_empty() {
let injector = JsInjector::cleanup();
for (i, s) in injector.after_scripts().iter().enumerate() {
assert!(
s.len() > 200,
"cleanup after[{}] too short ({} chars), must be real implementation",
i,
s.len()
);
}
}
#[test]
fn cleanup_scripts_are_iife() {
let injector = JsInjector::cleanup();
for (i, s) in injector.after_scripts().iter().enumerate() {
assert!(
s.contains("(function") && s.trim_end().ends_with("})();"),
"cleanup after[{}] must be an IIFE",
i
);
}
}
#[test]
fn new_creates_empty_injector() {
let injector = JsInjector::new();
assert!(injector.before_scripts().is_empty());
assert!(injector.after_scripts().is_empty());
}
#[test]
fn default_equals_new() {
let a = JsInjector::new();
let b = JsInjector::default();
assert_eq!(a.before_scripts().len(), b.before_scripts().len());
assert_eq!(a.after_scripts().len(), b.after_scripts().len());
}
#[test]
fn add_before_extends_before_scripts() {
let mut injector = JsInjector::new();
injector.add_before("console.log('a');".to_string());
injector.add_before("console.log('b');".to_string());
assert_eq!(injector.before_scripts().len(), 2);
assert_eq!(injector.before_scripts()[0], "console.log('a');");
assert_eq!(injector.before_scripts()[1], "console.log('b');");
}
#[test]
fn add_after_extends_after_scripts() {
let mut injector = JsInjector::new();
injector.add_after("console.log('x');".to_string());
assert_eq!(injector.after_scripts().len(), 1);
assert_eq!(injector.after_scripts()[0], "console.log('x');");
}
#[test]
fn add_before_does_not_touch_after() {
let mut injector = JsInjector::stealth();
injector.add_before("console.log('extra');".to_string());
assert_eq!(injector.before_scripts().len(), 3);
assert!(injector.after_scripts().is_empty());
}
#[test]
fn add_after_does_not_touch_before() {
let mut injector = JsInjector::cleanup();
injector.add_after("console.log('extra');".to_string());
assert_eq!(injector.after_scripts().len(), 4);
assert!(injector.before_scripts().is_empty());
}
#[test]
fn add_before_returns_mut_self_for_chaining() {
let mut injector = JsInjector::new();
injector
.add_before("a".to_string())
.add_before("b".to_string())
.add_after("c".to_string());
assert_eq!(injector.before_scripts().len(), 2);
assert_eq!(injector.after_scripts().len(), 1);
}
#[test]
fn inject_phase_display_before_load() {
assert_eq!(format!("{}", InjectPhase::BeforeLoad), "BeforeLoad");
}
#[test]
fn inject_phase_display_after_load() {
assert_eq!(format!("{}", InjectPhase::AfterLoad), "AfterLoad");
}
#[test]
fn inject_phase_equality() {
assert_eq!(InjectPhase::BeforeLoad, InjectPhase::BeforeLoad);
assert_eq!(InjectPhase::AfterLoad, InjectPhase::AfterLoad);
assert_ne!(InjectPhase::BeforeLoad, InjectPhase::AfterLoad);
}
#[test]
fn inject_phase_clone_copy() {
let phase = InjectPhase::BeforeLoad;
let cloned = phase; assert_eq!(phase, cloned);
}
#[test]
fn clone_preserves_scripts() {
let injector = JsInjector::cleanup();
let cloned = injector.clone();
assert_eq!(
injector.before_scripts().len(),
cloned.before_scripts().len()
);
assert_eq!(injector.after_scripts().len(), cloned.after_scripts().len());
for (a, b) in injector
.after_scripts()
.iter()
.zip(cloned.after_scripts().iter())
{
assert_eq!(a, b);
}
}
#[tokio::test]
async fn apply_with_empty_scripts_returns_ok_without_evaluating() {
let injector = JsInjector::new();
assert!(injector.before_scripts().is_empty());
assert!(injector.after_scripts().is_empty());
}
#[test]
fn stealth_then_add_cleanup_yields_combined_injector() {
let mut injector = JsInjector::stealth();
let cleanup = JsInjector::cleanup();
for s in cleanup.after_scripts() {
injector.add_after(s.clone());
}
assert_eq!(injector.before_scripts().len(), 2);
assert_eq!(injector.after_scripts().len(), 3);
}
#[test]
fn script_source_headers_preserved() {
let stealth = JsInjector::stealth();
let cleanup = JsInjector::cleanup();
for s in stealth.before_scripts()[..1]
.iter()
.chain(cleanup.after_scripts().iter())
{
assert!(
s.starts_with("// Source: crawl4ai js_snippet/"),
"script missing crawl4ai source header: {}",
&s[..s.len().min(60)]
);
}
let webgl = &stealth.before_scripts()[1];
assert!(
webgl.starts_with("// Source: crawlrs original"),
"webgl_overrider is original and must be marked as such: {}",
&webgl[..webgl.len().min(60)]
);
for s in stealth
.before_scripts()
.iter()
.chain(cleanup.after_scripts().iter())
{
assert!(
s.contains("License: Apache-2.0"),
"script missing license header"
);
}
}
}