963 lines
36 KiB
Python
963 lines
36 KiB
Python
import copy
|
||
import json
|
||
import re
|
||
import time
|
||
import uuid
|
||
from typing import Any, Dict, List, Optional, TYPE_CHECKING
|
||
from urllib.parse import urlsplit
|
||
|
||
from app.core.config import get_logger
|
||
|
||
if TYPE_CHECKING:
|
||
from app.core.tab_pool import TabSession
|
||
|
||
|
||
logger = get_logger("CMD_ENG")
|
||
|
||
|
||
class CommandEngineResultsMixin:
|
||
MAX_EVENT_QUEUE_ITEMS = 50
|
||
MAX_COMMAND_RESULT_EVENTS = 50
|
||
|
||
@staticmethod
|
||
def _normalize_domain_host(value: Any) -> str:
|
||
text = str(value or "").strip().lower()
|
||
if not text:
|
||
return ""
|
||
try:
|
||
if "://" in text:
|
||
parsed = urlsplit(text)
|
||
text = parsed.hostname or text
|
||
else:
|
||
text = text.split("/", 1)[0]
|
||
except Exception:
|
||
pass
|
||
if text.count(":") == 1:
|
||
host, port = text.rsplit(":", 1)
|
||
if port.isdigit():
|
||
text = host
|
||
return text.strip().strip(".")
|
||
|
||
def _domain_matches(self, target_domain: Any, actual_domain: Any) -> bool:
|
||
target = self._normalize_domain_host(target_domain)
|
||
actual = self._normalize_domain_host(actual_domain)
|
||
if not target or not actual:
|
||
return False
|
||
return actual == target or actual.endswith(f".{target}")
|
||
|
||
def _stringify_result(self, value: Any) -> str:
|
||
if value is None:
|
||
return ""
|
||
if isinstance(value, str):
|
||
return value
|
||
if isinstance(value, (dict, list, tuple)):
|
||
try:
|
||
return json.dumps(value, ensure_ascii=False, sort_keys=True)
|
||
except Exception:
|
||
return str(value)
|
||
return str(value)
|
||
|
||
def _match_value_rule(self, actual: str, expected: str, rule: str) -> bool:
|
||
normalized_rule = self._normalize_match_rule(rule)
|
||
if normalized_rule == "contains":
|
||
if not expected:
|
||
return False
|
||
return expected in actual
|
||
if normalized_rule == "not_equals":
|
||
return actual != expected
|
||
return actual == expected
|
||
|
||
def _get_command_result(self, command_id: str, tab_id: str) -> Optional[Dict[str, Any]]:
|
||
with self._lock:
|
||
return copy.deepcopy(self._command_results.get((command_id, tab_id)))
|
||
|
||
def _match_command_result_trigger(
|
||
self,
|
||
command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
consume: bool = False,
|
||
) -> bool:
|
||
trigger = command.get("trigger", {})
|
||
source_id = str(trigger.get("command_id", "")).strip()
|
||
if not source_id:
|
||
return False
|
||
|
||
result_entry = self._get_command_result(source_id, session.id)
|
||
if not result_entry:
|
||
return False
|
||
|
||
action_ref = str(trigger.get("action_ref", "")).strip()
|
||
actual = result_entry.get("result", "")
|
||
if action_ref:
|
||
actual = result_entry.get("step_results", {}).get(action_ref, actual)
|
||
|
||
expected = self._stringify_result(trigger.get("expected_value", ""))
|
||
rule = trigger.get("match_rule", "equals")
|
||
if not self._match_value_rule(self._stringify_result(actual), expected, rule):
|
||
return False
|
||
|
||
if consume:
|
||
state, _ = self._ensure_trigger_state(command["id"], session)
|
||
token = str(result_entry.get("token", ""))
|
||
if state.get("result_token") == token:
|
||
return False
|
||
with self._lock:
|
||
state["result_token"] = token
|
||
|
||
return True
|
||
|
||
def _prepare_command_result_trigger_dispatch(
|
||
self,
|
||
command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
) -> Optional[Dict[str, Any]]:
|
||
trigger = command.get("trigger", {})
|
||
source_id = str(trigger.get("command_id", "")).strip()
|
||
if not source_id:
|
||
return None
|
||
|
||
result_entry = self._get_command_result(source_id, session.id)
|
||
if not result_entry:
|
||
return None
|
||
|
||
action_ref = str(trigger.get("action_ref", "")).strip()
|
||
actual = result_entry.get("result", "")
|
||
if action_ref:
|
||
actual = result_entry.get("step_results", {}).get(action_ref, actual)
|
||
|
||
expected = self._stringify_result(trigger.get("expected_value", ""))
|
||
rule = trigger.get("match_rule", "equals")
|
||
if not self._match_value_rule(self._stringify_result(actual), expected, rule):
|
||
return None
|
||
|
||
token = str(result_entry.get("token", ""))
|
||
state, _ = self._ensure_trigger_state(command["id"], session)
|
||
with self._lock:
|
||
if state.get("result_token") == token:
|
||
return None
|
||
state["result_token"] = token
|
||
|
||
return {
|
||
"rollback": {"kind": "result_token", "token": token},
|
||
}
|
||
|
||
@staticmethod
|
||
def _extract_command_check_actual(
|
||
trigger: Dict[str, Any],
|
||
execution_result: Dict[str, Any],
|
||
) -> str:
|
||
action_ref = str(trigger.get("action_ref", "")).strip()
|
||
actual: Any = execution_result.get("result", "")
|
||
if action_ref:
|
||
for step in execution_result.get("steps", []) or []:
|
||
if str(step.get("action_ref", "")).strip() == action_ref:
|
||
actual = step.get("result", "")
|
||
break
|
||
return actual
|
||
|
||
def _run_command_check_source(
|
||
self,
|
||
command: Dict[str, Any],
|
||
source_command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
) -> Optional[Dict[str, Any]]:
|
||
source_id = str((source_command or {}).get("id", "")).strip()
|
||
session_id = str(getattr(session, "id", "") or "").strip()
|
||
if not source_id or not session_id:
|
||
return None
|
||
|
||
exec_key = (source_id, session_id)
|
||
with self._lock:
|
||
if exec_key in self._executing:
|
||
return None
|
||
self._executing.add(exec_key)
|
||
|
||
with self._command_logging_context(source_command):
|
||
try:
|
||
return self._execute_command(
|
||
source_command,
|
||
session,
|
||
chain=[str((command or {}).get("id", "")).strip()],
|
||
record_result=False,
|
||
emit_followups=False,
|
||
update_trigger_stats=False,
|
||
)
|
||
except Exception as e:
|
||
logger.warning(
|
||
f"[CMD] 命令检查执行失败: {source_command.get('name', source_id)} "
|
||
f"(标签页={session_id}, 错误={e})"
|
||
)
|
||
return {
|
||
"mode": str(source_command.get("mode", "") or ""),
|
||
"result": f"command_check_failed: {e}",
|
||
"steps": [],
|
||
"error": str(e),
|
||
}
|
||
finally:
|
||
with self._lock:
|
||
self._executing.discard(exec_key)
|
||
|
||
def _prepare_command_check_dispatch(
|
||
self,
|
||
command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
) -> Optional[Dict[str, Any]]:
|
||
trigger = command.get("trigger", {}) or {}
|
||
source_id = str(trigger.get("command_id", "")).strip()
|
||
target_id = str(command.get("id", "")).strip()
|
||
if not source_id or not target_id or source_id == target_id:
|
||
return None
|
||
|
||
source_command = self.get_command(source_id)
|
||
if not source_command:
|
||
return None
|
||
|
||
execution_result = self._run_command_check_source(command, source_command, session)
|
||
if not execution_result:
|
||
return None
|
||
|
||
actual_raw = self._extract_command_check_actual(trigger, execution_result)
|
||
actual = self._stringify_result(actual_raw)
|
||
expected = self._stringify_result(trigger.get("expected_value", ""))
|
||
rule = trigger.get("match_rule", "equals")
|
||
matched = self._match_value_rule(actual, expected, rule)
|
||
|
||
state, _ = self._ensure_trigger_state(command["id"], session)
|
||
signature = f"{source_id}|{str(trigger.get('action_ref', '')).strip()}|{actual}"
|
||
with self._lock:
|
||
if matched:
|
||
if str(state.get("command_check_sig", "") or "") == signature:
|
||
return None
|
||
state["command_check_sig"] = signature
|
||
state["command_check_actual"] = actual[:500]
|
||
else:
|
||
state["command_check_sig"] = ""
|
||
state["command_check_actual"] = actual[:500]
|
||
return None
|
||
|
||
return {
|
||
"interrupt_context": {
|
||
"command_check": {
|
||
"source_command_id": source_id,
|
||
"source_command_name": str(source_command.get("name", "") or source_id),
|
||
"actual_result": actual[:500],
|
||
"expected_value": expected[:200],
|
||
"match_rule": str(rule or "equals"),
|
||
}
|
||
}
|
||
}
|
||
|
||
def _record_command_result(
|
||
self,
|
||
command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
execution_result: Dict[str, Any],
|
||
):
|
||
if not command.get("id"):
|
||
return
|
||
|
||
token = f"{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}"
|
||
step_results = {}
|
||
for step in execution_result.get("steps", []) or []:
|
||
ref = str(step.get("action_ref", "")).strip()
|
||
if not ref:
|
||
continue
|
||
step_results[ref] = self._stringify_result(step.get("result", ""))
|
||
|
||
entry = {
|
||
"token": token,
|
||
"timestamp": time.time(),
|
||
"result": self._stringify_result(execution_result.get("result", "")),
|
||
"step_results": step_results,
|
||
"mode": execution_result.get("mode", ""),
|
||
}
|
||
logger.debug(f"[CMD] 执行结果已记录: {command.get('name')} (标签页={session.id})")
|
||
event = self._build_command_result_event(command, execution_result, entry, session)
|
||
with self._lock:
|
||
self._command_results[(command["id"], session.id)] = entry
|
||
self._append_bounded_event(self._command_result_events, session.id, event)
|
||
|
||
def _build_command_result_event(
|
||
self,
|
||
command: Dict[str, Any],
|
||
execution_result: Dict[str, Any],
|
||
entry: Dict[str, Any],
|
||
session: 'TabSession',
|
||
) -> Dict[str, Any]:
|
||
summary, informative = self._summarize_command_result(command, execution_result, entry)
|
||
return {
|
||
"token": entry.get("token", ""),
|
||
"timestamp": float(entry.get("timestamp", time.time()) or time.time()),
|
||
"source_command_id": str(command.get("id", "")).strip(),
|
||
"source_command_name": str(command.get("name", "")).strip(),
|
||
"source_group_name": self._normalize_group_name(command.get("group_name")),
|
||
"result": str(entry.get("result", "") or ""),
|
||
"summary": summary,
|
||
"informative": bool(informative),
|
||
"mode": str(entry.get("mode", "") or ""),
|
||
"task_id": str(getattr(session, "current_task_id", "") or ""),
|
||
}
|
||
|
||
def _summarize_command_result(
|
||
self,
|
||
command: Dict[str, Any],
|
||
execution_result: Dict[str, Any],
|
||
entry: Dict[str, Any],
|
||
) -> tuple[str, bool]:
|
||
error_text = str(execution_result.get("error", "") or "").strip()
|
||
if error_text:
|
||
return (error_text, True)
|
||
|
||
result_text = str(entry.get("result", "") or "").strip()
|
||
if result_text:
|
||
generic_prefixes = (
|
||
"waited:",
|
||
"page_refreshed",
|
||
"cookies_cleared",
|
||
"new_chat_clicked",
|
||
"element_clicked:",
|
||
"element_stealth_clicked:",
|
||
"coordinates_clicked:",
|
||
"navigated:",
|
||
"preset_switched:",
|
||
)
|
||
informative_values = {"VERIFY", "BLACK", "READY", "UNKNOWN"}
|
||
if result_text in informative_values:
|
||
return (result_text, True)
|
||
lowered = result_text.lower()
|
||
if "failed" in lowered or "error" in lowered or "timeout" in lowered:
|
||
return (result_text, True)
|
||
if not lowered.startswith(generic_prefixes):
|
||
return (result_text, True)
|
||
|
||
for step in execution_result.get("steps", []) or []:
|
||
if not bool(step.get("ok", True)):
|
||
text = self._stringify_result(step.get("result", "")).strip()
|
||
return (text or "步骤执行失败", True)
|
||
|
||
cmd_name = str(command.get("name", "")).strip() or "命令"
|
||
return (f"{cmd_name} 执行完成", False)
|
||
|
||
def _get_latest_command_result_event(self, tab_id: str) -> Optional[Dict[str, Any]]:
|
||
with self._lock:
|
||
items = self._command_result_events.get(tab_id) or []
|
||
if not items:
|
||
return None
|
||
return copy.deepcopy(items[-1])
|
||
|
||
def _append_bounded_event(
|
||
self,
|
||
bucket: Dict[str, List[Dict[str, Any]]],
|
||
tab_id: str,
|
||
event: Dict[str, Any],
|
||
*,
|
||
max_events: Optional[int] = None,
|
||
) -> None:
|
||
queue = bucket.setdefault(tab_id, [])
|
||
queue.append(event)
|
||
limit = max(1, int(max_events or self.MAX_EVENT_QUEUE_ITEMS))
|
||
overflow = len(queue) - limit
|
||
if overflow > 0:
|
||
del queue[:overflow]
|
||
|
||
def _get_command_result_events(self, tab_id: str) -> List[Dict[str, Any]]:
|
||
with self._lock:
|
||
return copy.deepcopy(list(self._command_result_events.get(tab_id) or []))
|
||
|
||
def emit_external_command_result_event(
|
||
self,
|
||
session: 'TabSession',
|
||
*,
|
||
source_command_id: str,
|
||
source_command_name: str,
|
||
summary: Any,
|
||
result: Any = "",
|
||
informative: bool = True,
|
||
mode: str = "external",
|
||
group_name: Any = "",
|
||
trigger_commands: bool = True,
|
||
extra_fields: Optional[Dict[str, Any]] = None,
|
||
) -> Optional[Dict[str, Any]]:
|
||
if session is None:
|
||
return None
|
||
|
||
normalized_command_id = str(source_command_id or "").strip()
|
||
normalized_name = str(source_command_name or "").strip()
|
||
normalized_summary = str(summary or "").strip()
|
||
if not normalized_command_id or not normalized_name or not normalized_summary:
|
||
return None
|
||
|
||
event = {
|
||
"token": f"{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}",
|
||
"timestamp": time.time(),
|
||
"source_command_id": normalized_command_id,
|
||
"source_command_name": normalized_name,
|
||
"source_group_name": self._normalize_group_name(group_name),
|
||
"result": self._stringify_result(result),
|
||
"summary": normalized_summary,
|
||
"informative": bool(informative),
|
||
"mode": str(mode or "external").strip() or "external",
|
||
"task_id": str(getattr(session, "current_task_id", "") or ""),
|
||
}
|
||
if isinstance(extra_fields, dict):
|
||
for key, value in extra_fields.items():
|
||
normalized_key = str(key or "").strip()
|
||
if not normalized_key or normalized_key in event:
|
||
continue
|
||
event[normalized_key] = copy.deepcopy(value)
|
||
|
||
with self._lock:
|
||
self._append_bounded_event(
|
||
self._command_result_events,
|
||
session.id,
|
||
copy.deepcopy(event),
|
||
)
|
||
|
||
logger.info(
|
||
f"[CMD] 外部结果事件已记录: {normalized_name} "
|
||
f"(标签页={session.id}, 摘要={normalized_summary})"
|
||
)
|
||
|
||
if trigger_commands:
|
||
pseudo_command = {
|
||
"id": normalized_command_id,
|
||
"name": normalized_name,
|
||
"group_name": self._normalize_group_name(group_name),
|
||
}
|
||
self._trigger_result_event_commands(pseudo_command, session)
|
||
|
||
return copy.deepcopy(event)
|
||
|
||
def _parse_result_event_source_ids(self, trigger: Dict[str, Any]) -> tuple[bool, set[str]]:
|
||
listen_all = bool(trigger.get("listen_all_commands", False))
|
||
raw = trigger.get("command_ids", [])
|
||
values = raw if isinstance(raw, list) else str(raw or "").split(",")
|
||
normalized = {str(item or "").strip() for item in values if str(item or "").strip()}
|
||
if "*" in normalized:
|
||
listen_all = True
|
||
normalized.discard("*")
|
||
return listen_all, normalized
|
||
|
||
@staticmethod
|
||
def _get_consumed_history(state: Dict[str, Any], field: str) -> List[str]:
|
||
history_field = f"{field}s"
|
||
raw_history = state.get(history_field, [])
|
||
if isinstance(raw_history, list):
|
||
history = [str(item or "").strip() for item in raw_history if str(item or "").strip()]
|
||
else:
|
||
history = []
|
||
latest = str(state.get(field, "") or "").strip()
|
||
if latest and latest not in history:
|
||
history.append(latest)
|
||
return history[-50:]
|
||
|
||
def _result_event_matches_trigger(self, trigger: Dict[str, Any], event: Dict[str, Any]) -> bool:
|
||
listen_all = bool(trigger.get("listen_all_commands", False))
|
||
raw = trigger.get("command_ids", [])
|
||
values = raw if isinstance(raw, list) else str(raw or "").split(",")
|
||
command_ids = {str(item or "").strip() for item in values if str(item or "").strip()}
|
||
if "*" in command_ids:
|
||
listen_all = True
|
||
command_ids.discard("*")
|
||
|
||
source_id = str(event.get("source_command_id", "")).strip()
|
||
if not listen_all and command_ids and source_id not in command_ids:
|
||
return False
|
||
if not listen_all and not command_ids:
|
||
return False
|
||
if bool(trigger.get("informative_only", True)) and not bool(event.get("informative", False)):
|
||
return False
|
||
|
||
expected = self._stringify_result(
|
||
trigger.get("expected_value")
|
||
if trigger.get("expected_value") not in (None, "")
|
||
else trigger.get("value", "")
|
||
)
|
||
if expected:
|
||
actual_parts = []
|
||
for field in (
|
||
"summary",
|
||
"result",
|
||
"default_response",
|
||
"response_a",
|
||
"response_b",
|
||
"source_command_name",
|
||
"source_command_id",
|
||
):
|
||
value = self._stringify_result(event.get(field, ""))
|
||
if value:
|
||
actual_parts.append(value)
|
||
actual = "\n".join(actual_parts)
|
||
if not self._match_value_rule(actual, expected, trigger.get("match_rule", "contains")):
|
||
return False
|
||
return True
|
||
|
||
@staticmethod
|
||
def _normalize_result_event_dedupe_fields(trigger: Dict[str, Any]) -> List[str]:
|
||
raw = trigger.get("dedupe_key_fields", trigger.get("result_event_dedupe_fields", []))
|
||
if isinstance(raw, str):
|
||
values = str(raw or "").replace(",", ",").split(",")
|
||
elif isinstance(raw, (list, tuple, set)):
|
||
values = list(raw)
|
||
else:
|
||
values = []
|
||
fields = [str(item or "").strip() for item in values if str(item or "").strip()]
|
||
return fields
|
||
|
||
def _build_result_event_dedupe_signature(
|
||
self,
|
||
trigger: Dict[str, Any],
|
||
event: Dict[str, Any],
|
||
) -> str:
|
||
fields = self._normalize_result_event_dedupe_fields(trigger)
|
||
if not fields:
|
||
return ""
|
||
|
||
parts: List[str] = []
|
||
for field in fields:
|
||
value = event.get(field, "")
|
||
parts.append(f"{field}={str(value or '').strip()}")
|
||
return "|".join(parts)
|
||
|
||
def _remember_consumed_token(
|
||
self,
|
||
state: Dict[str, Any],
|
||
field: str,
|
||
token: str,
|
||
) -> None:
|
||
token = str(token or "").strip()
|
||
if not token:
|
||
return
|
||
history = self._get_consumed_history(state, field)
|
||
if token in history:
|
||
history.remove(token)
|
||
history.append(token)
|
||
state[field] = token
|
||
overflow = len(history) - 50
|
||
if overflow > 0:
|
||
del history[:overflow]
|
||
state[f"{field}s"] = history
|
||
|
||
def _get_next_command_result_event(
|
||
self,
|
||
command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
consume: bool = False,
|
||
copy_event: bool = True,
|
||
) -> Optional[Dict[str, Any]]:
|
||
trigger = command.get("trigger", {}) or {}
|
||
state, _ = self._ensure_trigger_state(command["id"], session)
|
||
with self._lock:
|
||
items = list(self._command_result_events.get(session.id) or [])
|
||
consumed = set(self._get_consumed_history(state, "result_event_token"))
|
||
latched_signature = str(state.get("result_event_latch_sig", "") or "").strip()
|
||
for event in items:
|
||
token = str(event.get("token", "")).strip()
|
||
if not token or token in consumed:
|
||
continue
|
||
if not self._result_event_matches_trigger(trigger, event):
|
||
continue
|
||
signature = self._build_result_event_dedupe_signature(trigger, event)
|
||
if signature and signature == latched_signature:
|
||
if consume:
|
||
self._remember_consumed_token(state, "result_event_token", token)
|
||
continue
|
||
if consume:
|
||
self._remember_consumed_token(state, "result_event_token", token)
|
||
if signature:
|
||
state["result_event_latch_sig"] = signature
|
||
return copy.deepcopy(event) if copy_event else event
|
||
return None
|
||
|
||
def _match_command_result_event_trigger(
|
||
self,
|
||
command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
consume: bool = False,
|
||
) -> bool:
|
||
return self._get_next_command_result_event(
|
||
command,
|
||
session,
|
||
consume=consume,
|
||
copy_event=False,
|
||
) is not None
|
||
|
||
def _prepare_command_result_event_dispatch(
|
||
self,
|
||
command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
) -> Optional[Dict[str, Any]]:
|
||
event = self._get_next_command_result_event(command, session, consume=True)
|
||
if not event:
|
||
return None
|
||
token = str(event.get("token", "")).strip()
|
||
|
||
return {
|
||
"rollback": {"kind": "result_event_token", "token": token},
|
||
"interrupt_context": {"command_result_event": event},
|
||
}
|
||
|
||
def _normalize_status_codes(self, raw_codes: Any) -> set[int]:
|
||
if isinstance(raw_codes, (list, tuple, set)):
|
||
values = raw_codes
|
||
else:
|
||
values = str(raw_codes or "").replace(",", ",").split(",")
|
||
|
||
result: set[int] = set()
|
||
for item in values:
|
||
text = str(item).strip()
|
||
if not text:
|
||
continue
|
||
try:
|
||
result.add(int(text))
|
||
except Exception:
|
||
continue
|
||
return result
|
||
|
||
def _pattern_to_listen_hint(self, pattern: str, mode: str) -> str:
|
||
raw = str(pattern or "").strip()
|
||
if not raw:
|
||
return ""
|
||
|
||
if str(mode or "").strip().lower() == "regex":
|
||
if "|" in raw:
|
||
return "http"
|
||
tokens = re.split(r"[\^\$\.\*\+\?\(\)\[\]\{\}\|\\]+", raw)
|
||
tokens = [t.strip() for t in tokens if t and len(t.strip()) >= 3]
|
||
if not tokens:
|
||
wildcard_fallback = raw.replace(".*", "").replace("\\/", "/")
|
||
wildcard_fallback = wildcard_fallback.strip("* ").strip()
|
||
return wildcard_fallback[:120]
|
||
tokens.sort(key=len, reverse=True)
|
||
return tokens[0][:120]
|
||
|
||
simplified = raw.strip("* ").strip()
|
||
return simplified[:120]
|
||
|
||
# H12:网络事件 URL 正则的求值预算(与工作流 matches 运算符一致:25ms)
|
||
URL_REGEX_MAX_PATTERN = 512
|
||
URL_REGEX_MAX_INPUT = 8192
|
||
URL_REGEX_TIMEOUT_SEC = 0.025
|
||
|
||
@classmethod
|
||
def _bounded_regex_search(cls, pattern: str, url: str) -> Optional[bool]:
|
||
"""带超时的正则匹配:返回 True/False;模式无效返回 None;超时视为不匹配。"""
|
||
import regex as _regex
|
||
|
||
try:
|
||
return bool(_regex.search(
|
||
pattern,
|
||
url[: cls.URL_REGEX_MAX_INPUT],
|
||
flags=_regex.IGNORECASE,
|
||
timeout=cls.URL_REGEX_TIMEOUT_SEC,
|
||
))
|
||
except TimeoutError:
|
||
logger.warning(f"[CMD] URL 正则超过 25ms 求值预算,按不匹配处理: {pattern[:120]}")
|
||
return False
|
||
except _regex.error:
|
||
return None
|
||
|
||
def _matches_url_rule(self, url: str, pattern: str, mode: str) -> bool:
|
||
if not pattern:
|
||
return True
|
||
if mode == "regex":
|
||
if len(pattern) > self.URL_REGEX_MAX_PATTERN:
|
||
logger.warning(f"[CMD] URL 正则超过 {self.URL_REGEX_MAX_PATTERN} 字符,按关键词匹配")
|
||
return pattern.lower() in url.lower()
|
||
matched = self._bounded_regex_search(pattern, url)
|
||
if matched is not None:
|
||
return matched
|
||
logger.warning(f"[CMD] 无效正则,回退通配/关键词匹配: {pattern}")
|
||
wildcard = str(pattern).replace(".", r"\.").replace("*", ".*")
|
||
matched = self._bounded_regex_search(wildcard, url)
|
||
if matched is not None:
|
||
return matched
|
||
simplified = str(pattern).replace("*", "").strip()
|
||
if simplified:
|
||
return simplified.lower() in url.lower()
|
||
return pattern.lower() in url.lower()
|
||
|
||
def _matches_network_trigger(self, trigger: Dict[str, Any], event: Dict[str, Any]) -> bool:
|
||
url = str(event.get("url", "") or "")
|
||
status = event.get("status")
|
||
pattern = str(trigger.get("url_pattern") or trigger.get("value") or "").strip()
|
||
match_mode = str(trigger.get("match_mode", "keyword")).strip().lower()
|
||
codes = self._normalize_status_codes(trigger.get("status_codes", ""))
|
||
|
||
if not self._matches_url_rule(url, pattern, match_mode):
|
||
return False
|
||
if codes and int(status or 0) not in codes:
|
||
return False
|
||
return True
|
||
|
||
def _build_network_signature(self, event: Dict[str, Any]) -> str:
|
||
event_id = str(event.get("event_id", "")).strip()
|
||
if event_id:
|
||
return event_id
|
||
ts = str(event.get("timestamp", ""))
|
||
return f"{ts}:{event.get('status')}:{event.get('url', '')}"
|
||
|
||
def _consume_network_signature(self, command_id: str, session: 'TabSession', signature: str) -> bool:
|
||
if not command_id:
|
||
return False
|
||
state, _ = self._ensure_trigger_state(command_id, session)
|
||
with self._lock:
|
||
if signature in self._get_consumed_history(state, "net_sig"):
|
||
return False
|
||
self._remember_consumed_token(state, "net_sig", signature)
|
||
return True
|
||
|
||
def _prepare_network_trigger_dispatch(
|
||
self,
|
||
command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
event: Optional[Dict[str, Any]] = None,
|
||
) -> Optional[Dict[str, Any]]:
|
||
trigger = command.get("trigger", {}) or {}
|
||
if event is None:
|
||
for candidate in self._snapshot_network_events(session.id):
|
||
if not self._matches_network_trigger(trigger, candidate):
|
||
continue
|
||
signature = self._build_network_signature(candidate)
|
||
if not self._consume_network_signature(command.get("id"), session, signature):
|
||
continue
|
||
event = candidate
|
||
break
|
||
else:
|
||
if not self._matches_network_trigger(trigger, event):
|
||
return None
|
||
signature = self._build_network_signature(event)
|
||
if not self._consume_network_signature(command.get("id"), session, signature):
|
||
return None
|
||
if event is None:
|
||
return None
|
||
signature = self._build_network_signature(event)
|
||
|
||
return {
|
||
"rollback": {"kind": "net_sig", "token": signature},
|
||
"interrupt_context": {"network_event": copy.deepcopy(event)},
|
||
}
|
||
|
||
def _get_latest_network_event(self, tab_id: str) -> Optional[Dict[str, Any]]:
|
||
with self._lock:
|
||
items = self._network_events.get(tab_id) or []
|
||
if not items:
|
||
return None
|
||
return copy.deepcopy(items[-1])
|
||
|
||
def _snapshot_network_events(self, tab_id: str) -> List[Dict[str, Any]]:
|
||
with self._lock:
|
||
return list(self._network_events.get(tab_id) or [])
|
||
|
||
def _get_network_events(self, tab_id: str) -> List[Dict[str, Any]]:
|
||
with self._lock:
|
||
return copy.deepcopy(list(self._network_events.get(tab_id) or []))
|
||
|
||
def _matches_scope(self, command: Dict, session: 'TabSession') -> bool:
|
||
trigger = command.get("trigger", {})
|
||
scope = trigger.get("scope", "all")
|
||
|
||
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:
|
||
return self._domain_matches(target_domain, session_domain)
|
||
return not target_domain
|
||
|
||
if scope == "tab":
|
||
target_index = trigger.get("tab_index")
|
||
return target_index is None or session.persistent_index == target_index
|
||
|
||
return True
|
||
|
||
def _rollback_trigger_consumption(
|
||
self,
|
||
command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
rollback: Optional[Dict[str, Any]],
|
||
):
|
||
if not rollback:
|
||
return
|
||
state, _ = self._ensure_trigger_state(command["id"], session)
|
||
field_map = {
|
||
"result_token": "result_token",
|
||
"result_event_token": "result_event_token",
|
||
"net_sig": "net_sig",
|
||
}
|
||
field = field_map.get(str(rollback.get("kind", "")).strip())
|
||
token = str(rollback.get("token", "") or "")
|
||
if not field or not token:
|
||
return
|
||
with self._lock:
|
||
history = [item for item in self._get_consumed_history(state, field) if item != token]
|
||
state[f"{field}s"] = history
|
||
state[field] = history[-1] if history else ""
|
||
|
||
def _trigger_chained_commands(
|
||
self,
|
||
source_command: Dict,
|
||
session: 'TabSession',
|
||
chain: Optional[List[str]] = None,
|
||
interrupt_context: Optional[Dict[str, Any]] = None,
|
||
):
|
||
source_id = source_command.get("id")
|
||
if not source_id:
|
||
return
|
||
|
||
chain = list(chain or [])
|
||
next_chain = chain + [source_id]
|
||
|
||
try:
|
||
commands = self._load_commands()
|
||
except Exception as e:
|
||
logger.debug(f"链式命令加载失败,跳过: {e}")
|
||
return
|
||
|
||
for cmd in commands:
|
||
if not cmd.get("enabled", True):
|
||
continue
|
||
|
||
target_id = cmd.get("id")
|
||
trigger = cmd.get("trigger", {})
|
||
if trigger.get("type") != "command_triggered":
|
||
continue
|
||
if trigger.get("command_id") != source_id:
|
||
continue
|
||
if not target_id or target_id in next_chain:
|
||
continue
|
||
if not self._matches_scope(cmd, session):
|
||
continue
|
||
|
||
exec_key = (target_id, session.id)
|
||
with self._lock:
|
||
if exec_key in self._executing:
|
||
continue
|
||
|
||
logger.info(
|
||
f"[CMD] 链式触发: {source_command.get('name')} -> {cmd.get('name')} "
|
||
f"(标签页={session.id})"
|
||
)
|
||
if interrupt_context is not None:
|
||
self._dispatch_interrupt_followup_command(
|
||
cmd, session, next_chain, interrupt_context
|
||
)
|
||
else:
|
||
self._execute_command_async(cmd, session, chain=next_chain)
|
||
|
||
def _trigger_result_match_commands(
|
||
self,
|
||
source_command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
chain: Optional[List[str]] = None,
|
||
interrupt_context: Optional[Dict[str, Any]] = None,
|
||
):
|
||
source_id = source_command.get("id")
|
||
if not source_id:
|
||
return
|
||
|
||
chain = list(chain or [])
|
||
next_chain = chain + [source_id]
|
||
|
||
try:
|
||
commands = self._load_commands()
|
||
except Exception as e:
|
||
logger.debug(f"条件分支命令加载失败,跳过: {e}")
|
||
return
|
||
|
||
for cmd in commands:
|
||
if not cmd.get("enabled", True):
|
||
continue
|
||
|
||
target_id = cmd.get("id")
|
||
trigger = cmd.get("trigger", {})
|
||
if trigger.get("type") != "command_result_match":
|
||
continue
|
||
if str(trigger.get("command_id", "")).strip() != source_id:
|
||
continue
|
||
if not target_id or target_id in next_chain:
|
||
continue
|
||
if not self._matches_scope(cmd, session):
|
||
continue
|
||
dispatch = self._prepare_command_result_trigger_dispatch(cmd, session)
|
||
if not dispatch:
|
||
continue
|
||
|
||
logger.info(
|
||
f"[CMD] 条件分支触发: {source_command.get('name')} -> {cmd.get('name')} "
|
||
f"(标签页={session.id})"
|
||
)
|
||
combined_context = copy.deepcopy(interrupt_context) if interrupt_context is not None else None
|
||
extra_context = dispatch.get("interrupt_context")
|
||
if extra_context:
|
||
combined_context = combined_context or {}
|
||
combined_context.update(copy.deepcopy(extra_context))
|
||
if interrupt_context is not None:
|
||
self._dispatch_interrupt_followup_command(
|
||
cmd, session, next_chain, combined_context or interrupt_context
|
||
)
|
||
else:
|
||
self._execute_command_async(
|
||
cmd,
|
||
session,
|
||
chain=next_chain,
|
||
interrupt_context=combined_context,
|
||
trigger_rollback=dispatch.get("rollback"),
|
||
)
|
||
|
||
def _trigger_result_event_commands(
|
||
self,
|
||
source_command: Dict[str, Any],
|
||
session: 'TabSession',
|
||
chain: Optional[List[str]] = None,
|
||
interrupt_context: Optional[Dict[str, Any]] = None,
|
||
):
|
||
source_id = str(source_command.get("id", "")).strip()
|
||
if not source_id:
|
||
return
|
||
|
||
chain = list(chain or [])
|
||
next_chain = chain + [source_id]
|
||
|
||
try:
|
||
commands = self._load_commands()
|
||
except Exception as e:
|
||
logger.debug(f"结果事件命令加载失败,跳过: {e}")
|
||
return
|
||
|
||
for cmd in commands:
|
||
if not cmd.get("enabled", True):
|
||
continue
|
||
target_id = str(cmd.get("id", "")).strip()
|
||
if not target_id or target_id in next_chain:
|
||
continue
|
||
trigger = cmd.get("trigger", {}) or {}
|
||
if str(trigger.get("type", "")).strip() != "command_result_event":
|
||
continue
|
||
if not self._matches_scope(cmd, session):
|
||
continue
|
||
dispatch = self._prepare_command_result_event_dispatch(cmd, session)
|
||
if not dispatch:
|
||
continue
|
||
|
||
logger.info(
|
||
f"[CMD] 结果事件触发: {source_command.get('name')} -> {cmd.get('name')} "
|
||
f"(标签页={session.id})"
|
||
)
|
||
combined_context = copy.deepcopy(interrupt_context) if interrupt_context is not None else None
|
||
extra_context = dispatch.get("interrupt_context")
|
||
if extra_context:
|
||
combined_context = combined_context or {}
|
||
combined_context.update(copy.deepcopy(extra_context))
|
||
if interrupt_context is not None:
|
||
self._dispatch_interrupt_followup_command(
|
||
cmd, session, next_chain, combined_context or interrupt_context
|
||
)
|
||
else:
|
||
self._execute_command_async(
|
||
cmd,
|
||
session,
|
||
chain=next_chain,
|
||
interrupt_context=combined_context,
|
||
trigger_rollback=dispatch.get("rollback"),
|
||
)
|