@reconcrap/boss-recommend-mcp 2.0.30 → 2.0.32

package/README.md

@@ -227,10 +227,35 @@ config/screening-config.example.json
 - `apiKey`
 - `model`
 
+也可以用 `llmModels` 配置多个 OpenAI-compatible 模型。运行时会先调用第一个模型；当该模型请求失败、超时、返回非 JSON、或没有返回 `{"passed": true/false}` 决策时，会自动切到下一个模型。未配置 `llmModels` 或数组为空时，继续使用上面的单模型字段，旧配置无需迁移。
+
+```json
+{
+  "llmModels": [
+    {
+      "name": "primary",
+      "baseUrl": "https://api.openai.com/v1",
+      "apiKey": "sk-primary",
+      "model": "gpt-4.1-mini"
+    },
+    {
+      "name": "backup",
+      "baseUrl": "https://api.openai.com/v1",
+      "apiKey": "sk-backup",
+      "model": "gpt-4.1-nano"
+    }
+  ],
+  "greetingMessage": "Hi同学，能麻烦发下简历吗？",
+  "llmThinkingLevel": "low",
+  "llmMaxRetries": 1
+}
+```
+
 可选字段：
 
 - `openaiOrganization`
 - `openaiProject`
+- `greetingMessage`：chat 求简历流程发送的招呼语。兼容 `greetingText` / `greeting_text`；本次 run 显式传入的 `greeting_text` 优先级最高。
 - `debugPort`：未显式传 `port` 时，recommend / search / chat CDP-only MCP run 和健康检查默认连接这个 Chrome 调试端口。
 - `outputDir`：recommend / search / chat 完成后的最终 CSV 与 report JSON 会写入这里；run state / checkpoint 仍保留在各自状态目录，方便 pause/resume/cancel。
 - `llmThinkingLevel`：默认 `low`。可设为 `off/minimal/low/medium/high/auto/current`，用于控制 OpenAI-compatible LLM 的 thinking/reasoning 强度。
@@ -243,7 +268,7 @@ npm 包安装后可直接使用可执行命令 `boss-recommend-mcp`。以下示
 ```bash
 node src/cli.js install --agent trae-cn
 node src/cli.js init-config
-node src/cli.js config set --base-url https://api.openai.com/v1 --api-key <your-key> --model gpt-4o-mini --thinking-level off
+node src/cli.js config set --base-url https://api.openai.com/v1 --api-key <your-key> --model gpt-4o-mini --thinking-level off --greeting-message "您好，方便发下简历吗？"
 node src/cli.js set-port --port 9222
 node src/cli.js doctor --agent trae-cn
 node src/cli.js launch-chrome --port 9222
@@ -283,7 +308,7 @@ node src/cli.js chat prepare-run --slow-live --port 9222
 - `profile` 可选，默认 `default`
 - `job` 与 `port` 继承 recommend run 已选岗位和调试端口
 - `baseUrl` / `apiKey` / `model` 不再单独传入，固定复用 recommend 的 `screening-config.json`
-- `greeting_text` 默认优先级：本次显式值 > profile 历史值 > 内置默认招呼语（`Hi同学，能麻烦发下简历吗？`）
+- `greeting_text` 默认优先级：本次显式值 > `screening-config.json.greetingMessage` > 内置默认招呼语（`Hi同学，能麻烦发下简历吗？`）
 - 若缺少 `follow_up.chat` 必填项，pipeline 会返回 `NEED_INPUT`
 - 如需聊天页筛选，请调用 `prepare_boss_chat_run` 获取岗位列表，再调用 `start_boss_chat_run`。
 - `boss-chat` 状态统一写入 `~/.boss-recommend-mcp/boss-chat`（或 `BOSS_CHAT_HOME` 指定目录），不再依赖工作区 `cwd`
@@ -313,7 +338,7 @@ chat-only 交互建议：
 
 - 先调用一次 `prepare_boss_chat_run`（可不带参数），服务会先导航到 `https://www.zhipin.com/web/chat/index` 并返回 `NEED_INPUT`，其中包含岗位 `job_options` 与待补字段。
 - 然后基于 `job_options` 让用户选择 `job`，并补齐 `start_from`、`target_count`、`criteria` 后调用 `start_boss_chat_run` 启动任务。
-- `greeting_text` 可选；未传时会自动沿用 profile 上次输入，若无历史值则使用默认招呼语（`Hi同学，能麻烦发下简历吗？`）。
+- `greeting_text` 可选；未传时使用 `screening-config.json.greetingMessage`，若未配置则使用默认招呼语（`Hi同学，能麻烦发下简历吗？`）。
 - `target_count` 支持正整数、`all`、`-1`；若用户给出 `全部候选人` / `所有候选人`，会自动按不限（扫到底）处理。
 
 Trae-CN / 长对话防循环建议：

package/config/screening-config.example.json

@@ -1,7 +1,9 @@
 {
-  "baseUrl": "https://api.openai.com/v1",
-  "apiKey": "replace-with-openai-api-key",
+  "baseUrl": "https://api.openai.com/v1",
+  "apiKey": "replace-with-openai-api-key",
   "model": "gpt-4.1-mini",
+  "llmModels": [],
+  "greetingMessage": "Hi同学，能麻烦发下简历吗？",
   "llmThinkingLevel": "low",
   "llmTimeoutMs": 60000,
   "llmMaxTokens": 512,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.0.30",
+  "version": "2.0.32",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",
@@ -24,6 +24,7 @@
     "test:run-state": "node src/test-run-state.js",
     "test:cdp-browser": "node src/test-cdp-browser.js",
     "test:core-capture": "node src/test-core-capture.js",
+    "test:core-cv-capture-target": "node src/test-core-cv-capture-target.js",
     "test:core-cv-acquisition": "node src/test-core-cv-acquisition.js",
     "test:core-greet-quota": "node src/test-core-greet-quota.js",
     "test:core-infinite-list": "node src/test-core-infinite-list.js",
@@ -72,6 +73,7 @@
     "live:chat-domain": "node scripts/live-chat-domain-smoke.js",
     "live:chat-run-service": "node scripts/live-chat-run-service-smoke.js",
     "live:chat-mcp": "node scripts/live-chat-mcp-smoke.js",
+    "live:cv-capture-target": "node scripts/live-cv-capture-target-smoke.js",
     "live:chat-phase10-full": "node scripts/live-chat-phase10-full.js",
     "live:chat-image-screening": "node scripts/live-chat-image-screening-smoke.js"
   },

package/src/chat-mcp.js

@@ -50,6 +50,7 @@ import {
   resolveBossChatRuntimeLayout,
   resolveBossScreeningConfig
 } from "./chat-runtime-config.js";
+import { DEFAULT_MAX_IMAGE_PAGES } from "./core/cv-acquisition/index.js";
 
 const DEFAULT_CHAT_HOST = "127.0.0.1";
 const DEFAULT_CHAT_PORT = 9222;
@@ -874,12 +875,14 @@ async function readChatJobOptionsFromSession(session) {
 
 function normalizeChatStartInput(args = {}, configResolution = null) {
   const target = normalizeTargetCountInput(getBossChatTargetCountValue(args));
+  const explicitGreetingText = normalizeText(args.greeting_text || args.greetingText || args.greeting);
+  const configuredGreetingText = normalizeText(configResolution?.config?.greetingMessage || configResolution?.config?.greetingText);
   return {
     profile: normalizeText(args.profile) || "default",
     job: normalizeText(args.job),
     startFrom: normalizeText(args.start_from).toLowerCase(),
     criteria: normalizeText(args.criteria),
-    greetingText: normalizeText(args.greeting_text || args.greetingText || args.greeting),
+    greetingText: explicitGreetingText || configuredGreetingText,
     target,
     targetCount: target.targetCount,
     publicTargetCount: target.publicValue,
@@ -1098,7 +1101,7 @@ function getRunOptions(args, normalized, session, { workspaceRoot = "", configRe
       slowLive ? 30000 : 15000
     ),
     resumeDomTimeoutMs: slowLive ? 120000 : 60000,
-    maxImagePages: parsePositiveInteger(args.max_image_pages, 8),
+    maxImagePages: parsePositiveInteger(args.max_image_pages, DEFAULT_MAX_IMAGE_PAGES),
     imageWheelDeltaY: parsePositiveInteger(args.image_wheel_delta_y, 650),
     llmConfig: resolvedConfig.ok ? {
       ...resolvedConfig.config

package/src/chat-runtime-config.js

@@ -243,6 +243,55 @@ function normalizeLlmThinkingLevel(raw, fallback = "low") {
   return LLM_THINKING_LEVELS.has(normalized) ? normalized : fallback;
 }
 
+function firstConfiguredValue(...values) {
+  for (const value of values) {
+    if (value === undefined || value === null) continue;
+    if (typeof value === "string" && !value.trim()) continue;
+    return value;
+  }
+  return "";
+}
+
+function resolveRawLlmModelEntries(config = {}) {
+  if (Array.isArray(config.llmModels) && config.llmModels.length > 0) return config.llmModels;
+  if (Array.isArray(config.models) && config.models.length > 0) return config.models;
+  return [config];
+}
+
+function normalizeScreeningLlmModel(config = {}, rawEntry = {}, index = 0) {
+  const entry = typeof rawEntry === "string"
+    ? { model: rawEntry }
+    : (rawEntry && typeof rawEntry === "object" && !Array.isArray(rawEntry) ? rawEntry : {});
+  return {
+    name: normalizeText(firstConfiguredValue(entry.name, entry.label, entry.id, entry.providerName, entry.provider)),
+    baseUrl: normalizeText(firstConfiguredValue(entry.baseUrl, entry.base_url, config.baseUrl, config.base_url)).replace(/\/+$/, ""),
+    apiKey: normalizeText(firstConfiguredValue(entry.apiKey, entry.api_key, config.apiKey, config.api_key)),
+    model: normalizeText(firstConfiguredValue(entry.model, entry.modelName, entry.model_name, typeof rawEntry === "string" ? rawEntry : "", config.model)),
+    openaiOrganization: normalizeText(firstConfiguredValue(entry.openaiOrganization, entry.organization, config.openaiOrganization, config.organization)),
+    openaiProject: normalizeText(firstConfiguredValue(entry.openaiProject, entry.project, config.openaiProject, config.project)),
+    llmThinkingLevel: normalizeLlmThinkingLevel(
+      firstConfiguredValue(entry.llmThinkingLevel, entry.thinkingLevel, entry.reasoningEffort, config.llmThinkingLevel, config.thinkingLevel, config.reasoningEffort),
+      "low"
+    ),
+    llmTimeoutMs: parsePositiveInteger(firstConfiguredValue(entry.llmTimeoutMs, entry.timeoutMs, config.llmTimeoutMs, config.timeoutMs), null),
+    llmMaxRetries: parsePositiveInteger(firstConfiguredValue(entry.llmMaxRetries, entry.maxRetries, config.llmMaxRetries, config.maxRetries), null),
+    llmMaxTokens: parsePositiveInteger(firstConfiguredValue(entry.llmMaxTokens, entry.maxTokens, config.llmMaxTokens, config.maxTokens), null),
+    llmMaxCompletionTokens: parsePositiveInteger(
+      firstConfiguredValue(entry.llmMaxCompletionTokens, entry.maxCompletionTokens, config.llmMaxCompletionTokens, config.maxCompletionTokens),
+      null
+    ),
+    llmImageLimit: parsePositiveInteger(firstConfiguredValue(entry.llmImageLimit, entry.imageLimit, config.llmImageLimit, config.imageLimit), null),
+    llmImageDetail: normalizeText(firstConfiguredValue(entry.llmImageDetail, entry.imageDetail, config.llmImageDetail, config.imageDetail)),
+    temperature: parseConfigNumber(firstConfiguredValue(entry.temperature, config.temperature), null),
+    topP: parseConfigNumber(firstConfiguredValue(entry.topP, entry.top_p, config.topP, config.top_p), null),
+    llmProviderIndex: index
+  };
+}
+
+function normalizeScreeningLlmModels(config = {}) {
+  return resolveRawLlmModelEntries(config).map((entry, index) => normalizeScreeningLlmModel(config, entry, index));
+}
+
 function resolveConfigPathValue(raw, configDir) {
   const normalized = normalizeText(raw);
   if (!normalized) return "";
@@ -259,13 +308,14 @@ function validateScreeningConfig(config) {
       message: "screening-config.json 缺失或格式无效。请填写 baseUrl、apiKey、model。"
     };
   }
-  const baseUrl = normalizeText(config.baseUrl).replace(/\/+$/, "");
-  const apiKey = normalizeText(config.apiKey);
-  const model = normalizeText(config.model);
+  const llmModels = normalizeScreeningLlmModels(config);
   const missing = [];
-  if (!baseUrl) missing.push("baseUrl");
-  if (!apiKey) missing.push("apiKey");
-  if (!model) missing.push("model");
+  for (const [index, llmModel] of llmModels.entries()) {
+    const prefix = llmModels.length > 1 ? `llmModels[${index}]` : "";
+    if (!llmModel.baseUrl) missing.push(prefix ? `${prefix}.baseUrl` : "baseUrl");
+    if (!llmModel.apiKey) missing.push(prefix ? `${prefix}.apiKey` : "apiKey");
+    if (!llmModel.model) missing.push(prefix ? `${prefix}.model` : "model");
+  }
   if (missing.length > 0) {
     return {
       ok: false,
@@ -273,17 +323,20 @@ function validateScreeningConfig(config) {
       message: `screening-config.json 缺少必填字段：${missing.join(", ")}。`
     };
   }
-  if (/^replace-with/i.test(apiKey) || apiKey === SCREEN_CONFIG_TEMPLATE_DEFAULTS.apiKey) {
+  const placeholderModel = llmModels.find((item) => /^replace-with/i.test(item.apiKey) || item.apiKey === SCREEN_CONFIG_TEMPLATE_DEFAULTS.apiKey);
+  if (placeholderModel) {
     return {
       ok: false,
       reason: "PLACEHOLDER_API_KEY",
       message: "screening-config.json 的 apiKey 仍是模板占位符，请填写真实 API Key。"
     };
   }
+  const firstModel = llmModels[0] || {};
   if (
-    baseUrl === SCREEN_CONFIG_TEMPLATE_DEFAULTS.baseUrl
-    && apiKey === SCREEN_CONFIG_TEMPLATE_DEFAULTS.apiKey
-    && model === SCREEN_CONFIG_TEMPLATE_DEFAULTS.model
+    llmModels.length === 1
+    && firstModel.baseUrl === SCREEN_CONFIG_TEMPLATE_DEFAULTS.baseUrl
+    && firstModel.apiKey === SCREEN_CONFIG_TEMPLATE_DEFAULTS.apiKey
+    && firstModel.model === SCREEN_CONFIG_TEMPLATE_DEFAULTS.model
   ) {
     return {
       ok: false,
@@ -393,24 +446,28 @@ export function resolveBossScreeningConfig(workspaceRoot) {
       candidate_paths: candidatePaths
     };
   }
+  const llmModels = normalizeScreeningLlmModels(parsed);
+  const primaryLlmModel = llmModels[0] || {};
+  const greetingText = normalizeText(
+    parsed.greetingMessage
+    || parsed.greeting_message
+    || parsed.greetingText
+    || parsed.greeting_text
+    || parsed.greeting
+  );
   return {
     ok: true,
     config: {
-      baseUrl: normalizeText(parsed.baseUrl).replace(/\/+$/, ""),
-      apiKey: normalizeText(parsed.apiKey),
-      model: normalizeText(parsed.model),
-      openaiOrganization: normalizeText(parsed.openaiOrganization || parsed.organization),
-      openaiProject: normalizeText(parsed.openaiProject || parsed.project),
+      ...primaryLlmModel,
+      baseUrl: primaryLlmModel.baseUrl,
+      apiKey: primaryLlmModel.apiKey,
+      model: primaryLlmModel.model,
+      openaiOrganization: primaryLlmModel.openaiOrganization,
+      openaiProject: primaryLlmModel.openaiProject,
+      llmModels,
+      greetingMessage: greetingText,
+      greetingText,
       debugPort: parsePositiveInteger(parsed.debugPort, 9222),
-      llmThinkingLevel: normalizeLlmThinkingLevel(parsed.llmThinkingLevel || parsed.thinkingLevel || parsed.reasoningEffort, "low"),
-      llmTimeoutMs: parsePositiveInteger(parsed.llmTimeoutMs || parsed.timeoutMs, null),
-      llmMaxRetries: parsePositiveInteger(parsed.llmMaxRetries || parsed.maxRetries, null),
-      llmMaxTokens: parsePositiveInteger(parsed.llmMaxTokens || parsed.maxTokens, null),
-      llmMaxCompletionTokens: parsePositiveInteger(parsed.llmMaxCompletionTokens || parsed.maxCompletionTokens, null),
-      llmImageLimit: parsePositiveInteger(parsed.llmImageLimit || parsed.imageLimit, null),
-      llmImageDetail: normalizeText(parsed.llmImageDetail || parsed.imageDetail),
-      temperature: parseConfigNumber(parsed.temperature, null),
-      topP: parseConfigNumber(parsed.topP || parsed.top_p, null),
       outputDir: resolveConfigPathValue(parsed.outputDir, configDir),
       humanRestEnabled: parseConfigBoolean(parsed.humanRestEnabled, false)
     },

package/src/cli.js

@@ -57,6 +57,7 @@ const autoSyncSkipCommands = new Set(["install", "install-skill", "where", "help
 const externalMcpTargetsEnv = "BOSS_RECOMMEND_MCP_CONFIG_TARGETS";
 const externalSkillDirsEnv = "BOSS_RECOMMEND_EXTERNAL_SKILL_DIRS";
 const installConfigDefaults = Object.freeze({
+  greetingMessage: "Hi同学，能麻烦发下简历吗？",
   llmThinkingLevel: "low",
   llmMaxTokens: 512,
   llmMaxRetries: 3,
@@ -1431,6 +1432,8 @@ async function setScreeningConfig(options = {}) {
     apiKey,
     model
   };
+  delete nextConfig.llmModels;
+  delete nextConfig.models;
   if (typeof options["thinking-level"] === "string" && options["thinking-level"].trim()) {
     nextConfig.llmThinkingLevel = options["thinking-level"].trim();
   } else if (typeof options.llmThinkingLevel === "string" && options.llmThinkingLevel.trim()) {
@@ -1445,6 +1448,16 @@ async function setScreeningConfig(options = {}) {
   if (typeof options["output-dir"] === "string" && options["output-dir"].trim()) {
     nextConfig.outputDir = options["output-dir"].trim();
   }
+  const greetingMessage = String(
+    options["greeting-message"]
+    ?? options.greetingMessage
+    ?? options.greeting_text
+    ?? options.greetingText
+    ?? ""
+  ).trim();
+  if (greetingMessage) {
+    nextConfig.greetingMessage = greetingMessage;
+  }
   const debugPort = parsePositivePort(options.port || options["debug-port"]);
   if (debugPort) {
     nextConfig.debugPort = debugPort;
@@ -2538,7 +2551,7 @@ function printHelp() {
   console.log("  boss-recommend-mcp run --detached --instruction \"...\" --overrides-file overrides.json --confirmation-file confirmation.json");
   console.log("  boss-recommend-mcp list-jobs --slow-live --port 9222");
   console.log("  boss-recommend-mcp chat prepare-run --slow-live --port 9222    # CDP-only preflight; start runs through MCP start_boss_chat_run");
-  console.log("  boss-recommend-mcp config set --base-url <url> --api-key <key> --model <model> [--thinking-level off|low|medium|high|current] [--openai-organization <id>] [--openai-project <id>]");
+  console.log("  boss-recommend-mcp config set --base-url <url> --api-key <key> --model <model> [--thinking-level off|low|medium|high|current] [--greeting-message <text>] [--openai-organization <id>] [--openai-project <id>]");
   console.log("  boss-recommend-mcp install --agent trae-cn");
   console.log("  boss-recommend-mcp install --agent qclaw    # updates ~/.qclaw/openclaw.json mcp.servers and mirrors skills");
   console.log("  boss-recommend-mcp doctor --agent trae-cn --page-scope featured");

package/src/core/cv-acquisition/index.js

@@ -5,6 +5,7 @@ export const CV_ACQUISITION_MODE_IMAGE = "image";
 export const NETWORK_RESUME_WAIT_MS = 4200;
 export const NETWORK_RESUME_RETRY_WAIT_MS = 2000;
 export const NETWORK_RESUME_IMAGE_MODE_GRACE_MS = 1000;
+export const DEFAULT_MAX_IMAGE_PAGES = 24;
 
 const VALID_MODES = new Set([
   CV_ACQUISITION_MODE_UNKNOWN,

package/src/core/cv-capture-target/index.js

@@ -0,0 +1,299 @@
+import {
+  getFrameDocumentNodeId,
+  getNodeBox,
+  querySelector,
+  querySelectorAll,
+  sleep
+} from "../browser/index.js";
+
+export const CV_CAPTURE_TARGET_SELECTORS = Object.freeze([
+  ".resume-center-side .resume-detail-wrap",
+  ".resume-container .resume-detail-wrap",
+  ".resume-container .resume-content-wrap",
+  ".resume-item-detail",
+  ".resume-detail-wrap",
+  ".resume-content-wrap",
+  ".resume-common-wrap",
+  ".new-resume-online-main-ui",
+  ".resume-detail",
+  ".resume-recommend",
+  "canvas#resume",
+  ".resume-container"
+]);
+
+const IFRAME_BODY_SELECTORS = Object.freeze(["body", "html"]);
+
+function slotNodeId(slot = null) {
+  return Number(slot?.node_id || slot?.nodeId || 0) || 0;
+}
+
+function rootNodeId(root = null) {
+  return Number(root?.nodeId || root?.node_id || root?.root_node_id || 0) || 0;
+}
+
+function normalizeRootName(root = null, fallback = "") {
+  return String(root?.name || root?.root || fallback || "").trim() || null;
+}
+
+function uniqueRoots(roots = []) {
+  const seen = new Set();
+  const result = [];
+  for (const root of roots) {
+    const nodeId = rootNodeId(root);
+    if (!nodeId || seen.has(nodeId)) continue;
+    seen.add(nodeId);
+    result.push({
+      ...root,
+      name: normalizeRootName(root),
+      nodeId
+    });
+  }
+  return result;
+}
+
+function slotAsRoot(slot = null, fallbackName = "") {
+  const nodeId = slotNodeId(slot);
+  if (!nodeId) return null;
+  return {
+    name: normalizeRootName(slot, fallbackName),
+    nodeId,
+    selector: slot?.selector || null,
+    root_node_id: slot?.root_node_id || null
+  };
+}
+
+function isVisibleBox(box = null) {
+  return box?.rect?.width > 2 && box?.rect?.height > 2;
+}
+
+async function readVisibleBox(client, nodeId) {
+  if (!nodeId) return null;
+  try {
+    const box = await getNodeBox(client, nodeId);
+    return isVisibleBox(box) ? box : null;
+  } catch {
+    return null;
+  }
+}
+
+function isCvScopedSelector(selector = "") {
+  const normalized = String(selector || "").trim();
+  if (!normalized) return false;
+  if (/boss-popup|boss-dialog|dialog-wrap|geek-detail-modal|\bmodal\b|new-chat-resume-dialog-main-ui/i.test(normalized)) {
+    return false;
+  }
+  return /resume-item-detail|resume-detail-wrap|resume-content-wrap|resume-common-wrap|new-resume-online-main-ui|resume-detail(?:\b|[.#:])|resume-recommend|canvas#resume|resume-container/i.test(normalized);
+}
+
+function buildTarget({
+  domain = "",
+  nodeId,
+  source,
+  selector = null,
+  root = null,
+  rootNodeId = null,
+  box = null,
+  iframeNodeId = null,
+  iframeDocumentNodeId = null,
+  fallback = false
+} = {}) {
+  return {
+    schema_version: 1,
+    domain: domain || null,
+    node_id: nodeId,
+    source,
+    selector,
+    root,
+    root_node_id: rootNodeId || null,
+    iframe_node_id: iframeNodeId || null,
+    iframe_document_node_id: iframeDocumentNodeId || null,
+    cv_only: !fallback,
+    fallback: Boolean(fallback),
+    rect: box?.rect || null,
+    center: box?.center || null
+  };
+}
+
+async function firstVisibleSelectorTarget(client, roots = [], selectors = CV_CAPTURE_TARGET_SELECTORS, {
+  domain = "",
+  source = "cv_selector",
+  iframeNodeId = null,
+  iframeDocumentNodeId = null
+} = {}) {
+  for (const root of uniqueRoots(roots)) {
+    for (const selector of selectors) {
+      let nodeIds = [];
+      try {
+        nodeIds = await querySelectorAll(client, root.nodeId, selector);
+      } catch {
+        nodeIds = [];
+      }
+      for (const nodeId of nodeIds) {
+        const box = await readVisibleBox(client, nodeId);
+        if (!box) continue;
+        return buildTarget({
+          domain,
+          nodeId,
+          source,
+          selector,
+          root: root.name,
+          rootNodeId: root.nodeId,
+          box,
+          iframeNodeId,
+          iframeDocumentNodeId
+        });
+      }
+    }
+  }
+  return null;
+}
+
+async function visibleSlotTarget(client, slot = null, {
+  domain = "",
+  source = "cv_slot",
+  fallback = false
+} = {}) {
+  const nodeId = slotNodeId(slot);
+  if (!nodeId) return null;
+  if (!fallback && !isCvScopedSelector(slot?.selector)) return null;
+  const box = await readVisibleBox(client, nodeId);
+  if (!box) return null;
+  return buildTarget({
+    domain,
+    nodeId,
+    source,
+    selector: slot?.selector || null,
+    root: slot?.root || null,
+    rootNodeId: slot?.root_node_id || null,
+    box,
+    fallback
+  });
+}
+
+async function resolveIframeCaptureTarget(client, resumeIframe = null, {
+  domain = "",
+  selectors = CV_CAPTURE_TARGET_SELECTORS
+} = {}) {
+  const iframeNodeId = slotNodeId(resumeIframe);
+  if (!iframeNodeId) return null;
+
+  try {
+    const documentNodeId = await getFrameDocumentNodeId(client, iframeNodeId);
+    const selectorTarget = await firstVisibleSelectorTarget(client, [{
+      name: "resume-iframe-document",
+      nodeId: documentNodeId
+    }], selectors, {
+      domain,
+      source: "resume_iframe_cv_selector",
+      iframeNodeId,
+      iframeDocumentNodeId: documentNodeId
+    });
+    if (selectorTarget) return selectorTarget;
+
+    for (const selector of IFRAME_BODY_SELECTORS) {
+      const nodeId = await querySelector(client, documentNodeId, selector).catch(() => 0);
+      const box = await readVisibleBox(client, nodeId);
+      if (!box) continue;
+      return buildTarget({
+        domain,
+        nodeId,
+        source: "resume_iframe_body",
+        selector,
+        root: "resume-iframe-document",
+        rootNodeId: documentNodeId,
+        box,
+        iframeNodeId,
+        iframeDocumentNodeId: documentNodeId
+      });
+    }
+  } catch {}
+
+  const iframeBox = await readVisibleBox(client, iframeNodeId);
+  if (!iframeBox) return null;
+  return buildTarget({
+    domain,
+    nodeId: iframeNodeId,
+    source: "resume_iframe_element",
+    selector: resumeIframe?.selector || null,
+    root: resumeIframe?.root || null,
+    rootNodeId: resumeIframe?.root_node_id || null,
+    box: iframeBox,
+    iframeNodeId,
+    fallback: false
+  });
+}
+
+async function resolveSlotCaptureTarget(client, slot = null, {
+  domain = "",
+  slotName = "content",
+  selectors = CV_CAPTURE_TARGET_SELECTORS
+} = {}) {
+  const root = slotAsRoot(slot, slotName);
+  const selectorTarget = root
+    ? await firstVisibleSelectorTarget(client, [root], selectors, {
+      domain,
+      source: `${slotName}_cv_selector`
+    })
+    : null;
+  if (selectorTarget) return selectorTarget;
+  return visibleSlotTarget(client, slot, {
+    domain,
+    source: `${slotName}_cv_slot`
+  });
+}
+
+export async function resolveCvCaptureTarget(client, detailState = null, {
+  domain = "",
+  selectors = CV_CAPTURE_TARGET_SELECTORS
+} = {}) {
+  const iframeTarget = await resolveIframeCaptureTarget(client, detailState?.resumeIframe, {
+    domain,
+    selectors
+  });
+  if (iframeTarget) return iframeTarget;
+
+  const contentTarget = await resolveSlotCaptureTarget(client, detailState?.content, {
+    domain,
+    slotName: "content",
+    selectors
+  });
+  if (contentTarget) return contentTarget;
+
+  const popupTarget = await resolveSlotCaptureTarget(client, detailState?.popup, {
+    domain,
+    slotName: "popup",
+    selectors
+  });
+  if (popupTarget) return popupTarget;
+
+  return firstVisibleSelectorTarget(client, detailState?.roots || [], selectors, {
+    domain,
+    source: "root_cv_selector"
+  });
+}
+
+export async function waitForCvCaptureTarget(client, detailState = null, {
+  timeoutMs = 6000,
+  intervalMs = 250,
+  ...options
+} = {}) {
+  const started = Date.now();
+  let target = null;
+  while (Date.now() - started <= Math.max(0, Number(timeoutMs) || 0)) {
+    target = await resolveCvCaptureTarget(client, detailState, options);
+    if (target?.node_id) {
+      return {
+        ok: true,
+        elapsed_ms: Date.now() - started,
+        target
+      };
+    }
+    await sleep(Math.max(50, Number(intervalMs) || 250));
+  }
+  target = await resolveCvCaptureTarget(client, detailState, options);
+  return {
+    ok: Boolean(target?.node_id),
+    elapsed_ms: Date.now() - started,
+    target: target || null
+  };
+}