import copy import threading import time import uuid from typing import Any, Dict, List, Optional, TYPE_CHECKING from app.core.config import get_logger if TYPE_CHECKING: from app.core.tab_pool import TabSession logger = get_logger("CMD_ENG") class CommandEngineRuntimeMixin: def _workflow_queue_key( self, command: Dict[str, Any], trigger_rollback: Optional[Dict[str, Any]] = None, ) -> str: cmd_id = str((command or {}).get("id", "")).strip() rollback = trigger_rollback or {} kind = str(rollback.get("kind", "") or "").strip() token = str(rollback.get("token", "") or "").strip() if cmd_id and kind and token: return f"{cmd_id}:{kind}:{token}" return cmd_id def _dedupe_deferred_items(self, items: List[Dict[str, Any]]) -> List[Dict[str, Any]]: deduped: List[Dict[str, Any]] = [] seen: set[str] = set() for item in items or []: if not isinstance(item, dict): continue queue_key = str(item.get("queue_key", "") or "").strip() if not queue_key: queue_key = self._workflow_queue_key( item.get("command") or {}, item.get("trigger_rollback") if isinstance(item.get("trigger_rollback"), dict) else None, ) if queue_key: item = dict(item) item["queue_key"] = queue_key if queue_key and queue_key in seen: continue if queue_key: seen.add(queue_key) deduped.append(item) return deduped def _has_active_workflow(self, session: 'TabSession') -> bool: runtime = self._get_active_workflow_runtime(session) return bool(runtime and runtime.get("active")) def begin_workflow_runtime( self, session: 'TabSession', *, task_id: str = "", preset_name: str = "", priority: Optional[int] = None, ) -> Dict[str, Any]: runtime = { "runtime_id": uuid.uuid4().hex, "task_id": str(task_id or "").strip(), "preset_name": str(preset_name or "").strip(), "parser_id": str(getattr(session, "_workflow_parser_id", "") or "").strip().lower(), "target_side": str(getattr(session, "_workflow_target_side", "") or "").strip().lower(), "priority": self._normalize_priority(priority, self._get_request_priority_baseline()), "current_step_index": -1, "current_step_action": "", "pending_interrupts": [], "pending_interrupt_ids": set(), "deferred_commands": [], "deferred_command_ids": set(), "active": True, "interrupting": False, } with self._lock: stack = list(getattr(session, "_workflow_runtime_stack", None) or []) stack.append(runtime) setattr(session, "_workflow_runtime_stack", stack) setattr(session, "_workflow_runtime_id", runtime["runtime_id"]) setattr(session, "_workflow_target_side", runtime["target_side"]) return runtime def update_workflow_runtime_step( self, session: 'TabSession', step_index: int, step: Optional[Dict[str, Any]] = None, ): runtime = self._get_active_workflow_runtime(session) if not runtime: return runtime["current_step_index"] = int(step_index) runtime["current_step_action"] = str((step or {}).get("action", "") or "") def update_workflow_target_side(self, session: 'TabSession', side: str) -> bool: normalized = str(side or "").strip().lower() if normalized not in {"left", "right"}: return False runtime = self._get_active_workflow_runtime(session) if not runtime: return False runtime["target_side"] = normalized setattr(session, "_workflow_target_side", normalized) return True def finish_workflow_runtime( self, session: 'TabSession', *, aborted: bool = False, ) -> Optional[Dict[str, Any]]: with self._lock: stack = list(getattr(session, "_workflow_runtime_stack", None) or []) if not stack: return None runtime = stack.pop() setattr(session, "_workflow_runtime_stack", stack) pending_interrupts = list(runtime.get("pending_interrupts") or []) deferred_commands = list(runtime.get("deferred_commands") or []) stop_reason = str(getattr(session, "_workflow_stop_reason", "") or "").strip() preserve_pending_interrupts = bool(pending_interrupts) and ( not aborted or stop_reason in {"command_interrupt", "command_interrupt_abort"} ) if preserve_pending_interrupts: deferred_ids = { str(item.get("queue_key", "") or "").strip() or self._workflow_queue_key( item.get("command") or {}, item.get("trigger_rollback") if isinstance(item.get("trigger_rollback"), dict) else None, ) for item in deferred_commands if isinstance(item, dict) } for item in pending_interrupts: if not isinstance(item, dict): continue command = copy.deepcopy(item.get("command") or {}) queue_key = str(item.get("queue_key", "") or "").strip() or self._workflow_queue_key( command, item.get("trigger_rollback") if isinstance(item.get("trigger_rollback"), dict) else None, ) if queue_key and queue_key in deferred_ids: continue deferred_commands.append({ "command": command, "chain": list(item.get("chain") or []), "interrupt_context": copy.deepcopy(item.get("interrupt_context") or {}), "trigger_rollback": copy.deepcopy(item.get("trigger_rollback") or {}), "queue_key": queue_key, "queued_at": float(item.get("requested_at", time.time()) or time.time()), }) if queue_key: deferred_ids.add(queue_key) runtime["active"] = False runtime["interrupting"] = False runtime["pending_interrupts"] = [] runtime["pending_interrupt_ids"] = set() preserve_deferred = bool(deferred_commands) and ( not aborted or stop_reason == "command_interrupt_abort" ) if stack: parent = stack[-1] if preserve_deferred: parent_deferred = parent.setdefault("deferred_commands", []) parent_ids = parent.setdefault("deferred_command_ids", set()) for item in deferred_commands: queue_key = str(item.get("queue_key", "") or "").strip() or self._workflow_queue_key( item.get("command") or {}, item.get("trigger_rollback") if isinstance(item.get("trigger_rollback"), dict) else None, ) if queue_key and queue_key in parent_ids: continue parent_deferred.append(item) if queue_key: parent_ids.add(queue_key) elif preserve_deferred: existing = list(getattr(session, "_pending_post_workflow_commands", None) or []) existing_ids = { str((item.get("command") or {}).get("id", "")).strip() for item in existing if isinstance(item, dict) } merged = self._dedupe_deferred_items(existing + deferred_commands) setattr(session, "_pending_post_workflow_commands", merged) else: setattr(session, "_pending_post_workflow_commands", []) parent = stack[-1] if stack else None if parent: setattr(session, "_workflow_runtime_id", str(parent.get("runtime_id") or "")) setattr(session, "_workflow_parser_id", str(parent.get("parser_id") or "")) setattr(session, "_workflow_target_side", str(parent.get("target_side") or "")) else: setattr(session, "_workflow_runtime_id", "") setattr(session, "_workflow_parser_id", "") setattr(session, "_workflow_target_side", "") return runtime def flush_deferred_workflow_commands(self, session: 'TabSession'): if bool(getattr(self, "_shutdown_requested", False)): return with self._lock: items = list(getattr(session, "_pending_post_workflow_commands", None) or []) setattr(session, "_pending_post_workflow_commands", []) if not items: return requeued = 0 for item in items: command = copy.deepcopy((item or {}).get("command") or {}) if not command or not command.get("enabled", True): continue dispatched = self._execute_command_async( command, session, chain=list((item or {}).get("chain") or []), interrupt_context=copy.deepcopy((item or {}).get("interrupt_context") or {}) or None, trigger_rollback=copy.deepcopy((item or {}).get("trigger_rollback") or {}) or None, ) if dispatched: requeued += 1 logger.info( f"[CMD] 已将延后命令交回命令调度器执行 " f"(标签页={getattr(session, 'id', '')}, count={requeued})" ) def schedule_deferred_workflow_commands( self, session: 'TabSession', *, delay_sec: float = 0.25, ): if bool(getattr(self, "_shutdown_requested", False)): return False delay = max(0.0, float(delay_sec or 0.0)) thread = threading.Thread( target=self.flush_deferred_workflow_commands, args=(session,), daemon=True, name=f"cmd-resume-delay-{getattr(session, 'id', 'tab')}", ) if delay > 0: # Timer waits before dispatching, while command execution itself stays in # the command scheduler path instead of touching the tab from this helper. thread = threading.Timer(delay, self.flush_deferred_workflow_commands, args=(session,)) thread.daemon = True thread.name = f"cmd-resume-delay-{getattr(session, 'id', 'tab')}" thread.start() return True def _get_workflow_interrupt_policy(self, command: Dict[str, Any]) -> str: trigger = command.get("trigger", {}) or {} policy = str( trigger.get("interrupt_policy", command.get("interrupt_policy", "auto")) or "auto" ).strip().lower() return policy if policy in {"auto", "resume", "abort"} else "auto" def _build_workflow_interrupt_message(self, command: Dict[str, Any]) -> str: trigger = command.get("trigger", {}) or {} custom = str( trigger.get("interrupt_message", command.get("interrupt_message", "")) or "" ).strip() if custom: return custom return f"触发 {command.get('name', '命令')},后续工作流已打断,请重试" def _allow_command_during_workflow(self, command: Dict[str, Any]) -> bool: trigger = command.get("trigger", {}) or {} raw = trigger.get("allow_during_workflow", None) if raw is None: trigger_type = str(trigger.get("type", "")).strip().lower() if trigger_type != "page_check": return False policy = self._get_workflow_interrupt_policy(command) if policy in {"resume", "abort"}: return True return self._get_command_priority(command) > self._get_request_priority_baseline() return bool(raw) def _queue_workflow_interrupt( self, command: Dict[str, Any], session: 'TabSession', chain: Optional[List[str]] = None, interrupt_context: Optional[Dict[str, Any]] = None, trigger_rollback: Optional[Dict[str, Any]] = None, ) -> bool: runtime = self._get_active_workflow_runtime(session) if not runtime or not runtime.get("active"): return False if not self._allow_command_during_workflow(command): return False queue_key = self._workflow_queue_key(command, trigger_rollback) if not queue_key: return False with self._lock: pending_ids = runtime.setdefault("pending_interrupt_ids", set()) if queue_key in pending_ids: return False runtime.setdefault("pending_interrupts", []).append({ "command": copy.deepcopy(command), "chain": list(chain or []), "interrupt_context": copy.deepcopy(interrupt_context or {}), "trigger_rollback": copy.deepcopy(trigger_rollback or {}), "queue_key": queue_key, "requested_at": time.time(), "priority": self._get_command_priority(command), }) pending_ids.add(queue_key) setattr(session, "_workflow_stop_reason", "command_interrupt") logger.info( f"[CMD] 请求暂停工作流: {command.get('name')} " f"(标签页={session.id}, 工作流优先级={runtime.get('priority')}, " f"命令优先级={self._get_command_priority(command)})" ) return True def _schedule_command_for_active_workflow( self, command: Dict[str, Any], session: 'TabSession', chain: Optional[List[str]] = None, interrupt_context: Optional[Dict[str, Any]] = None, trigger_rollback: Optional[Dict[str, Any]] = None, ) -> bool: runtime = self._get_active_workflow_runtime(session) if not runtime or not runtime.get("active"): return False if self._allow_command_during_workflow(command): return self._queue_workflow_interrupt( command, session, chain=chain, interrupt_context=interrupt_context, trigger_rollback=trigger_rollback, ) self._defer_command_until_workflow_resume( runtime, command, chain=chain, interrupt_context=interrupt_context, trigger_rollback=trigger_rollback, ) logger.info( f"[CMD] 工作流忙碌,延后执行命令: {command.get('name')} " f"(标签页={session.id}, 工作流优先级={runtime.get('priority')}, " f"命令优先级={self._get_command_priority(command)})" ) return True def workflow_interrupt_requested(self, session: 'TabSession') -> bool: runtime = self._get_active_workflow_runtime(session) if not runtime: return False with self._lock: return bool(runtime.get("pending_interrupts")) def _defer_command_until_workflow_resume( self, runtime: Dict[str, Any], command: Dict[str, Any], chain: Optional[List[str]] = None, interrupt_context: Optional[Dict[str, Any]] = None, trigger_rollback: Optional[Dict[str, Any]] = None, ): queue_key = self._workflow_queue_key(command, trigger_rollback) if not queue_key: return with self._lock: deferred_ids = runtime.setdefault("deferred_command_ids", set()) if queue_key in deferred_ids: return runtime.setdefault("deferred_commands", []).append({ "command": copy.deepcopy(command), "chain": list(chain or []), "interrupt_context": copy.deepcopy(interrupt_context or {}), "trigger_rollback": copy.deepcopy(trigger_rollback or {}), "queue_key": queue_key, "queued_at": time.time(), }) deferred_ids.add(queue_key) def _mark_interrupt_abort( self, command: Dict[str, Any], interrupt_context: Dict[str, Any], ): if interrupt_context.get("abort"): return policy = self._get_workflow_interrupt_policy(command) priority = self._get_command_priority(command) workflow_priority = self._normalize_priority( interrupt_context.get("workflow_priority", self._get_request_priority_baseline()), self._get_request_priority_baseline(), ) if policy == "abort" or (policy == "auto" and priority > workflow_priority): interrupt_context["abort"] = True interrupt_context["message"] = self._build_workflow_interrupt_message(command) interrupt_context["abort_by"] = command.get("name", "") def _dispatch_interrupt_followup_command( self, command: Dict[str, Any], session: 'TabSession', chain: Optional[List[str]], interrupt_context: Dict[str, Any], ): runtime = interrupt_context.get("runtime") or {} workflow_priority = self._normalize_priority( interrupt_context.get("workflow_priority", self._get_request_priority_baseline()), self._get_request_priority_baseline(), ) priority = self._get_command_priority(command) policy = self._get_workflow_interrupt_policy(command) if priority > workflow_priority or policy == "abort": logger.info( f"[CMD] 工作流暂停期间继续执行高优先级命令: {command.get('name')} " f"(标签页={session.id}, 命令优先级={priority}, 工作流优先级={workflow_priority})" ) self._execute_command(command, session, chain=chain, interrupt_context=interrupt_context) self._mark_interrupt_abort(command, interrupt_context) return logger.info( f"[CMD] 延后命令至工作流恢复后执行: {command.get('name')} " f"(标签页={session.id}, 命令优先级={priority}, 工作流优先级={workflow_priority})" ) self._defer_command_until_workflow_resume( runtime, command, chain=chain, interrupt_context=interrupt_context, ) @staticmethod def _interrupt_item_sort_key(item: Dict[str, Any]) -> tuple[int, float]: try: priority = int(item.get("priority", 0) or 0) except (TypeError, ValueError): priority = 0 try: requested_at = float(item.get("requested_at", 0.0) or 0.0) except (TypeError, ValueError): requested_at = 0.0 return -priority, requested_at def _take_next_pending_interrupt( self, runtime: Dict[str, Any], ) -> Optional[Dict[str, Any]]: with self._lock: raw_pending = runtime.get("pending_interrupts") or [] pending = raw_pending if isinstance(raw_pending, list) else list(raw_pending) pending = [item for item in pending if isinstance(item, dict)] if not pending: runtime["pending_interrupts"] = [] runtime["pending_interrupt_ids"] = set() return None best_index = 0 best_key = self._interrupt_item_sort_key(pending[0]) for index in range(1, len(pending)): key = self._interrupt_item_sort_key(pending[index]) if key < best_key: best_index = index best_key = key item = pending.pop(best_index) runtime["pending_interrupts"] = pending return item def _drop_pending_interrupts_by_key( self, runtime: Dict[str, Any], queue_key: str, ) -> None: if not queue_key: return with self._lock: runtime["pending_interrupts"] = [ existing for existing in runtime.get("pending_interrupts", []) if isinstance(existing, dict) and ( str(existing.get("queue_key", "") or "").strip() or self._workflow_queue_key( (existing.get("command") or {}), existing.get("trigger_rollback") if isinstance(existing.get("trigger_rollback"), dict) else None, ) ) != queue_key ] def handle_pending_workflow_interrupts(self, session: 'TabSession') -> Dict[str, Any]: runtime = self._get_active_workflow_runtime(session) if not runtime or runtime.get("interrupting"): return {"handled": False, "abort": False, "message": ""} with self._lock: pending = list(runtime.get("pending_interrupts") or []) if not pending: return {"handled": False, "abort": False, "message": ""} with self._lock: if runtime.get("interrupting"): return {"handled": False, "abort": False, "message": ""} runtime["interrupting"] = True interrupt_context = { "workflow_priority": runtime.get("priority", self._get_request_priority_baseline()), "runtime": runtime, "abort": False, "message": "", "abort_by": "", } try: while True: item = self._take_next_pending_interrupt(runtime) if not item: break cmd = copy.deepcopy(item.get("command") or {}) chain = list(item.get("chain") or []) queue_key = str(item.get("queue_key", "") or "").strip() or self._workflow_queue_key( cmd, item.get("trigger_rollback") if isinstance(item.get("trigger_rollback"), dict) else None, ) interrupt_payload = copy.deepcopy(item.get("interrupt_context") or {}) self._drop_pending_interrupts_by_key(runtime, queue_key) with self._lock: runtime.setdefault("pending_interrupt_ids", set()).discard(queue_key) if not cmd or not cmd.get("enabled", True): continue logger.info( f"[CMD] 工作流已暂停,执行插队命令: {cmd.get('name')} " f"(标签页={session.id}, 步骤={runtime.get('current_step_index')})" ) merged_context = dict(interrupt_context) if interrupt_payload: merged_context.update(interrupt_payload) self._execute_command(cmd, session, chain=chain, interrupt_context=merged_context) self._mark_interrupt_abort(cmd, interrupt_context) if interrupt_context.get("abort"): with self._lock: runtime["pending_interrupts"] = [] runtime["pending_interrupt_ids"] = set() break finally: with self._lock: runtime["interrupting"] = False if interrupt_context.get("abort"): setattr(session, "_workflow_stop_reason", "command_interrupt_abort") else: setattr(session, "_workflow_stop_reason", None) return { "handled": True, "abort": bool(interrupt_context.get("abort")), "message": str(interrupt_context.get("message", "") or ""), "abort_by": str(interrupt_context.get("abort_by", "") or ""), }