Add logging and sync guards around chat search decrypt flow

Co-authored-by: Codex <noreply@openai.com>

Author: 2977094657

frontend/composables/chat/useChatSearch.js

@@ -43,6 +43,28 @@ export const useChatSearch = ({
   selectContact,
   loadMoreMessages
 }) => {
+const isDesktopRenderer = () => {
+if (!process.client || typeof window === 'undefined') return false
+return !!window.wechatDesktop?.__brand
+}
+
+const logSearchPhase = (phase, details = {}) => {
+const payload = {
+  account: String(selectedAccount.value || '').trim(),
+  selectedUsername: String(selectedContact.value?.username || '').trim(),
+  contextUsername: String(searchContext.value?.username || '').trim(),
+  ...details
+}
+
+if (isDesktopRenderer()) {
+  try {
+    window.wechatDesktop?.logDebug?.('chat-search', phase, payload)
+  } catch {}
+}
+
+console.info(`[chat-search] ${phase}`, payload)
+}
+
 const messageSearchOpen = ref(false)
 const messageSearchQuery = ref('')
 const messageSearchScope = ref('global') // conversation | global
@@ -1007,24 +1029,65 @@ updateJumpToBottomState()
 
 const locateSearchHit = async (hit) => {
 if (!process.client) return
-if (!selectedAccount.value) return
-if (!hit?.id) return
+if (!selectedAccount.value) {
+  logSearchPhase('locateSearchHit:skip:no-account', {
+    hitId: String(hit?.id || '').trim(),
+    hitUsername: String(hit?.username || '').trim()
+  })
+  return
+}
+if (!hit?.id) {
+  logSearchPhase('locateSearchHit:skip:missing-hit-id', {
+    hitKeys: Object.keys(hit || {})
+  })
+  return
+}
 
 const targetUsername = String(hit?.username || selectedContact.value?.username || '').trim()
-if (!targetUsername) return
+if (!targetUsername) {
+  logSearchPhase('locateSearchHit:skip:missing-target-username', {
+    hitId: String(hit?.id || '').trim(),
+    hitUsername: String(hit?.username || '').trim(),
+    selectedUsernameFallback: String(selectedContact.value?.username || '').trim()
+  })
+  return
+}
+
+logSearchPhase('locateSearchHit:start', {
+  hitId: String(hit?.id || '').trim(),
+  hitUsername: String(hit?.username || '').trim(),
+  targetUsername,
+  conversationName: String(hit?.conversationName || '').trim()
+})
 
 const targetContact = resolveSearchTargetContact({
   username: targetUsername,
   displayName: String(hit?.conversationName || hit?.username || targetUsername).trim(),
   avatar: String(hit?.conversationAvatar || hit?.senderAvatar || '').trim(),
   isGroup: targetUsername.endsWith('@chatroom')
 })
+logSearchPhase('locateSearchHit:target-resolved', {
+  hitId: String(hit?.id || '').trim(),
+  targetUsername,
+  contactResolved: !!targetContact,
+  contactSource: targetContact
+    ? (contacts.value.find((c) => String(c?.username || '').trim() === targetUsername) ? 'contacts' : 'transient')
+    : 'none'
+})
 if (targetContact && selectedContact.value?.username !== targetUsername) {
   await selectContact(targetContact, { skipLoadMessages: true })
+  logSearchPhase('locateSearchHit:selectContact:done', {
+    hitId: String(hit?.id || '').trim(),
+    targetUsername
+  })
 }
 
 if (searchContext.value?.active && searchContext.value.username !== targetUsername) {
   await exitSearchContext()
+  logSearchPhase('locateSearchHit:exitSearchContext:done', {
+    hitId: String(hit?.id || '').trim(),
+    targetUsername
+  })
 }
 
 if (!searchContext.value?.active) {
@@ -1053,6 +1116,12 @@ if (!searchContext.value?.active) {
 }
 
 try {
+  logSearchPhase('locateSearchHit:messagesAround:start', {
+    hitId: String(hit?.id || '').trim(),
+    targetUsername,
+    before: 35,
+    after: 35
+  })
   const resp = await api.getChatMessagesAround({
     account: selectedAccount.value,
     username: targetUsername,
@@ -1065,13 +1134,31 @@ try {
   const mapped = raw.map(normalizeMessage)
   allMessages.value = { ...allMessages.value, [targetUsername]: mapped }
   messagesMeta.value = { ...messagesMeta.value, [targetUsername]: { total: mapped.length, hasMore: false } }
+  logSearchPhase('locateSearchHit:messagesAround:end', {
+    hitId: String(hit?.id || '').trim(),
+    targetUsername,
+    messageCount: mapped.length,
+    anchorId: String(resp?.anchorId || hit?.id || '').trim(),
+    anchorIndex: Number(resp?.anchorIndex ?? -1)
+  })
 
   searchContext.value.anchorId = String(resp?.anchorId || hit.id)
   searchContext.value.anchorIndex = Number(resp?.anchorIndex ?? -1)
 
   const ok = await scrollToMessageId(searchContext.value.anchorId)
+  logSearchPhase('locateSearchHit:scroll:end', {
+    hitId: String(hit?.id || '').trim(),
+    targetUsername,
+    anchorId: String(searchContext.value.anchorId || '').trim(),
+    scrollFound: !!ok
+  })
   if (ok) flashMessage(searchContext.value.anchorId)
 } catch (e) {
+  logSearchPhase('locateSearchHit:error', {
+    hitId: String(hit?.id || '').trim(),
+    targetUsername,
+    error: String(e?.message || e || '')
+  })
   window.alert(e?.message || '定位失败')
 }
 }
@@ -1356,6 +1443,11 @@ try {
 
 const onSearchHitClick = async (hit, idx) => {
 messageSearchSelectedIndex.value = Number(idx || 0)
+logSearchPhase('onSearchHitClick', {
+  index: Number(idx || 0),
+  hitId: String(hit?.id || '').trim(),
+  hitUsername: String(hit?.username || '').trim()
+})
 await locateSearchHit(hit)
 }
 

src/wechat_decrypt_tool/chat_realtime_autosync.py

@@ -123,9 +123,62 @@ def __init__(self) -> None:
 
         self._mu = threading.Lock()
         self._states: dict[str, _AccountState] = {}
+        self._paused_accounts: dict[str, int] = {}
         self._stop = threading.Event()
         self._thread: Optional[threading.Thread] = None
 
+    def _is_account_paused_locked(self, account: str) -> bool:
+        key = str(account or "").strip()
+        if not key:
+            return False
+        return int(self._paused_accounts.get(key) or 0) > 0
+
+    def is_account_paused(self, account: str) -> bool:
+        with self._mu:
+            return self._is_account_paused_locked(account)
+
+    def pause_account(self, account: str, reason: str = "") -> int:
+        key = str(account or "").strip()
+        if not key:
+            return 0
+
+        with self._mu:
+            depth = int(self._paused_accounts.get(key) or 0) + 1
+            self._paused_accounts[key] = depth
+            st = self._states.get(key)
+            if st is not None:
+                st.due_at = 0.0
+
+        logger.info(
+            "[realtime-autosync] pause account=%s reason=%s depth=%s",
+            key,
+            str(reason or "").strip() or "-",
+            int(depth),
+        )
+        return depth
+
+    def resume_account(self, account: str, reason: str = "") -> int:
+        key = str(account or "").strip()
+        if not key:
+            return 0
+
+        with self._mu:
+            current = int(self._paused_accounts.get(key) or 0)
+            if current <= 1:
+                self._paused_accounts.pop(key, None)
+                depth = 0
+            else:
+                depth = current - 1
+                self._paused_accounts[key] = depth
+
+        logger.info(
+            "[realtime-autosync] resume account=%s reason=%s depth=%s",
+            key,
+            str(reason or "").strip() or "-",
+            int(depth),
+        )
+        return depth
+
     def start(self) -> None:
         if not self._enabled:
             logger.info("[realtime-autosync] disabled by env WECHAT_TOOL_REALTIME_AUTOSYNC=0")
@@ -188,6 +241,12 @@ def _tick(self) -> None:
             if self._stop.is_set():
                 break
 
+            if self.is_account_paused(acc):
+                with self._mu:
+                    st = self._states.setdefault(acc, _AccountState())
+                    st.due_at = 0.0
+                continue
+
             try:
                 account_dir = _resolve_account_dir(acc)
             except HTTPException:
@@ -238,6 +297,9 @@ def _tick(self) -> None:
             for acc, st in self._states.items():
                 if running >= int(self._workers):
                     break
+                if self._is_account_paused_locked(acc):
+                    st.due_at = 0.0
+                    continue
                 if st.due_at <= 0 or st.due_at > now:
                     continue
                 if st.thread is not None and st.thread.is_alive():
@@ -278,6 +340,9 @@ def _sync_account_runner(self, account: str) -> None:
         try:
             if self._stop.is_set() or (not account):
                 return
+            if self.is_account_paused(account):
+                logger.info("[realtime-autosync] sync skipped account=%s reason=paused", account)
+                return
             res = self._sync_account(account)
             inserted = int((res or {}).get("inserted_total") or (res or {}).get("insertedTotal") or 0)
             synced = int((res or {}).get("synced") or (res or {}).get("sessionsSynced") or 0)
@@ -297,6 +362,8 @@ def _sync_account(self, account: str) -> dict[str, Any]:
         account = str(account or "").strip()
         if not account:
             return {"status": "skipped", "reason": "missing account"}
+        if self.is_account_paused(account):
+            return {"status": "skipped", "reason": "paused"}
 
         try:
             account_dir = _resolve_account_dir(account)

src/wechat_decrypt_tool/routers/chat.py

@@ -7071,13 +7071,26 @@ async def get_chat_messages_around(
     if after > 200:
         after = 200
 
+    trace_id = f"msg-around-{int(time.time() * 1000)}-{threading.get_ident()}"
+    logger.info(
+        "[%s] chat messages around start account=%s username=%s anchor_id=%s before=%s after=%s",
+        trace_id,
+        str(account or "").strip(),
+        str(username or "").strip(),
+        str(anchor_id or "").strip(),
+        int(before),
+        int(after),
+    )
+
     parts = str(anchor_id).split(":", 2)
     if len(parts) != 3:
+        logger.warning("[%s] chat messages around invalid anchor format anchor_id=%s", trace_id, str(anchor_id or "").strip())
         raise HTTPException(status_code=400, detail="Invalid anchor_id.")
     anchor_db_stem, anchor_table_name_in, anchor_local_id_str = parts
     try:
         anchor_local_id = int(anchor_local_id_str)
     except Exception:
+        logger.warning("[%s] chat messages around invalid anchor local_id anchor_id=%s", trace_id, str(anchor_id or "").strip())
         raise HTTPException(status_code=400, detail="Invalid anchor_id.")
 
     account_dir = _resolve_account_dir(account)
@@ -7093,6 +7106,13 @@ async def get_chat_messages_around(
             anchor_db_path = p
             break
     if anchor_db_path is None:
+        logger.warning(
+            "[%s] chat messages around anchor db missing account=%s username=%s anchor_db=%s",
+            trace_id,
+            account_dir.name,
+            username,
+            anchor_db_stem,
+        )
         raise HTTPException(status_code=404, detail="Anchor database not found.")
 
     # Open resource DB once (optional), and reuse for all message DBs.
@@ -7491,6 +7511,18 @@ def sort_key_global(m: dict[str, Any]) -> tuple[int, int, str, int]:
         head_image_db_path=head_image_db_path,
     )
 
+    logger.info(
+        "[%s] chat messages around done account=%s username=%s anchor_id=%s canonical_anchor=%s anchor_index=%s returned=%s merged_total=%s",
+        trace_id,
+        account_dir.name,
+        username,
+        str(anchor_id or "").strip(),
+        anchor_id_canon,
+        int(anchor_index),
+        len(return_messages),
+        len(merged),
+    )
+
     return {
         "status": "success",
         "account": account_dir.name,