@reconcrap/boss-recommend-mcp 1.3.24 → 1.3.26

package/package.json

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

package/src/cli.js

@@ -39,7 +39,6 @@ const chromeOnboardingUrlPattern = /^chrome:\/\/(welcome|intro|newtab|signin|his
 const supportedMcpClients = ["generic", "cursor", "trae", "claudecode", "openclaw"];
 const defaultMcpServerName = "boss-recommend";
 const defaultMcpCommand = "npx";
-const defaultMcpArgs = ["-y", "@reconcrap/boss-recommend-mcp@latest", "start"];
 const recommendMcpPackageName = "@reconcrap/boss-recommend-mcp";
 const recommendMcpBinaryName = "boss-recommend-mcp";
 const autoSyncSkipCommands = new Set(["install", "install-skill", "where", "help", "--help", "-h"]);
@@ -65,6 +64,29 @@ function getPackageVersion() {
 
 const packageVersion = getPackageVersion();
 
+function isInstalledPackageRoot(rootPath = packageRoot) {
+  const normalized = path.resolve(String(rootPath || ""))
+    .replace(/\\/g, "/")
+    .toLowerCase();
+  return (
+    normalized.includes("/appdata/local/npm-cache/_npx/")
+    || normalized.includes("/node_modules/@reconcrap/boss-recommend-mcp")
+  );
+}
+
+function getDefaultMcpPackageSpecifier(options = {}) {
+  const version = String(options.packageVersion || packageVersion).trim();
+  const rootPath = options.packageRootPath || packageRoot;
+  if (version && version !== "0.0.0" && isInstalledPackageRoot(rootPath)) {
+    return `${recommendMcpPackageName}@${version}`;
+  }
+  return `${recommendMcpPackageName}@latest`;
+}
+
+function buildDefaultMcpArgs(options = {}) {
+  return ["-y", getDefaultMcpPackageSpecifier(options), "start"];
+}
+
 function getCodexHome() {
   return process.env.CODEX_HOME
     ? path.resolve(process.env.CODEX_HOME)
@@ -338,7 +360,7 @@ function buildMcpLaunchConfig(options = {}) {
     ? args
     : command === "boss-recommend-mcp"
       ? ["start"]
-      : defaultMcpArgs.slice();
+      : buildDefaultMcpArgs();
   const launchConfig = { command, args: launchArgs };
   if (env && typeof env === "object" && !Array.isArray(env) && Object.keys(env).length > 0) {
     launchConfig.env = env;
@@ -1606,9 +1628,13 @@ export async function runCli(argv = process.argv) {
 
 export const __testables = {
   buildBossChatCliInput,
+  buildDefaultMcpArgs,
+  buildMcpLaunchConfig,
   getBossChatCliRunTarget,
+  getDefaultMcpPackageSpecifier,
   getRunFollowUp,
   installSkill,
+  isInstalledPackageRoot,
   runBossChatCliCommand,
   runPipelineOnce
 };

package/src/test-boss-chat.js

@@ -16,6 +16,8 @@ import {
 import { __testables as cliTestables } from "./cli.js";
 import { __testables as indexTestables } from "./index.js";
 import { BossChatApp } from "../vendor/boss-chat-cli/src/app.js";
+import { __testables as vendorCliTestables } from "../vendor/boss-chat-cli/src/cli.js";
+import { BossChatPage } from "../vendor/boss-chat-cli/src/browser/chat-page.js";
 import { LlmClient, parseLlmJson } from "../vendor/boss-chat-cli/src/services/llm.js";
 
 const { handleRequest } = indexTestables;
@@ -398,6 +400,90 @@ async function testBossChatPrepareShouldRetryWhenChatPageIsNotReady() {
   });
 }
 
+async function testBossChatPageShouldTreatBlankChatShellAsOnChatPage() {
+  const fakeChromeClient = {
+    async callFunction() {
+      return {
+        href: "https://www.zhipin.com/web/chat/index",
+        readyState: "complete",
+        hasListContainer: false,
+        listItemCount: 0
+      };
+    }
+  };
+
+  const page = new BossChatPage(fakeChromeClient);
+  const pageState = await page.ensureOnChatPage();
+  assert.equal(pageState.href, "https://www.zhipin.com/web/chat/index");
+
+  await assert.rejects(
+    () => page.ensureReady(),
+    /CHAT_LIST_CONTAINER_NOT_FOUND/
+  );
+}
+
+async function testBossChatRecoverToChatIndexShouldForceNavigateAndWaitForCompleteLoad() {
+  const calls = [];
+  let stateIndex = 0;
+  const states = [
+    {
+      href: "https://www.zhipin.com/web/chat/index",
+      readyState: "loading",
+      hasListContainer: false,
+      listItemCount: 0
+    },
+    {
+      href: "https://www.zhipin.com/web/chat/index",
+      readyState: "interactive",
+      hasListContainer: false,
+      listItemCount: 0
+    },
+    {
+      href: "https://www.zhipin.com/web/chat/index",
+      readyState: "complete",
+      hasListContainer: false,
+      listItemCount: 0
+    }
+  ];
+
+  const fakeChromeClient = {
+    async callFunction(fn, arg) {
+      calls.push({ name: fn.name, arg });
+      if (fn.name === "browserGetCurrentHref") {
+        return { href: "https://www.zhipin.com/web/chat/index" };
+      }
+      if (fn.name === "browserNavigateToChatIndex") {
+        return { ok: true, changed: true, href: "https://www.zhipin.com/web/chat/index" };
+      }
+      if (fn.name === "browserGetPageState") {
+        const value = states[Math.min(stateIndex, states.length - 1)];
+        stateIndex += 1;
+        return value;
+      }
+      throw new Error(`unexpected function: ${fn.name}`);
+    }
+  };
+
+  const page = new BossChatPage(fakeChromeClient);
+  const result = await page.recoverToChatIndex({
+    forceNavigate: true,
+    waitForReadyState: "complete",
+    maxAttempts: 5,
+    delayMs: 0
+  });
+
+  assert.equal(result.changed, true);
+  assert.equal(result.href, "https://www.zhipin.com/web/chat/index");
+  assert.equal(
+    calls.some((entry) => entry.name === "browserNavigateToChatIndex" && entry.arg?.force === true),
+    true
+  );
+  assert.equal(
+    calls.filter((entry) => entry.name === "browserGetPageState").length >= 3,
+    true
+  );
+}
+
 async function testBossChatMcpToolsShouldValidateAndRoute() {
   await withBossChatWorkspace(async (workspaceRoot) => {
     const toolsResponse = await handleRequest({
@@ -599,6 +685,118 @@ async function testBossChatCliShouldSupportRunAndFollowUpParsing() {
   });
 }
 
+async function testVendorBossChatCliShouldWaitForHydratedChatShell() {
+  const pageStates = [
+    { href: "https://www.zhipin.com/web/chat/index", hasListContainer: false, listItemCount: 0 },
+    { href: "https://www.zhipin.com/web/chat/index", hasListContainer: false, listItemCount: 0 },
+    { href: "https://www.zhipin.com/web/chat/index", hasListContainer: true, listItemCount: 40 },
+  ];
+  const jobsPerAttempt = [
+    [],
+    [],
+    [{ value: "job-1", label: "AI应用开发工程师（2026） _ 杭州", active: false }],
+  ];
+  let ensureCallCount = 0;
+  let listJobsCallCount = 0;
+  const page = {
+    async ensureOnChatPage() {
+      const next = pageStates[Math.min(ensureCallCount, pageStates.length - 1)];
+      ensureCallCount += 1;
+      return next;
+    },
+    async listJobs() {
+      const next = jobsPerAttempt[Math.min(listJobsCallCount, jobsPerAttempt.length - 1)];
+      listJobsCallCount += 1;
+      return next;
+    },
+  };
+
+  const hydrated = await vendorCliTestables.waitForChatShellHydration({
+    page,
+    maxAttempts: 4,
+    delayMs: 0,
+  });
+  assert.equal(Array.isArray(hydrated.jobs), true);
+  assert.equal(hydrated.jobs.length, 1);
+  assert.equal(hydrated.pageState.listItemCount, 40);
+  assert.equal(ensureCallCount >= 3, true);
+}
+
+async function testVendorBossChatCliShouldRetryJobListDuringPromptRunProfile() {
+  const page = {
+    _attempt: 0,
+    async ensureOnChatPage() {
+      return {
+        href: "https://www.zhipin.com/web/chat/index",
+        hasListContainer: this._attempt >= 1,
+        listItemCount: this._attempt >= 1 ? 10 : 0,
+      };
+    },
+    async listJobs() {
+      this._attempt += 1;
+      if (this._attempt < 2) {
+        return [];
+      }
+      return [
+        {
+          value: "job-1",
+          label: "AI应用开发工程师（2026） _ 杭州",
+          active: false,
+        },
+      ];
+    },
+  };
+
+  const profile = await vendorCliTestables.promptRunProfile({
+    page,
+    persistentProfile: {
+      llm: {
+        baseUrl: "https://api.example.com/v1",
+        apiKey: "sk-test-key",
+        model: "gpt-4.1-mini",
+      },
+      chrome: {
+        port: 9222,
+      },
+      runtime: {},
+    },
+    overrides: {
+      jobSelection: "AI应用开发工程师（2026） _ 杭州",
+      startFrom: "unread",
+      screeningCriteria: "小样本联通性验证",
+      targetCount: 1,
+    },
+  });
+  assert.equal(profile.jobSelection.label, "AI应用开发工程师（2026） _ 杭州");
+  assert.equal(profile.startFrom, "unread");
+  assert.equal(profile.targetCount, 1);
+}
+
+function testCliShouldPinInstalledPackageVersionInGeneratedMcpConfig() {
+  const installedSpecifier = cliTestables.getDefaultMcpPackageSpecifier({
+    packageVersion: "1.3.25",
+    packageRootPath: "C:\\Users\\yaolin\\AppData\\Roaming\\npm\\node_modules\\@reconcrap\\boss-recommend-mcp",
+  });
+  assert.equal(installedSpecifier, "@reconcrap/boss-recommend-mcp@1.3.25");
+
+  const cachedSpecifier = cliTestables.getDefaultMcpPackageSpecifier({
+    packageVersion: "1.3.25",
+    packageRootPath: "C:\\Users\\yaolin\\AppData\\Local\\npm-cache\\_npx\\abcd1234\\node_modules\\@reconcrap\\boss-recommend-mcp",
+  });
+  assert.equal(cachedSpecifier, "@reconcrap/boss-recommend-mcp@1.3.25");
+
+  const sourceSpecifier = cliTestables.getDefaultMcpPackageSpecifier({
+    packageVersion: "1.3.25-dev",
+    packageRootPath: "C:\\Users\\yaolin\\Documents\\codex_projects\\boss recommend pipeline\\boss-recommend-mcp",
+  });
+  assert.equal(sourceSpecifier, "@reconcrap/boss-recommend-mcp@latest");
+
+  const launchConfig = cliTestables.buildMcpLaunchConfig({});
+  assert.equal(launchConfig.command, "npx");
+  assert.equal(Array.isArray(launchConfig.args), true);
+  assert.equal(launchConfig.args[0], "-y");
+}
+
 function testBossChatLlmEvidenceGateShouldDemoteMissingEvidence() {
   const parsed = parseLlmJson(
     JSON.stringify({
@@ -941,8 +1139,13 @@ async function testBossChatAppShouldPersistEvidenceArtifacts() {
 async function main() {
   await testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli();
   await testBossChatPrepareShouldRetryWhenChatPageIsNotReady();
+  await testBossChatPageShouldTreatBlankChatShellAsOnChatPage();
+  await testBossChatRecoverToChatIndexShouldForceNavigateAndWaitForCompleteLoad();
   await testBossChatMcpToolsShouldValidateAndRoute();
   await testBossChatCliShouldSupportRunAndFollowUpParsing();
+  await testVendorBossChatCliShouldWaitForHydratedChatShell();
+  await testVendorBossChatCliShouldRetryJobListDuringPromptRunProfile();
+  testCliShouldPinInstalledPackageVersionInGeneratedMcpConfig();
   testBossChatLlmEvidenceGateShouldDemoteMissingEvidence();
   testBossChatLlmEvidenceGateShouldDemoteUnmatchedEvidence();
   await testBossChatLlmTextChunkFallbackShouldWork();

package/vendor/boss-chat-cli/src/browser/chat-page.js

@@ -24,6 +24,7 @@ function browserGetPageState() {
 
   return {
     href: window.location.href,
+    readyState: document.readyState,
     hasListContainer: Boolean(listContainer),
     listItemCount: listItems.length,
   };
@@ -33,9 +34,10 @@ function browserGetCurrentHref() {
   return { href: window.location.href };
 }
 
-function browserNavigateToChatIndex() {
+function browserNavigateToChatIndex(options = {}) {
   const chatUrl = 'https://www.zhipin.com/web/chat/index';
-  if (!String(window.location.href || '').includes('/web/chat/index')) {
+  const force = options?.force === true;
+  if (force || !String(window.location.href || '').includes('/web/chat/index')) {
     window.location.assign(chatUrl);
     return { ok: true, changed: true, href: chatUrl };
   }
@@ -2236,11 +2238,20 @@ export class BossChatPage {
     return target?.type === 'page' && String(target.url || '').includes(CHAT_URL_TOKEN);
   }
 
-  async ensureReady() {
-    const pageState = await this.chromeClient.callFunction(browserGetPageState);
+  async getPageState() {
+    return this.chromeClient.callFunction(browserGetPageState);
+  }
+
+  async ensureOnChatPage() {
+    const pageState = await this.getPageState();
     if (!pageState?.href?.includes(CHAT_URL_TOKEN)) {
       throw new Error('ACTIVE_TAB_IS_NOT_BOSS_CHAT_PAGE');
     }
+    return pageState;
+  }
+
+  async ensureReady() {
+    const pageState = await this.ensureOnChatPage();
     if (!pageState.hasListContainer && Number(pageState.listItemCount || 0) <= 0) {
       throw new Error('CHAT_LIST_CONTAINER_NOT_FOUND');
     }
@@ -2250,16 +2261,20 @@ export class BossChatPage {
   async recoverToChatIndex(options = {}) {
     const maxAttempts = options.maxAttempts || 20;
     const delayMs = options.delayMs || 500;
+    const forceNavigate = options.forceNavigate === true;
+    const waitForReadyState = options.waitForReadyState || 'complete';
     const hrefResult = await this.chromeClient.callFunction(browserGetCurrentHref);
-    if (String(hrefResult?.href || '').includes(CHAT_URL_TOKEN)) {
+    if (!forceNavigate && String(hrefResult?.href || '').includes(CHAT_URL_TOKEN)) {
       return { changed: false, href: hrefResult?.href || '' };
     }
 
-    await this.chromeClient.callFunction(browserNavigateToChatIndex);
+    await this.chromeClient.callFunction(browserNavigateToChatIndex, { force: forceNavigate });
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
       await new Promise((resolve) => setTimeout(resolve, delayMs));
-      const state = await this.chromeClient.callFunction(browserGetPageState);
-      if (String(state?.href || '').includes(CHAT_URL_TOKEN)) {
+      const state = await this.getPageState();
+      const onChatPage = String(state?.href || '').includes(CHAT_URL_TOKEN);
+      const ready = !waitForReadyState || String(state?.readyState || '').toLowerCase() === String(waitForReadyState).toLowerCase();
+      if (onChatPage && ready) {
         return { changed: true, href: state.href };
       }
     }

package/vendor/boss-chat-cli/src/cli.js

@@ -44,6 +44,11 @@ const CLI_FILE_PATH = fileURLToPath(import.meta.url);
 const MINIMAL_TERMINAL_PATTERNS = [/^进度: /, /^候选人结果: /];
 const CHAT_INDEX_URL = 'https://www.zhipin.com/web/chat/index';
 const CHAT_START_REQUIRED_FIELDS = ['job', 'start_from', 'target_count', 'criteria'];
+const CHAT_PAGE_RENAVIGATE_MAX_ATTEMPTS = 3;
+const CHAT_PAGE_HYDRATION_MAX_ATTEMPTS = 12;
+const CHAT_PAGE_HYDRATION_DELAY_MS = 250;
+const CHAT_JOB_LIST_MAX_ATTEMPTS = 16;
+const CHAT_JOB_LIST_DELAY_MS = 250;
 
 function sanitizePathToken(value, fallback = 'run') {
   const token = String(value || '')
@@ -70,6 +75,10 @@ function shouldPrintToMinimalTerminal(message) {
   return MINIMAL_TERMINAL_PATTERNS.some((pattern) => pattern.test(message));
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 async function createRunLogger(dataDir, { runId = '', detachedWorker = false } = {}) {
   const logsDir = path.join(dataDir, 'logs');
   await mkdir(logsDir, { recursive: true });
@@ -497,7 +506,7 @@ function resolveJobSelection(jobs, input) {
 }
 
 async function promptRunProfile({ page, persistentProfile, overrides }) {
-  const jobs = await page.listJobs();
+  const jobs = await resolveJobsWithRetry({ page });
   if (!Array.isArray(jobs) || jobs.length === 0) {
     throw new Error('未解析到岗位列表，请确认岗位下拉可见。');
   }
@@ -646,11 +655,109 @@ function buildPreparePendingQuestions(args, jobs = []) {
   return pendingQuestions;
 }
 
+function hasHydratedChatShell(pageState, jobs = []) {
+  const hasChatList =
+    Boolean(pageState?.hasListContainer)
+    || Number(pageState?.listItemCount || 0) > 0;
+  return hasChatList || (Array.isArray(jobs) && jobs.length > 0);
+}
+
+async function waitForChatShellHydration({
+  page,
+  maxAttempts = CHAT_PAGE_HYDRATION_MAX_ATTEMPTS,
+  delayMs = CHAT_PAGE_HYDRATION_DELAY_MS,
+} = {}) {
+  let lastPageState = null;
+  let lastJobs = [];
+  let lastError = null;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      lastPageState = await page.ensureOnChatPage();
+    } catch (error) {
+      lastError = error;
+      break;
+    }
+
+    try {
+      lastJobs = await page.listJobs();
+    } catch (error) {
+      lastError = error;
+      lastJobs = [];
+    }
+
+    if (hasHydratedChatShell(lastPageState, lastJobs)) {
+      return {
+        pageState: lastPageState,
+        jobs: lastJobs,
+      };
+    }
+
+    if (attempt < maxAttempts) {
+      await sleep(delayMs);
+    }
+  }
+
+  const lastErrorMessage = String(lastError?.message || lastError || '');
+  if (/ACTIVE_TAB_IS_NOT_BOSS_CHAT_PAGE/.test(lastErrorMessage)) {
+    throw lastError;
+  }
+
+  return {
+    pageState: lastPageState,
+    jobs: lastJobs,
+  };
+}
+
+async function resolveJobsWithRetry({
+  page,
+  maxAttempts = CHAT_JOB_LIST_MAX_ATTEMPTS,
+  delayMs = CHAT_JOB_LIST_DELAY_MS,
+} = {}) {
+  let lastError = null;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      const jobs = await page.listJobs();
+      if (Array.isArray(jobs) && jobs.length > 0) {
+        return jobs;
+      }
+    } catch (error) {
+      lastError = error;
+      const message = String(error?.message || error || '');
+      if (/ACTIVE_TAB_IS_NOT_BOSS_CHAT_PAGE/.test(message)) {
+        throw error;
+      }
+    }
+
+    const hydrated = await waitForChatShellHydration({
+      page,
+      maxAttempts: 1,
+      delayMs,
+    });
+    if (Array.isArray(hydrated?.jobs) && hydrated.jobs.length > 0) {
+      return hydrated.jobs;
+    }
+
+    if (attempt < maxAttempts) {
+      await sleep(delayMs);
+    }
+  }
+
+  if (lastError) {
+    throw lastError;
+  }
+
+  return [];
+}
+
 async function connectBossChatPage(chromeClient) {
   const isBossDomainTarget = (target) =>
     target?.type === 'page' && /zhipin\.com/i.test(String(target?.url || ''));
   let target = null;
   let recoveredToChatIndex = false;
+  let blankChatPage = false;
+  let renavigateAttempts = 0;
 
   try {
     target = await chromeClient.connect(BossChatPage.targetMatcher);
@@ -659,15 +766,53 @@ async function connectBossChatPage(chromeClient) {
   }
 
   const page = new BossChatPage(chromeClient);
-  try {
-    await page.ensureReady();
-  } catch {
-    await page.recoverToChatIndex();
-    recoveredToChatIndex = true;
-    await page.ensureReady();
+  for (let attempt = 1; attempt <= CHAT_PAGE_RENAVIGATE_MAX_ATTEMPTS + 1; attempt += 1) {
+    try {
+      await page.ensureReady();
+      return {
+        target,
+        page,
+        recoveredToChatIndex,
+        blankChatPage,
+        renavigateAttempts,
+      };
+    } catch (error) {
+      const message = String(error?.message || error || '');
+      if (/CHAT_LIST_CONTAINER_NOT_FOUND/.test(message)) {
+        blankChatPage = true;
+        const hydrated = await waitForChatShellHydration({ page });
+        if (hasHydratedChatShell(hydrated?.pageState, hydrated?.jobs)) {
+          return {
+            target,
+            page,
+            recoveredToChatIndex,
+            blankChatPage,
+            renavigateAttempts,
+          };
+        }
+      }
+      const canRetry =
+        /ACTIVE_TAB_IS_NOT_BOSS_CHAT_PAGE|CHAT_LIST_CONTAINER_NOT_FOUND/.test(message)
+        && attempt <= CHAT_PAGE_RENAVIGATE_MAX_ATTEMPTS;
+
+      if (!canRetry) {
+        if (/CHAT_LIST_CONTAINER_NOT_FOUND/.test(message)) {
+          await page.ensureOnChatPage();
+          break;
+        }
+        throw error;
+      }
+
+      await page.recoverToChatIndex({
+        forceNavigate: true,
+        waitForReadyState: 'complete',
+      });
+      recoveredToChatIndex = true;
+      renavigateAttempts += 1;
+    }
   }
 
-  return { target, page, recoveredToChatIndex };
+  return { target, page, recoveredToChatIndex, blankChatPage, renavigateAttempts };
 }
 
 async function handlePrepareRunCommand(args, dataDir) {
@@ -704,8 +849,8 @@ async function handlePrepareRunCommand(args, dataDir) {
   let chromeClient = null;
   try {
     chromeClient = new ChromeClient(mergedProfile.chrome.port);
-    const { target, page, recoveredToChatIndex } = await connectBossChatPage(chromeClient);
-    const jobs = await page.listJobs();
+    const { target, page, recoveredToChatIndex, blankChatPage, renavigateAttempts } = await connectBossChatPage(chromeClient);
+    const jobs = await resolveJobsWithRetry({ page });
     if (!Array.isArray(jobs) || jobs.length === 0) {
       return {
         status: 'FAILED',
@@ -723,6 +868,8 @@ async function handlePrepareRunCommand(args, dataDir) {
       page_url: CHAT_INDEX_URL,
       connected_target: target?.url || '',
       recovered_to_chat_index: recoveredToChatIndex,
+      blank_chat_page: blankChatPage,
+      renavigate_attempts: renavigateAttempts,
       required_fields: CHAT_START_REQUIRED_FIELDS.slice(),
       defaults: {
         profile: String(args.profile || 'default').trim() || 'default',
@@ -1159,10 +1306,13 @@ async function executeRunCommand(args, dataDir) {
 
     chromeClient = new ChromeClient(persistentProfile.chrome.port);
 
-    const { target, page, recoveredToChatIndex } = await connectBossChatPage(chromeClient);
+    const { target, page, recoveredToChatIndex, blankChatPage, renavigateAttempts } = await connectBossChatPage(chromeClient);
     logger.log(`已连接 Chrome tab: ${target.title || target.url}`);
     if (recoveredToChatIndex) {
-      logger.log(`检测到当前标签不在聊天页，已自动跳转到 ${CHAT_INDEX_URL}`);
+      logger.log(`检测到页面不符合预期，已重新跳转到 ${CHAT_INDEX_URL} 并等待加载完成。attempts=${renavigateAttempts}`);
+    }
+    if (blankChatPage) {
+      logger.log('检测到聊天页处于空白未初始化状态，将继续通过岗位选择和首位候选人预热来恢复列表。');
     }
 
     const runProfile = await promptRunProfile({
@@ -1389,12 +1539,22 @@ async function main() {
   }
 }
 
-main().catch((error) => {
-  const runLogPath = String(error?.runLogPath || '').trim();
-  if (runLogPath) {
-    console.error(`执行失败，详细日志见: ${runLogPath}`);
-  } else {
-    console.error(`执行失败: ${error.message}`);
-  }
-  process.exitCode = 1;
-});
+export const __testables = {
+  connectBossChatPage,
+  hasHydratedChatShell,
+  promptRunProfile,
+  resolveJobsWithRetry,
+  waitForChatShellHydration,
+};
+
+if (process.argv[1] && path.resolve(process.argv[1]) === CLI_FILE_PATH) {
+  main().catch((error) => {
+    const runLogPath = String(error?.runLogPath || '').trim();
+    if (runLogPath) {
+      console.error(`执行失败，详细日志见: ${runLogPath}`);
+    } else {
+      console.error(`执行失败: ${error.message}`);
+    }
+    process.exitCode = 1;
+  });
+}