# -*- coding: utf-8 -*- """GUI 无关的后台运行时：日志转发与机器人轮询线程。 原先住在 wechat_gui.py（Tk 控制台）里，Qt 控制台 import 它时会连带把整个 tkinter/tcl 拖进进程——打包后的 EXE 每次冷启动都白付这笔钱。抽出来之后两个 界面共用，谁也不用替对方的依赖买单。 """ import glob import json import os import tempfile import threading import time import traceback from runtime_paths import application_data_dir MESSAGE_BATCH_WINDOW_SECONDS = 20.0 MESSAGE_BATCH_WINDOW_MIN_SECONDS = 1.0 MESSAGE_BATCH_WINDOW_MAX_SECONDS = 120.0 SEND_DELAY_SECONDS = 1.0 SEND_DELAY_MIN_SECONDS = 0.0 SEND_DELAY_MAX_SECONDS = 30.0 SEND_MODE_AUTO = "auto" SEND_MODE_REVIEW = "review" # 输入框里有人工草稿时，等多少分钟就直接把框里那句发出去。 # # 0 = 关闭（默认）：永远不替人按回车，草稿一直留着，会话被跳过。这是唯一 # 一个"机器人发送的内容不是它自己生成的"的口子，所以默认必须是关的——开不开 # 由用它的人明确决定，而不是装上就替他做主。 FOREIGN_DRAFT_AUTOSEND_MINUTES = 0.0 FOREIGN_DRAFT_AUTOSEND_MIN_MINUTES = 0.0 FOREIGN_DRAFT_AUTOSEND_MAX_MINUTES = 1440.0 def normalize_message_batch_window_seconds(value, default=MESSAGE_BATCH_WINDOW_SECONDS): """读取本地设置时安全归一化消息合并等待时间。""" if isinstance(value, bool): return float(default) try: seconds = float(value) except (TypeError, ValueError): return float(default) if not MESSAGE_BATCH_WINDOW_MIN_SECONDS <= seconds <= MESSAGE_BATCH_WINDOW_MAX_SECONDS: return float(default) return seconds def normalize_send_delay_seconds(value, default=SEND_DELAY_SECONDS): """读取本地设置时安全归一化发送前等待时间。""" if isinstance(value, bool): return float(default) try: seconds = float(value) except (TypeError, ValueError): return float(default) if not SEND_DELAY_MIN_SECONDS <= seconds <= SEND_DELAY_MAX_SECONDS: return float(default) return seconds def normalize_foreign_draft_autosend_minutes( value, default=FOREIGN_DRAFT_AUTOSEND_MINUTES ): """归一化"人工草稿放多久就直接发"的分钟数。 坏值一律回落到默认的 0（关闭）而不是某个中间值：这个开关一旦生效，机器人 会把别人写在输入框里的字发给真实客户。配置读坏了的时候，宁可什么都不做。 """ if isinstance(value, bool): return float(default) try: minutes = float(value) except (TypeError, ValueError): return float(default) if not ( FOREIGN_DRAFT_AUTOSEND_MIN_MINUTES <= minutes <= FOREIGN_DRAFT_AUTOSEND_MAX_MINUTES ): return float(default) return minutes def normalize_send_mode(value, default=SEND_MODE_AUTO): """Normalize persisted send mode to the two production-supported values.""" normalized = str(value or "").strip().lower() if normalized in {SEND_MODE_AUTO, SEND_MODE_REVIEW}: return normalized return SEND_MODE_REVIEW if default == SEND_MODE_REVIEW else SEND_MODE_AUTO def cancel_assistant_review_for_state(state, root): """Close only the explicitly cancelled episode; never start native I/O.""" if not isinstance(state, dict) or not state.get("assistant_review_id"): return True event = state.get("database_event") or {} account = str(state.get("account") or event.get("account") or "") if not account: return False coordinator = None try: from review_assistant import ReviewAssistantCoordinator coordinator = ReviewAssistantCoordinator(root=root, account=account) if coordinator.cancel_review(state) is False: print("[助理审核] 任务已移除，但提醒取消尚未保存，请检查审核提醒状态") return False return True except Exception as exc: print(f"[助理审核] 任务已移除，但提醒取消失败（{type(exc).__name__}），请检查审核提醒状态") return False finally: if coordinator is not None: coordinator.close() def delete_pending_reply_file(keys, path="", *, handoff=False, confirm_uncertain=False): """Atomically remove selected reply tasks while the bot is not running.""" requested = {str(key or "").strip() for key in (keys or [])} requested.discard("") result = {"deleted": [], "missing": sorted(requested), "protected": [], "scheduled": []} if handoff: result["requires_confirmation"] = [] if not requested: return result target = str(path or os.path.join(application_data_dir(), "pending_replies.json")) try: with open(target, encoding="utf-8") as handle: raw = json.load(handle) except FileNotFoundError: return result except (OSError, ValueError, TypeError) as exc: result["error"] = str(exc) return result if not isinstance(raw, dict): result["error"] = "待回复队列文件格式不正确" return result pending = raw["pending"] if isinstance(raw.get("pending"), dict) else raw if handoff: history = raw.get("manual_handoffs", {}) if not isinstance(history, dict): result["error"] = "人工接管记录格式不正确，无法安全转交人工" return result if pending is raw: pending = {key: state for key, state in raw.items() if key != "manual_handoffs"} raw = {"pending": pending, "manual_handoffs": history} else: raw["manual_handoffs"] = history removed = [] protocol = raw.get("transport") == "protocol" if handoff and protocol and not isinstance(raw.get("seen", {}), dict): result["error"] = "协议去重记录格式不正确，无法安全转交人工" return result for key in sorted(requested): state = pending.get(key) if not isinstance(state, dict): continue send_state = str(state.get("send_state") or "") stage = str(state.get("stage") or "") sending = send_state == "sending" or stage == "sending" uncertain = send_state in {"uncertain", "sent_uncommitted", "unknown"} or stage in {"receipt_check", "uncertain", "unknown"} if sending or (uncertain and not (handoff and confirm_uncertain)): result["protected"].append(key) if handoff and uncertain and not sending: result["requires_confirmation"].append(key) continue if handoff and protocol and state.get("dedup_key"): raw.setdefault("seen", {})[key] = state["dedup_key"] if handoff: raw["manual_handoffs"][key] = { "state": dict(state), "handed_off_at": time.time(), "receipt_checked_by_user": bool(confirm_uncertain), "delivery_confirmed": False, } pending.pop(key, None) removed.append((key, state)) if not removed: result["missing"] = sorted(requested.difference(result["protected"])) return result directory = os.path.dirname(os.path.abspath(target)) or "." os.makedirs(directory, exist_ok=True) handle = tempfile.NamedTemporaryFile( "w", encoding="utf-8", dir=directory, prefix=".pending_replies_", suffix=".tmp", delete=False, ) try: with handle: json.dump(raw, handle, ensure_ascii=False, indent=2) os.replace(handle.name, target) except Exception as exc: try: os.unlink(handle.name) except OSError: pass result["error"] = str(exc) return result for _key, state in removed: cancel_assistant_review_for_state(state, directory) result["deleted"] = [key for key, _state in removed] result["missing"] = sorted(requested.difference(result["deleted"]).difference(result["protected"])) try: from queue_log import QueueLog queue_log = QueueLog() for key, state in removed: queue_log.append( key, str(state.get("display_name") or "（未识别昵称）"), "转人工" if handoff else "手动删除", ("用户已确认人工接管；发送结果未作确认，保留发送流水和去重记录，不自动重发" if handoff else "用户从回复队列中手动删除；本条未完成回复不再自动发送"), ) except Exception: pass return result def handoff_pending_reply_file(keys, path="", *, confirm_uncertain=False): """Retire stopped work after explicit human takeover; preserve send evidence.""" result = delete_pending_reply_file(keys, path, handoff=True, confirm_uncertain=confirm_uncertain) result["handed_off"] = list(result.get("deleted") or []) return result class LogQueue: """把后台线程的标准输出转发到界面，同时留一份带时间戳的磁盘副本。 界面日志随窗口关闭就没了，出问题时无从回溯——真正卡住发送的那一行往往 几分钟前就被刷走了。落盘副本让事后还查得到。 日志目录用的是可长期写入的数据目录：打包成 EXE 后 __file__ 指向随进程 销毁的解包目录，往那儿写等于退出即丢。 """ LOG_DIR = os.path.join(str(application_data_dir()), "logs") KEEP_FILES = 20 # 「数据保留 N 天」的默认值与允许范围，与设置页的输入框保持一致 DEFAULT_RETENTION_DAYS = 90 MIN_RETENTION_DAYS = 7 MAX_RETENTION_DAYS = 365 _PROGRESS_PREFIXES = ( ("[新消息]", "未读定位"), ("[未读扫描]", "未读扫描"), ("[页面校验]", "页面校验"), ("[会话校验]", "会话校验"), ("[会话识别]", "会话识别"), ("[会话守护]", "会话守护"), ("[页面恢复]", "页面恢复"), ("[页面清理]", "页面清理"), ("[视觉重定位]", "视觉重定位"), ("[视觉安全]", "视觉安全"), ("[视觉队列]", "视觉队列"), ("[目标指纹]", "目标确认"), ("[消息合并]", "消息合并"), ("[剪贴板]", "消息复制"), ("[发送保护]", "发送保护"), ("[发送对账]", "发送对账"), ("[发送回执]", "发送回执"), ("[安全模式]", "安全模式"), ("[安全验证]", "安全验证"), ("[人手]", "人机协同"), ("[AI 页面确认]", "AI 页面确认"), ("[AI页面守护]", "AI 页面守护"), ("[AI]", "AI 处理"), ) def __init__(self, target_queue, retention_days=None): self.target_queue = target_queue self.retention_days = self.normalize_retention_days(retention_days) self._handle = None self._open_log_file() @classmethod def normalize_retention_days(cls, value): """把设置里的「数据保留」天数收进允许范围；不合法一律用默认值。""" try: if isinstance(value, bool): raise TypeError days = int(value) except (TypeError, ValueError): return cls.DEFAULT_RETENTION_DAYS return max(cls.MIN_RETENTION_DAYS, min(cls.MAX_RETENTION_DAYS, days)) def _open_log_file(self): try: os.makedirs(self.LOG_DIR, exist_ok=True) self._prune_old_logs() stamp = time.strftime("%Y%m%d_%H%M%S") self._handle = open( os.path.join(self.LOG_DIR, f"gui_{stamp}.log"), "a", encoding="utf-8", buffering=1, ) except Exception: self._handle = None def _prune_old_logs(self): """按「数据保留天数」和文件数上限清理历史日志。 设置页一直有个「数据保留 90 天」的输入框，能改、能存、能读回来，但过去 代码里没有任何一处按它删过东西——只有一条按文件个数保留最近 20 份的规则。 界面上承诺的事情必须真的发生，否则这个设置就是骗人的。 """ try: files = sorted( glob.glob(os.path.join(self.LOG_DIR, "gui_*.log")), key=os.path.getmtime, ) except Exception: return doomed = list(files[: max(0, len(files) - self.KEEP_FILES + 1)]) keep_seconds = self.retention_days * 86400.0 now = time.time() for path in files: if path in doomed: continue try: age = now - os.path.getmtime(path) except OSError: continue # 时钟被回拨时 age 会是负数。这时宁可留着，也不能把刚写的日志删掉 if age > keep_seconds: doomed.append(path) for path in doomed: try: os.unlink(path) except OSError: pass def write(self, message): text = str(message).rstrip() if not text: return self.target_queue.put(("log", text)) progress = self.progress_from_log(text) if progress: # 旧代码里大量关键闸门只写了 print。把这些结构化标签同步到进程 # 通道，扫描、页面恢复等底层动作也能进入胶囊，不会只显示模型阶段。 self.target_queue.put(("progress", progress)) if self._handle is not None: try: self._handle.write(f"{time.strftime('%H:%M:%S')} {text}\n") except Exception: self._handle = None @classmethod def progress_from_log(cls, message): """把带操作标签的日志压成一行胶囊进程；聊天正文不进入浮窗。""" first_line = next( (line.strip() for line in str(message or "").splitlines() if line.strip()), "", ) if not first_line: return "" for prefix, phase in cls._PROGRESS_PREFIXES: if not first_line.startswith(prefix): continue detail = first_line[len(prefix):].strip() if prefix == "[AI]" and ( not detail or detail.startswith("本次提取的新内容") ): return "" return f"{phase} · {detail}" if detail else phase return "" def flush(self): if self._handle is not None: try: self._handle.flush() except Exception: pass def close(self): if self._handle is not None: try: self._handle.close() except Exception: pass self._handle = None class BotThread(threading.Thread): """在后台运行企业微信轮询，避免阻塞界面主线程。""" def __init__(self, target_queue, reply_text, poll_seconds, mouse_idle_enabled=True, mouse_idle_seconds=5.0, message_batch_window_seconds=MESSAGE_BATCH_WINDOW_SECONDS, send_delay_seconds=SEND_DELAY_SECONDS, send_mode=SEND_MODE_AUTO, foreign_draft_autosend_minutes=FOREIGN_DRAFT_AUTOSEND_MINUTES, enable_engine_b=True, engine_b_poll_interval=2.0, engine_a_enabled=True, engine_b_data_source="parallel"): super().__init__(daemon=True) self.target_queue = target_queue self.reply_text = reply_text self.poll_seconds = poll_seconds self.mouse_idle_enabled = mouse_idle_enabled self.mouse_idle_seconds = mouse_idle_seconds self.bot = None self._engine_b = None self._db_source = None self._cancel_lock = threading.Lock() self._queued_cancellations = set() self._queued_handoffs = set() self._queued_handoff_confirmations = set() self._queued_retries = set() self._queued_approvals = set() self.message_batch_window_seconds = MESSAGE_BATCH_WINDOW_SECONDS self.set_message_batch_window_seconds(message_batch_window_seconds) self.send_delay_seconds = SEND_DELAY_SECONDS self.set_send_delay_seconds(send_delay_seconds) self.send_mode = SEND_MODE_AUTO self.set_send_mode(send_mode) self.foreign_draft_autosend_minutes = FOREIGN_DRAFT_AUTOSEND_MINUTES self.set_foreign_draft_autosend_minutes(foreign_draft_autosend_minutes) self.stop_event = threading.Event() self._reply_wakeup = threading.Event() self.enable_engine_b = bool(enable_engine_b) self.engine_a_enabled = bool(engine_a_enabled) self.engine_b_data_source = str(engine_b_data_source or "parallel").lower() if self.engine_b_data_source not in ("parallel", "db", "json"): self.engine_b_data_source = "parallel" try: self.engine_b_poll_interval = max(0.5, float(engine_b_poll_interval)) except (TypeError, ValueError): self.engine_b_poll_interval = 2.0 def set_message_batch_window_seconds(self, value): """更新下一次消息合并窗口；不会改变已经开始等待的窗口快照。""" seconds = normalize_message_batch_window_seconds(value) self.message_batch_window_seconds = seconds bot = getattr(self, "bot", None) if bot is not None: bot.message_batch_window_seconds = seconds def set_foreign_draft_autosend_minutes(self, value): """更新"人工草稿放多久就直接发出去"的分钟数（0 = 关闭）。""" minutes = normalize_foreign_draft_autosend_minutes(value) self.foreign_draft_autosend_minutes = minutes bot = getattr(self, "bot", None) if bot is not None: bot.foreign_draft_autosend_minutes = minutes def set_send_delay_seconds(self, value): """更新后续自动回复在最终发送前使用的独立等待时间。""" seconds = normalize_send_delay_seconds(value) self.send_delay_seconds = seconds bot = getattr(self, "bot", None) if bot is not None: bot.send_delay_seconds = seconds def set_send_mode(self, value): """Switch subsequent replies between automatic Enter and manual review.""" mode = normalize_send_mode(value) self.send_mode = mode bot = getattr(self, "bot", None) if bot is not None: bot.send_mode = mode def _report_progress(self, text): """把机器人此刻在做什么送到界面上那行进度文字。""" try: self.target_queue.put(("progress", str(text or ""))) except Exception: # 进度提示纯属好看，永远不该把轮询带下去 pass def _report_visual_state(self, payload): """把只读视觉监听结果送到 Qt 主线程显示。""" try: self.target_queue.put(("visual", dict(payload or {}))) except Exception: pass def cancel_pending_tasks(self, keys): """Cancel live work, or queue cancellation until the bot finishes starting.""" requested = {str(key or "").strip() for key in (keys or [])} requested.discard("") if not requested: return {"deleted": [], "missing": [], "protected": [], "scheduled": []} with self._cancel_lock: bot = self.bot if bot is None: self._queued_cancellations.update(requested) return { "deleted": [], "missing": [], "protected": [], "scheduled": sorted(requested), } return bot.cancel_pending_replies(requested) @staticmethod def _handoff_bot_tasks(bot, keys, *, confirm_uncertain=False): handoff = getattr(bot, "handoff_pending_replies", None) if callable(handoff): return handoff(keys, confirm_uncertain=confirm_uncertain) result = bot.cancel_pending_replies(keys) result["handed_off"] = list(result.get("deleted") or []) return result def handoff_pending_tasks(self, keys, *, confirm_uncertain=False): """Keep explicit takeover separate from ordinary cancellation at startup.""" requested = {str(key or "").strip() for key in (keys or [])} requested.discard("") if not requested: return {"handed_off": [], "deleted": [], "missing": [], "protected": [], "scheduled": []} with self._cancel_lock: bot = self.bot if bot is None: self._queued_handoffs.update(requested) if confirm_uncertain: self._queued_handoff_confirmations.update(requested) return {"handed_off": [], "deleted": [], "missing": [], "protected": [], "scheduled": sorted(requested)} return self._handoff_bot_tasks(bot, requested, confirm_uncertain=confirm_uncertain) def _drain_queued_handoffs(self, bot): with self._cancel_lock: requested = set(self._queued_handoffs) confirmed = requested & self._queued_handoff_confirmations self._queued_handoffs.clear() self._queued_handoff_confirmations.clear() if requested - confirmed: result = self._handoff_bot_tasks(bot, requested - confirmed, confirm_uncertain=False) self._report_queued_handoff_result(result) if confirmed: result = self._handoff_bot_tasks(bot, confirmed, confirm_uncertain=True) self._report_queued_handoff_result(result) def _report_queued_handoff_result(self, result): """Report startup command results without turning a retry into consent.""" result = result if isinstance(result, dict) else {} if result.get("error"): self.target_queue.put(("log", "[转人工] 启动后处理交接失败，请返回任务队列核对：" + str(result["error"]))) return accepted = set(result.get("handed_off") or result.get("deleted") or []) pending_confirmation = set(result.get("requires_confirmation") or []) protected = set(result.get("protected") or []) - pending_confirmation scheduled = set(result.get("scheduled") or []) missing = set(result.get("missing") or []) if accepted: self.target_queue.put(("log", f"[转人工] 启动后已将 {len(accepted)} 条任务交给人工；保留发送记录，不自动重发。")) if pending_confirmation: self.target_queue.put(("log", f"[转人工] {len(pending_confirmation)} 条任务的发送结果需要核对，此次未执行移交。请返回任务队列，在企业微信核对后重新点击转人工并确认。")) if protected: self.target_queue.put(("log", f"[转人工] {len(protected)} 条任务仍受发送或账号保护，此次未执行移交。请返回任务队列查看原因。")) if scheduled: self.target_queue.put(("log", f"[转人工] {len(scheduled)} 条任务仍在等待处理，尚未完成交接。")) if missing: self.target_queue.put(("log", f"[转人工] {len(missing)} 条任务已不在待处理队列，此次未执行交接。")) def retry_pending_tasks(self, keys): """Retry live work, or queue the request until bot startup completes.""" requested = {str(key or "").strip() for key in (keys or [])} requested.discard("") if not requested: return { "retried": [], "missing": [], "protected": [], "not_retryable": [], "scheduled": [], } with self._cancel_lock: bot = self.bot if bot is None: self._queued_retries.update(requested) return { "retried": [], "missing": [], "protected": [], "not_retryable": [], "scheduled": sorted(requested), } return bot.retry_pending_replies(requested) def approve_pending_tasks(self, keys): """人工放行待审核草稿；bot 还没起来就先记下，起来后补做。""" requested = {str(key or "").strip() for key in (keys or [])} requested.discard("") if not requested: return {"approved": [], "missing": [], "not_pending": [], "scheduled": []} with self._cancel_lock: bot = self.bot if bot is None: self._queued_approvals.update(requested) return { "approved": [], "missing": [], "not_pending": [], "scheduled": sorted(requested), } return bot.approve_pending_replies(requested) def _drain_queued_cancellations(self, bot): with self._cancel_lock: requested = set(self._queued_cancellations) self._queued_cancellations.clear() if requested: bot.cancel_pending_replies(requested) def _drain_queued_retries(self, bot): with self._cancel_lock: requested = set(self._queued_retries) self._queued_retries.clear() if requested: bot.retry_pending_replies(requested) def _drain_queued_approvals(self, bot): with self._cancel_lock: requested = set(self._queued_approvals) self._queued_approvals.clear() if requested: bot.approve_pending_replies(requested) def _wait_for_recovery(self, context, failures, *, error=None, detail=""): """Keep the listener alive without resetting delivery or approval state.""" delay = min(30.0, 2.0 ** min(max(0, failures - 1), 5)) self.target_queue.put(("status", "recovering")) self._report_progress(f"{context} · 监听仍在运行，{delay:g} 秒后重新检查") reason = str(detail or error or "暂不可用") signature = (context, type(error).__name__, reason) now = time.monotonic() if (signature != getattr(self, "_last_recovery_signature", None) or now - getattr(self, "_last_recovery_log_at", 0.0) >= 30): self._last_recovery_signature = signature self._last_recovery_log_at = now message = f"[监听恢复] {context}：{reason}；保留任务与发送保护，{delay:g} 秒后重新检查。" if error is not None: # Unexpected programming errors stay observable, too; a single # failed poll must not silently terminate the whole listener. message += "\n" + "".join(traceback.format_exception(type(error), error, error.__traceback__)) self.target_queue.put(("log", message)) # Only user stop interrupts backoff. New-message wakeups must not cause # a disconnected database or unsupported client to spin in a hot loop. self.stop_event.wait(delay) def _recovery_completed(self, context): self._last_recovery_signature = None self.target_queue.put(("log", f"[监听恢复] {context}已恢复，继续监听。")) self.target_queue.put(("status", "running")) def _visual_verification_complete(self, bot, bot_module): """Observe the login gate; never click or solve a verification challenge.""" self.target_queue.put(("status", "verification")) self._report_progress("监听仍在运行 · 请在企业微信完成人工验证，验证期间不点击或发送") try: full = bot._capture_full_window() ready = (not bot_module.looks_like_security_verification(full) and bool(bot._message_nav_selected(full))) except Exception as exc: ready = False marker = (type(exc).__name__, str(exc)) if marker != getattr(self, "_verification_capture_error", None): self._verification_capture_error = marker self.target_queue.put(("log", f"[安全验证] 暂不能确认消息界面恢复，继续等待：{exc}")) self._verification_ready_checks = (getattr(self, "_verification_ready_checks", 0) + 1) if ready else 0 if self._verification_ready_checks < 2: self.stop_event.wait(2.0) return False if self.stop_event.is_set(): return False self._verification_ready_checks = 0 self._verification_capture_error = None bot.security_verification_required = False bot._security_log_emitted = False bot._window_ready = False # Next poll must revalidate the real window. self.target_queue.put(("log", "[安全验证] 连续确认验证页面已消失且消息界面已恢复，继续监听。")) return True def run(self): bot = None failed = False try: import wechat_bot as bot_module bot_module.AUTO_REPLY_TEXT = self.reply_text bot = bot_module.WeChatBot() self.bot = bot from reply_database import LiveReplyDatabase self._db_source = LiveReplyDatabase() bot._db_source = self._db_source bot._reply_wakeup = self._reply_wakeup self._drain_queued_handoffs(bot) self._drain_queued_cancellations(bot) self._drain_queued_retries(bot) self._drain_queued_approvals(bot) bot.mouse_idle_enabled = self.mouse_idle_enabled bot.mouse_idle_seconds = self.mouse_idle_seconds bot.message_batch_window_seconds = self.message_batch_window_seconds bot.send_delay_seconds = self.send_delay_seconds bot.send_mode = self.send_mode bot.foreign_draft_autosend_minutes = self.foreign_draft_autosend_minutes bot._stop_check = self.stop_event bot.safe_window_mode = True bot.auto_activate_window = True bot.progress_cb = self._report_progress bot._visual_state_cb = self._report_visual_state connection_failures = 0 while not self.stop_event.is_set(): try: connected = bot.connect(activate=False, wait_if_missing=True) except Exception as exc: connection_failures += 1 self._wait_for_recovery("企业微信连接等待恢复", connection_failures, error=exc) continue if connected: break connection_failures += 1 self._wait_for_recovery("企业微信连接等待恢复", connection_failures, detail="请确认企业微信已登录并显示主界面") if self.stop_event.is_set(): return if connection_failures: self._recovery_completed("企业微信连接") # 引擎 B：数据直读检测（第二套方案）。与引擎 A 并行投递共享队列， # 发送动作仍收敛到引擎 A 的恢复通道 + 发送互斥锁，B 自身不碰窗口。 if self.enable_engine_b: try: from engine_b import DataEngine # 按数据源模式决定是否接入 DB 直读： # parallel：DB 直读 + conversations.json 并行双跑（默认） # db：DB 直读；初始化或解密失败期间保留引擎 A 的备用检测 # json：仅 conversations.json 档案监听 db_source = self._db_source if self.engine_b_data_source in ("parallel", "db") else None self._engine_b = DataEngine( bot=bot, poll_interval=self.engine_b_poll_interval, db_source=db_source, data_source_mode=self.engine_b_data_source, ) self._engine_b.start() self.target_queue.put(( "log", f"[引擎B] 数据直读检测已启用（每 {self.engine_b_poll_interval:g}s 轮询，" f"数据源={self.engine_b_data_source}）", )) except Exception as exc: self._engine_b = None self.target_queue.put(( "log", f"[-] 引擎 B 启动失败（不影响引擎 A）: {exc}", )) print("[+] 窗口激活模式已开启：企业微信未显示时会自动还原到前台") print("[i] 数据库新消息与未读标记共同触发回复任务，窗口异常时保留任务并重试") if bot.mouse_idle_enabled: print( f"[+] 人机共存已开启：鼠标静止 " f"{bot.mouse_idle_seconds:.0f} 秒后才自动操作" ) print( f"[+] 连续消息合并等待：" f"{bot.message_batch_window_seconds:.0f} 秒" ) print(f"[+] 发送前等待：{bot.send_delay_seconds:g} 秒") if bot.send_mode == SEND_MODE_REVIEW: # 审核模式下"输入框里出现了回复却不发送"是正常结果，不是故障。 # 不写清楚的话，每个第一次用的人都会来报同一个 bug。 print( "[+] 发送模式：人工审核草稿" "（AI 只把回复填进输入框，不会自动按回车；" "需要自动发送请在设置里切到“自动发送”）" ) else: print("[+] 发送模式：自动发送（通过全部安全校验后自动按回车）") try: bot.report_vision_capability() except Exception as exc: print(f"[-] 视觉巡检未能完成（不影响监听）: {exc}") last_ready = bool(bot._window_ready) self.target_queue.put(("status", "running" if last_ready else "waiting")) self.target_queue.put(("info", { "hwnd": f"0x{bot.hwnd:08X}", "size": f"{bot.R - bot.L} x {bot.B - bot.T}", "input": f"({bot.input_x}, {bot.input_y})", })) poll_failures = 0 while not self.stop_event.is_set(): self._reply_wakeup.clear() # Read-only assistant reconciliation remains available while the screen is busy. try: bot.poll_review_assistant() except Exception as exc: self.target_queue.put(("log", f"[助理审核] 核验暂不可用（{type(exc).__name__}），保留审核任务")) if bot.security_verification_required: if not self._visual_verification_complete(bot, bot_module): continue last_ready = None # GUI 保存后只改变尚未开始的下一轮合并窗口；当前窗口不会被截断。 bot.message_batch_window_seconds = self.message_batch_window_seconds bot.send_delay_seconds = self.send_delay_seconds bot.send_mode = self.send_mode bot.foreign_draft_autosend_minutes = self.foreign_draft_autosend_minutes # 引擎 A 开关：关闭时跳过红点截图扫描，只保留队列恢复 # （引擎 B 投递的待回复任务仍会被捡起并发送）。 try: bot._poll_once(scan_unread=self.engine_a_enabled) except Exception as exc: if self.stop_event.is_set(): break poll_failures += 1 self._wait_for_recovery("视觉轮询等待恢复", poll_failures, error=exc) last_ready = None continue if poll_failures: self._recovery_completed("视觉轮询") poll_failures = 0 last_ready = None if bot.security_verification_required: self.target_queue.put(("status", "verification")) self._report_progress("监听仍在运行 · 等待用户完成企业微信安全验证") continue ready = bool(bot._window_ready) if ready != last_ready: last_ready = ready self.target_queue.put(("status", "running" if ready else "waiting")) if ready: self.target_queue.put(("info", { "hwnd": f"0x{bot.hwnd:08X}", "size": f"{bot.R - bot.L} x {bot.B - bot.T}", "input": f"({bot.input_x}, {bot.input_y})", })) self.target_queue.put(("stats", { "replied": bot.reply_count, "false_pos": len(bot.false_pos_rows), })) if not self.stop_event.is_set(): self._reply_wakeup.wait(self.poll_seconds) except Exception as exc: failed = True self.target_queue.put(( "log", f"[-] 后台线程异常：{exc}\n{traceback.format_exc()}", )) self.target_queue.put(("status", "error")) finally: if self._engine_b is not None: try: self._engine_b.stop() except Exception: pass self._engine_b = None if bot is not None: try: bot.close_review_assistant() except Exception: pass if self._db_source is not None: try: self._db_source.close() except Exception: pass self._db_source = None if bot is not None: try: bot.stop_visual_observer() except Exception: pass self.bot = None if not failed: self.target_queue.put(("status", "stopped")) def stop(self): self.stop_event.set() self._reply_wakeup.set() if self._engine_b is not None: try: self._engine_b.stop() except Exception: pass self._engine_b = None active_bot = getattr(self, "bot", None) if active_bot is not None: try: active_bot.close_review_assistant() except Exception: pass if self._db_source is not None: try: self._db_source.close() except Exception: pass self._db_source = None bot = getattr(self, "bot", None) if bot is not None: try: bot.stop_visual_observer() except Exception: pass def stop_after_current(self): """不再开始下一轮轮询，并让当前会话处理自然收尾。 普通的 ``stop`` 会立即关闭数据库源和视觉观察器，适合用户主动停止； 自动升级则必须避免在一次回复尚未落盘时拆掉这些资源，所以这里只设置 循环退出标记。``run`` 的 finally 会在当前 ``_poll_once`` 返回后统一清理。 """ self.stop_event.set()