Initial commit

This commit is contained in:
Alex committed 2026-11-02 22:54:14 +08:00
commit 57fc3525eb
7311 files changed
+1291398

No files matched your search

+918
View File
@@ -0,0 +1,918 @@
"""CommandEngine 的一部分(R2-3 拆分):触发判定:请求计数、网络事件、优先级与忙碌判断、导航事件分发。
方法原样从 command_engine.py 迁出,行为不变;通过 mixin 组合回 CommandEngine,
类属性与实例状态都在 CommandEngine(command_engine.py)里定义。
"""
import time
import uuid
from typing import Dict, List, Optional, Any, TYPE_CHECKING
from app.utils.site_url import extract_remote_site_domain
from app.services.command_engine_common import logger
if TYPE_CHECKING:
from app.core.tab_pool import TabSession # noqa: F401
class CommandEngineTriggersMixin:
"""触发判定:请求计数、网络事件、优先级与忙碌判断、导航事件分发"""
def check_triggers(self, session: 'TabSession'):
"""
检查所有命令的触发条件
在 TabSession.release() 后调用(锁外、后台,不阻塞主流程)
"""
self.ensure_scheduler_running()
try:
commands = self._load_commands_for_checks()
except Exception as e:
logger.debug(f"命令加载失败,跳过触发检查: {e}")
return
if not commands:
return
ordered_commands = [
(idx, cmd) for idx, cmd in enumerate(commands)
if cmd.get("enabled", True)
]
ordered_commands.sort(key=lambda item: (-self._get_command_priority(item[1]), item[0]))
for _, cmd in ordered_commands:
with self._command_logging_context(cmd):
try:
if self._should_trigger(cmd, session):
meta = self._take_pending_async_trigger_meta(cmd, session) or {}
self._execute_command_async(
cmd,
session,
interrupt_context=meta.get("interrupt_context"),
trigger_rollback=meta.get("rollback"),
)
except Exception as e:
logger.error(f"trigger check failed [{cmd.get('name')}]: {e}")
def check_workflow_triggers_now(self, session: 'TabSession') -> bool:
"""Check commands for an active workflow and enqueue matching interrupts immediately."""
if not self._has_active_workflow(session):
return False
self.ensure_scheduler_running()
try:
commands = self._load_commands_for_checks()
except Exception as e:
logger.debug(f"命令加载失败,跳过工作流触发检查: {e}")
return False
ordered_commands = [
(idx, cmd) for idx, cmd in enumerate(commands)
if cmd.get("enabled", True)
]
ordered_commands.sort(key=lambda item: (-self._get_command_priority(item[1]), item[0]))
scheduled_any = False
for _, cmd in ordered_commands:
with self._command_logging_context(cmd):
try:
trigger = cmd.get("trigger", {}) or {}
trigger_type = str(trigger.get("type", "")).strip().lower()
if (
trigger_type == "page_check"
and not self._should_evaluate_page_check_while_busy_workflow(cmd)
):
continue
if not self._should_trigger(cmd, session):
continue
meta = self._take_pending_async_trigger_meta(cmd, session) or {}
scheduled = self._schedule_command_for_active_workflow(
cmd,
session,
interrupt_context=meta.get("interrupt_context"),
trigger_rollback=meta.get("rollback"),
)
if scheduled:
scheduled_any = True
elif meta.get("rollback"):
self._rollback_trigger_consumption(cmd, session, meta.get("rollback"))
except Exception as e:
logger.error(f"workflow trigger check failed [{cmd.get('name')}]: {e}")
return scheduled_any
def submit_background_task(self, fn, *args, **kwargs):
"""Submit non-trigger command work to the bounded command executor."""
return self._command_executor.submit(fn, *args, **kwargs)
def handle_network_event(self, session: 'TabSession', event: Dict[str, Any]) -> bool:
"""
处理实时网络事件。
返回值:
- True: 命中了网络拦截,当前监听应暂停并交回工作流处理
- False: 不需要暂停当前监听
"""
self.ensure_scheduler_running()
if not event:
return False
event_copy = dict(event)
if not event_copy.get("event_id"):
event_copy["event_id"] = f"net_{uuid.uuid4().hex[:10]}"
event_copy.setdefault("timestamp", time.time())
with self._lock:
self._append_bounded_event(self._network_events, session.id, event_copy)
try:
commands = self._load_commands_for_checks()
except Exception as e:
logger.debug(f"命令加载失败,跳过网络事件触发: {e}")
return False
should_interrupt_listener = False
for cmd in commands:
if not cmd.get("enabled", True):
continue
trigger = cmd.get("trigger", {})
if trigger.get("type") != "network_request_error":
continue
if not self._matches_scope(cmd, session):
continue
with self._command_logging_context(cmd):
dispatch = self._prepare_network_trigger_dispatch(cmd, session, event_copy)
if not dispatch:
continue
if self._has_active_workflow(session):
scheduled = self._schedule_command_for_active_workflow(
cmd,
session,
interrupt_context=dispatch.get("interrupt_context"),
trigger_rollback=dispatch.get("rollback"),
)
if scheduled:
should_interrupt_listener = (
should_interrupt_listener
or self.workflow_interrupt_requested(session)
)
else:
scheduled = self._execute_command_async(
cmd,
session,
interrupt_context=dispatch.get("interrupt_context"),
trigger_rollback=dispatch.get("rollback"),
)
if scheduled:
should_interrupt_listener = (
should_interrupt_listener
or bool(trigger.get("abort_on_match", True))
)
if scheduled:
continue
if dispatch.get("rollback"):
self._rollback_trigger_consumption(cmd, session, dispatch.get("rollback"))
return should_interrupt_listener
def has_network_interception_for_session(self, session: 'TabSession') -> bool:
"""当前会话是否存在可生效的网络异常拦截触发器。"""
try:
commands = self._load_commands_for_checks()
except Exception:
return False
for cmd in commands:
if not cmd.get("enabled", True):
continue
trigger = cmd.get("trigger", {})
if trigger.get("type") != "network_request_error":
continue
if self._matches_scope(cmd, session):
return True
return False
def get_network_listen_pattern(self, session: 'TabSession') -> str:
"""
依据网络异常拦截命令推断一个 listen_pattern。
仅用于事件监听,不要求完全精准。
"""
try:
commands = self._load_commands_for_checks()
except Exception:
return "http"
hints: List[str] = []
for cmd in commands:
if not cmd.get("enabled", True):
continue
trigger = cmd.get("trigger", {})
if trigger.get("type") != "network_request_error":
continue
if not self._matches_scope(cmd, session):
continue
pattern = str(trigger.get("url_pattern") or trigger.get("value") or "").strip()
if not pattern:
continue
hint = self._pattern_to_listen_hint(pattern, str(trigger.get("match_mode", "keyword")))
if hint:
hints.append(hint)
if not hints:
return "http"
hints.sort(key=len, reverse=True)
return hints[0]
def _ensure_trigger_state(
self,
command_id: str,
session: 'TabSession',
state_key: Optional[tuple] = None,
initial_req: Optional[int] = None,
initial_err: Optional[int] = None,
) -> tuple[Dict[str, Any], bool]:
state_key = state_key or (command_id, session.id)
req_baseline = session.request_count if initial_req is None else int(initial_req)
err_baseline = session.error_count if initial_err is None else int(initial_err)
with self._lock:
state = self._trigger_states.get(state_key)
if state is None:
state = {
"req": req_baseline,
"err": err_baseline,
"result_token": "",
"net_sig": "",
"page_key": "",
"page_hit": False,
"page_last_fire_at": 0.0,
}
self._trigger_states[state_key] = state
return state, True
return state, False
def _coerce_int(self, value: Any, default: int) -> int:
try:
return int(value)
except (TypeError, ValueError, OverflowError):
return default
def _coerce_float(self, value: Any, default: float) -> float:
try:
return float(value)
except (TypeError, ValueError, OverflowError):
return default
@staticmethod
def _counter_inc(counter: Dict[str, int], key: str):
if not key:
return
counter[key] = int(counter.get(key, 0)) + 1
@staticmethod
def _counter_dec(counter: Dict[str, int], key: str):
if not key:
return
next_value = int(counter.get(key, 0)) - 1
if next_value > 0:
counter[key] = next_value
else:
counter.pop(key, None)
def _normalize_priority(self, value: Any, default: int = 2) -> int:
try:
p = int(value)
except (TypeError, ValueError, OverflowError):
p = int(default)
return p
def _get_request_priority_baseline(self) -> int:
return self._normalize_priority(getattr(self, "_request_priority_baseline", 2), 2)
def _get_command_priority(self, command: Dict) -> int:
trigger = command.get("trigger", {}) or {}
raw = trigger.get("priority", trigger.get("command_priority", 2))
return self._normalize_priority(raw, 2)
def _should_evaluate_page_check_while_busy_workflow(self, command: Dict) -> bool:
trigger = command.get("trigger", {}) or {}
raw = trigger.get("check_while_busy_workflow", None)
if raw is None:
return True
return bool(raw)
def _command_affects_domain(self, command: Dict) -> bool:
actions = command.get("actions", [])
for action in actions or []:
if str((action or {}).get("type", "")).strip() == "clear_cookies":
return True
return False
def _has_busy_peer_on_domain(self, domain: str, exclude_session_id: str = "") -> bool:
normalized = str(domain or "").strip().lower()
if not normalized:
return False
try:
browser = self._get_browser()
pool = getattr(browser, "_tab_pool", None)
if pool is None:
return False
status = pool.get_status() if hasattr(pool, "get_status") else {}
for tab in status.get("tabs", []) or []:
sid = str(tab.get("id", "") or "")
if exclude_session_id and sid == exclude_session_id:
continue
if str(tab.get("status", "")).lower() != "busy":
continue
tab_domain = str(tab.get("current_domain", "") or "").strip().lower()
if self._domain_matches(normalized, tab_domain):
return True
except Exception:
return False
return False
def should_block_request_for_session(self, session: "TabSession", task_id: str = "") -> bool:
if session is None:
return False
task = str(task_id or "").strip().lower()
if task.startswith("cmd_") or task.startswith("group_") or task.startswith("cmd_test_") or task.startswith("group_test_"):
return False
session_id = str(getattr(session, "id", "") or "")
domain = self._get_session_domain(session)
with self._lock:
if int(self._pending_high_by_session.get(session_id, 0)) > 0:
return True
if int(self._running_high_by_session.get(session_id, 0)) > 0:
return True
if domain and int(self._pending_high_by_domain.get(domain, 0)) > 0:
return True
if domain and int(self._running_high_by_domain.get(domain, 0)) > 0:
return True
return False
def _get_session_domain(self, session: 'TabSession') -> str:
try:
url = str(getattr(session.tab, "url", "") or "")
domain = str(extract_remote_site_domain(url) or "").strip().lower()
if domain:
session.current_domain = domain
return domain
except Exception:
pass
domain = str(getattr(session, "current_domain", "") or "").strip().lower()
if domain:
return domain
return ""
def _get_active_workflow_runtime(self, session: 'TabSession') -> Optional[Dict[str, Any]]:
stack = getattr(session, "_workflow_runtime_stack", None) or []
if not stack:
return None
runtime = stack[-1]
return runtime if isinstance(runtime, dict) else None
def _build_request_count_state_key(self, command: Dict, session: 'TabSession') -> tuple:
trigger = command.get("trigger", {}) or {}
scope = str(trigger.get("scope", "all") or "all").strip().lower()
if scope == "all":
return (command["id"], "__scope:all")
if scope == "domain":
domain_key = str(trigger.get("domain", "") or "").strip().lower()
if not domain_key:
domain_key = self._get_session_domain(session)
return (command["id"], f"__scope:domain:{domain_key or '_'}")
return (command["id"], session.id)
def _get_scope_request_count(self, command: Dict, session: 'TabSession') -> int:
trigger = command.get("trigger", {}) or {}
scope = str(trigger.get("scope", "all") or "all").strip().lower()
if scope == "tab":
try:
return int(getattr(session, "request_count", 0) or 0)
except Exception:
return 0
try:
browser = self._get_browser()
pool = getattr(browser, "_tab_pool", None)
if pool is None:
return int(getattr(session, "request_count", 0) or 0)
status = pool.get_status() if hasattr(pool, "get_status") else {}
tabs = status.get("tabs", []) or []
except Exception:
return int(getattr(session, "request_count", 0) or 0)
if scope == "all":
total = 0
for tab in tabs:
try:
total += int(tab.get("request_count", 0) or 0)
except Exception:
continue
return total
if scope == "domain":
target_domain = str(trigger.get("domain", "") or "").strip().lower()
if not target_domain:
target_domain = self._get_session_domain(session)
if not target_domain:
return int(getattr(session, "request_count", 0) or 0)
total = 0
for tab in tabs:
try:
tab_domain = str(tab.get("current_domain", "") or "").strip().lower()
if not tab_domain:
url = str(tab.get("url", "") or "")
if "://" in url:
tab_domain = url.split("//", 1)[1].split("/", 1)[0].strip().lower()
if self._domain_matches(target_domain, tab_domain):
total += int(tab.get("request_count", 0) or 0)
except Exception:
continue
return total
try:
return int(getattr(session, "request_count", 0) or 0)
except Exception:
return 0
def _should_trigger(self, command: Dict, session: 'TabSession') -> bool:
trigger = command.get("trigger", {})
trigger_type = trigger.get("type", "")
scope = trigger.get("scope", "all")
# Scope pre-check
if scope == "domain":
target_domain = str(trigger.get("domain", "") or "").strip().lower()
session_domain = self._get_session_domain(session)
if target_domain and session_domain:
if not self._domain_matches(target_domain, session_domain):
return False
elif target_domain:
return False
elif scope == "tab":
target_index = trigger.get("tab_index")
if target_index is not None and session.persistent_index != target_index:
return False
# Skip if same command already executing on this tab
exec_key = (command["id"], session.id)
with self._lock:
if exec_key in self._executing:
return False
request_state_key = None
scope_request_count = None
initial_req = None
if trigger_type == "request_count":
request_state_key = self._build_request_count_state_key(command, session)
scope_request_count = self._get_scope_request_count(command, session)
try:
# Count the current completed request as the first hit so
# a threshold of N fires on the Nth completed request rather
# than the (N+1)th after state initialization.
initial_req = max(0, int(scope_request_count) - 1)
except Exception:
initial_req = scope_request_count
# Initialize or load trigger state
state, is_new = self._ensure_trigger_state(
command["id"],
session,
state_key=request_state_key,
initial_req=initial_req if trigger_type == "request_count" else scope_request_count,
)
if is_new and trigger_type not in {"page_check", "command_check"}:
return False # Newly initialized: wait for next check cycle
# Evaluate trigger condition by trigger type
if trigger_type == "request_count":
threshold = max(1, self._coerce_int(trigger.get("value", 10), 10))
current_count = (
int(scope_request_count)
if scope_request_count is not None
else self._get_scope_request_count(command, session)
)
with self._lock:
baseline = int(state.get("req", 0))
delta = current_count - baseline
should_fire = delta >= threshold
if should_fire:
# 先记录旧基线;若后续因标签页忙碌/超时未实际执行,可回滚以便重试。
state["req_prev"] = baseline
state["req_pending"] = True
state["req"] = current_count
logger.debug_throttled(
f"cmd.request_count.{command.get('id')}:{session.id}:{self._format_scope_label(scope)}",
f"[CMD] 请求计数检查: {command.get('name')} "
f"(当前={current_count}, 基线={baseline}, 增量={delta}, 阈值={threshold}, "
f"标签页={session.id}, 范围={self._format_scope_label(scope)})",
interval_sec=10.0,
)
if should_fire:
logger.info(
f"[CMD] 触发命令: {command.get('name')} "
f"(请求增量={delta}, 阈值={threshold}, 标签页={session.id}, "
f"范围={self._format_scope_label(scope)})"
)
return True
elif trigger_type == "error_count":
threshold = max(1, self._coerce_int(trigger.get("value", 3), 3))
delta = session.error_count - state["err"]
if delta >= threshold:
logger.info(
f"[CMD] 触发命令: {command.get('name')} "
f"(错误增量={delta}, 阈值={threshold})"
)
with self._lock:
state["err"] = session.error_count
return True
elif trigger_type == "idle_timeout":
threshold_sec = max(1.0, self._coerce_float(trigger.get("value", 300), 300.0))
idle = time.time() - session.last_used_at
if idle >= threshold_sec:
logger.info(
f"[CMD] 触发命令: {command.get('name')} "
f"(空闲时长={idle:.0f}秒, 阈值={threshold_sec}秒)"
)
return True
elif trigger_type == "page_check":
check_text = str(trigger.get("value", ""))
normalized_text = check_text.lower().strip()
op, keywords = self._parse_page_check_expression(check_text)
probe_js = str(trigger.get("probe_js", "") or "").strip()
match_info = (
self._evaluate_page_check_expr(session, op, keywords)
if keywords else {
"hit": True if probe_js else False,
"matched_keywords": [],
"snapshot_preview": "",
}
)
current_hit = bool(match_info.get("hit"))
probe_always = bool(trigger.get("probe_always", False))
if probe_js and (current_hit or probe_always):
probe_info = self._evaluate_page_check_probe(session, probe_js)
match_info["probe_hit"] = bool(probe_info.get("hit"))
match_info["probe_result"] = probe_info.get("result")
match_info["probe_summary"] = str(probe_info.get("summary") or "").strip()
current_hit = bool(probe_info.get("hit"))
match_info["hit"] = current_hit
fire_mode = str(trigger.get("fire_mode", "edge") or "edge").strip().lower()
cooldown_sec = max(0.0, self._coerce_float(trigger.get("cooldown_sec", 0), 0.0))
stable_for_sec = max(0.0, self._coerce_float(trigger.get("stable_for_sec", 0), 0.0))
now_ts = time.time()
once_per_request = bool(trigger.get("once_per_request", False))
current_request_id = ""
if once_per_request:
try:
for attr_name in ("_command_request_id", "_bound_request_id"):
req_id = str(getattr(session, attr_name, "") or "").strip()
if req_id:
current_request_id = req_id
break
if not current_request_id:
task_id = str(getattr(session, "current_task_id", "") or "").strip()
if task_id.startswith("req-"):
current_request_id = task_id
except Exception:
pass
with self._lock:
if once_per_request and current_request_id:
triggered_reqs = state.setdefault("triggered_requests", set())
if current_request_id in triggered_reqs:
return False
prev_key = str(state.get("page_key", ""))
prev_hit = bool(state.get("page_hit", False)) if prev_key == normalized_text else False
prev_stable = bool(state.get("page_stable", False)) if prev_key == normalized_text else False
hit_since = float(state.get("page_hit_since", 0.0) or 0.0) if prev_key == normalized_text else 0.0
if current_hit:
if not prev_hit or hit_since <= 0:
hit_since = now_ts
else:
hit_since = 0.0
state["page_key"] = normalized_text
state["page_hit"] = current_hit
state["page_hit_since"] = hit_since
last_fire_at = float(state.get("page_last_fire_at", 0.0) or 0.0)
stable_hit = bool(current_hit and ((now_ts - hit_since) >= stable_for_sec))
state["page_stable"] = stable_hit
if fire_mode == "level":
if stable_hit and (cooldown_sec <= 0 or (now_ts - last_fire_at) >= cooldown_sec):
if once_per_request and current_request_id:
triggered_reqs = state.setdefault("triggered_requests", set())
if current_request_id in triggered_reqs:
return False
triggered_reqs.add(current_request_id)
state["page_last_fire_at"] = now_ts
logger.info(
f"[CMD] 触发命令: {command.get('name')} "
f"(页面检查命中, 模式=持续触发, 文本='{check_text[:30]}', "
f"冷却={cooldown_sec}秒)"
)
self._log_page_check_hit_details(command, session, match_info)
return True
else:
if stable_hit and not prev_stable:
if once_per_request and current_request_id:
triggered_reqs = state.setdefault("triggered_requests", set())
if current_request_id in triggered_reqs:
return False
triggered_reqs.add(current_request_id)
state["page_last_fire_at"] = now_ts
logger.info(
f"[CMD] 触发命令: {command.get('name')} "
f"(页面检查命中, 模式=边沿触发, 文本='{check_text[:30]}')"
)
self._log_page_check_hit_details(command, session, match_info)
return True
elif trigger_type == "command_result_match":
dispatch = self._prepare_command_result_trigger_dispatch(command, session)
if dispatch:
self._set_pending_async_trigger_meta(command, session, dispatch)
logger.info(
f"[CMD] 触发命令: {command.get('name')} "
f"(命中命令结果匹配条件)"
)
return True
elif trigger_type == "command_check":
dispatch = self._prepare_command_check_dispatch(command, session)
if dispatch:
self._set_pending_async_trigger_meta(command, session, dispatch)
check_info = (dispatch.get("interrupt_context") or {}).get("command_check", {})
logger.info(
f"[CMD] 触发命令: {command.get('name')} "
f"(命令检查命中: 来源={check_info.get('source_command_name', '')}, "
f"结果={str(check_info.get('actual_result', '') or '')[:80]})"
)
return True
elif trigger_type == "command_result_event":
dispatch = self._prepare_command_result_event_dispatch(command, session)
if dispatch:
self._set_pending_async_trigger_meta(command, session, dispatch)
logger.info(
f"[CMD] 触发命令: {command.get('name')} "
f"(命中命令结果事件条件)"
)
return True
elif trigger_type == "network_request_error":
dispatch = self._prepare_network_trigger_dispatch(command, session)
if dispatch:
event = (dispatch.get("interrupt_context") or {}).get("network_event", {})
self._set_pending_async_trigger_meta(command, session, dispatch)
if (dispatch.get("rollback") or {}).get("token"):
logger.info(
f"[CMD] 触发命令: {command.get('name')} "
f"(网络异常状态码={event.get('status')}, 地址={event.get('url', '')[:80]})"
)
return True
return False
def _is_command_applicable_on_navigation(self, cmd: Dict[str, Any]) -> bool:
"""判断命令是否适用于页面导航/刷新事件触发。"""
if not isinstance(cmd, dict) or not bool(cmd.get("enabled", True)):
return False
trigger = cmd.get("trigger", {}) or {}
# 1. 显式配置 check_on_navigation / check_on_page_load
if bool(trigger.get("check_on_navigation", False)) or bool(cmd.get("check_on_navigation", False)):
return True
if bool(trigger.get("check_on_page_load", False)) or bool(cmd.get("check_on_page_load", False)):
return True
# 2. page_check 触发器天然依赖页面 DOM/内容,页面跳转刷新后必须立即重新检查
trigger_type = str(trigger.get("type", "")).strip().lower()
if trigger_type == "page_check":
return True
# 3. 包含 bootstrap_on_session_ready 的 run_js_file 命令需要在页面就绪后注入/执行
for action in list(cmd.get("actions") or []):
if isinstance(action, dict) and bool(action.get("bootstrap_on_session_ready", False)):
return True
return False
def notify_tab_navigated(
self,
session: 'TabSession',
reason: str = "page_reload",
async_dispatch: bool = True,
) -> None:
"""
通用的页面导航/刷新通知接口。
当标签页发生刷新(F5、location.reload、断流恢复刷新等)或导航(URL 跳转、新标签页打开等)时调用。
执行操作:
1. 即时重置 JS 执行失败退避锁(_pc_js_backoff_until = 0.0)和失败计数(_pc_js_failures = 0)
2. 清空页面快照缓存与刷新宽限期,重置 observer 探测节流与缓存
3. 清除 observer 缓存与 haystack 缓存,重置适用命令的周期倒计时与 edge 锁存
4. 异步或同步派发页面导航后评估(_dispatch_tab_navigated_evaluation):
- 同步 bootstrap 启动 JS 文件注入(Page.addScriptToEvaluateOnNewDocument + 立即执行)
- 重新注入/同步 MutationObserver
- 毫秒级触发并评估适用命令
"""
if session is None:
return
session_id = getattr(session, "id", "")
if not session_id:
return
# 1. 同步清理 session 上的快照与退避状态
try:
setattr(session, "_pc_js_failures", 0)
setattr(session, "_pc_js_backoff_until", 0.0)
setattr(session, "_pc_refresh_grace_until", 0.0)
setattr(session, "_pc_snapshot_cached", None)
setattr(session, "_last_pc_observer_check_at", 0.0)
setattr(session, "_pc_observer_empty_cleanup_done", False)
if hasattr(self, "_invalidate_wake_throttle"):
self._invalidate_wake_throttle(session)
except Exception as e:
logger.debug(f"[CMD] 重置会话退避状态失败(忽略): {e}")
# 2. 清理引擎层全局缓存与适用命令的状态
try:
commands = self._load_commands_for_checks()
except Exception as e:
logger.debug(f"[CMD] 导航通知加载命令失败: {e}")
commands = []
applicable_cmds = []
with self._lock:
self._observer_keywords_by_session.pop(session_id, None)
self._compact_haystack_cache = None
for cmd in commands:
cmd_id = cmd.get("id")
if not cmd_id:
continue
if self._is_command_applicable_on_navigation(cmd):
self._periodic_next_run[(cmd_id, session_id)] = 0.0
applicable_cmds.append(cmd)
for cmd in applicable_cmds:
self._reset_page_check_latch(cmd, session, reason=f"navigated:{reason}")
logger.debug(
f"[CMD] 标签页导航/刷新通知: session={session_id}, reason={reason}, async={async_dispatch}"
)
# 3. 派发评估
if async_dispatch:
self.submit_background_task(self._dispatch_tab_navigated_evaluation, session, reason)
else:
self._dispatch_tab_navigated_evaluation(session, reason)
def _dispatch_tab_navigated_evaluation(
self,
session: 'TabSession',
reason: str = "page_reload",
) -> None:
"""在页面导航/刷新后执行 bootstrap 脚本注入、observer 同步及命令评估调度。"""
if self._is_session_closed(session):
return
self.ensure_scheduler_running()
try:
commands = self._load_commands_for_checks()
except Exception as e:
logger.debug(f"[CMD] 导航后评估加载命令失败: {e}")
return
if not commands:
return
# 1. 优先执行/注入 bootstrap 启动脚本(例如 Page.addScriptToEvaluateOnNewDocument 及即时注入)
try:
self._sync_session_bootstrap_js_files(commands, session)
except Exception as e:
logger.warning(f"[CMD] 导航后同步 bootstrap 脚本失败: {e}")
# 2. 同步 Page Check Observer(如果有 page_check 关键词)
try:
pc_keywords = self._collect_page_check_keywords(commands, session)
if pc_keywords:
self._ensure_page_check_observer(session, pc_keywords)
else:
self._clear_page_check_observer(session)
except Exception as e:
logger.debug(f"[CMD] 导航后同步 observer 失败: {e}")
# 3. 评估并调度适用的命令
applicable_commands = [
(idx, cmd) for idx, cmd in enumerate(commands)
if self._is_command_applicable_on_navigation(cmd) and self._matches_scope(cmd, session)
]
applicable_commands.sort(key=lambda item: (-self._get_command_priority(item[1]), item[0]))
for _, cmd in applicable_commands:
with self._command_logging_context(cmd):
try:
current_status = str(getattr(getattr(session, "status", None), "value", "")).lower()
if current_status == "busy" and not self._has_active_workflow(session):
continue
if current_status not in {"idle", "busy"}:
continue
if self._should_trigger(cmd, session):
meta = self._take_pending_async_trigger_meta(cmd, session) or {}
if current_status == "busy":
scheduled = self._schedule_command_for_active_workflow(
cmd,
session,
interrupt_context=meta.get("interrupt_context"),
trigger_rollback=meta.get("rollback"),
)
if not scheduled:
if meta.get("rollback"):
self._rollback_trigger_consumption(cmd, session, meta.get("rollback"))
self._finalize_request_count_trigger_state(cmd, session, rollback=True)
self._reset_page_check_latch(cmd, session, reason="workflow_schedule_failed")
else:
self._execute_command_async(
cmd,
session,
interrupt_context=meta.get("interrupt_context"),
trigger_rollback=meta.get("rollback"),
)
except Exception as e:
logger.error(f"[CMD] 导航后触发检查失败 [{cmd.get('name')}]: {e}")
def _finalize_request_count_trigger_state(
self,
command: Dict,
session: 'TabSession',
*,
rollback: bool = False
):
"""
收尾 request_count 触发状态:
- rollback=True: 未实际执行时回滚 req 到触发前基线,避免触发被“吃掉”
- rollback=False: 实际开始执行后清理 pending 标记
"""
trigger = command.get("trigger", {}) or {}
if str(trigger.get("type", "")).strip().lower() != "request_count":
return
key = self._build_request_count_state_key(command, session)
with self._lock:
state = self._trigger_states.get(key)
if not state:
return
pending = bool(state.pop("req_pending", False))
prev_req = state.pop("req_prev", None)
if rollback and pending and prev_req is not None:
try:
state["req"] = int(prev_req)
except Exception:
pass
@staticmethod
def _execution_needs_page_check_retry(execution_result: Any) -> bool:
"""
Determine whether a page_check-triggered command should be retried.
Retry signal is inferred from:
- Step-level ok flag being False (exception during execution)
- Action results shaped like {"ok": False, ...}
- String results containing known failure prefixes (e.g. "js_failed:")
"""
if not isinstance(execution_result, dict):
return False
_FAIL_PREFIXES = (
"js_failed:",
"python_failed:",
"unsupported_lang:",
"ERROR:",
"refresh_failed:",
"navigate_failed:",
)
direct_result = execution_result.get("result")
if isinstance(direct_result, dict) and direct_result.get("ok") is False:
return True
if isinstance(direct_result, str) and direct_result.startswith(_FAIL_PREFIXES):
return True
steps = execution_result.get("steps")
if isinstance(steps, list):
for step in steps:
if not isinstance(step, dict):
continue
# Check step-level ok flag (set by _execute_simple on exceptions)
if step.get("ok") is False:
return True
step_result = step.get("result")
if isinstance(step_result, dict) and step_result.get("ok") is False:
return True
if isinstance(step_result, str) and step_result.startswith(_FAIL_PREFIXES):
return True
return False
def _normalize_match_rule(self, rule: Any) -> str:
rule_value = str(rule or "").strip().lower()
mapping = {
"eq": "equals",
"equal": "equals",
"equals": "equals",
"is": "equals",
"contains": "contains",
"include": "contains",
"includes": "contains",
"ne": "not_equals",
"not_equal": "not_equals",
"not_equals": "not_equals",
}
return mapping.get(rule_value, "equals")