@reconcrap/boss-recommend-mcp 2.0.46 → 2.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.0.46",
+  "version": "2.0.48",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",

package/src/core/browser/index.js

@@ -29,6 +29,7 @@ export const FORBIDDEN_CDP_DOMAINS = new Set(["Runtime"]);
 const BOSS_LOGIN_URL_PATTERN = /(?:zhipin\.com\/web\/user(?:\/|\?|$)|passport\.zhipin\.com|login\.zhipin\.com)/i;
 const BOSS_LOGIN_TEXT_PATTERN = /扫码登录|验证码登录|密码登录|登录后|请登录|登录BOSS直聘|Boss登录|BOSS登录/i;
 const CHROME_DEBUG_UNAVAILABLE_PATTERN = /ECONNREFUSED|ECONNRESET|ENOTFOUND|ETIMEDOUT|connect|socket hang up/i;
+const CDP_CLOSED_TRANSPORT_PATTERN = /WebSocket is not open|readyState\s+\d+\s+\(CLOSED\)|ECONNRESET|socket hang up|Target closed|Session closed|Connection closed/i;
 const BOSS_LOGIN_DOM_SELECTORS = [
   ".login-box",
   ".login-form",
@@ -872,34 +873,143 @@ export async function connectToChromeTargetOrOpen({
   }
 }
 
-export function createGuardedCdpClient(client, { methodLog = [] } = {}) {
-  return new Proxy(client, {
-    get(target, property, receiver) {
+export function isClosedCdpTransportError(error) {
+  return CDP_CLOSED_TRANSPORT_PATTERN.test(String(error?.message || error || ""));
+}
+
+function cloneCdpParams(params = {}) {
+  if (!params || typeof params !== "object" || typeof params === "function") return params;
+  try {
+    return JSON.parse(JSON.stringify(params));
+  } catch {
+    return { ...params };
+  }
+}
+
+function shouldReplayCdpSetupCall(domain, method) {
+  return method === "enable"
+    || (domain === "Network" && method === "setCacheDisabled")
+    || (domain === "Page" && method === "bringToFront");
+}
+
+export function createGuardedCdpClient(client, { methodLog = [], reconnect = null } = {}) {
+  let currentClient = client;
+  let reconnectInFlight = null;
+  const setupCalls = [];
+  const eventSubscriptions = [];
+
+  async function replaySessionSetup(nextClient) {
+    for (const call of setupCalls) {
+      const fn = nextClient?.[call.domain]?.[call.method];
+      if (typeof fn === "function") {
+        await fn.call(nextClient[call.domain], cloneCdpParams(call.params));
+      }
+    }
+    for (const subscription of eventSubscriptions) {
+      const fn = nextClient?.[subscription.domain]?.[subscription.event];
+      if (typeof fn === "function") {
+        fn.call(nextClient[subscription.domain], subscription.listener);
+      }
+    }
+  }
+
+  async function reconnectClient() {
+    if (typeof reconnect !== "function") return null;
+    if (!reconnectInFlight) {
+      reconnectInFlight = Promise.resolve()
+        .then(() => reconnect())
+        .then(async (nextClient) => {
+          if (!nextClient) throw new Error("CDP reconnect returned no client");
+          currentClient = nextClient;
+          await replaySessionSetup(nextClient);
+          return nextClient;
+        })
+        .finally(() => {
+          reconnectInFlight = null;
+        });
+    }
+    return reconnectInFlight;
+  }
+
+  async function invokeWithReconnect({
+    methodNameForLog,
+    invoke,
+    retryable = true
+  }) {
+    recordMethod(methodLog, methodNameForLog);
+    try {
+      return await invoke(currentClient);
+    } catch (error) {
+      if (!retryable || !isClosedCdpTransportError(error) || typeof reconnect !== "function") {
+        throw error;
+      }
+      await reconnectClient();
+      recordMethod(methodLog, `${methodNameForLog}:retry_after_reconnect`);
+      return invoke(currentClient);
+    }
+  }
+
+  return new Proxy({}, {
+    get(_target, property, receiver) {
       if (property === "send") {
         return async (method, params = {}) => {
           if (isForbiddenMethod(method)) {
             throw new Error(`Forbidden CDP method blocked: ${method}`);
           }
-          recordMethod(methodLog, method);
-          return target.send(method, params);
+          return invokeWithReconnect({
+            methodNameForLog: method,
+            invoke: (activeClient) => activeClient.send(method, params)
+          });
         };
       }
 
-      const value = Reflect.get(target, property, receiver);
+      if (property === "close") {
+        return async () => currentClient?.close?.();
+      }
+
+      if (property === "__rawClient") return currentClient;
+
+      const value = Reflect.get(currentClient, property, receiver);
       if (!value || typeof value !== "object") return value;
 
-      return new Proxy(value, {
-        get(domainTarget, method, domainReceiver) {
+      return new Proxy({}, {
+        get(_domainTarget, method, domainReceiver) {
+          const domainTarget = Reflect.get(currentClient, property, receiver);
           const domainValue = Reflect.get(domainTarget, method, domainReceiver);
           if (typeof domainValue !== "function") return domainValue;
 
-          return async (params = {}) => {
+          return (params = {}) => {
             const fullMethod = methodName(property, method);
             if (isForbiddenMethod(fullMethod)) {
               throw new Error(`Forbidden CDP method blocked: ${fullMethod}`);
             }
-            recordMethod(methodLog, fullMethod);
-            return domainValue.call(domainTarget, params);
+            if (typeof params === "function") {
+              eventSubscriptions.push({
+                domain: property,
+                event: method,
+                listener: params
+              });
+              recordMethod(methodLog, fullMethod);
+              return domainValue.call(domainTarget, params);
+            }
+            if (shouldReplayCdpSetupCall(property, method)) {
+              setupCalls.push({
+                domain: property,
+                method,
+                params: cloneCdpParams(params)
+              });
+            }
+            return invokeWithReconnect({
+              methodNameForLog: fullMethod,
+              invoke: (activeClient) => {
+                const activeDomain = activeClient?.[property];
+                const activeMethod = activeDomain?.[method];
+                if (typeof activeMethod !== "function") {
+                  throw new Error(`CDP method is unavailable after reconnect: ${fullMethod}`);
+                }
+                return activeMethod.call(activeDomain, params);
+              }
+            });
           };
         }
       });
@@ -928,14 +1038,37 @@ export async function connectToChromeTarget({
     throw new Error(`No matching Chrome target found on ${host}:${port}.\nAvailable targets:\n${urls}`);
   }
 
-  const rawClient = await CDP({ host, port, target });
+  let rawClient = await CDP({ host, port, target });
+  let activeTarget = target;
   const methodLog = [];
-  const client = createGuardedCdpClient(rawClient, { methodLog });
+  const client = createGuardedCdpClient(rawClient, {
+    methodLog,
+    reconnect: async () => {
+      const latestTargets = await listChromeTargets({ host, port });
+      const nextTarget = activeTarget?.id
+        ? latestTargets.find((item) => item?.id === activeTarget.id)
+        : latestTargets.find(matcher);
+      if (!nextTarget) {
+        const urls = latestTargets.map((item) => item.url).filter(Boolean).join("\n");
+        throw new Error(`No matching Chrome target found while reconnecting to ${host}:${port}.\nAvailable targets:\n${urls}`);
+      }
+      try {
+        await rawClient.close();
+      } catch {}
+      rawClient = await CDP({ host, port, target: nextTarget });
+      activeTarget = nextTarget;
+      return rawClient;
+    }
+  });
 
   return {
     client,
-    rawClient,
-    target,
+    get rawClient() {
+      return rawClient;
+    },
+    get target() {
+      return activeTarget;
+    },
     methodLog,
     async close() {
       await rawClient.close();

package/src/core/screening/index.js

@@ -189,6 +189,44 @@ function normalizeBlockText(input) {
   return String(input ?? "").trim();
 }
 
+function normalizeReasoningKey(input) {
+  return normalizeBlockText(input).replace(/\s+/g, " ");
+}
+
+function collapseRepeatedReasoningText(input) {
+  const text = normalizeBlockText(input);
+  if (!text) return "";
+  const chunks = text.split(/\n{2,}/).map(normalizeBlockText).filter(Boolean);
+  if (chunks.length >= 2 && chunks.length % 2 === 0) {
+    const midpoint = chunks.length / 2;
+    const first = chunks.slice(0, midpoint);
+    const second = chunks.slice(midpoint);
+    if (normalizeReasoningKey(first.join("\n\n")) === normalizeReasoningKey(second.join("\n\n"))) {
+      return first.join("\n\n");
+    }
+  }
+
+  const compacted = normalizeReasoningKey(text);
+  if (compacted.length < 160) return text;
+  const midpoint = Math.floor(compacted.length / 2);
+  for (let offset = -32; offset <= 32; offset += 1) {
+    const split = midpoint + offset;
+    if (split <= 80 || split >= compacted.length - 80) continue;
+    const first = compacted.slice(0, split).trim();
+    const second = compacted.slice(split).trim();
+    if (first && first === second) return first;
+  }
+  return text;
+}
+
+function firstReasoningText(lines) {
+  for (const line of lines) {
+    const cleaned = collapseRepeatedReasoningText(line);
+    if (cleaned) return cleaned;
+  }
+  return "";
+}
+
 function compact(input) {
   return normalizeText(input).toLowerCase();
 }
@@ -472,7 +510,9 @@ function flattenChatMessageContent(content) {
 
 function collectLlmReasoningText(choice = {}) {
   const message = choice?.message || {};
-  return [
+  const seen = new Set();
+  const unique = [];
+  for (const item of [
     message.reasoning_content,
     message.provider_specific_fields?.reasoning_content,
     message.reasoning,
@@ -489,7 +529,14 @@ function collectLlmReasoningText(choice = {}) {
     choice.provider_specific_fields?.cot,
     choice.chain_of_thought,
     choice.provider_specific_fields?.chain_of_thought
-  ].map(flattenChatMessageContent).map(normalizeBlockText).filter(Boolean).join("\n\n");
+  ]) {
+    const text = collapseRepeatedReasoningText(flattenChatMessageContent(item));
+    const key = normalizeReasoningKey(text);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    unique.push(text);
+  }
+  return collapseRepeatedReasoningText(unique.join("\n\n"));
 }
 
 function mimeTypeForImagePath(filePath) {
@@ -1621,7 +1668,7 @@ async function callScreeningLlmWithProvider({
       const evidence = Array.isArray(parsed?.evidence)
         ? parsed.evidence.map(normalizeText).filter(Boolean)
         : [];
-      const decisionCot = firstUsefulLine([
+      const decisionCot = firstReasoningText([
         parsed?.cot,
         parsed?.decision_cot,
         parsed?.reasoning,

package/src/domains/recommend/detail.js

@@ -310,12 +310,17 @@ export async function readRecommendDetailHtml(client, detailState) {
   };
 }
 
-export function isStaleRecommendNodeError(error) {
-  const message = String(error?.message || error || "");
-  return /Could not find node with given id|No node with given id|Node is detached|Cannot find node/i.test(message);
-}
-
-export async function findRecommendCardNodeForCandidateKey(client, {
+export function isStaleRecommendNodeError(error) {
+  const message = String(error?.message || error || "");
+  return /Could not find node with given id|No node with given id|Node is detached|Cannot find node/i.test(message);
+}
+
+export function isRecommendDetailOpenMissError(error) {
+  const message = String(error?.message || error || "");
+  return /Candidate detail did not open|no known detail selectors mounted/i.test(message);
+}
+
+export async function findRecommendCardNodeForCandidateKey(client, {
   candidateKey = "",
   rootState = null,
   targetUrl = "",
@@ -448,18 +453,20 @@ export async function openRecommendCardDetailWithFreshRetry(client, {
         card_candidate: currentCandidate,
         retry_attempts: attempts
       };
-    } catch (error) {
-      const stale = isStaleRecommendNodeError(error);
-      attempts.push({
-        attempt: attemptIndex + 1,
-        node_id: currentNodeId,
-        stale_node: stale,
-        error: error?.message || String(error)
-      });
-      if (!stale || attemptIndex >= limit - 1 || !candidateKey) {
-        error.recommend_detail_open_attempts = attempts;
-        throw error;
-      }
+    } catch (error) {
+      const stale = isStaleRecommendNodeError(error);
+      const detailOpenMiss = isRecommendDetailOpenMissError(error);
+      attempts.push({
+        attempt: attemptIndex + 1,
+        node_id: currentNodeId,
+        stale_node: stale,
+        detail_open_miss: detailOpenMiss,
+        error: error?.message || String(error)
+      });
+      if ((!stale && !detailOpenMiss) || attemptIndex >= limit - 1 || !candidateKey) {
+        error.recommend_detail_open_attempts = attempts;
+        throw error;
+      }
 
       const resolved = await findRecommendCardNodeForCandidateKey(client, {
         candidateKey,

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

@@ -46,13 +46,14 @@ import {
   screenCandidate
 } from "../../core/screening/index.js";
 import {
-  closeRecommendDetail,
-  createRecommendDetailNetworkRecorder,
-  extractRecommendDetailCandidate,
-  isStaleRecommendNodeError,
-  openRecommendCardDetailWithFreshRetry,
-  waitForRecommendDetailNetworkEvents
-} from "./detail.js";
+  closeRecommendDetail,
+  createRecommendDetailNetworkRecorder,
+  extractRecommendDetailCandidate,
+  isRecommendDetailOpenMissError,
+  isStaleRecommendNodeError,
+  openRecommendCardDetailWithFreshRetry,
+  waitForRecommendDetailNetworkEvents
+} from "./detail.js";
 import {
   readRecommendCardCandidate,
   waitForRecommendCardNodeIds
@@ -416,12 +417,13 @@ export function countRecommendResultStatuses(results = [], {
     detail_open_failed: results.filter((item) => (
       item.error?.code === "DETAIL_STALE_NODE"
       || item.error?.code === "DETAIL_OPEN_FAILED"
-    )).length,
-    transient_recovered: results.filter((item) => (
-      item.error?.code === "DETAIL_STALE_NODE"
-      || item.error?.code === "IMAGE_CAPTURE_STALE_NODE"
-      || item.error?.code === "IMAGE_CAPTURE_TIMEOUT"
-      || item.error?.code === "IMAGE_CAPTURE_TOTAL_TIMEOUT"
+    )).length,
+    transient_recovered: results.filter((item) => (
+      item.error?.code === "DETAIL_STALE_NODE"
+      || item.error?.code === "DETAIL_OPEN_FAILED"
+      || item.error?.code === "IMAGE_CAPTURE_STALE_NODE"
+      || item.error?.code === "IMAGE_CAPTURE_TIMEOUT"
+      || item.error?.code === "IMAGE_CAPTURE_TOTAL_TIMEOUT"
     )).length
   };
 }
@@ -461,6 +463,9 @@ function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
   if (error.passed_count != null) {
     result.passed_count = error.passed_count;
   }
+  if (Array.isArray(error.recommend_detail_open_attempts)) {
+    result.recommend_detail_open_attempts = error.recommend_detail_open_attempts;
+  }
   return result;
 }
 
@@ -548,9 +553,9 @@ function createImageCaptureFailureScreening(candidate, error) {
   };
 }
 
-export function isRecoverableRecommendDetailError(error) {
-  return isStaleRecommendNodeError(error);
-}
+export function isRecoverableRecommendDetailError(error) {
+  return isStaleRecommendNodeError(error) || isRecommendDetailOpenMissError(error);
+}
 
 function compactRecoverableDetailError(error) {
   return compactError(error, isStaleRecommendNodeError(error) ? "DETAIL_STALE_NODE" : "DETAIL_OPEN_FAILED");
@@ -560,10 +565,12 @@ function createRecoverableDetailFailureScreening(candidate, error) {
   return {
     status: "fail",
     passed: false,
-    score: 0,
-    reasons: isStaleRecommendNodeError(error)
-      ? ["detail_open_failed", "stale_node"]
-      : ["detail_open_failed"],
+    score: 0,
+    reasons: isStaleRecommendNodeError(error)
+      ? ["detail_open_failed", "stale_node"]
+      : isRecommendDetailOpenMissError(error)
+      ? ["detail_open_failed", "detail_open_miss"]
+      : ["detail_open_failed"],
     error: compactRecoverableDetailError(error),
     candidate
   };