Initial commit
This commit is contained in:
commit
57fc3525eb
7311 files changed
+1291398
No files matched your search
@@ -0,0 +1,962 @@
|
||||
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"),
|
||||
)
|
||||
Reference in new issue
Block a user