"""L4 SendTextFlow：发送文本消息状态机。 8 个 transition：activate → click_search_box → type_query → open_session → focus_input → type_content → send → cleanup。 会话缓存命中时跳过前 4 步，仅做 _verify_session_still_open。 异常时调 _reset_to_idle 恢复 UI 状态。 """ from __future__ import annotations import asyncio import logging import random import time from typing import Awaitable, Callable, Optional from woc_bridge.ui.backends.base import WindowGeometry from woc_bridge.ui.errors import FlowError, PermanentError from woc_bridge.ui.flow import ( Flow, FlowContext, FlowResult, FlowState, _FLOW_TIMEOUT_SEC, ) logger = logging.getLogger("woc-bridge") # 微信窗口标题 _WECHAT_WINDOW_TITLE = "微信" # DB 校验参数 _DB_VERIFY_TIMEOUT_SEC = 3.0 _DB_VERIFY_INTERVAL_SEC = 0.2 class SendTextFlow(Flow): """发送文本消息 Flow。""" def __init__(self, actions, db_reader=None, session_cache=None) -> None: super().__init__(actions, db_reader) self.session_cache = session_cache # 基线消息的 local_id，与 before_msg_id（create_time）配合用于 DB 游标查询 self._before_msg_local_id: int = 0 async def run(self, ctx: FlowContext) -> FlowResult: """执行发送文本流程。""" started_at = time.monotonic() # 后台 task：获取 before_msg_id（与 _activate 并行） before_msg_task: Optional[asyncio.Task] = None logger.info( "[flow:send_text] START to_wxid=%s display_name=%s content_len=%d client_request_id=%s", ctx.to_wxid, ctx.display_name, len(ctx.content), ctx.client_request_id, ) try: async with asyncio.timeout(_FLOW_TIMEOUT_SEC): # 检查会话缓存（用 to_wxid 做 key，display_name 非唯一） cache_hit = False if self.session_cache is not None: cache_hit = self.session_cache.get(ctx.to_wxid) if cache_hit: logger.info( "[flow:send_text] session cache hit for %s", ctx.to_wxid, ) if cache_hit: # 跳过 click_search_box ~ open_session，但仍需激活窗口 # （30s 内用户可能切到其他应用，微信失去焦点） t0 = time.perf_counter() before_msg_task = asyncio.create_task( self._get_latest_create_time(ctx.to_wxid) ) # 仅激活窗口 + 获取几何，跳过 Esc 清场（会话已打开） await self.actions.backend.activate_window(_WECHAT_WINDOW_TITLE) ctx.win_geom = self._ensure_valid_geometry( await self.actions.backend.get_window_geometry( _WECHAT_WINDOW_TITLE ) ) await self._verify_session_still_open(ctx) ctx.current_state = FlowState.SESSION_OPENED logger.info( "[flow:send_text] cache_hit branch done geom=%dx%d (%.0fms)", ctx.win_geom.width, ctx.win_geom.height, (time.perf_counter() - t0) * 1000, ) else: # 完整流程 await self._activate(ctx) # 并行启动 before_msg_id 获取 before_msg_task = asyncio.create_task( self._get_latest_create_time(ctx.to_wxid) ) await self._click_search_box(ctx) await self._type_query(ctx) await self._open_session(ctx) await self._focus_input(ctx) await self._type_content(ctx) # 等待 before_msg_task 完成（如果已启动） if before_msg_task is not None: ct, lid = await before_msg_task ctx.before_msg_id = ct self._before_msg_local_id = lid logger.info( "[flow:send_text] before_msg baseline ct=%d local_id=%d", ct, lid, ) else: logger.warning( "[flow:send_text] before_msg_task is None, baseline unavailable" ) await self._send(ctx) await self._cleanup(ctx) # 成功：更新会话缓存（用 to_wxid 做 key） if self.session_cache is not None and ctx.verified: self.session_cache.set(ctx.to_wxid) logger.info( "[flow:send_text] DONE success=%s verified=%s local_id=%s state=%s (%.0fms)", True, ctx.verified, ctx.local_send_id, ctx.current_state, (time.monotonic() - started_at) * 1000, ) return FlowResult( success=True, local_id=ctx.local_send_id, verified=ctx.verified, state=ctx.current_state, image_confidence=ctx.image_confidence, duration_ms=(time.monotonic() - started_at) * 1000, ) except (FlowError, asyncio.TimeoutError) as exc: logger.warning( "[flow:send_text] failed at state=%s: %s: %s", ctx.current_state, type(exc).__name__, exc, ) # 尝试恢复 try: await self._reset_to_idle(ctx.win_geom) except Exception as reset_exc: logger.warning( "[flow:send_text] reset_to_idle failed: %s", reset_exc ) # 失败时仅失效当前联系人会话缓存 if self.session_cache is not None: self.session_cache.invalidate(ctx.to_wxid) error_code = "SEND_FAILED" error_msg = str(exc) if isinstance(exc, FlowError) and exc.code: error_code = exc.code elif isinstance(exc, asyncio.TimeoutError): error_code = "SEND_TIMEOUT" return FlowResult( success=False, local_id=ctx.local_send_id, verified=False, error=error_msg, error_code=error_code, state=FlowState.FAILED, duration_ms=(time.monotonic() - started_at) * 1000, ) except Exception as exc: logger.exception("[flow:send_text] unexpected exception") try: await self._reset_to_idle(ctx.win_geom) except Exception: pass if self.session_cache is not None: self.session_cache.invalidate(ctx.to_wxid) return FlowResult( success=False, error=str(exc), error_code="BRIDGE_INTERNAL_ERROR", state=FlowState.FAILED, duration_ms=(time.monotonic() - started_at) * 1000, ) finally: # 兜底：确保 before_msg_task 被取消（CancelledError 路径也走这里） # Python 3.8+ 中 CancelledError 继承自 BaseException， # except Exception 无法捕获，finally 块保证清理执行 if before_msg_task is not None and not before_msg_task.done(): before_msg_task.cancel() try: await before_msg_task except (asyncio.CancelledError, Exception): pass # ------------------------------------------------------------------ # Transitions # ------------------------------------------------------------------ def _ensure_valid_geometry(self, geom: Optional[WindowGeometry]) -> WindowGeometry: """校验窗口几何有效，防止拿到 1×1 隐藏窗后继续误点 (0,0)。 返回校验后的 WindowGeometry，方便调用方获得窄化类型。 """ if geom is None: raise PermanentError( "WINDOW_GEOMETRY_INVALID", "无法获取微信窗口几何，无法执行 UI 操作", ) if geom.width < 200 or geom.height < 200: raise PermanentError( "WINDOW_GEOMETRY_INVALID", f"微信窗口几何异常 {geom.width}x{geom.height}，无法执行 UI 操作", ) return geom async def _activate(self, ctx: FlowContext) -> None: """激活窗口 + 获取几何 + 重置状态（回到会话列表首页）。""" await self.actions.backend.activate_window(_WECHAT_WINDOW_TITLE) ctx.win_geom = self._ensure_valid_geometry( await self.actions.backend.get_window_geometry(_WECHAT_WINDOW_TITLE) ) # 重置状态：点击左侧"会话管理"图标，强制回到会话列表首页， # 清除可能存在的搜索覆盖层、弹窗或非会话页面。 await self.actions.click_element("session_manager_icon", ctx.win_geom) await self.actions.backend.key_press("Escape") await asyncio.sleep(0.3) ctx.current_state = FlowState.WINDOW_ACTIVATED logger.info( "[flow:send_text] activated window geom=%dx%d", ctx.win_geom.width, ctx.win_geom.height, ) async def _click_search_box(self, ctx: FlowContext) -> None: """点击搜索框。""" t0 = time.perf_counter() logger.info("[flow:send_text] step=search_box click start") await self.actions.click_element("search_box", ctx.win_geom) ctx.current_state = FlowState.SEARCH_BOX_CLICKED # 点击后短暂等待 UI 响应，高并发场景下调短以提升吞吐 await asyncio.sleep(0.2) logger.info( "[flow:send_text] step=search_box click done (%.0fms)", (time.perf_counter() - t0) * 1000, ) async def _type_query(self, ctx: FlowContext) -> None: """输入搜索查询（display_name）。""" t0 = time.perf_counter() logger.info( "[flow:send_text] step=type_query start display_name=%r", ctx.display_name, ) # 清空可能的残留：Ctrl+A 全选 + BackSpace 删除，比 BackSpace×30 更可靠 await self.actions.backend.key_press("ctrl+a") await self.actions.backend.key_press("BackSpace") await asyncio.sleep(0.2) await self.actions.backend.type_text(ctx.display_name) ctx.current_state = FlowState.QUERY_TYPED # 自适应等待搜索结果渲染；P1 阶段无 OpenCV 时 find_element 的 geom 兜底 # 不可信，因此 _check_search_result_appeared 只在 image 命中时返回 True。 appeared = await self._wait_for_condition( lambda: self._check_search_result_appeared(ctx), timeout=1.5, interval=0.3, ) if not appeared: logger.warning( "[flow:send_text] search result not appeared in 1.5s, continue (%.0fms)", (time.perf_counter() - t0) * 1000, ) else: logger.info( "[flow:send_text] step=type_query done (search result appeared, %.0fms)", (time.perf_counter() - t0) * 1000, ) async def _open_session(self, ctx: FlowContext) -> None: """点击搜索结果第一项打开会话。""" t0 = time.perf_counter() logger.info("[flow:send_text] step=open_session click search_result_first start") await self.actions.click_element("search_result_first", ctx.win_geom) ctx.current_state = FlowState.SESSION_OPENED # 自适应等待 input_box 出现；P1 阶段无 OpenCV 时 find_element 的 geom 兜底 # 不可信，因此 _check_input_box_appeared 只在 image 命中时返回 True。 appeared = await self._wait_for_condition( lambda: self._check_input_box_appeared(ctx), timeout=1.5, interval=0.3, ) if not appeared: logger.warning( "[flow:send_text] input_box not appeared in 1.5s, continue (%.0fms)", (time.perf_counter() - t0) * 1000, ) else: logger.info( "[flow:send_text] step=open_session done (input_box appeared, %.0fms)", (time.perf_counter() - t0) * 1000, ) async def _focus_input(self, ctx: FlowContext) -> None: """聚焦输入框。""" t0 = time.perf_counter() logger.info("[flow:send_text] step=focus_input click input_box start") await self.actions.click_element("input_box", ctx.win_geom) ctx.current_state = FlowState.INPUT_FOCUSED await asyncio.sleep(0.1) logger.info( "[flow:send_text] step=focus_input done (%.0fms)", (time.perf_counter() - t0) * 1000, ) async def _type_content(self, ctx: FlowContext) -> None: """输入消息内容。""" t0 = time.perf_counter() # 清理开头/结尾的空白和换行，避免输入框视觉为空、发送按钮灰色 cleaned_content = ctx.content.strip() if cleaned_content != ctx.content: logger.info( "[flow:send_text] step=type_content stripped leading/trailing whitespace: " "original_len=%d cleaned_len=%d", len(ctx.content), len(cleaned_content), ) ctx.content = cleaned_content logger.info( "[flow:send_text] step=type_content start content_len=%d", len(ctx.content), ) await self.actions.backend.type_text(ctx.content) ctx.current_state = FlowState.TEXT_TYPED logger.info( "[flow:send_text] step=type_content done (%.0fms)", (time.perf_counter() - t0) * 1000, ) async def _send(self, ctx: FlowContext) -> None: """点击发送按钮 + 校验。""" t0 = time.perf_counter() logger.info("[flow:send_text] step=send click send_button start") await self.actions.click_element("send_button", ctx.win_geom) ctx.current_state = FlowState.SENT ctx.local_send_id = f"local_{int(time.time())}_{random.randint(1000,9999)}" ctx.verified = await self._verify_sent(ctx) logger.info( "[flow:send_text] step=send done local_id=%s verified=%s (%.0fms)", ctx.local_send_id, ctx.verified, (time.perf_counter() - t0) * 1000, ) async def _cleanup(self, ctx: FlowContext) -> None: """清理：Esc。""" t0 = time.perf_counter() logger.info("[flow:send_text] step=cleanup Esc start") await self.actions.backend.key_press("Escape") await asyncio.sleep(0.2) ctx.current_state = FlowState.CLEANED_UP logger.info( "[flow:send_text] step=cleanup done (%.0fms)", (time.perf_counter() - t0) * 1000, ) # ------------------------------------------------------------------ # 校验 # ------------------------------------------------------------------ async def _verify_sent(self, ctx: FlowContext) -> bool: """发送结果校验：DB 校验优先，失败降级截图校验。""" t0 = time.perf_counter() if self.db_reader is None: logger.warning( "[flow:send_text] no db_reader, fall back to screenshot verify" ) result = await self._verify_by_screenshot(ctx) logger.info( "[flow:send_text] _verify_sent done (no db_reader) result=%s (%.0fms)", result, (time.perf_counter() - t0) * 1000, ) return result # before_msg_id=0 表示无法建立基线（DB 不可用或会话无历史消息）， # 直接降级截图校验，避免 cursor=0 查询返回所有历史消息导致假阳性 if ctx.before_msg_id <= 0: logger.warning( "[flow:send_text] before_msg_id=%d, skip DB verify, fall back to screenshot", ctx.before_msg_id, ) result = await self._verify_by_screenshot(ctx) logger.info( "[flow:send_text] _verify_sent done (no baseline) result=%s (%.0fms)", result, (time.perf_counter() - t0) * 1000, ) return result deadline = time.monotonic() + _DB_VERIFY_TIMEOUT_SEC attempts = 0 while time.monotonic() < deadline: attempts += 1 try: result = await asyncio.to_thread( self.db_reader.get_messages_by_session, ctx.to_wxid, cursor=ctx.before_msg_id, cursor_local_id=self._before_msg_local_id, limit=3, direction="after", is_sender=None, ) messages = result.get("messages", []) if messages: # 防串号：校验是否有消息内容匹配发送的 content # 注意：get_messages_by_session 按 talker 分表查询，talker 字段恒等于 to_wxid， # 无法通过 talker 字段检测串号。改为内容匹配校验。 for msg in messages: msg_content = msg.get("content", "") # 微信消息内容可能包含发送者前缀（群消息），用 in 匹配 if ctx.content and ctx.content in msg_content: logger.info( "[flow:send_text] DB verify OK (attempt=%d, content matched, is_sender=%s, %d new msgs)", attempts, msg.get("is_sender"), len(messages), ) return True # 有新消息但内容不匹配 → 可能串号或消息未到达 logger.warning( "[flow:send_text] DB verify: %d new msgs but content not matched (attempt=%d, contents=%s)", len(messages), attempts, [m.get("content", "")[:50] for m in messages], ) # 继续轮询，可能是 DB 写入延迟 except Exception as exc: logger.debug( "[flow:send_text] DB verify attempt=%d exception: %s", attempts, exc, ) await asyncio.sleep(_DB_VERIFY_INTERVAL_SEC) logger.warning( "[flow:send_text] DB verify timeout after %ds/%d attempts, fall back to screenshot", _DB_VERIFY_TIMEOUT_SEC, attempts, ) result = await self._verify_by_screenshot(ctx) logger.info( "[flow:send_text] _verify_sent done (DB timeout) result=%s (%.0fms)", result, (time.perf_counter() - t0) * 1000, ) return result async def _verify_by_screenshot(self, ctx: FlowContext) -> bool: """截图校验：轮询等待 input_box_empty 模板出现。 策略说明： - OpenCV image 命中 → 可靠校验通过，返回 True - geom 兜底命中 → 不可靠，继续轮询等待 image 命中；超时后返回 False - 超时/异常 → 返回 False geom 兜底永远返回坐标，无法证明输入框已清空。以往乐观返回 True 会掩盖 真实发送失败，现改为只有 image 命中才认为校验通过。 """ if ctx.win_geom is None: logger.warning("[flow:send_text] screenshot verify skipped: win_geom is None") return False t0 = time.perf_counter() deadline = time.monotonic() + 3.0 attempts = 0 last_strategy: Optional[str] = None last_conf: float = 0.0 while time.monotonic() < deadline: attempts += 1 try: elem = await self.actions.find_element( "input_box_empty", ctx.win_geom ) if elem is None: continue if elem.strategy == "image": logger.info( "[flow:send_text] screenshot verify OK (image matched, conf=%.3f, attempts=%d, %.0fms)", elem.confidence, attempts, (time.perf_counter() - t0) * 1000, ) return True # geom 兜底：记录策略，继续轮询看 image 是否能匹配 last_strategy = elem.strategy last_conf = elem.confidence except Exception as exc: logger.debug( "[flow:send_text] screenshot verify attempt=%d exception: %s", attempts, exc, ) await asyncio.sleep(0.3) # 超时：只有 image 命中才算成功，geom 兜底不再乐观返回 if last_strategy == "geom": logger.warning( "[flow:send_text] screenshot verify FAIL: only geom fallback matched, " "image not matched in 3s/%d attempts, %.0fms — cannot prove send success", attempts, (time.perf_counter() - t0) * 1000, ) return False logger.warning( "[flow:send_text] screenshot verify FAIL: input_box_empty not found in 3s " "(attempts=%d, %.0fms)", attempts, (time.perf_counter() - t0) * 1000, ) return False async def _verify_session_still_open(self, ctx: FlowContext) -> None: """会话缓存命中时校验会话仍打开（input_box 存在）。""" t0 = time.perf_counter() # 获取窗口几何（缓存命中时未走 _activate），并校验/窄化类型 ctx.win_geom = self._ensure_valid_geometry( await self.actions.backend.get_window_geometry(_WECHAT_WINDOW_TITLE) ) try: elem = await self.actions.wait_for( "input_box", ctx.win_geom, timeout=2.0, interval=0.3 ) if elem is None: logger.warning( "[flow:send_text] session_still_open FAIL: input_box not found (%.0fms)", (time.perf_counter() - t0) * 1000, ) raise PermanentError( "ELEMENT_NOT_FOUND", "session cache hit but input_box not found", ) logger.info( "[flow:send_text] session_still_open OK (input_box found, strategy=%s, %.0fms)", elem.strategy, (time.perf_counter() - t0) * 1000, ) except PermanentError: raise except Exception as exc: logger.warning( "[flow:send_text] session_still_open exception: %s (%.0fms)", exc, (time.perf_counter() - t0) * 1000, ) raise PermanentError( "ELEMENT_NOT_FOUND", f"session cache verify failed: {exc}", ) # ------------------------------------------------------------------ # 自适应轮询 # ------------------------------------------------------------------ async def _wait_for_condition( self, condition_fn: Callable[[], Awaitable[bool]], timeout: float, interval: float, ) -> bool: """自适应轮询：condition_fn 返回 True 时立即返回，超时返回 False。""" deadline = time.monotonic() + timeout while time.monotonic() < deadline: try: if await condition_fn(): return True except Exception: pass await asyncio.sleep(interval) return False async def _check_search_result_appeared(self, ctx: FlowContext) -> bool: """检查搜索结果是否真正出现。 P1 阶段：find_element 在 image 匹配失败时会回退到 geom 兜底， 而 geom 兜底只是返回 YAML profile 中写死的比例坐标，不能证明 搜索结果已渲染。因此只有 image 命中（strategy == "image"） 才视为可靠出现。 """ try: elem = await self.actions.find_element( "search_result_first", ctx.win_geom ) return elem is not None and elem.strategy == "image" except Exception: return False async def _check_input_box_appeared(self, ctx: FlowContext) -> bool: """检查输入框是否真正出现。 同 _check_search_result_appeared，只有 image 命中才视为可靠。 """ try: elem = await self.actions.find_element("input_box", ctx.win_geom) return elem is not None and elem.strategy == "image" except Exception: return False # ------------------------------------------------------------------ # DB 辅助 # ------------------------------------------------------------------ async def _get_latest_create_time(self, to_wxid: str) -> tuple[int, int]: """获取目标会话当前最新消息的 (create_time, local_id)。""" if self.db_reader is None: logger.debug("[flow:send_text] get_latest_create_time: db_reader is None") return (0, 0) t0 = time.perf_counter() try: result = await asyncio.to_thread( self.db_reader.get_messages_by_session, to_wxid, cursor=0, limit=1, direction="before", is_sender=None, ) messages = result.get("messages", []) if messages: ct = int(messages[0].get("create_time", 0)) lid = int(messages[0].get("local_id", 0)) logger.info( "[flow:send_text] get_latest_create_time OK to_wxid=%s ct=%d local_id=%d (%.0fms)", to_wxid, ct, lid, (time.perf_counter() - t0) * 1000, ) return (ct, lid) logger.info( "[flow:send_text] get_latest_create_time: no history msgs for to_wxid=%s (%.0fms)", to_wxid, (time.perf_counter() - t0) * 1000, ) except Exception as exc: logger.warning( "[flow:send_text] get_latest_create_time exception: %s (%.0fms)", exc, (time.perf_counter() - t0) * 1000, ) return (0, 0)