Files
2026-11-02 22:54:14 +08:00

1553 lines
68 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""
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']