@reconcrap/boss-recommend-mcp 2.0.54 → 2.0.56

package/src/domains/recommend/run-service.js

@@ -45,7 +45,9 @@ import {
   llmResultToScreening,
   screenCandidate
 } from "../../core/screening/index.js";
-import {
+import {
+  closeRecommendBlockingPanels,
+  closeRecommendAvatarPreview,
   closeRecommendDetail,
   createRecommendDetailNetworkRecorder,
   extractRecommendDetailCandidate,
@@ -465,12 +467,17 @@ function countPassedResults(results = []) {
 
 function compactCloseResult(closeResult) {
   if (!closeResult) return null;
-  return {
+  const result = {
     closed: Boolean(closeResult.closed),
     reason: closeResult.reason || null,
+    probe: closeResult.probe || null,
     attempts: closeResult.attempts || [],
     verification: closeResult.verification || null
   };
+  if (closeResult.already_closed !== undefined) {
+    result.already_closed = Boolean(closeResult.already_closed);
+  }
+  return result;
 }
 
 function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
@@ -482,6 +489,9 @@ function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
   if (error.close_result) {
     result.close_result = compactCloseResult(error.close_result);
   }
+  if (error.phase) {
+    result.phase = error.phase;
+  }
   if (error.refresh_attempt) {
     result.refresh_attempt = error.refresh_attempt;
   }
@@ -497,6 +507,16 @@ function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
   if (Array.isArray(error.recommend_detail_open_attempts)) {
     result.recommend_detail_open_attempts = error.recommend_detail_open_attempts;
   }
+  if (Array.isArray(error.click_attempts)) {
+    result.click_attempts = error.click_attempts;
+  }
+  if (error.avatar_preview) {
+    result.avatar_preview = {
+      open: Boolean(error.avatar_preview.open),
+      selector: error.avatar_preview.preview?.selector || null,
+      rect: error.avatar_preview.preview?.rect || null
+    };
+  }
   return result;
 }
 
@@ -507,6 +527,14 @@ function createRecommendCloseFailureError(closeResult) {
   return error;
 }
 
+function createRecommendBlockingPanelCloseFailureError(closeResult, phase = "") {
+  const error = new Error(closeResult?.reason || "Boss account-rights panel did not close before recovery");
+  error.code = "ACCOUNT_RIGHTS_PANEL_CLOSE_FAILED";
+  error.close_result = closeResult || null;
+  error.phase = phase || null;
+  return error;
+}
+
 function createRecommendRefreshFailureError(refreshAttempt, {
   listEndReason = "",
   targetCount = 0,
@@ -699,10 +727,11 @@ export async function runRecommendWorkflow({
   let refreshRounds = 0;
   let contextRecoveryAttempts = 0;
   let greetCount = 0;
-  const candidateRecoveryCounts = new Map();
-  let jobSelection = null;
+  const candidateRecoveryCounts = new Map();
+  let jobSelection = null;
   let pageScopeSelection = null;
   let filterResult = null;
+  let rootState = null;
   let cardNodeIds = [];
   let listEndReason = "";
   let lastHumanEvent = null;
@@ -769,9 +798,9 @@ export async function runRecommendWorkflow({
     });
   }
 
-  function checkpointInProgressCandidate({
-    index = results.length,
-    candidateKey = "",
+  function checkpointInProgressCandidate({
+    index = results.length,
+    candidateKey = "",
     cardNodeId = null,
     detailStep = "",
     error = null
@@ -785,11 +814,22 @@ export async function runRecommendWorkflow({
         counters: countRecommendResultStatuses(results, { greetCount }),
         error: compactError(error, "RECOMMEND_IN_PROGRESS_ERROR")
       },
-      candidate_list: compactInfiniteListState(listState)
-    });
-  }
-
-  async function recoverAndReapplyRecommendContext(reason = "context_recovery", error = null, {
+      candidate_list: compactInfiniteListState(listState)
+    });
+  }
+
+  async function closeRecommendBlockingPanelsForRun(phase = "cleanup") {
+    const result = await closeRecommendBlockingPanels(client, {
+      attemptsLimit: 2,
+      rootState
+    });
+    if (!result?.closed) {
+      throw createRecommendBlockingPanelCloseFailureError(result, phase);
+    }
+    return result;
+  }
+
+  async function recoverAndReapplyRecommendContext(reason = "context_recovery", error = null, {
     forceRecentNotView = true
   } = {}) {
     await runControl.waitIfPaused();
@@ -797,9 +837,9 @@ export async function runRecommendWorkflow({
     const started = Date.now();
     runControl.setPhase("recommend:recover-context");
     contextRecoveryAttempts += 1;
-    const refreshResult = await refreshRecommendListAtEnd(client, {
-      rootState,
-      jobLabel,
+    const refreshResult = await refreshRecommendListAtEnd(client, {
+      rootState,
+      jobLabel,
       pageScope: pageScopeSelection?.effective_scope || requestedPageScope,
       fallbackPageScope: normalizedFallbackPageScope,
       filter: normalizedFilter,
@@ -808,16 +848,24 @@ export async function runRecommendWorkflow({
       targetUrl: targetUrl || RECOMMEND_TARGET_URL,
       forceRecentNotView,
       cardTimeoutMs,
-      buttonSettleMs: refreshButtonSettleMs,
-      reloadSettleMs: refreshReloadSettleMs
-    });
-    const compactRefresh = {
-      ...compactRefreshAttempt(refreshResult),
-      context_recovery: true,
-      recovery_reason: reason,
-      trigger_error: compactError(error, "RECOMMEND_CONTEXT_RECOVERY_TRIGGER"),
-      elapsed_ms: Date.now() - started
-    };
+      buttonSettleMs: refreshButtonSettleMs,
+      reloadSettleMs: refreshReloadSettleMs
+    });
+    let blockingPanelClose = null;
+    if (refreshResult.ok) {
+      blockingPanelClose = await closeRecommendBlockingPanels(client, {
+        attemptsLimit: 2,
+        rootState: refreshResult.root_state || rootState
+      });
+    }
+    const compactRefresh = {
+      ...compactRefreshAttempt(refreshResult),
+      context_recovery: true,
+      recovery_reason: reason,
+      trigger_error: compactError(error, "RECOMMEND_CONTEXT_RECOVERY_TRIGGER"),
+      account_rights_panel_close: compactCloseResult(blockingPanelClose),
+      elapsed_ms: Date.now() - started
+    };
     refreshAttempts.push(compactRefresh);
     runControl.checkpoint({
       context_recovery: {
@@ -834,10 +882,15 @@ export async function runRecommendWorkflow({
         refresh_method: refreshResult.method || null,
         refresh_forced_recent_not_view: forceRecentNotView,
         recovery_reason: reason
-      });
-      throw new Error(`Recommend context recovery failed after ${reason}: ${refreshResult.reason || refreshResult.error || "refresh returned no cards"}`);
-    }
-    rootState = refreshResult.root_state || await getRecommendRoots(client);
+      });
+      throw new Error(`Recommend context recovery failed after ${reason}: ${refreshResult.reason || refreshResult.error || "refresh returned no cards"}`);
+    }
+    if (!blockingPanelClose?.closed) {
+      const panelError = createRecommendBlockingPanelCloseFailureError(blockingPanelClose, `recover:${reason}`);
+      panelError.refresh_attempt = compactRefresh;
+      throw panelError;
+    }
+    rootState = refreshResult.root_state || await getRecommendRoots(client);
     rootState = await ensureRecommendViewport(rootState, "recover_after");
     cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
       timeoutMs: cardTimeoutMs,
@@ -863,13 +916,15 @@ export async function runRecommendWorkflow({
     return refreshResult;
   }
 
-  runControl.setPhase("recommend:cleanup");
-  await closeRecommendDetail(client, { attemptsLimit: 2 });
-
-  await runControl.waitIfPaused();
-  runControl.throwIfCanceled();
-  runControl.setPhase("recommend:roots");
-  let rootState = await getRecommendRoots(client);
+  runControl.setPhase("recommend:cleanup");
+  await closeRecommendDetail(client, { attemptsLimit: 2 });
+  await closeRecommendAvatarPreview(client, { attemptsLimit: 2 });
+  await closeRecommendBlockingPanelsForRun("cleanup");
+
+  await runControl.waitIfPaused();
+  runControl.throwIfCanceled();
+  runControl.setPhase("recommend:roots");
+  rootState = await getRecommendRoots(client);
   rootState = await ensureRecommendViewport(rootState, "roots");
   runControl.checkpoint({
     iframe_selector: rootState.iframe.selector,
@@ -1067,9 +1122,28 @@ export async function runRecommendWorkflow({
       try {
         await runControl.waitIfPaused();
         runControl.throwIfCanceled();
-        runControl.setPhase("recommend:detail");
-        detailStep = "ensure_viewport";
-        rootState = await ensureRecommendViewport(rootState, "detail");
+        runControl.setPhase("recommend:detail");
+        detailStep = "ensure_viewport";
+        rootState = await ensureRecommendViewport(rootState, "detail");
+        const blockingPanelClose = await closeRecommendBlockingPanels(client, {
+          attemptsLimit: 2,
+          rootState
+        });
+        if (!blockingPanelClose?.closed) {
+          const panelError = createRecommendBlockingPanelCloseFailureError(
+            blockingPanelClose,
+            "before_detail_open"
+          );
+          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
+          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error: panelError });
+          await recoverAndReapplyRecommendContext("account_rights_panel_before_detail", panelError, {
+            forceRecentNotView: true
+          });
+          continue;
+        }
+        if (blockingPanelClose.already_closed === false) {
+          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
+        }
         checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
         detailStep = "open_detail";
         networkRecorder.clear();
@@ -1182,12 +1256,14 @@ export async function runRecommendWorkflow({
               const recoveryCount = candidateRecoveryCounts.get(candidateKey) || 0;
               if (recoveryCount < 1) {
                 candidateRecoveryCounts.set(candidateKey, recoveryCount + 1);
-                timings.image_capture_recovery_trigger = compactError(error, "IMAGE_CAPTURE_FAILED");
-                checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
-                await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
-                await recoverAndReapplyRecommendContext(`image_capture:${detailStep}`, error, {
-                  forceRecentNotView: true
-                });
+                timings.image_capture_recovery_trigger = compactError(error, "IMAGE_CAPTURE_FAILED");
+                checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
+                await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
+                await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
+                await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
+                await recoverAndReapplyRecommendContext(`image_capture:${detailStep}`, error, {
+                  forceRecentNotView: true
+                });
                 continue;
               }
               imageEvidence = createRecoverableImageCaptureEvidence(error, {
@@ -1232,20 +1308,24 @@ export async function runRecommendWorkflow({
         if (!isRecoverableRecommendDetailError(error)) throw error;
         const recoveryCount = candidateRecoveryCounts.get(candidateKey) || 0;
         if (recoveryCount < 1) {
-          candidateRecoveryCounts.set(candidateKey, recoveryCount + 1);
-          timings.detail_recovery_trigger = compactRecoverableDetailError(error);
-          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
-          await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
-          await recoverAndReapplyRecommendContext(`detail:${detailStep}`, error, {
-            forceRecentNotView: true
-          });
+          candidateRecoveryCounts.set(candidateKey, recoveryCount + 1);
+          timings.detail_recovery_trigger = compactRecoverableDetailError(error);
+          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
+          await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
+          await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
+          await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
+          await recoverAndReapplyRecommendContext(`detail:${detailStep}`, error, {
+            forceRecentNotView: true
+          });
           continue;
         }
-        recoverableDetailError = error;
-        detailResult = null;
-        timings.detail_recovered_error = compactRecoverableDetailError(error);
-        await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
-      }
+        recoverableDetailError = error;
+        detailResult = null;
+        timings.detail_recovered_error = compactRecoverableDetailError(error);
+        await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
+        await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
+        await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
+      }
     }
 
     await runControl.waitIfPaused();

package/src/domains/recruit/detail.js

@@ -13,6 +13,10 @@ import {
   buildScreeningCandidateFromDetail,
   htmlToText
 } from "../../core/screening/index.js";
+import {
+  closeBossAccountRightsBlockingPanel,
+  findBossAccountRightsBlockingPanel
+} from "../common/account-rights-panel.js";
 import {
   RECRUIT_DETAIL_CLOSE_SELECTORS,
   RECRUIT_DETAIL_NETWORK_PATTERNS,
@@ -64,6 +68,17 @@ export function createRecruitDetailNetworkRecorder(client) {
   };
 }
 
+export async function findRecruitBlockingPanel(client, options = {}) {
+  return findBossAccountRightsBlockingPanel(client, options);
+}
+
+export async function closeRecruitBlockingPanels(client, options = {}) {
+  return closeBossAccountRightsBlockingPanel(client, {
+    resolveRoots: getRecruitRoots,
+    ...options
+  });
+}
+
 export async function waitForRecruitDetailNetworkEvents(recorder, {
   minCount = 1,
   requireLoaded = true,

package/src/domains/recruit/run-service.js

@@ -44,6 +44,7 @@ import {
   screenCandidate
 } from "../../core/screening/index.js";
 import {
+  closeRecruitBlockingPanels,
   closeRecruitDetail,
   createRecruitDetailNetworkRecorder,
   extractRecruitDetailCandidate,
@@ -159,6 +160,12 @@ function compactError(error, fallbackCode = "RECRUIT_RUN_ERROR") {
     code: error.code || fallbackCode,
     message: error.message || String(error)
   };
+  if (error.close_result) {
+    result.close_result = compactCloseResult(error.close_result);
+  }
+  if (error.phase) {
+    result.phase = error.phase;
+  }
   if (error.refresh_attempt) {
     result.refresh_attempt = error.refresh_attempt;
   }
@@ -174,6 +181,21 @@ function compactError(error, fallbackCode = "RECRUIT_RUN_ERROR") {
   return result;
 }
 
+function compactCloseResult(closeResult) {
+  if (!closeResult) return null;
+  const result = {
+    closed: Boolean(closeResult.closed),
+    reason: closeResult.reason || null,
+    probe: closeResult.probe || null,
+    attempts: closeResult.attempts || [],
+    verification: closeResult.verification || null
+  };
+  if (closeResult.already_closed !== undefined) {
+    result.already_closed = Boolean(closeResult.already_closed);
+  }
+  return result;
+}
+
 function createRecruitCloseFailureError(closeResult) {
   const error = new Error(closeResult?.reason || "Recruit detail did not close before recovery");
   error.code = "DETAIL_CLOSE_FAILED";
@@ -181,6 +203,14 @@ function createRecruitCloseFailureError(closeResult) {
   return error;
 }
 
+function createRecruitBlockingPanelCloseFailureError(closeResult, phase = "") {
+  const error = new Error(closeResult?.reason || "Boss account-rights panel did not close before recovery");
+  error.code = "ACCOUNT_RIGHTS_PANEL_CLOSE_FAILED";
+  error.close_result = closeResult || null;
+  error.phase = phase || null;
+  return error;
+}
+
 function createRecruitRefreshFailureError(refreshAttempt, {
   listEndReason = "",
   targetCount = 0,
@@ -397,6 +427,7 @@ export async function runRecruitWorkflow({
   let refreshRounds = 0;
   let contextRecoveryAttempts = 0;
   const candidateRecoveryCounts = new Map();
+  let rootState = null;
   let cardNodeIds = [];
   let listEndReason = "";
   let lastHumanEvent = null;
@@ -482,6 +513,17 @@ export async function runRecruitWorkflow({
     });
   }
 
+  async function closeRecruitBlockingPanelsForRun(phase = "cleanup") {
+    const result = await closeRecruitBlockingPanels(client, {
+      attemptsLimit: 2,
+      rootState
+    });
+    if (!result?.closed) {
+      throw createRecruitBlockingPanelCloseFailureError(result, phase);
+    }
+    return result;
+  }
+
   async function recoverAndReapplyRecruitContext(reason = "context_recovery", error = null, {
     forceRecentViewed = true
   } = {}) {
@@ -499,11 +541,18 @@ export async function runRecruitWorkflow({
       cityOptionTimeoutMs,
       forceRecentViewed
     });
+    let blockingPanelClose = null;
+    if (refreshResult.ok) {
+      blockingPanelClose = await closeRecruitBlockingPanels(client, {
+        attemptsLimit: 2
+      });
+    }
     const compactRefresh = {
       ...compactRefreshAttempt(refreshResult),
       context_recovery: true,
       recovery_reason: reason,
       trigger_error: compactError(error, "RECRUIT_CONTEXT_RECOVERY_TRIGGER"),
+      account_rights_panel_close: compactCloseResult(blockingPanelClose),
       elapsed_ms: Date.now() - started
     };
     refreshAttempts.push(compactRefresh);
@@ -525,6 +574,11 @@ export async function runRecruitWorkflow({
       });
       throw new Error(`Recruit context recovery failed after ${reason}: ${refreshResult.application?.reason || "refresh returned no cards"}`);
     }
+    if (!blockingPanelClose?.closed) {
+      const panelError = createRecruitBlockingPanelCloseFailureError(blockingPanelClose, `recover:${reason}`);
+      panelError.refresh_attempt = compactRefresh;
+      throw panelError;
+    }
     rootState = await getRecruitRoots(client);
     rootState = await ensureRecruitViewport(rootState, "recover_after");
     cardNodeIds = await waitForRecruitCardNodeIds(client, rootState.iframe.documentNodeId, {
@@ -553,11 +607,12 @@ export async function runRecruitWorkflow({
 
   runControl.setPhase("recruit:cleanup");
   await closeRecruitDetail(client, { attemptsLimit: 2 });
+  await closeRecruitBlockingPanelsForRun("cleanup");
 
   await runControl.waitIfPaused();
   runControl.throwIfCanceled();
   runControl.setPhase("recruit:roots");
-  let rootState = await getRecruitRoots(client);
+  rootState = await getRecruitRoots(client);
   rootState = await ensureRecruitViewport(rootState, "roots");
   runControl.checkpoint({
     iframe_selector: rootState.iframe.selector,
@@ -732,6 +787,25 @@ export async function runRecruitWorkflow({
         runControl.setPhase("recruit:detail");
         detailStep = "ensure_viewport";
         rootState = await ensureRecruitViewport(rootState, "detail");
+        const blockingPanelClose = await closeRecruitBlockingPanels(client, {
+          attemptsLimit: 2,
+          rootState
+        });
+        if (!blockingPanelClose?.closed) {
+          const panelError = createRecruitBlockingPanelCloseFailureError(
+            blockingPanelClose,
+            "before_detail_open"
+          );
+          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
+          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error: panelError });
+          await recoverAndReapplyRecruitContext("account_rights_panel_before_detail", panelError, {
+            forceRecentViewed: true
+          });
+          continue;
+        }
+        if (blockingPanelClose.already_closed === false) {
+          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
+        }
         checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
         detailStep = "open_detail";
         networkRecorder.clear();
@@ -835,6 +909,7 @@ export async function runRecruitWorkflow({
                 timings.image_capture_recovery_trigger = compactError(error, "IMAGE_CAPTURE_FAILED");
                 checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
                 await closeRecruitDetail(client, { attemptsLimit: 2 }).catch(() => null);
+                await closeRecruitBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
                 await recoverAndReapplyRecruitContext(`image_capture:${detailStep}`, error, {
                   forceRecentViewed: true
                 });
@@ -907,6 +982,7 @@ export async function runRecruitWorkflow({
           timings.detail_recovery_trigger = compactRecoverableDetailError(error);
           checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
           await closeRecruitDetail(client, { attemptsLimit: 2 }).catch(() => null);
+          await closeRecruitBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
           await recoverAndReapplyRecruitContext(`detail:${detailStep}`, error, {
             forceRecentViewed: true
           });
@@ -916,6 +992,7 @@ export async function runRecruitWorkflow({
         detailResult = null;
         timings.detail_recovered_error = compactRecoverableDetailError(error);
         await closeRecruitDetail(client, { attemptsLimit: 2 }).catch(() => null);
+        await closeRecruitBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
       }
     }