use super::decision::{MllmDecision, ScrollDirection};
use chromiumoxide::cdp::browser_protocol::dom::{BackendNodeId, ResolveNodeParams};
use chromiumoxide::cdp::js_protocol::runtime::CallFunctionOnParams;
use chromiumoxide::Page;
use log::debug;
use std::time::Duration;
#[derive(Debug)]
pub struct ActionResult {
pub success: bool,
pub message: String,
}
impl ActionResult {
pub fn ok(message: impl Into<String>) -> Self {
Self {
success: true,
message: message.into(),
}
}
pub fn err(message: impl Into<String>) -> Self {
Self {
success: false,
message: message.into(),
}
}
}
pub async fn execute_decision(decision: &MllmDecision, page: &Page) -> ActionResult {
match decision {
MllmDecision::Click {
selector, ax_id, ..
} => execute_click(page, selector, *ax_id).await,
MllmDecision::Scroll { direction, .. } => execute_scroll(page, direction).await,
MllmDecision::Input { selector, text, .. } => execute_input(page, selector, text).await,
MllmDecision::Wait { seconds, .. } => execute_wait(*seconds).await,
MllmDecision::Extract { .. } => ActionResult::ok("extract_requested"),
MllmDecision::Done { .. } => ActionResult::ok("done"),
}
}
async fn execute_click(page: &Page, selector: &str, ax_id: Option<i64>) -> ActionResult {
if let Some(backend_id) = ax_id {
match click_by_backend_node_id(page, backend_id).await {
Ok(result) => return result,
Err(e) => {
debug!(
"MLLM action: click by ax_id {} failed ({}); falling back to selector '{}'",
backend_id, e, selector
);
}
}
}
debug!("MLLM action: click({})", selector);
match page.find_element(selector).await {
Ok(element) => match element.click().await {
Ok(_) => ActionResult::ok(format!("clicked: {}", selector)),
Err(e) => ActionResult::err(format!("click failed for '{}': {}", selector, e)),
},
Err(e) => ActionResult::err(format!("element not found '{}': {}", selector, e)),
}
}
async fn click_by_backend_node_id(page: &Page, backend_id: i64) -> Result<ActionResult, String> {
let resolve_params = ResolveNodeParams::builder()
.backend_node_id(BackendNodeId::new(backend_id))
.build();
let resolved = page.execute(resolve_params).await.map_err(|e| {
crate::i18n::tr_log_args("mllm-dom-resolve-node-failed", &[("error", e.to_string())])
})?;
let object_id = resolved
.result
.object
.object_id
.ok_or_else(|| "resolved node has no RemoteObjectId".to_string())?;
let call_params = CallFunctionOnParams::builder()
.object_id(object_id)
.function_declaration(
r#"function() {
this.scrollIntoView({ block: 'center', inline: 'center', behavior: 'instant' });
this.click();
}"#,
)
.user_gesture(true)
.build()
.map_err(|e| {
crate::i18n::tr_log_args(
"mllm-call-function-params-invalid",
&[("error", e.to_string())],
)
})?;
page.execute(call_params).await.map_err(|e| {
crate::i18n::tr_log_args(
"mllm-call-function-click-failed",
&[("error", e.to_string())],
)
})?;
Ok(ActionResult::ok(format!(
"clicked via ax_id {}",
backend_id
)))
}
async fn execute_scroll(page: &Page, direction: &ScrollDirection) -> ActionResult {
let scroll_expr = match direction {
ScrollDirection::Down => "window.scrollBy(0, window.innerHeight * 0.8)",
ScrollDirection::Up => "window.scrollBy(0, -(window.innerHeight * 0.8))",
};
debug!("MLLM action: scroll({:?})", direction);
match page.evaluate_expression(scroll_expr).await {
Ok(_) => ActionResult::ok(format!("scrolled: {:?}", direction)),
Err(e) => ActionResult::err(format!("scroll failed: {}", e)),
}
}
async fn execute_input(page: &Page, selector: &str, text: &str) -> ActionResult {
debug!("MLLM action: input({}, {:?})", selector, text);
match page.find_element(selector).await {
Ok(element) => {
if let Err(e) = element.focus().await {
return ActionResult::err(format!("focus failed for '{}': {}", selector, e));
}
let _ = element
.call_js_fn(
r#"function(el) {
el.value = '';
el.dispatchEvent(new Event('input', { bubbles: true }));
}"#,
false,
)
.await;
match element.type_str(text).await {
Ok(_) => ActionResult::ok(format!("input: {} → {:?}", selector, text)),
Err(e) => ActionResult::err(format!("type_str failed for '{}': {}", selector, e)),
}
}
Err(e) => ActionResult::err(format!("element not found '{}': {}", selector, e)),
}
}
async fn execute_wait(seconds: u32) -> ActionResult {
let clamped = seconds.min(30);
debug!("MLLM action: wait({}s, clamped to {}s)", seconds, clamped);
tokio::time::sleep(Duration::from_secs(clamped as u64)).await;
ActionResult::ok(format!("waited: {}s", clamped))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_action_result_ok() {
let result = ActionResult::ok("test success");
assert!(result.success);
assert_eq!(result.message, "test success");
}
#[test]
fn test_action_result_err() {
let result = ActionResult::err("test failure");
assert!(!result.success);
assert_eq!(result.message, "test failure");
}
#[tokio::test]
async fn test_execute_wait() {
let start = std::time::Instant::now();
let result = execute_wait(1).await;
assert!(result.success);
assert!(start.elapsed() >= Duration::from_millis(900));
}
#[tokio::test]
async fn test_execute_wait_clamped() {
let result = execute_wait(100).await;
assert!(result.success);
assert!(result.message.contains("30s"));
}
#[tokio::test]
async fn test_extract_returns_ok() {
let decision = MllmDecision::Extract {
reasoning: "test".to_string(),
};
let result = ActionResult::ok("extract_requested");
assert!(result.success);
assert_eq!(result.message, "extract_requested");
let _ = decision; }
#[tokio::test]
async fn test_done_returns_ok() {
let result = ActionResult::ok("done");
assert!(result.success);
assert_eq!(result.message, "done");
}
}