@reconcrap/boss-recommend-mcp 2.0.2 → 2.0.4

package/src/core/browser/index.js

@@ -1,7 +1,12 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import CDP from "chrome-remote-interface";
 
 export const DEFAULT_CHROME_HOST = "127.0.0.1";
 export const DEFAULT_CHROME_PORT = 9222;
+export const BOSS_LOGIN_URL = "https://www.zhipin.com/web/user/?ka=bticket";
 
 export const ALLOWED_CDP_DOMAINS = new Set([
   "Accessibility",
@@ -14,6 +19,21 @@ export const ALLOWED_CDP_DOMAINS = new Set([
 
 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 BOSS_LOGIN_DOM_SELECTORS = [
+  ".login-box",
+  ".login-form",
+  ".login-dialog",
+  ".sign-form",
+  ".qrcode-box",
+  ".user-login",
+  "input[name='phone']",
+  "input[placeholder*='手机号']",
+  "input[placeholder*='验证码']"
+];
+
 function nowIso() {
   return new Date().toISOString();
 }
@@ -49,6 +69,378 @@ export function assertNoForbiddenCdpCalls(methodLog = []) {
   }
 }
 
+export function isBossLoginUrl(url) {
+  return BOSS_LOGIN_URL_PATTERN.test(String(url || ""));
+}
+
+export function createBossLoginRequiredError({
+  domain = "boss",
+  currentUrl = "",
+  targetUrl = "",
+  loginUrl = BOSS_LOGIN_URL,
+  loginDetection = null,
+  chrome = null
+} = {}) {
+  const error = new Error(`Boss login is required before starting the ${domain} run.`);
+  error.code = "BOSS_LOGIN_REQUIRED";
+  error.requires_login = true;
+  error.current_url = currentUrl || null;
+  error.target_url = targetUrl || null;
+  error.login_url = loginUrl;
+  error.login_detection = loginDetection || null;
+  error.chrome = chrome || null;
+  error.retryable = true;
+  return error;
+}
+
+export async function detectBossLoginState(client, { currentUrl = "" } = {}) {
+  const inspectedUrl = currentUrl || await getMainFrameUrl(client).catch(() => "");
+  if (isBossLoginUrl(inspectedUrl)) {
+    return {
+      requires_login: true,
+      reason: "url",
+      current_url: inspectedUrl,
+      matched_selectors: []
+    };
+  }
+
+  let root = null;
+  try {
+    root = await getDocumentRoot(client, { depth: 1, pierce: true });
+  } catch (error) {
+    return {
+      requires_login: false,
+      reason: "dom_unavailable",
+      current_url: inspectedUrl,
+      error: error?.message || String(error || "")
+    };
+  }
+
+  const matchedSelectors = [];
+  for (const selector of BOSS_LOGIN_DOM_SELECTORS) {
+    const nodeId = await querySelector(client, root.nodeId, selector).catch(() => 0);
+    if (nodeId) matchedSelectors.push(selector);
+  }
+
+  if (matchedSelectors.length === 0) {
+    return {
+      requires_login: false,
+      reason: "no_login_dom",
+      current_url: inspectedUrl,
+      matched_selectors: []
+    };
+  }
+
+  const html = await getOuterHTML(client, root.nodeId).catch(() => "");
+  const looksLikeLogin = BOSS_LOGIN_TEXT_PATTERN.test(html);
+  return {
+    requires_login: looksLikeLogin,
+    reason: looksLikeLogin ? "dom" : "login_selector_without_login_text",
+    current_url: inspectedUrl,
+    matched_selectors: matchedSelectors
+  };
+}
+
+export function isChromeDebugUnavailableError(error) {
+  return CHROME_DEBUG_UNAVAILABLE_PATTERN.test(String(error?.message || error || ""));
+}
+
+function pathExists(targetPath) {
+  try {
+    return Boolean(targetPath) && fs.existsSync(targetPath);
+  } catch {
+    return false;
+  }
+}
+
+function ensureDir(targetPath) {
+  fs.mkdirSync(targetPath, { recursive: true });
+}
+
+function isLocalChromeHost(host) {
+  const normalized = String(host || "").trim().toLowerCase();
+  return !normalized || normalized === "127.0.0.1" || normalized === "localhost" || normalized === "::1";
+}
+
+function getCodexHome() {
+  return process.env.CODEX_HOME
+    ? path.resolve(process.env.CODEX_HOME)
+    : path.join(os.homedir(), ".codex");
+}
+
+function getDefaultChromeExecutableCandidates() {
+  const candidates = [
+    process.env.BOSS_MCP_CHROME_PATH,
+    process.env.BOSS_RECOMMEND_CHROME_PATH
+  ].filter(Boolean);
+  if (process.platform === "win32") {
+    candidates.push(
+      path.join(process.env.LOCALAPPDATA || "", "Google", "Chrome", "Application", "chrome.exe"),
+      path.join(process.env.ProgramFiles || "", "Google", "Chrome", "Application", "chrome.exe"),
+      path.join(process.env["ProgramFiles(x86)"] || "", "Google", "Chrome", "Application", "chrome.exe")
+    );
+  } else if (process.platform === "darwin") {
+    candidates.push(
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      path.join(os.homedir(), "Applications", "Google Chrome.app", "Contents", "MacOS", "Google Chrome"),
+      "/Applications/Chromium.app/Contents/MacOS/Chromium"
+    );
+  } else {
+    candidates.push(
+      "/usr/bin/google-chrome",
+      "/usr/bin/google-chrome-stable",
+      "/usr/bin/chromium-browser",
+      "/usr/bin/chromium",
+      "/snap/bin/chromium"
+    );
+  }
+  return Array.from(new Set(candidates.filter(Boolean)));
+}
+
+export function getChromeExecutable() {
+  return getDefaultChromeExecutableCandidates().find((candidate) => pathExists(candidate)) || null;
+}
+
+export function getBossChromeUserDataDir(port = DEFAULT_CHROME_PORT) {
+  const sharedPath = path.join(getCodexHome(), "boss-mcp", `chrome-profile-${port}`);
+  ensureDir(sharedPath);
+  return sharedPath;
+}
+
+export async function waitForChromeDebugPort({
+  host = DEFAULT_CHROME_HOST,
+  port = DEFAULT_CHROME_PORT,
+  timeoutMs = 8000,
+  intervalMs = 300
+} = {}) {
+  const started = Date.now();
+  let lastError = null;
+  while (Date.now() - started <= timeoutMs) {
+    try {
+      const targets = await listChromeTargets({ host, port });
+      return {
+        ok: true,
+        elapsed_ms: Date.now() - started,
+        targets
+      };
+    } catch (error) {
+      lastError = error;
+      await sleep(intervalMs);
+    }
+  }
+  return {
+    ok: false,
+    elapsed_ms: Date.now() - started,
+    error: lastError?.message || String(lastError || "Chrome debug port did not become ready")
+  };
+}
+
+export async function launchChromeDebugInstance({
+  host = DEFAULT_CHROME_HOST,
+  port = DEFAULT_CHROME_PORT,
+  url = "about:blank",
+  slowLive = false
+} = {}) {
+  if (!isLocalChromeHost(host)) {
+    throw new Error(`Cannot auto-launch Chrome for non-local debug host: ${host}`);
+  }
+  const chromePath = getChromeExecutable();
+  if (!chromePath) {
+    throw new Error("Chrome executable not found. Set BOSS_MCP_CHROME_PATH or BOSS_RECOMMEND_CHROME_PATH.");
+  }
+  const userDataDir = getBossChromeUserDataDir(port);
+  const args = [
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${userDataDir}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--new-window",
+    url
+  ];
+  const child = spawn(chromePath, args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: false
+  });
+  child.unref();
+  const readiness = await waitForChromeDebugPort({
+    host,
+    port,
+    timeoutMs: slowLive ? 30000 : 12000,
+    intervalMs: slowLive ? 700 : 300
+  });
+  if (!readiness.ok) {
+    throw new Error(`Chrome launched but DevTools port ${port} did not become reachable: ${readiness.error}`);
+  }
+  return {
+    launched: true,
+    chrome_path: chromePath,
+    user_data_dir: userDataDir,
+    port,
+    url,
+    readiness: {
+      elapsed_ms: readiness.elapsed_ms,
+      target_count: readiness.targets.length
+    }
+  };
+}
+
+export async function ensureChromeDebugPort({
+  host = DEFAULT_CHROME_HOST,
+  port = DEFAULT_CHROME_PORT,
+  url = "about:blank",
+  slowLive = false,
+  launchIfMissing = true
+} = {}) {
+  try {
+    const targets = await listChromeTargets({ host, port });
+    return {
+      launched: false,
+      reused: true,
+      port,
+      target_count: targets.length
+    };
+  } catch (error) {
+    if (!launchIfMissing || !isChromeDebugUnavailableError(error)) {
+      throw error;
+    }
+    return launchChromeDebugInstance({ host, port, url, slowLive });
+  }
+}
+
+export async function openChromeTarget({
+  host = DEFAULT_CHROME_HOST,
+  port = DEFAULT_CHROME_PORT,
+  url
+} = {}) {
+  const encodedUrl = encodeURIComponent(url || "about:blank");
+  const endpoint = `http://${host}:${port}/json/new?${encodedUrl}`;
+  const methods = ["PUT", "GET"];
+  let lastError = null;
+  for (const method of methods) {
+    try {
+      const response = await fetch(endpoint, { method });
+      if (response.ok) {
+        let payload = null;
+        try {
+          payload = await response.json();
+        } catch {}
+        return {
+          ok: true,
+          method,
+          target_id: payload?.id || null,
+          url: payload?.url || url || null
+        };
+      }
+      lastError = new Error(`DevTools /json/new returned ${response.status}`);
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  return {
+    ok: false,
+    error: lastError?.message || "Failed to open Chrome target"
+  };
+}
+
+export async function connectToChromeTargetOrOpen({
+  host = DEFAULT_CHROME_HOST,
+  port = DEFAULT_CHROME_PORT,
+  targetUrlIncludes,
+  targetPredicate,
+  fallbackTargetPredicate,
+  targetUrl,
+  allowNavigate = true,
+  slowLive = false,
+  launchIfMissing = true
+} = {}) {
+  let chrome = null;
+  if (allowNavigate && targetUrl) {
+    chrome = await ensureChromeDebugPort({
+      host,
+      port,
+      url: targetUrl,
+      slowLive,
+      launchIfMissing
+    });
+  }
+
+  try {
+    const session = await connectToChromeTarget({
+      host,
+      port,
+      targetUrlIncludes,
+      targetPredicate
+    });
+    return {
+      ...session,
+      chrome: {
+        ...(chrome || { launched: false, reused: true, port }),
+        target_created: false
+      }
+    };
+  } catch (primaryError) {
+    if (!allowNavigate) throw primaryError;
+
+    if (typeof fallbackTargetPredicate === "function") {
+      try {
+        const session = await connectToChromeTarget({
+          host,
+          port,
+          targetPredicate: fallbackTargetPredicate
+        });
+        return {
+          ...session,
+          chrome: {
+            ...(chrome || { launched: false, reused: true, port }),
+            target_created: false,
+            fallback_target: true
+          }
+        };
+      } catch {}
+    }
+
+    let openAttempt = null;
+    if (targetUrl) {
+      openAttempt = await openChromeTarget({ host, port, url: targetUrl });
+      if (openAttempt.ok) {
+        const session = await connectToChromeTarget({
+          host,
+          port,
+          targetPredicate: (target) => (
+            (openAttempt.target_id && target?.id === openAttempt.target_id)
+            || String(target?.url || "").includes(targetUrlIncludes || targetUrl)
+            || (targetUrl.includes("zhipin.com") && String(target?.url || "").includes("zhipin.com"))
+          )
+        });
+        return {
+          ...session,
+          chrome: {
+            ...(chrome || { launched: false, reused: true, port }),
+            target_created: true,
+            open_attempt: openAttempt
+          }
+        };
+      }
+    }
+
+    const session = await connectToChromeTarget({
+      host,
+      port,
+      targetPredicate: (target) => target?.type === "page"
+    });
+    return {
+      ...session,
+      chrome: {
+        ...(chrome || { launched: false, reused: true, port }),
+        target_created: false,
+        open_attempt: openAttempt,
+        fallback_any_page: true
+      }
+    };
+  }
+}
+
 export function createGuardedCdpClient(client, { methodLog = [] } = {}) {
   return new Proxy(client, {
     get(target, property, receiver) {

package/src/core/screening/index.js

@@ -37,7 +37,7 @@ const GENDER_CODE_MAP = {
   2: "女"
 };
 
-const LLM_THINKING_LEVELS = new Set(["off", "low", "medium", "high", "current"]);
+const LLM_THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "auto", "current"]);
 
 function nowIso() {
   return new Date().toISOString();
@@ -64,9 +64,9 @@ function isVolcengineModel(baseUrl, model) {
 
 function applyChatCompletionThinking(payload, { baseUrl = "", model = "", thinkingLevel = "" } = {}) {
   const level = normalizeLlmThinkingLevel(thinkingLevel);
-  if (!level || level === "current") return payload;
+  if (!level || level === "current" || level === "auto") return payload;
   if (isVolcengineModel(baseUrl, model)) {
-    if (level === "off") {
+    if (level === "off" || level === "minimal") {
       payload.thinking = { type: "disabled" };
     } else {
       payload.thinking = { type: "enabled" };

package/src/index.js

@@ -7,7 +7,8 @@ import { fileURLToPath } from "node:url";
 import {
   getFeaturedCalibrationResolution,
   getBossChatTargetCountValue,
-  normalizeTargetCountInput
+  normalizeTargetCountInput,
+  resolveBossScreeningConfig
 } from "./chat-runtime-config.js";
 import {
   __resetChatMcpStateForTests,
@@ -1890,7 +1891,8 @@ async function handleRunRecommendSelfHealTool({ workspaceRoot, args }) {
   }
 
   const host = "127.0.0.1";
-  const port = parsePositiveInteger(args.port, 9222);
+  const configResolution = resolveBossScreeningConfig(workspaceRoot);
+  const port = parsePositiveInteger(args.port, configResolution.ok ? configResolution.config.debugPort : 9222);
   let session = null;
   try {
     session = await connectToChromeTarget({