""" app/core/workflow/executor.py - 工作流执行器 职责: - 工作流步骤编排 - 点击、等待等基础操作 - 可靠发送(图片上传场景) - 与 StreamMonitor 协同 """ import copy import json import time import random import uuid from typing import Generator, Dict, Any, Callable, Optional from app.core.config import ( logger, SSEFormatter, ElementNotFoundError, WorkflowError, ) from app.core.elements import ElementFinder from app.core.page_capture import create_page_fetch_capture from app.core.request_transport import ( normalize_request_transport_config, ) from app.core.stream_monitor import StreamMonitor from app.services.arena_image_generation import ArenaImageGenerationError from app.core.network_monitor import ( create_network_monitor, NetworkMonitorTimeout, NetworkMonitorError, NetworkMonitorTerminalError, NetworkInterceptionTriggered, ) from .attachment_monitor import AttachmentMonitor from .arena_send_watchdog import ( ArenaConfirmedSendNoTarget, ArenaPageError, ArenaSendUnconfirmed, ArenaSendWatchdog, ArenaSendWatchdogCancelled, ) from .text_input import TextInputHandler from .image_input import ImageInputHandler from .executor_actions import WorkflowExecutorActionMixin from .executor_interaction import WorkflowExecutorInteractionMixin from .executor_request_transport import WorkflowExecutorRequestTransportMixin from .executor_send import WorkflowExecutorSendMixin from .script_loader import script_loader from app.core.driver import driver_for_tab class WorkflowExecutor( WorkflowExecutorRequestTransportMixin, WorkflowExecutorSendMixin, WorkflowExecutorInteractionMixin, WorkflowExecutorActionMixin, ): """工作流执行器""" def __init__(self, tab, stealth_mode: bool = False, should_stop_checker: Callable[[], bool] = None, extractor = None, image_config: Dict = None, stream_config: Dict = None, file_paste_config: Dict = None, site_advanced_config: Dict = None, selectors: Dict = None, session = None): self.tab = tab self.session = session self.stealth_mode = stealth_mode self.finder = ElementFinder(tab) self.formatter = SSEFormatter() self._completion_id = SSEFormatter._generate_id() self._should_stop = should_stop_checker or (lambda: False) self._extractor = extractor self._image_config = image_config or {} self._stream_config = stream_config or {} self._file_paste_config = file_paste_config or {} self._site_advanced_config = site_advanced_config or {} self._selectors = selectors or {} # 🆕 初始化双 Monitor(优先网络,回退 DOM) self._network_monitor = None self._stream_monitor = None self._last_input_element = None self._last_input_target_key = "" self._last_stream_media_state = {} self._last_stream_media_items: list[Dict[str, Any]] = [] self._pending_interrupted_image_dom_resume: Optional[Dict[str, Any]] = None self._request_transport = normalize_request_transport_config( (stream_config or {}).get("request_transport") ) self._pending_request_transport_state: Optional[Dict[str, Any]] = None self._request_transport_bypass = False self._last_request_transport_sent = False self._last_send_attempt_state: Dict[str, Any] = {} self._arena_page_error_baseline: Dict[str, Any] = {} self._input_stability_wait_pending = False self._last_new_chat_clicked_snapshot: Dict[str, Any] = {} self._last_fill_completed_at = 0.0 self._last_fill_text_length = 0 self._last_fill_after_new_chat = False self._workflow_scope_depth = 0 self._workflow_focus_emulation_active = False self._workflow_visibility_emulation_active = False self._current_result_prompt = "" self._current_step_execution: Dict[str, Any] = {} # Stable owner token lets a late cleanup from an older executor avoid # touching scripts installed by a newer workflow on the same tab. self._script_lifecycle_owner = f"workflow:{uuid.uuid4().hex}" self._script_lifecycle_started = False self._result_event_handler = self._create_result_event_handler() # 检查是否启用网络监听模式 self._stream_mode = stream_config.get("mode", "dom") if stream_config else "dom" network_config = stream_config.get("network", {}) if stream_config else {} self._network_config = network_config self._intercept_only_mode = False self._page_fetch_capture = create_page_fetch_capture( tab=tab, formatter=self.formatter, stream_config=self._stream_config, stop_checker=should_stop_checker, interaction_slot=self._page_interaction_slot, ) interception_enabled = False interception_pattern = "" if self.session is not None: try: from app.services.command_engine import command_engine interception_enabled = command_engine.has_network_interception_for_session(self.session) if interception_enabled: interception_pattern = command_engine.get_network_listen_pattern(self.session) except Exception as e: logger.debug(f"[Executor] 读取网络拦截命令失败(忽略): {e}") # 正常网络流式:使用 parser 解析增量 if self._stream_mode == "network" and network_config and network_config.get("parser"): try: effective_stream_config = stream_config if interception_enabled: network_listen_pattern = str(network_config.get("listen_pattern") or "").strip() merged_pattern = self._merge_network_listen_patterns( network_listen_pattern, interception_pattern, ) effective_stream_config = copy.deepcopy(stream_config or {}) effective_network_config = dict(effective_stream_config.get("network") or {}) effective_network_config["listen_pattern"] = merged_pattern if not str(effective_network_config.get("stream_match_pattern") or "").strip(): effective_network_config["stream_match_pattern"] = ( network_listen_pattern or merged_pattern ) if not str(effective_network_config.get("stream_match_mode") or "").strip(): effective_network_config["stream_match_mode"] = "keyword" effective_stream_config["network"] = effective_network_config self._network_monitor = create_network_monitor( tab=tab, formatter=self.formatter, stream_config=effective_stream_config, image_config=self._image_config, stop_checker=should_stop_checker, event_handler=self._handle_network_event, result_handler=self._result_event_handler, ) except Exception as e: logger.warning(f"[Executor] 网络监听器创建失败: {e}") # DOM 流式 + 网络异常拦截:启用 event-only 网络监听(独立于 stream_mode) elif interception_enabled: try: logger.debug( "[Executor] DOM 模式下跳过 event-only 网络监听,避免与 DOM 轮询并发抢占同一 CDP 连接 " f"(pattern={interception_pattern or 'http'!r})" ) except Exception as e: logger.warning(f"[Executor] 网络异常拦截监听创建失败: {e}") # 始终创建 DOM 监听器(作为回退) self._stream_monitor = StreamMonitor( tab=tab, finder=self.finder, formatter=self.formatter, stop_checker=should_stop_checker, extractor=extractor, image_config=image_config, stream_config=stream_config, session=session, ) # 🆕 隐身模式鼠标位置追踪(CDP 绝对坐标) self._mouse_pos = None self._attachment_monitor_config = self._build_attachment_monitor_config( stream_config=stream_config, file_paste_config=file_paste_config, ) from app.utils.attachments import attachment_config upload_config = attachment_config(self._file_paste_config.get("attachments")) self._attachment_monitor_config["error_selectors"] = upload_config["error_selectors"] composer_root = self._selectors.get("composer_root") if composer_root: self._attachment_monitor_config["root_selectors"] = [self._to_query_selector(composer_root)] + self._attachment_monitor_config.get("root_selectors", []) self._attachment_monitor = AttachmentMonitor( tab=tab, selectors=self._selectors, config=self._attachment_monitor_config, check_cancelled_fn=self._check_cancelled, ) # 初始化输入处理器 self._text_handler = TextInputHandler( tab=tab, stealth_mode=stealth_mode, smart_delay_fn=self._smart_delay, check_cancelled_fn=self._check_cancelled, file_paste_config=file_paste_config, selectors=self._selectors, attachment_monitor=self._attachment_monitor, attachment_monitor_config=self._attachment_monitor_config, ) self._attachment_uploader = self._text_handler.get_attachment_uploader() self._attachment_uploader.focus = self._focus_last_input_for_attachment_paste self._image_handler = ImageInputHandler( tab=tab, stealth_mode=stealth_mode, smart_delay_fn=self._smart_delay, check_cancelled_fn=self._check_cancelled, attachment_monitor=self._attachment_monitor, focus_input_fn=self._focus_last_input_for_attachment_paste, selectors=self._selectors, coordinator=self._attachment_uploader, ) if self._image_config.get("enabled"): logger.debug(f"[IMAGE] 图片提取已启用") if self.stealth_mode: logger.debug("[STEALTH] 低熵模式已启用") def rebuild_network_listener_after_external_interruption( self, reason: str = "external_interrupt", *, allow_dom_image_resume: bool = False, ) -> None: self._pending_interrupted_image_dom_resume = None stream_monitor = getattr(self, "_stream_monitor", None) if allow_dom_image_resume and stream_monitor is not None: try: resume_state = stream_monitor.capture_interrupted_image_resume_state() except Exception as e: logger.debug(f"[Executor] 读取插队前图片恢复状态失败(忽略): {e}") resume_state = None if resume_state: self._pending_interrupted_image_dom_resume = resume_state logger.info( "[Executor] 检测到插队前已生成图片,保留原发送基线并改用 DOM 收尾 " f"(urls={len(resume_state.get('image_urls') or [])})" ) return monitor = getattr(self, "_network_monitor", None) if monitor is None: return try: if hasattr(monitor, "rebuild_after_external_interruption"): monitor.rebuild_after_external_interruption(reason) else: monitor.pre_start() logger.debug(f"[Executor] 外部中断后已确认网络监听: {reason}") except Exception as e: logger.debug(f"[Executor] 外部中断后重建网络监听失败(忽略): {e}") def _consume_interrupted_image_dom_resume(self) -> Optional[Dict[str, Any]]: state = getattr(self, "_pending_interrupted_image_dom_resume", None) self._pending_interrupted_image_dom_resume = None return state if isinstance(state, dict) and state else None def page_looks_generating(self, send_selector: str = "") -> bool: try: state = self._probe_send_post_click_state(send_selector) except Exception: state = {} return self._is_send_post_click_confirmed(state) @staticmethod def _is_rate_limit_terminal_error(error: Any) -> bool: detail = str(error or "").strip().lower() return ( "429" in detail or "403" in detail or "503" in detail or "too many requests" in detail or "rate limit" in detail or "forbidden" in detail or "service unavailable" in detail ) def _page_has_security_verification(self) -> bool: script = r""" return (function() { try { function visible(el) { if (!el) return false; var style = window.getComputedStyle ? window.getComputedStyle(el) : null; if (style && (style.display === 'none' || style.visibility === 'hidden')) return false; if (style && Number(style.opacity || 1) <= 0.02) return false; var rect = el.getBoundingClientRect ? el.getBoundingClientRect() : null; return !rect || (rect.width > 5 && rect.height > 5); } var text = String((document.body && document.body.innerText) || '').toLowerCase(); var textHit = text.indexOf('security verification') !== -1 || text.indexOf('protected by recaptcha') !== -1 || text.indexOf('verify you are human') !== -1 || text.indexOf('checking your browser') !== -1 || text.indexOf('人机身份验证') !== -1 || text.indexOf('确认您是真人') !== -1; if (textHit) return true; var selectors = [ 'iframe[src*="recaptcha"]', 'iframe[src*="google.com/recaptcha"]', 'iframe[src*="challenges.cloudflare.com"]', 'iframe[src*="turnstile"]', '.g-recaptcha', '.cf-turnstile', '[name="g-recaptcha-response"]', '[name="cf-turnstile-response"]', '[title*="recaptcha" i]', '[aria-label*="recaptcha" i]' ]; for (var i = 0; i < selectors.length; i++) { try { var nodes = document.querySelectorAll(selectors[i]); for (var j = 0; j < nodes.length; j++) { if (visible(nodes[j])) return true; } } catch (e) {} } return false; } catch (e) { return false; } })(); """ try: probe_timeout = float( (self._stream_config or {}).get("verification_probe_timeout_seconds", 0.5) ) except (TypeError, ValueError): probe_timeout = 0.5 probe_timeout = min(2.0, max(0.1, probe_timeout)) try: return bool(driver_for_tab(self.tab).run_js(script, timeout=probe_timeout)) except Exception as e: logger.debug(f"[Executor] 验证页面探测失败(忽略): {e}") return False def _wait_for_verification_interrupt_after_rate_limit(self, error: Any) -> bool: if self.session is None or not self._is_rate_limit_terminal_error(error): return False try: wait_seconds = float( (self._stream_config or {}).get("verification_recovery_wait_seconds", 20.0) ) except Exception: wait_seconds = 20.0 wait_seconds = min(20.0, max(0.5, wait_seconds)) deadline = time.time() + wait_seconds saw_verification = False trigger_check_requested = False while time.time() < deadline: try: from app.services.command_engine import command_engine if command_engine.workflow_interrupt_requested(self.session): setattr(self.session, "_workflow_stop_reason", "command_interrupt") setattr(self.session, "_workflow_retry_current_stream_step", True) logger.warning( "[Executor] 429 后检测到验证码命令已接管,暂停当前监听等待恢复" ) return True except Exception: pass if self._check_cancelled(): return False if not saw_verification and self._page_has_security_verification(): saw_verification = True logger.warning( "[Executor] 目标流返回 429,但页面处于人机验证态,等待验证命令接管" ) if saw_verification and not trigger_check_requested: trigger_check_requested = True try: from app.services.command_engine import command_engine if not command_engine.check_workflow_triggers_now(self.session): command_engine.submit_background_task(command_engine.check_triggers, self.session) except Exception as e: logger.debug(f"[Executor] 主动触发验证码命令检查失败(忽略): {e}") time.sleep(0.2 if saw_verification else 0.1) return False def cleanup_after_workflow(self) -> None: """Release page-side helpers installed for this executor.""" self._cleanup_workflow_scripts() try: if self._attachment_monitor is not None: self._attachment_monitor.destroy() except Exception as e: logger.debug(f"[Executor] 附件监控清理失败(忽略): {e}") try: if self._network_monitor is not None and hasattr(self._network_monitor, "cleanup"): self._network_monitor.cleanup() except Exception as e: logger.debug(f"[Executor] 网络监听器清理失败(忽略): {e}") try: if self._stream_monitor is not None and hasattr(self._stream_monitor, "cleanup"): self._stream_monitor.cleanup() except Exception as e: logger.debug(f"[Executor] DOM 流式监听器清理失败(忽略): {e}") self._last_stream_media_state = {} self._last_stream_media_items = [] self._pending_interrupted_image_dom_resume = None def _begin_workflow_scripts(self) -> None: """Dispose non-resident scripts owned by an older workflow on this tab.""" if self._script_lifecycle_started: return self._script_lifecycle_started = True source = ( "(function(){try{var l=window.__UWA_SCRIPT_LIFECYCLE__;" "if(l&&typeof l.beginWorkflow==='function') l.beginWorkflow(" f"{json.dumps(self._script_lifecycle_owner)}" ");" "var p=window.__ARENA_PAYLOAD_INTERCEPTOR_DISPOSE__;" "var policy=window.__ARENA_PAYLOAD_INTERCEPTOR_POLICY__;" "if(typeof p==='function' && policy!=='resident') p();" "return true;}catch(e){return false;}})();" ) try: driver_for_tab(self.tab).run_js(source) except Exception as e: logger.debug(f"[JS_LIFECYCLE] 旧工作流脚本清理失败(忽略): {e}") def _cleanup_workflow_scripts(self) -> None: """Dispose all scripts owned by this executor, preserving resident scripts.""" owner = getattr(self, "_script_lifecycle_owner", "") if not owner: return source = ( "(function(){try{var l=window.__UWA_SCRIPT_LIFECYCLE__;" "if(l&&typeof l.cleanupOwner==='function') l.cleanupOwner(" f"{json.dumps(owner)}" "); return true;}catch(e){return false;}})();" ) try: driver_for_tab(self.tab).run_js(source) except Exception as e: logger.debug(f"[JS_LIFECYCLE] 工作流脚本清理失败(忽略): {e}") def _cleanup_script_id(self, script_id: str) -> None: """Dispose one non-resident script activation after a step completes.""" if not script_id: return source = ( "(function(){try{var l=window.__UWA_SCRIPT_LIFECYCLE__;" "if(l&&typeof l.cleanup==='function') l.cleanup(" f"{json.dumps(script_id)}" "); return true;}catch(e){return false;}})();" ) try: driver_for_tab(self.tab).run_js(source) except Exception as e: logger.debug(f"[JS_LIFECYCLE] 单步脚本清理失败(忽略): {e}") @staticmethod def _coerce_bool(value: Any, default: bool = False) -> bool: if isinstance(value, bool): return value if value is None: return default if isinstance(value, (int, float)): return bool(value) if isinstance(value, str): lowered = value.strip().lower() if lowered in ("1", "true", "yes", "on"): return True if lowered in ("0", "false", "no", "off"): return False return default @staticmethod def _coerce_float(value: Any, default: float, minimum: Optional[float] = None) -> float: try: result = float(value) except (TypeError, ValueError, OverflowError): result = float(default) if minimum is not None: result = max(float(minimum), result) return result @staticmethod def _coerce_int(value: Any, default: int, minimum: Optional[int] = None) -> int: try: result = int(value) except (TypeError, ValueError, OverflowError): result = int(default) if minimum is not None: result = max(int(minimum), result) return result @staticmethod def _normalize_attachment_rule_list(raw_value) -> list: if not isinstance(raw_value, list): return [] cleaned = [] for item in raw_value: value = str(item or "").strip() if value and value not in cleaned: cleaned.append(value) return cleaned def _build_attachment_monitor_config( self, *, stream_config: Optional[Dict[str, Any]] = None, file_paste_config: Optional[Dict[str, Any]] = None, ) -> Dict[str, Any]: config = {} if isinstance(stream_config, dict): raw_config = stream_config.get("attachment_monitor", {}) or {} if isinstance(raw_config, dict): config.update(raw_config) if isinstance(file_paste_config, dict): raw_config = file_paste_config.get("attachment_monitor", {}) or {} if isinstance(raw_config, dict): config.update(raw_config) attachment_selectors = self._normalize_attachment_rule_list( config.get("attachment_selectors", []) ) legacy_selectors = self._normalize_attachment_rule_list( (file_paste_config or {}).get("upload_signal_selectors", []) ) for selector in legacy_selectors: if selector not in attachment_selectors: attachment_selectors.append(selector) if attachment_selectors: config["attachment_selectors"] = attachment_selectors return config def _get_file_paste_send_confirmation_config(self) -> Dict[str, Any]: if not isinstance(self._file_paste_config, dict): return {} raw_config = self._file_paste_config.get("send_confirmation", {}) or {} return raw_config if isinstance(raw_config, dict) else {} def _get_file_paste_state_probe_config(self) -> Dict[str, Any]: if not isinstance(self._file_paste_config, dict): return {} raw_config = self._file_paste_config.get("state_probe", {}) or {} return raw_config if isinstance(raw_config, dict) else {} def _get_attachment_monitor_flag(self, key: str, default: bool = False) -> bool: raw_value = {} if isinstance(self._attachment_monitor_config, dict): raw_value = self._attachment_monitor_config value = raw_value.get(key, default) if isinstance(value, bool): return value if isinstance(value, str): lowered = value.strip().lower() if lowered in ("1", "true", "yes", "on"): return True if lowered in ("0", "false", "no", "off"): return False return bool(value) def _create_result_event_handler(self): try: from app.services.result_event_bridge import create_result_event_handler bridge_handler = create_result_event_handler(self._get_result_event_context) def handle_result(payload): self._update_workflow_target_side(payload) return bridge_handler(payload) return handle_result except Exception as e: logger.debug(f"[Executor] 结果事件桥接初始化失败(忽略): {e}") return None def _update_workflow_target_side(self, payload: Dict[str, Any]) -> None: if self.session is None or not isinstance(payload, dict): return parser_id = str(payload.get("parser_id") or "").strip().lower() if "winner" not in parser_id: return parse_result = payload.get("parse_result") if not isinstance(parse_result, dict): return side = str( parse_result.get("winner_side") or parse_result.get("completion_side") or "" ).strip().lower() if side not in {"left", "right"}: return try: from app.services.command_engine import command_engine command_engine.update_workflow_target_side(self.session, side) except Exception as e: logger.debug(f"[Executor] 更新 Arena winner 目标侧失败(忽略): {e}") def _get_result_event_context(self) -> Dict[str, Any]: session_id = "" if self.session is not None: for attr in ("id", "session_id", "tab_id"): try: value = getattr(self.session, attr, "") except Exception: value = "" if value: session_id = str(value) break return { "prompt": self._current_result_prompt, "completion_id": self._completion_id, "session_id": session_id, "session": self.session, } def _handle_network_event(self, event: Dict[str, Any]) -> bool: """ 将网络事件上报给命令引擎。 返回 True 表示命中拦截条件,应立即中断当前监听。 """ if not self.session: return False try: from app.services.command_engine import command_engine matched = bool(command_engine.handle_network_event(self.session, event)) if matched: if command_engine.workflow_interrupt_requested(self.session): setattr(self.session, "_workflow_stop_reason", "command_interrupt") return True # 让 DOM/STREAM 流程也能立即停下来(与 stream_mode 无关) try: from app.services.request_manager import request_manager request_manager.cancel_current("network_intercepted", tab_id=self.session.id) except Exception: pass try: if hasattr(self.tab, "stop_loading"): self.tab.stop_loading() driver_for_tab(self.tab).run_js("if (window.stop) { window.stop(); }") except Exception: pass return matched except Exception as e: logger.debug(f"[Executor] 网络事件上报失败(忽略): {e}") return False def _capture_dom_send_baseline(self, reason: str = "") -> None: if self._stream_monitor is None: return selector = str((self._selectors or {}).get("result_container") or "").strip() if not selector: return try: context = getattr(self, "_context", None) or {} user_input = context.get("prompt", "") if isinstance(context, dict) else "" self._stream_monitor.capture_send_baseline(selector, user_input=user_input) logger.debug(f"[Executor] 已预捕获 DOM 发送基线 ({reason or 'send'})") except Exception as e: logger.debug(f"[Executor] 预捕获 DOM 发送基线失败(忽略): {e}") def _capture_arena_page_error_baseline(self, reason: str = "") -> None: """Capture Arena terminal-error nodes immediately before submit.""" if not ArenaSendWatchdog.applies_to(getattr(self, "tab", None)): self._arena_page_error_baseline = {} return try: self._arena_page_error_baseline = ArenaSendWatchdog.capture_page_error_baseline( tab=self.tab, selectors=self._selectors, ) logger.debug( "[Executor] 已捕获 Arena 页面错误基线 " f"({reason or 'send'}, items={len(self._arena_page_error_baseline.get('items') or [])})" ) except Exception as exc: self._arena_page_error_baseline = {"available": False, "items": []} logger.debug(f"[Executor] Arena 页面错误基线捕获失败(忽略): {exc}") def _build_dom_fallback_kwargs(self) -> Dict[str, Any]: kwargs: Dict[str, Any] = {} try: if self._stream_monitor is not None: baseline = self._stream_monitor.consume_send_baseline() if baseline: kwargs["baseline_snapshot"] = baseline except Exception as e: logger.debug(f"[Executor] 读取 DOM 发送基线失败(忽略): {e}") try: if self._network_monitor is not None: sent_chars = self._network_monitor.get_total_content_chars() if sent_chars > 0: kwargs["sent_content_length"] = sent_chars except Exception as e: logger.debug(f"[Executor] 读取网络已发送长度失败(忽略): {e}") try: if self._page_fetch_capture is not None: page_capture_sent_chars = self._page_fetch_capture.get_sent_content_length() else: page_capture_sent_chars = 0 if page_capture_sent_chars > 0: kwargs["sent_content_length"] = max( int(kwargs.get("sent_content_length") or 0), page_capture_sent_chars, ) except Exception as e: logger.debug(f"[Executor] 读取页面抓流已发送长度失败(忽略): {e}") if kwargs: baseline = kwargs.get("baseline_snapshot") or {} logger.debug( "[Executor] DOM 回退参数已准备: " f"baseline={bool(baseline)}, " f"baseline_len={int(baseline.get('text_len', 0) or 0) if isinstance(baseline, dict) else 0}, " f"network_sent={int(kwargs.get('sent_content_length') or 0)}" ) return kwargs def _stop_stalled_image_generation(self) -> bool: selector = str((self._selectors or {}).get("stop_btn") or "").strip() if not selector: return False try: stopped = bool(self._execute_click(selector, "stop_btn", optional=True)) if stopped: logger.info("[Image Recovery] 已主动停止卡住的图片生成") return stopped except Exception as exc: logger.warning(f"[Image Recovery] 停止卡住的图片生成失败: {exc}") return False def _restart_stalled_image_generation(self) -> bool: self._stop_stalled_image_generation() time.sleep(0.8) selectors = self._selectors or {} target_key = "retry_send_btn" if selectors.get("retry_send_btn") else "retry button" selector = str(selectors.get(target_key) or "").strip() if not selector: logger.warning("[Image Recovery] 当前预设未配置重新运行按钮,无法自动重试") return False try: restarted = bool(self._execute_click(selector, target_key, optional=True)) except Exception as exc: logger.warning(f"[Image Recovery] 自动重新运行图片生成失败: {exc}") return False if restarted: logger.info("[Image Recovery] 已重新运行本轮图片生成") else: logger.warning("[Image Recovery] 未找到可用的重新运行按钮") return restarted def _focus_last_input_for_attachment_paste(self) -> bool: """Re-focus the active composer before Ctrl+V image paste.""" ele = getattr(self, "_last_input_element", None) if ele is None: selector = str(self._selectors.get("input_box") or "").strip() if selector: try: ele = self.finder.find_with_fallback(selector, "input_box") except Exception as e: logger.debug(f"[IMAGE] 重新定位输入框失败: {e}") ele = None if ele is not None: self._last_input_element = ele self._last_input_target_key = "input_box" if ele is None: logger.warning("[IMAGE] 粘贴前无法定位输入框") return False try: self._text_handler.focus_to_end(ele) return bool(self._text_handler.ensure_input_focus(ele, attempts=2, log_failure=False)) except Exception as e: logger.debug(f"[IMAGE] 粘贴前聚焦输入框失败: {e}") return False @staticmethod def _merge_network_listen_patterns(primary: str, secondary: str) -> str: first = str(primary or "").strip() second = str(secondary or "").strip() if not first: return second or "http" if not second: return first first_lower = first.lower() second_lower = second.lower() if first_lower == "http" or second_lower == "http": return "http" if first_lower == second_lower: return first if first_lower in second_lower: return first if second_lower in first_lower: return second return "http" def _prepare_page_fetch_capture(self) -> None: if self._page_fetch_capture is None: return self._page_fetch_capture.prepare() # ================= 控制方法 ================= def _check_cancelled(self) -> bool: """检查是否被取消""" return self._should_stop() def execute_step(self, action: str, selector: str, target_key: str, value: Any = None, optional: bool = False, context: Dict = None, execution: Dict = None) -> Generator[str, None, None]: """执行单个步骤""" if self._check_cancelled(): logger.debug(f"步骤 {action} 跳过(已取消)") return self._context = context previous_step_execution = self._current_step_execution self._current_step_execution = execution if isinstance(execution, dict) else {} if action in ("STREAM_WAIT", "STREAM_OUTPUT"): self._last_stream_media_state = {} try: if action == "WAIT": wait_time = float(value or 0.5) elapsed = 0 while elapsed < wait_time: if self._check_cancelled(): return time.sleep(min(0.1, wait_time - elapsed)) elapsed += 0.1 elif action == "KEY_PRESS": key = target_key or value # 包含 Enter 的按键(Enter、Ctrl+Enter 等)可能触发提交 if self._combo_contains_submit_key(key): self._capture_arena_page_error_baseline("keypress") if self._network_monitor is not None: self._prepare_page_fetch_capture() self._network_monitor.pre_start() if self._attempt_request_transport_send(): return if self._has_pending_request_transport_prompt(): self._ensure_cached_prompt_filled() self._wait_for_attachments_ready_before_send( self._selectors.get("send_btn", "") ) if self._network_monitor is not None: self._prepare_page_fetch_capture() self._network_monitor.pre_start() self._network_monitor.mark_send_attempt() self._execute_keypress_combo(key) elif action == "JS_EXEC": self._execute_javascript( code=value, target=target_key, context=context, execution=execution, optional=optional, ) elif action == "READONLY_HINT": logger.debug(f"[WORKFLOW_HINT] {str(value or '')[:160]}") return elif action == "SELECT_MODEL": self._execute_select_model( selector=selector, target_key=target_key, value=value, context=context, optional=optional, ) elif action == "PAGE_FETCH": self._last_request_transport_sent = False if self._network_monitor is not None: self._prepare_page_fetch_capture() self._network_monitor.pre_start() if not self._has_pending_request_transport_prompt(): self._stage_request_transport_from_context( selector=selector, target_key=target_key, optional=optional, context=context, ) if self._attempt_request_transport_send(): return if self._has_pending_request_transport_prompt(): pending = self._pending_request_transport_state or {} if pending.get("selector") or pending.get("target_key"): self._ensure_cached_prompt_filled() else: self._request_transport_bypass = True self._clear_request_transport_state() return elif action == "CLICK": # ===== 隐身模式:首次交互前执行人类行为预热 ===== self._maybe_warmup_page_for_stealth(action, target_key) if target_key == "send_btn": self._capture_arena_page_error_baseline("click") # 🆕 发送前启动网络监听(如果已配置) if self._network_monitor is not None: self._prepare_page_fetch_capture() self._network_monitor.pre_start() if self._attempt_request_transport_send(): return if self._has_pending_request_transport_prompt(): self._ensure_cached_prompt_filled() self._wait_for_attachments_ready_before_send(selector) if self._network_monitor is not None: self._prepare_page_fetch_capture() self._network_monitor.pre_start() self._execute_click_with_step_policy( selector, target_key, optional, click_fn=lambda: self._execute_click_send_reliably( selector=selector, target_key=target_key, optional=optional, ), ) else: self._execute_click_with_step_policy(selector, target_key, optional) elif action == "COORD_CLICK": self._maybe_warmup_page_for_stealth(action, target_key) self._execute_coord_click(value, optional) elif action == "COORD_SCROLL": self._maybe_warmup_page_for_stealth(action, target_key) self._execute_coord_scroll(value, optional) elif action == "FILL_INPUT": prompt = context.get("prompt", "") if context else "" if self._stage_request_transport_from_context( selector=selector, target_key=target_key, optional=optional, context=context, ): return self._execute_fill(selector, prompt, target_key, optional) elif action in ("STREAM_WAIT", "STREAM_OUTPUT"): user_input = context.get("prompt", "") if context else "" self._current_result_prompt = str(user_input or "") self._last_stream_media_state = {} self._last_stream_media_items = [] interrupted_image_resume = self._consume_interrupted_image_dom_resume() # 网络流式输出与网络异常拦截解耦: # - mode=network: 走网络流式(可回退 DOM) # - mode!=network 且启用拦截: 后台消费网络事件,前台仍走 DOM monitor_used = None use_network_stream = ( self._network_monitor is not None and not self._intercept_only_mode and self._stream_mode == "network" ) if interrupted_image_resume is not None: logger.info("[Executor] 从插队前原始基线继续 DOM 图片收尾") yield from self._stream_monitor.monitor( selector=selector, user_input=user_input, completion_id=self._completion_id, baseline_snapshot=interrupted_image_resume.get("baseline_snapshot"), sent_content_length=int( interrupted_image_resume.get("sent_content_length") or 0 ), fallback_reason="workflow_interrupt_dom_resume", recovery_mode="workflow_dom_resume", resume_image_urls=list( interrupted_image_resume.get("image_urls") or [] ), ) if self._stream_monitor is not None: self._stream_monitor.clear_send_baseline() monitor_used = "dom_interrupt_resume" elif use_network_stream: if ArenaSendWatchdog.applies_to(getattr(self, "tab", None)): if self.session is not None: setattr( self.session, "_arena_watchdog_input_selector", str(self._selectors.get("input_box") or ""), ) def _workflow_interrupt_pending() -> bool: if self.session is None: return False try: from app.services.command_engine import command_engine return bool( command_engine.workflow_interrupt_requested(self.session) ) except Exception: return False watchdog = ArenaSendWatchdog( tab=self.tab, network_monitor=self._network_monitor, selectors=self._selectors, should_stop=self._check_cancelled, workflow_interrupted=_workflow_interrupt_pending, page_error_baseline=self._arena_page_error_baseline, ) try: watchdog.wait_for_target() except ArenaSendWatchdogCancelled: return except ArenaPageError as exc: logger.error( f"[Executor] Arena 页面检测到明确错误拦截,立即终止工作流: {exc}" ) for monitor in (self._network_monitor, self._stream_monitor): try: if monitor is not None and hasattr(monitor, "cleanup"): monitor.cleanup() except Exception as cleanup_exc: logger.debug( "[Executor] Arena watchdog error cleanup failed: " f"{cleanup_exc}" ) raise WorkflowError(f"stream_terminal_error:{exc}") except ArenaSendUnconfirmed: raise WorkflowError("send_unconfirmed") except ArenaConfirmedSendNoTarget as exc: logger.warning( "[Executor] Arena confirmed the send but no matching " f"target stream arrived: {exc}" ) for monitor in (self._network_monitor, self._stream_monitor): try: if monitor is not None and hasattr(monitor, "cleanup"): monitor.cleanup() except Exception as cleanup_exc: logger.debug( "[Executor] Arena watchdog cleanup failed: " f"{cleanup_exc}" ) raise WorkflowError("arena_send_no_target") try: if self._page_fetch_capture is not None: logger.debug( f"[Executor] 尝试{self._page_fetch_capture.get_mode_name()}模式" ) yield from self._page_fetch_capture.monitor( completion_id=self._completion_id ) if self._stream_monitor is not None: self._stream_monitor.clear_send_baseline() monitor_used = self._page_fetch_capture.get_monitor_id() else: logger.debug("[Executor] 尝试网络监听模式") yield from self._network_monitor.monitor( selector=selector, user_input=user_input, completion_id=self._completion_id ) self._last_stream_media_state = ( self._network_monitor.get_media_generation_state() if self._network_monitor is not None else {} ) self._last_stream_media_items = ( self._network_monitor.get_stream_media_items() if self._network_monitor is not None else [] ) if self._stream_monitor is not None: self._stream_monitor.clear_send_baseline() monitor_used = "network" except NetworkInterceptionTriggered as e: logger.warning(f"[Executor] 网络拦截已触发: {e}") try: from app.services.command_engine import command_engine if self.session is not None and command_engine.workflow_interrupt_requested(self.session): setattr(self.session, "_workflow_stop_reason", "command_interrupt") return except Exception: pass raise WorkflowError("network_intercepted") except NetworkMonitorTerminalError as e: if self._wait_for_verification_interrupt_after_rate_limit(e): return clean_err = str(e) try: from app.services.error_metadata import resolve_error_metadata meta = resolve_error_metadata(clean_err) if meta and meta.message: clean_err = f"[{meta.code}] {meta.message}" if (meta.code and meta.code not in {"error", "workflow_failed", "upstream_error"}) else meta.message except Exception: pass logger.error(f"[Executor] 目标流已确认失败,终止工作流: {clean_err}") raise WorkflowError(f"stream_terminal_error:{e}") except NetworkMonitorTimeout as e: fallback_reason = str(e) logger.warning( f"[Executor] 网络监听超时,回退到 DOM 模式: {e}" ) # 回退到 DOM 监听 dom_fallback_kwargs = self._build_dom_fallback_kwargs() yield from self._stream_monitor.monitor( selector=selector, user_input=user_input, completion_id=self._completion_id, fallback_reason=fallback_reason, **dom_fallback_kwargs, ) if self._stream_monitor.stream_recovery_exhausted(): logger.error( "[Executor] 断流恢复未确认最终结果,终止本轮而不释放为成功" ) raise WorkflowError("stream_recovery_exhausted") if self._stream_monitor.image_recovery_exhausted(): retry_baseline = self._stream_monitor.capture_send_baseline( selector, user_input=user_input, ) self._stream_monitor.consume_send_baseline() if self._restart_stalled_image_generation(): yield from self._stream_monitor.monitor( selector=selector, user_input=user_input, completion_id=self._completion_id, baseline_snapshot=retry_baseline, sent_content_length=0, fallback_reason="image_generation_retry", ) if self._stream_monitor.image_recovery_exhausted(): logger.error( "[Image Recovery] 自动重试后仍未产出图片,停止本轮生成" ) self._stop_stalled_image_generation() if self._stream_monitor is not None: self._stream_monitor.clear_send_baseline() self._last_stream_media_state = {} self._last_stream_media_items = [] monitor_used = "dom_fallback" except NetworkMonitorError as e: fallback_reason = str(e) logger.error( f"[Executor] 网络监听错误,回退到 DOM 模式: {e}" ) # 回退到 DOM 监听 dom_fallback_kwargs = self._build_dom_fallback_kwargs() yield from self._stream_monitor.monitor( selector=selector, user_input=user_input, completion_id=self._completion_id, fallback_reason=fallback_reason, **dom_fallback_kwargs, ) if self._stream_monitor.stream_recovery_exhausted(): logger.error( "[Executor] 断流恢复未确认最终结果,终止本轮而不释放为成功" ) raise WorkflowError("stream_recovery_exhausted") if self._stream_monitor is not None: self._stream_monitor.clear_send_baseline() self._last_stream_media_state = {} self._last_stream_media_items = [] monitor_used = "dom_fallback" else: yield from self._stream_monitor.monitor( selector=selector, user_input=user_input, completion_id=self._completion_id ) if self._stream_monitor is not None: self._stream_monitor.clear_send_baseline() self._last_stream_media_state = {} self._last_stream_media_items = [] monitor_used = "dom" if monitor_used: logger.debug(f"[Executor] 监听完成 (mode={monitor_used})") else: logger.debug(f"未知动作: {action}") except ElementNotFoundError as e: if self._check_cancelled(): logger.info(f"[Executor] step cancelled after element lookup failure [{action}]: {e}") return if not optional: yield self.formatter.pack_error(f"元素未找到: {str(e)}") raise except ArenaImageGenerationError: # The browser workflow converts this Arena-only terminal state into # a 422 / non-retryable API error exactly once. raise except WorkflowError as e: if self._check_cancelled(): logger.info(f"[Executor] step cancelled; suppressing workflow exception [{action}]: {e}") return error_code = str(e) clean_err = error_code try: from app.services.error_metadata import resolve_error_metadata meta = resolve_error_metadata(error_code) if meta and meta.message: clean_err = f"[{meta.code}] {meta.message}" if (meta.code and meta.code not in {"error", "workflow_failed", "upstream_error"}) else meta.message except Exception: pass logger.error(f"步骤执行失败 [{action}]: {clean_err}") if error_code in { "new_chat_transition_timeout", "send_unconfirmed", "arena_send_no_target", "stream_recovery_exhausted", }: raise if error_code.startswith("attachment"): if self.session is not None and (getattr(self._attachment_uploader, "tainted", False) or self._attachment_uploader.completed_paths): # Keep the cause with its owner before ERROR stops control flow. self.session._workflow_failure = { "task_id": str(getattr(self.session, "current_task_id", "") or ""), "code": error_code, "message": "附件未能完整上传,已停止发送。", } self.session.mark_error(error_code) yield self.formatter.pack_error( "附件未能完整上传,已停止发送。请检查类型限制、上传入口和就绪探针。", code=error_code, ) raise if error_code.startswith("file_paste_length_error:"): message = error_code.split(":", 1)[1].strip() or "输入文本超过站点配置的长度限制" yield self.formatter.pack_error( message, code="file_paste_length_error", ) raise if "stream_terminal_error:" in error_code: yield self.formatter.pack_error(error_code) raise if not optional: file_paste_messages = { "file_paste_hint_unconfirmed": ( "临时文件已上传,但提示语没有成功写入输入框,已中止发送以避免空消息或重复附件" ), "file_paste_upload_unconfirmed": ( "临时文件上传状态没有确认,已中止发送以避免重复附件" ), } yield self.formatter.pack_error( file_paste_messages.get(error_code, f"执行失败: {error_code}"), code=error_code if error_code in file_paste_messages else "workflow_failed", ) raise except Exception as e: if self._check_cancelled(): logger.info(f"[Executor] step cancelled; suppressing exception [{action}]: {e}") return logger.error(f"步骤执行失败 [{action}]: {e}") if not optional: yield self.formatter.pack_error(f"执行失败: {str(e)}") raise finally: self._current_step_execution = previous_step_execution def _execute_keypress(self, key: str): """执行按键操作(隐身模式人类化时序)""" if self._check_cancelled(): return with self._page_interaction_slot("KEY_PRESS", str(key or "")) as acquired: if not acquired or self._check_cancelled(): return if self._combo_contains_submit_key(key): self._capture_arena_page_error_baseline("keypress") if self.stealth_mode: driver_for_tab(self.tab).actions.key_down(key) time.sleep(random.uniform(0.05, 0.13)) driver_for_tab(self.tab).actions.key_up(key) else: driver_for_tab(self.tab).actions.key_down(key).key_up(key) if self._combo_contains_submit_key(key): self._capture_dom_send_baseline("keypress") self._smart_delay(0.1, 0.2) def _execute_keypress_combo(self, key: Any): """执行按键动作,支持组合键。""" if self._check_cancelled(): return keys = self._parse_key_combo(key) if not keys: return with self._page_interaction_slot("KEY_PRESS", "+".join(keys)) as acquired: if not acquired or self._check_cancelled(): return if self._combo_contains_submit_key(key): self._capture_arena_page_error_baseline("keypress_combo") if self.stealth_mode: for item in keys: driver_for_tab(self.tab).actions.key_down(item) time.sleep(random.uniform(0.03, 0.09)) time.sleep(random.uniform(0.05, 0.13)) for item in reversed(keys): driver_for_tab(self.tab).actions.key_up(item) time.sleep(random.uniform(0.02, 0.08)) else: for item in keys: driver_for_tab(self.tab).actions.key_down(item) for item in reversed(keys): driver_for_tab(self.tab).actions.key_up(item) if self._combo_contains_submit_key(key): self._capture_dom_send_baseline("keypress_combo") self._smart_delay(0.1, 0.2) def _execute_javascript( self, code: Any, target: Optional[str] = None, context: Optional[Dict] = None, execution: Optional[Dict] = None, optional: bool = False, ): """在当前页面执行 JavaScript,支持通过 ScriptLoader 动态加载外部脚本与参数注入。""" if self._check_cancelled(): return None start_time = time.perf_counter() effective_context = context if context is not None else getattr(self, "_context", {}) ctx_summary = { k: v for k, v in (effective_context or {}).items() if k in {"model", "session_id", "tab_id", "current_domain", "stream"} } prompt_sample = str((effective_context or {}).get("prompt", "") or "")[:60] if prompt_sample: ctx_summary["prompt_preview"] = prompt_sample logger.info( f"[JS_EXEC:RUN] 准备执行脚本: target={target!r}, optional={optional}, " f"effective_context={ctx_summary}" ) self._begin_workflow_scripts() execution = execution if isinstance(execution, dict) else {} lifecycle = str( execution.get("lifecycle") or execution.get("script_lifecycle") or "workflow" ).strip().lower() if lifecycle not in {"workflow", "resident", "step"}: lifecycle = "workflow" script_id = str(execution.get("script_id") or target or "").strip() if not script_id and lifecycle != "workflow": script_id = f"inline:{uuid.uuid4().hex}" try: executable_script = script_loader.resolve_and_load( script_target=target, code_or_args=code, context=effective_context, script_id=script_id, lifecycle=lifecycle, owner_id=self._script_lifecycle_owner, ) except WorkflowError as e: if optional: logger.warning(f"[JS_EXEC] 可选脚本加载失败(已跳过): target={target!r}, error={e}") return None raise except Exception as e: logger.error(f"[JS_EXEC] 脚本准备失败 (target={target!r}): {e}") if optional: logger.warning(f"[JS_EXEC] 可选脚本准备失败(已跳过): target={target!r}, error={e}") return None raise WorkflowError(f"js_exec_prepare_failed: {e}") if not executable_script: if optional: logger.warning(f"[JS_EXEC] 可选脚本代码为空(已跳过): target={target!r}") return None raise WorkflowError("js_exec_empty") with self._page_interaction_slot("JS_EXEC", "workflow_js") as acquired: if not acquired or self._check_cancelled(): return None try: result = driver_for_tab(self.tab).run_js(executable_script) elapsed_ms = (time.perf_counter() - start_time) * 1000 logger.info( f"[JS_EXEC:DONE] 脚本执行成功: target={target!r}, 耗时={elapsed_ms:.2f}ms, " f"返回值={str(result)[:200]!r}" ) except Exception as e: elapsed_ms = (time.perf_counter() - start_time) * 1000 logger.error( f"[JS_EXEC:ERROR] 脚本执行异常: target={target!r}, 耗时={elapsed_ms:.2f}ms, error={e}" ) if optional: logger.warning(f"[JS_EXEC] 可选脚本执行失败(已跳过): target={target!r}, error={e}") return None raise WorkflowError(f"js_exec_failed: {e}") finally: if lifecycle == "step": self._cleanup_script_id(script_id) return result def _combo_contains_submit_key(self, key: Any) -> bool: return any(item == "Enter" for item in self._parse_key_combo(key)) def _parse_key_combo(self, key: Any) -> list[str]: raw = str(key or "").strip() if not raw: return [] parts = [part.strip() for part in raw.split("+") if part.strip()] normalized_parts = [self._normalize_key_name(part) for part in parts] normalized_parts = [part for part in normalized_parts if part] if not normalized_parts: return [] modifiers = {part for part in normalized_parts if part in {"Ctrl", "Alt", "Meta", "Shift"}} if not modifiers: return normalized_parts allow_uppercase_letters = "Shift" in modifiers adjusted_parts = [] for part in normalized_parts: if len(part) == 1 and part.isalpha(): adjusted_parts.append(part.upper() if allow_uppercase_letters else part.lower()) else: adjusted_parts.append(part) return adjusted_parts def _normalize_key_name(self, key: str) -> str: normalized = str(key or "").strip() if not normalized: return "" key_map = { "ctrl": "Ctrl", "control": "Ctrl", "cmd": "Meta", "command": "Meta", "meta": "Meta", "win": "Meta", "windows": "Meta", "shift": "Shift", "alt": "Alt", "option": "Alt", "enter": "Enter", "return": "Enter", "esc": "Escape", "escape": "Escape", "tab": "Tab", "space": "Space", "spacebar": "Space", "backspace": "Backspace", "delete": "Delete", "del": "Delete", "insert": "Insert", "home": "Home", "end": "End", "pageup": "PageUp", "pagedown": "PageDown", "up": "ArrowUp", "down": "ArrowDown", "left": "ArrowLeft", "right": "ArrowRight", "arrowup": "ArrowUp", "arrowdown": "ArrowDown", "arrowleft": "ArrowLeft", "arrowright": "ArrowRight", } lower_name = normalized.lower() if lower_name in key_map: return key_map[lower_name] if len(normalized) == 1: return normalized if lower_name.startswith("f") and lower_name[1:].isdigit(): return lower_name.upper() return normalized __all__ = ['WorkflowExecutor']