@reconcrap/boss-recommend-mcp 2.0.2 → 2.0.4

package/src/recommend-mcp.js

@@ -4,8 +4,13 @@ import process from "node:process";
 import {
   assertNoForbiddenCdpCalls,
   bringPageToFront,
-  connectToChromeTarget,
+  connectToChromeTargetOrOpen,
+  createBossLoginRequiredError,
+  detectBossLoginState,
   enableDomains,
+  getMainFrameUrl,
+  isBossLoginUrl,
+  waitForMainFrameUrl,
   sleep
 } from "./core/browser/index.js";
 import {
@@ -39,6 +44,10 @@ import {
   parseRecommendInstruction
 } from "./parser.js";
 import { getRunsDir } from "./run-state.js";
+import {
+  resolveBossConfiguredOutputDir,
+  resolveBossScreeningConfig
+} from "./chat-runtime-config.js";
 
 const DEFAULT_RECOMMEND_HOST = "127.0.0.1";
 const DEFAULT_RECOMMEND_PORT = 9222;
@@ -110,12 +119,14 @@ function getRecommendRunArtifacts(runId) {
   const normalized = normalizeRunId(runId);
   if (!normalized) return null;
   const runsDir = getRunsDir();
+  const outputDir = resolveBossConfiguredOutputDir("", runsDir);
   return {
     runs_dir: runsDir,
+    output_dir: outputDir,
     run_state_path: path.join(runsDir, `${normalized}.json`),
     checkpoint_path: path.join(runsDir, `${normalized}.checkpoint.json`),
-    output_csv: path.join(runsDir, `${normalized}.results.csv`),
-    report_json: path.join(runsDir, `${normalized}.report.json`)
+    output_csv: path.join(outputDir, `${normalized}.results.csv`),
+    report_json: path.join(outputDir, `${normalized}.report.json`)
   };
 }
 
@@ -479,8 +490,12 @@ async function readRecommendJobOptionsFromSession(session) {
 }
 
 export async function listRecommendJobsTool({ workspaceRoot = "", args = {} } = {}) {
+  const configResolution = resolveBossScreeningConfig(workspaceRoot);
   const host = normalizeText(args.host) || DEFAULT_RECOMMEND_HOST;
-  const port = parsePositiveInteger(args.port, DEFAULT_RECOMMEND_PORT);
+  const port = parsePositiveInteger(
+    args.port,
+    configResolution.ok ? configResolution.config.debugPort : DEFAULT_RECOMMEND_PORT
+  );
   const targetUrlIncludes = normalizeText(args.target_url_includes) || RECOMMEND_TARGET_URL;
   const allowNavigate = args.allow_navigate !== false;
   const slowLive = args.slow_live === true;
@@ -526,27 +541,36 @@ export async function listRecommendJobsTool({ workspaceRoot = "", args = {} } =
         host,
         port,
         target_url: session.navigation?.url || session.target?.url || RECOMMEND_TARGET_URL,
-        target_id: session.target?.id || null
+        target_id: session.target?.id || null,
+        auto_launch: session.chrome || null
       },
       method_summary: methodSummary(session.methodLog || []),
       method_log: session.methodLog || []
     };
   } catch (error) {
     const methodLog = session?.methodLog || [];
+    const loginRequired = error?.code === "BOSS_LOGIN_REQUIRED";
     return {
       status: "FAILED",
       stage: "recommend_job_list",
       cdp_only: true,
       runtime_evaluate_used: methodLog.some((entry) => String(entry?.method || entry).startsWith("Runtime.")),
       error: {
-        code: "RECOMMEND_JOB_LIST_FAILED",
+        code: loginRequired ? "BOSS_LOGIN_REQUIRED" : "RECOMMEND_JOB_LIST_FAILED",
         message: error?.message || "Failed to read recommend job list",
+        requires_login: Boolean(error?.requires_login),
+        login_url: error?.login_url || null,
+        login_detection: error?.login_detection || null,
+        current_url: error?.current_url || null,
+        target_url: error?.target_url || RECOMMEND_TARGET_URL,
+        chrome: error?.chrome || null,
         retryable: true
       },
       chrome: {
         host,
         port,
-        target_url: targetUrlIncludes
+        target_url: targetUrlIncludes,
+        auto_launch: error?.chrome || session?.chrome || null
       },
       method_summary: methodSummary(methodLog),
       method_log: methodLog
@@ -585,6 +609,14 @@ async function waitForHealthyRecommend(client, config, {
   const started = Date.now();
   let lastCheck = null;
   while (Date.now() - started <= timeoutMs) {
+    const loginDetection = await detectBossLoginState(client).catch(() => null);
+    if (loginDetection?.requires_login) {
+      return {
+        status: "login_required",
+        summary: "Boss login is required",
+        loginDetection
+      };
+    }
     const roots = await resolveRecommendSelfHealRoots(client, config);
     lastCheck = await runSelfHealCheck({
       client,
@@ -610,24 +642,18 @@ async function connectRecommendChromeSession({
   allowNavigate = true,
   slowLive = false
 } = {}) {
-  let session;
-  try {
-    session = await connectToChromeTarget({
-      host,
-      port,
-      targetUrlIncludes
-    });
-  } catch (error) {
-    if (!allowNavigate) throw error;
-    session = await connectToChromeTarget({
-      host,
-      port,
-      targetPredicate: (target) => (
-        target?.type === "page"
-        && String(target?.url || "").includes("zhipin.com/web/chat")
-      )
-    });
-  }
+  const session = await connectToChromeTargetOrOpen({
+    host,
+    port,
+    targetUrlIncludes,
+    targetUrl: RECOMMEND_TARGET_URL,
+    allowNavigate,
+    slowLive,
+    fallbackTargetPredicate: (target) => (
+      target?.type === "page"
+      && String(target?.url || "").includes("zhipin.com")
+    )
+  });
 
   const { client, target } = session;
   await enableDomains(client, ["Page", "DOM", "Input", "Network", "Accessibility"]);
@@ -644,12 +670,56 @@ async function connectRecommendChromeSession({
   if (allowNavigate && shouldNavigateToRecommend(targetUrl)) {
     await client.Page.navigate({ url: RECOMMEND_TARGET_URL });
     const settleMs = slowLive ? 12000 : 5000;
-    await sleep(settleMs);
+    const waited = await waitForMainFrameUrl(
+      client,
+      (url) => isBossLoginUrl(url) || !shouldNavigateToRecommend(url),
+      { timeoutMs: settleMs, intervalMs: 500 }
+    );
+    navigation = {
+      navigated: true,
+      url: RECOMMEND_TARGET_URL,
+      settle_ms: settleMs,
+      observed_url: waited.url || null,
+      observed_url_ok: waited.ok
+    };
+  }
+  let currentUrl = await getMainFrameUrl(client).catch(() => navigation.url || targetUrl);
+  if (allowNavigate && shouldNavigateToRecommend(currentUrl) && !isBossLoginUrl(currentUrl)) {
+    await client.Page.navigate({ url: RECOMMEND_TARGET_URL });
+    const settleMs = slowLive ? 12000 : 5000;
+    const waited = await waitForMainFrameUrl(
+      client,
+      (url) => isBossLoginUrl(url) || !shouldNavigateToRecommend(url),
+      { timeoutMs: settleMs, intervalMs: 500 }
+    );
     navigation = {
       navigated: true,
       url: RECOMMEND_TARGET_URL,
-      settle_ms: settleMs
+      settle_ms: settleMs,
+      observed_url: waited.url || null,
+      observed_url_ok: waited.ok,
+      reason: "observed_url_mismatch"
     };
+    currentUrl = await getMainFrameUrl(client).catch(() => waited.url || currentUrl);
+  }
+  const loginDetection = await detectBossLoginState(client, { currentUrl }).catch(() => ({
+    requires_login: isBossLoginUrl(currentUrl),
+    reason: "login_detection_failed",
+    current_url: currentUrl
+  }));
+  if (loginDetection.requires_login) {
+    await session.close?.();
+    throw createBossLoginRequiredError({
+      domain: "recommend",
+      currentUrl: loginDetection.current_url || currentUrl,
+      targetUrl: RECOMMEND_TARGET_URL,
+      loginDetection,
+      chrome: session.chrome || null
+    });
+  }
+  if (shouldNavigateToRecommend(currentUrl)) {
+    await session.close?.();
+    throw new Error(`Boss recommend page did not navigate to ${RECOMMEND_TARGET_URL}; current URL: ${currentUrl || "unknown"}`);
   }
 
   const selfHealConfig = buildRecommendSelfHealConfig();
@@ -657,7 +727,33 @@ async function connectRecommendChromeSession({
     timeoutMs: slowLive ? 180000 : 90000,
     intervalMs: slowLive ? 1200 : 800
   });
+  if (health?.loginDetection?.requires_login) {
+    await session.close?.();
+    throw createBossLoginRequiredError({
+      domain: "recommend",
+      currentUrl: health.loginDetection.current_url || currentUrl,
+      targetUrl: RECOMMEND_TARGET_URL,
+      loginDetection: health.loginDetection,
+      chrome: session.chrome || null
+    });
+  }
   if (!health || health.status !== HEALTH_STATUS.HEALTHY) {
+    const latestUrl = await getMainFrameUrl(client).catch(() => currentUrl);
+    const latestLoginDetection = await detectBossLoginState(client, { currentUrl: latestUrl }).catch(() => ({
+      requires_login: isBossLoginUrl(latestUrl),
+      reason: "login_detection_failed",
+      current_url: latestUrl
+    }));
+    if (latestLoginDetection.requires_login) {
+      await session.close?.();
+      throw createBossLoginRequiredError({
+        domain: "recommend",
+        currentUrl: latestLoginDetection.current_url || latestUrl,
+        targetUrl: RECOMMEND_TARGET_URL,
+        loginDetection: latestLoginDetection,
+        chrome: session.chrome || null
+      });
+    }
     throw new Error(`Boss recommend page is not healthy: ${health?.status || "missing"}`);
   }
 
@@ -836,7 +932,7 @@ function buildRecommendFilter(parsed, args = {}) {
   return groups.length ? { filterGroups: groups } : { enabled: false };
 }
 
-function normalizeRecommendStartInput(args = {}, parsed) {
+function normalizeRecommendStartInput(args = {}, parsed, configResolution = null) {
   const confirmation = args.confirmation || {};
   const overrides = args.overrides || {};
   const slowLive = args.slow_live === true;
@@ -846,7 +942,10 @@ function normalizeRecommendStartInput(args = {}, parsed) {
   );
   return {
     host: normalizeText(args.host) || DEFAULT_RECOMMEND_HOST,
-    port: parsePositiveInteger(args.port, DEFAULT_RECOMMEND_PORT),
+    port: parsePositiveInteger(
+      args.port,
+      configResolution?.ok ? configResolution.config.debugPort : DEFAULT_RECOMMEND_PORT
+    ),
     targetUrlIncludes: normalizeText(args.target_url_includes) || RECOMMEND_TARGET_URL,
     allowNavigate: args.allow_navigate !== false,
     slowLive,
@@ -952,7 +1051,8 @@ async function startRecommendPipelineRunInternal(args = {}, { workspaceRoot = ""
   const parsed = parseRecommendPipelineRequest(args);
   const gate = evaluateRecommendPipelineGate(parsed, args);
   if (gate) return gate;
-  const normalized = normalizeRecommendStartInput(args, parsed);
+  const configResolution = resolveBossScreeningConfig(workspaceRoot);
+  const normalized = normalizeRecommendStartInput(args, parsed, configResolution);
 
   let session;
   try {
@@ -964,13 +1064,21 @@ async function startRecommendPipelineRunInternal(args = {}, { workspaceRoot = ""
       slowLive: normalized.slowLive
     });
   } catch (error) {
+    const loginRequired = error?.code === "BOSS_LOGIN_REQUIRED";
     return {
       status: "FAILED",
       error: {
-        code: "BOSS_RECOMMEND_PAGE_NOT_READY",
+        code: loginRequired ? "BOSS_LOGIN_REQUIRED" : "BOSS_RECOMMEND_PAGE_NOT_READY",
         message: error?.message || "Boss recommend page is not ready",
+        requires_login: Boolean(error?.requires_login),
+        login_url: error?.login_url || null,
+        login_detection: error?.login_detection || null,
+        chrome: error?.chrome || null,
+        current_url: error?.current_url || null,
+        target_url: error?.target_url || RECOMMEND_TARGET_URL,
         retryable: true
-      }
+      },
+      chrome: error?.chrome || null
     };
   }
 
@@ -1000,7 +1108,8 @@ async function startRecommendPipelineRunInternal(args = {}, { workspaceRoot = ""
       host: normalized.host,
       port: normalized.port,
       target_url: session.navigation?.url || session.target?.url || RECOMMEND_TARGET_URL,
-      target_id: session.target?.id || null
+      target_id: session.target?.id || null,
+      auto_launch: session.chrome || null
     },
     health: session.health || null
   });

package/src/recruit-mcp.js

@@ -4,8 +4,13 @@ import path from "node:path";
 import {
   assertNoForbiddenCdpCalls,
   bringPageToFront,
-  connectToChromeTarget,
+  connectToChromeTargetOrOpen,
+  createBossLoginRequiredError,
+  detectBossLoginState,
   enableDomains,
+  getMainFrameUrl,
+  isBossLoginUrl,
+  waitForMainFrameUrl,
   sleep
 } from "./core/browser/index.js";
 import {
@@ -27,6 +32,10 @@ import {
   runRecruitWorkflow,
   waitForRecruitSearchControls
 } from "./domains/recruit/index.js";
+import {
+  resolveBossConfiguredOutputDir,
+  resolveBossScreeningConfig
+} from "./chat-runtime-config.js";
 
 const RUN_MODE_ASYNC = "async";
 const RUN_MODE_SYNC = "sync";
@@ -103,12 +112,14 @@ function getRecruitRunArtifacts(runId) {
   const normalized = normalizeRunId(runId);
   if (!normalized) return null;
   const runsDir = getRecruitRunsDir();
+  const outputDir = resolveBossConfiguredOutputDir("", runsDir);
   return {
     runs_dir: runsDir,
+    output_dir: outputDir,
     run_state_path: path.join(runsDir, `${normalized}.json`),
     checkpoint_path: path.join(runsDir, `${normalized}.checkpoint.json`),
-    output_csv: path.join(runsDir, `${normalized}.results.csv`),
-    report_json: path.join(runsDir, `${normalized}.report.json`)
+    output_csv: path.join(outputDir, `${normalized}.results.csv`),
+    report_json: path.join(outputDir, `${normalized}.report.json`)
   };
 }
 
@@ -586,6 +597,32 @@ function attachMethodEvidence(payload, runId) {
   };
 }
 
+async function waitForRecruitSearchControlsOrLogin(client, {
+  timeoutMs = 90000,
+  intervalMs = 300
+} = {}) {
+  const started = Date.now();
+  let lastControls = null;
+  while (Date.now() - started <= timeoutMs) {
+    const loginDetection = await detectBossLoginState(client).catch(() => null);
+    if (loginDetection?.requires_login) {
+      return {
+        ok: false,
+        reason: "login_required",
+        loginDetection
+      };
+    }
+    const remainingMs = Math.max(1, timeoutMs - (Date.now() - started));
+    lastControls = await waitForRecruitSearchControls(client, {
+      timeoutMs: Math.min(remainingMs, 1500),
+      intervalMs
+    });
+    if (lastControls.ok) return lastControls;
+    await sleep(intervalMs);
+  }
+  return lastControls || { ok: false, reason: "timeout" };
+}
+
 async function connectRecruitChromeSession({
   host = DEFAULT_RECRUIT_HOST,
   port = DEFAULT_RECRUIT_PORT,
@@ -593,24 +630,18 @@ async function connectRecruitChromeSession({
   allowNavigate = true,
   slowLive = false
 } = {}) {
-  let session;
-  try {
-    session = await connectToChromeTarget({
-      host,
-      port,
-      targetUrlIncludes
-    });
-  } catch (error) {
-    if (!allowNavigate) throw error;
-    session = await connectToChromeTarget({
-      host,
-      port,
-      targetPredicate: (target) => (
-        target?.type === "page"
-        && String(target?.url || "").includes("zhipin.com/web/chat")
-      )
-    });
-  }
+  const session = await connectToChromeTargetOrOpen({
+    host,
+    port,
+    targetUrlIncludes,
+    targetUrl: RECRUIT_TARGET_URL,
+    allowNavigate,
+    slowLive,
+    fallbackTargetPredicate: (target) => (
+      target?.type === "page"
+      && String(target?.url || "").includes("zhipin.com")
+    )
+  });
 
   const { client, target } = session;
   await enableDomains(client, ["Page", "DOM", "Input", "Network", "Accessibility"]);
@@ -620,21 +651,102 @@ async function connectRecruitChromeSession({
   await bringPageToFront(client);
 
   const targetUrl = String(target?.url || "");
+  let navigation = {
+    navigated: false,
+    url: targetUrl
+  };
   if (allowNavigate && !targetUrl.includes(targetUrlIncludes)) {
     await client.Page.navigate({ url: RECRUIT_TARGET_URL });
-    await sleep(slowLive ? 8000 : 3000);
+    const settleMs = slowLive ? 8000 : 3000;
+    const waited = await waitForMainFrameUrl(
+      client,
+      (url) => isBossLoginUrl(url) || String(url || "").includes(RECRUIT_TARGET_URL),
+      { timeoutMs: settleMs, intervalMs: 500 }
+    );
+    navigation = {
+      navigated: true,
+      url: RECRUIT_TARGET_URL,
+      settle_ms: settleMs,
+      observed_url: waited.url || null,
+      observed_url_ok: waited.ok
+    };
+  }
+  let currentUrl = await getMainFrameUrl(client).catch(() => targetUrl);
+  if (allowNavigate && !String(currentUrl || "").includes(RECRUIT_TARGET_URL) && !isBossLoginUrl(currentUrl)) {
+    await client.Page.navigate({ url: RECRUIT_TARGET_URL });
+    const settleMs = slowLive ? 8000 : 3000;
+    const waited = await waitForMainFrameUrl(
+      client,
+      (url) => isBossLoginUrl(url) || String(url || "").includes(RECRUIT_TARGET_URL),
+      { timeoutMs: settleMs, intervalMs: 500 }
+    );
+    navigation = {
+      navigated: true,
+      url: RECRUIT_TARGET_URL,
+      settle_ms: settleMs,
+      observed_url: waited.url || null,
+      observed_url_ok: waited.ok,
+      reason: "observed_url_mismatch"
+    };
+    currentUrl = await getMainFrameUrl(client).catch(() => waited.url || currentUrl);
+  }
+  const loginDetection = await detectBossLoginState(client, { currentUrl }).catch(() => ({
+    requires_login: isBossLoginUrl(currentUrl),
+    reason: "login_detection_failed",
+    current_url: currentUrl
+  }));
+  if (loginDetection.requires_login) {
+    await session.close?.();
+    throw createBossLoginRequiredError({
+      domain: "search",
+      currentUrl: loginDetection.current_url || currentUrl,
+      targetUrl: RECRUIT_TARGET_URL,
+      loginDetection,
+      chrome: session.chrome || null
+    });
+  }
+  if (!String(currentUrl || "").includes(RECRUIT_TARGET_URL)) {
+    await session.close?.();
+    throw new Error(`Boss search page did not navigate to ${RECRUIT_TARGET_URL}; current URL: ${currentUrl || "unknown"}`);
   }
 
-  const controls = await waitForRecruitSearchControls(client, {
+  const controls = await waitForRecruitSearchControlsOrLogin(client, {
     timeoutMs: slowLive ? 180000 : 90000,
     intervalMs: 300
   });
+  if (controls.loginDetection?.requires_login) {
+    await session.close?.();
+    throw createBossLoginRequiredError({
+      domain: "search",
+      currentUrl: controls.loginDetection.current_url || currentUrl,
+      targetUrl: RECRUIT_TARGET_URL,
+      loginDetection: controls.loginDetection,
+      chrome: session.chrome || null
+    });
+  }
   if (!controls.ok) {
+    const latestUrl = await getMainFrameUrl(client).catch(() => currentUrl);
+    const latestLoginDetection = await detectBossLoginState(client, { currentUrl: latestUrl }).catch(() => ({
+      requires_login: isBossLoginUrl(latestUrl),
+      reason: "login_detection_failed",
+      current_url: latestUrl
+    }));
+    if (latestLoginDetection.requires_login) {
+      await session.close?.();
+      throw createBossLoginRequiredError({
+        domain: "search",
+        currentUrl: latestLoginDetection.current_url || latestUrl,
+        targetUrl: RECRUIT_TARGET_URL,
+        loginDetection: latestLoginDetection,
+        chrome: session.chrome || null
+      });
+    }
     throw new Error("Boss recruit search page did not expose ready search controls");
   }
 
   return {
     ...session,
+    navigation,
     controls
   };
 }
@@ -701,24 +813,38 @@ async function startRecruitPipelineRunInternal(args = {}, { workspaceRoot = "" }
   const parsed = parseRecruitPipelineRequest(args);
   const gate = evaluateRecruitPipelineGate(parsed);
   if (gate) return gate;
+  const configResolution = resolveBossScreeningConfig(workspaceRoot);
+  const host = normalizeText(args.host) || DEFAULT_RECRUIT_HOST;
+  const port = parsePositiveInteger(
+    args.port,
+    configResolution.ok ? configResolution.config.debugPort : DEFAULT_RECRUIT_PORT
+  );
 
   let session;
   try {
     session = await recruitConnectorImpl({
-      host: normalizeText(args.host) || DEFAULT_RECRUIT_HOST,
-      port: parsePositiveInteger(args.port, DEFAULT_RECRUIT_PORT),
+      host,
+      port,
       targetUrlIncludes: normalizeText(args.target_url_includes) || RECRUIT_TARGET_URL,
       allowNavigate: args.allow_navigate !== false,
       slowLive: args.slow_live === true
     });
   } catch (error) {
+    const loginRequired = error?.code === "BOSS_LOGIN_REQUIRED";
     return {
       status: "FAILED",
       error: {
-        code: "BOSS_SEARCH_PAGE_NOT_READY",
+        code: loginRequired ? "BOSS_LOGIN_REQUIRED" : "BOSS_SEARCH_PAGE_NOT_READY",
         message: error?.message || "Boss recruit search page is not ready",
+        requires_login: Boolean(error?.requires_login),
+        login_url: error?.login_url || null,
+        login_detection: error?.login_detection || null,
+        chrome: error?.chrome || null,
+        current_url: error?.current_url || null,
+        target_url: error?.target_url || RECRUIT_TARGET_URL,
         retryable: true
-      }
+      },
+      chrome: error?.chrome || null
     };
   }
 
@@ -744,10 +870,11 @@ async function startRecruitPipelineRunInternal(args = {}, { workspaceRoot = "" }
     workspaceRoot: normalizeText(workspaceRoot) || globalThis.process?.cwd?.() || "",
     args: clonePlain(args, {}),
     chrome: {
-      host: normalizeText(args.host) || DEFAULT_RECRUIT_HOST,
-      port: parsePositiveInteger(args.port, DEFAULT_RECRUIT_PORT),
+      host,
+      port,
       target_url: session.target?.url || RECRUIT_TARGET_URL,
-      target_id: session.target?.id || null
+      target_id: session.target?.id || null,
+      auto_launch: session.chrome || null
     },
     parsed
   });