@reconcrap/boss-recommend-mcp 1.0.13 → 1.0.15

package/README.md

@@ -9,7 +9,6 @@ Boss 推荐页自动化流水线 MCP（stdio）服务。
 
 MCP 工具：
 
-- `run_recommend_pipeline`（默认异步，但会先执行与同步一致的前置门禁；仅门禁通过后返回 run_id）
 - `start_recommend_pipeline_run`（异步启动；同样先经过前置门禁，通过后返回 run_id）
 - `get_recommend_pipeline_run`（轮询 run_id 状态）
 - `cancel_recommend_pipeline_run`（取消运行中任务）
@@ -143,14 +142,14 @@ node src/cli.js run --instruction-file request.txt --confirmation-file confirmat
 
 当宿主 agent 对“长时间无回包”敏感（容易误判失败）时，建议改用异步工具：
 
-1. 优先调用 `run_recommend_pipeline`（默认异步）。
+1. 调用 `start_recommend_pipeline_run`。
 2. 若返回 `NEED_INPUT/NEED_CONFIRMATION/FAILED`，按同步流程先补齐前置条件（登录、页面就绪、岗位确认、最终确认）。
 3. 仅当门禁通过时，接口才会返回 `ACCEPTED + run_id`；随后每 5~15 秒调用一次 `get_recommend_pipeline_run` 轮询。
 4. 若需终止，调用 `cancel_recommend_pipeline_run`。
 
 说明：
 
-- `run_recommend_pipeline` 默认异步，但不会跳过同步确认流程；若确实需要阻塞式返回，可传 `execution_mode=sync`。
+- `start_recommend_pipeline_run` 为异步入口，但不会跳过同步确认流程。
 - 定时心跳默认 120 秒一次；`updated_at` 仍会在阶段或进度变化时刷新。
 - 每个 run 会持久化到 `~/.boss-recommend-mcp/runs/<run_id>.json`（可通过 `BOSS_RECOMMEND_HOME` 覆盖）。
 - 轮询期间不要重复 `start`，优先复用已有 `run_id`，避免重复筛选。

package/package.json

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

package/skills/boss-recommend-pipeline/SKILL.md

@@ -7,7 +7,7 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
 
 ## Purpose
 
-当用户希望在 Boss 推荐页按条件筛选候选人时，优先调用 MCP 工具 `run_recommend_pipeline` 完成端到端任务：
+当用户希望在 Boss 推荐页按条件筛选候选人时，优先调用 MCP 工具 `start_recommend_pipeline_run` 完成端到端任务：
 
 1. 解析推荐页筛选指令
 2. 第一阶段仅确认非岗位参数（filters / criteria / target_count / post_action / max_greet_count）
@@ -75,14 +75,22 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
 `post_action` 的确认是**单次运行级别**的：
 
 - 若用户确认 `favorite`，则本次运行中所有通过人选都统一收藏
-- 若用户确认 `greet`，则本次运行中先按 `max_greet_count` 执行打招呼，超出上限后自动改为收藏
-- 不要在每位候选人通过后再次逐个确认
-
+- 若用户确认 `greet`，则本次运行中先按 `max_greet_count` 执行打招呼，超出上限后自动改为收藏
+- 不要在每位候选人通过后再次逐个确认
+
+## Instruction 原文锁定与执行前回显校验（必须遵守）
+
+- 第一次收到用户自然语言需求时，必须把该条 `instruction` 原文锁定为 `locked_instruction_raw`。
+- 后续所有调用（包括二轮确认、最终执行、重试）都必须复用同一条 `locked_instruction_raw`，禁止改写、扩写、摘要、同义替换、翻译。
+- 未经用户明确要求，禁止 agent 自行生成新的 `instruction` 文案。
+- 最终执行前（即准备提交 `job_confirmed=true` 与 `final_confirmed=true` 的那次调用），必须先向用户逐字回显本次将提交的 `instruction`，并明确提示“将按以下原文执行”。
+- 回显校验规则：若当前待提交 `instruction` 与 `locked_instruction_raw` 不一致（按原样字符串比对），必须停止调用工具，先修正为原文后再执行。
+- 仅当用户明确要求修改 `instruction` 时，才允许更新 `locked_instruction_raw`；更新后仍需再次逐字回显并确认。
+
 ## Tool Contract
 
-- Tool name（默认异步）: `run_recommend_pipeline`
+- Tool name: `start_recommend_pipeline_run`
 - Input:
-  - `execution_mode`（可选：`async|sync`，默认 `async`）
   - `instruction` (required)
   - `confirmation`
     - `filters_confirmed`
@@ -117,7 +125,8 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
 
 长耗时宿主兼容（推荐）：
 
-- `run_recommend_pipeline` 默认异步，但开始前会先走与同步一致的前置门禁（登录/页面就绪/岗位确认/最终确认）。
+- 默认调用 `start_recommend_pipeline_run` 启动异步流程，并配合 `get_recommend_pipeline_run` 轮询。
+- `start_recommend_pipeline_run` 会先走同步一致的前置门禁（登录/页面就绪/岗位确认/最终确认）。
 - 只有门禁通过后才会返回 `ACCEPTED + run_id`；否则会先返回 `NEED_INPUT/NEED_CONFIRMATION/FAILED`，必须先按提示补齐。
 - 若宿主要显式拆成三步，也可使用：
   - `start_recommend_pipeline_run`
@@ -194,7 +203,7 @@ CLI fallback 的状态机与 MCP 保持一致：
 2) 若任意 npm_dep_* 失败：再安装 npm 依赖（chrome-remote-interface / ws）。
 3) 若 python_cli 失败：安装 Python，并确保 python 命令可用。
 4) 若 python_pillow 失败：最后执行 python -m pip install pillow。
-每一步完成后重新运行 doctor，全部通过后再重试 run_recommend_pipeline。
+每一步完成后重新运行 doctor，全部通过后再重试 start_recommend_pipeline_run。
 ```
 
 安装顺序约束（必须遵守）：

package/src/cli.js

@@ -880,7 +880,7 @@ function inspectAgentIntegration(agentRaw) {
 
   const hasRecommendIntent = (content) => /(recommend|推荐页|boss recommend|recommend page)/i.test(content);
   const hasSearchIntent = (content) => /(search|搜索页|boss search|search page)/i.test(content);
-  const hasRecommendPipelineRoute = (content) => /(boss-recommend-pipeline|run_recommend_pipeline)/i.test(content);
+  const hasRecommendPipelineRoute = (content) => /(boss-recommend-pipeline|start_recommend_pipeline_run)/i.test(content);
   const hasRecruitPipelineRoute = (content) => /(boss-recruit-pipeline|run_recruit_pipeline)/i.test(content);
 
   const skill_checks = skill_bases.map((baseDir) => {

package/src/index.js

@@ -5,7 +5,6 @@ import { fileURLToPath } from "node:url";
 import { runRecommendPipeline } from "./pipeline.js";
 import {
   RUN_MODE_ASYNC,
-  RUN_MODE_SYNC,
   RUN_STAGE_PREFLIGHT,
   RUN_STATE_CANCELED,
   RUN_STATE_COMPLETED,
@@ -25,7 +24,6 @@ import {
 const require = createRequire(import.meta.url);
 const { version: SERVER_VERSION } = require("../package.json");
 
-const TOOL_RUN_PIPELINE = "run_recommend_pipeline";
 const TOOL_START_RUN = "start_recommend_pipeline_run";
 const TOOL_GET_RUN = "get_recommend_pipeline_run";
 const TOOL_CANCEL_RUN = "cancel_recommend_pipeline_run";
@@ -78,11 +76,6 @@ function createRunInputSchema() {
         type: "string",
         description: "用户自然语言推荐筛选指令"
       },
-      execution_mode: {
-        type: "string",
-        enum: [RUN_MODE_ASYNC, RUN_MODE_SYNC],
-        description: "执行模式；默认 async。"
-      },
       confirmation: {
         type: "object",
         properties: {
@@ -219,11 +212,6 @@ function createRunInputSchema() {
 
 function createToolsSchema() {
   return [
-    {
-      name: TOOL_RUN_PIPELINE,
-      description: "Boss 推荐页流水线：默认异步，但会先走与同步一致的前置确认/页面就绪门禁；仅在门禁通过后返回 run_id。传 execution_mode=sync 可改为全程同步执行。",
-      inputSchema: createRunInputSchema()
-    },
     {
       name: TOOL_START_RUN,
       description: "异步启动 Boss 推荐页流水线（含同步门禁预检）；只有在前置确认与页面就绪通过后才返回 run_id。",
@@ -291,12 +279,6 @@ function getLastOutputLine(text) {
   return lines.length > 0 ? lines[lines.length - 1] : null;
 }
 
-function normalizeExecutionMode(value) {
-  const normalized = normalizeText(value).toLowerCase();
-  if (normalized === RUN_MODE_SYNC) return RUN_MODE_SYNC;
-  return RUN_MODE_ASYNC;
-}
-
 function normalizeRequiredConfirmations(value) {
   if (!Array.isArray(value)) return [];
   return value
@@ -413,31 +395,6 @@ function createRuntimeCallbacks(runId, heartbeatIntervalMs) {
   };
 }
 
-function attachSyncRunMetadata(result, runId, lastStage) {
-  if (!result || typeof result !== "object") return result;
-  if (result.status === "COMPLETED") {
-    const nextResult = result.result && typeof result.result === "object" ? result.result : {};
-    return {
-      ...result,
-      result: {
-        ...nextResult,
-        run_id: runId
-      }
-    };
-  }
-  if (result.status === "FAILED") {
-    const diagnostics = result.diagnostics && typeof result.diagnostics === "object" ? result.diagnostics : {};
-    return {
-      ...result,
-      diagnostics: {
-        ...diagnostics,
-        run_id: runId,
-        last_stage: lastStage || RUN_STAGE_PREFLIGHT
-      }
-    };
-  }
-  return result;
-}
 
 async function executeTrackedPipeline({
   runId,
@@ -552,31 +509,6 @@ function initializeRunStateOrThrow(runId, mode) {
   return writeRunState(snapshot);
 }
 
-async function handleSyncRunTool({ workspaceRoot, args }) {
-  cleanupExpiredRuns();
-  const runId = createRunId();
-  try {
-    initializeRunStateOrThrow(runId, RUN_MODE_SYNC);
-  } catch (error) {
-    return {
-      status: "FAILED",
-      error: {
-        code: "RUN_STATE_IO_ERROR",
-        message: `无法写入运行状态目录：${error.message || "unknown"}`,
-        retryable: false
-      }
-    };
-  }
-  const tracked = await executeTrackedPipeline({
-    runId,
-    mode: RUN_MODE_SYNC,
-    workspaceRoot,
-    args,
-    signal: null
-  });
-  return attachSyncRunMetadata(tracked.result, runId, tracked.lastStage);
-}
-
 async function handleStartRunTool({ workspaceRoot, args }) {
   const precheckArgs = buildAsyncPrecheckArgs(args);
   let precheckResult;
@@ -768,7 +700,7 @@ async function handleRequest(message, workspaceRoot) {
     const toolName = params?.name;
     const args = params?.arguments || {};
 
-    if ([TOOL_RUN_PIPELINE, TOOL_START_RUN].includes(toolName)) {
+    if (toolName === TOOL_START_RUN) {
       const inputError = validateRunArgs(args);
       if (inputError) {
         return createJsonRpcError(id, -32602, inputError);
@@ -783,12 +715,7 @@ async function handleRequest(message, workspaceRoot) {
 
     try {
       let payload;
-      if (toolName === TOOL_RUN_PIPELINE) {
-        const executionMode = normalizeExecutionMode(args.execution_mode);
-        payload = executionMode === RUN_MODE_SYNC
-          ? await handleSyncRunTool({ workspaceRoot, args })
-          : await handleStartRunTool({ workspaceRoot, args });
-      } else if (toolName === TOOL_START_RUN) {
+      if (toolName === TOOL_START_RUN) {
         payload = await handleStartRunTool({ workspaceRoot, args });
       } else if (toolName === TOOL_GET_RUN) {
         payload = handleGetRunTool(args);

package/src/test-index-async.js

@@ -47,7 +47,7 @@ async function waitForTerminalRunState(runId, timeoutMs = 4000) {
   throw new Error(`Timed out waiting terminal run state for run_id=${runId}`);
 }
 
-async function testAsyncStartStatusCancelAndSyncCompatibility() {
+async function testAsyncStartStatusAndCancel() {
   const previousHome = process.env.BOSS_RECOMMEND_HOME;
   const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-index-async-"));
 
@@ -130,6 +130,21 @@ async function testAsyncStartStatusCancelAndSyncCompatibility() {
     assert.deepEqual(gatedStartPayload.required_confirmations, ["job"]);
     assert.equal(gatedStartPayload.run_id, undefined);
 
+    const finalReviewGateResponse = await handleRequest(
+      makeToolCall(11, "start_recommend_pipeline_run", {
+        instruction: "need final review gate",
+        confirmation: {
+          job_confirmed: true,
+          job_value: "mock job",
+          final_confirmed: false
+        }
+      }),
+      process.cwd()
+    );
+    const finalReviewGatePayload = await readToolPayload(finalReviewGateResponse);
+    assert.equal(finalReviewGatePayload.status, "NEED_CONFIRMATION");
+    assert.deepEqual(finalReviewGatePayload.required_confirmations, ["final_review"]);
+
     const startResponse = await handleRequest(
       makeToolCall(2, "start_recommend_pipeline_run", {
         instruction: "slow task for cancel",
@@ -164,64 +179,14 @@ async function testAsyncStartStatusCancelAndSyncCompatibility() {
     const canceledRun = await waitForTerminalRunState(started.run_id);
     assert.equal(canceledRun.state, "canceled");
 
-    const defaultAsyncGatedResponse = await handleRequest(
-      makeToolCall(5, "run_recommend_pipeline", { instruction: "fast default async gate" }),
-      process.cwd()
-    );
-    const defaultAsyncGatedPayload = await readToolPayload(defaultAsyncGatedResponse);
-    assert.equal(defaultAsyncGatedPayload.status, "NEED_CONFIRMATION");
-    assert.deepEqual(defaultAsyncGatedPayload.required_confirmations, ["job"]);
-
-    const defaultAsyncResponse = await handleRequest(
-      makeToolCall(6, "run_recommend_pipeline", {
-        instruction: "fast async accepted run",
-        confirmation: {
-          job_confirmed: true,
-          job_value: "mock job",
-          final_confirmed: true
-        }
-      }),
-      process.cwd()
-    );
-    const defaultAsyncPayload = await readToolPayload(defaultAsyncResponse);
-    assert.equal(defaultAsyncPayload.status, "ACCEPTED");
-    assert.equal(typeof defaultAsyncPayload.run_id, "string");
-    const completedDefaultAsyncRun = await waitForTerminalRunState(defaultAsyncPayload.run_id);
-    assert.equal(completedDefaultAsyncRun.state, "completed");
-
-    const syncResponse = await handleRequest(
-      makeToolCall(7, "run_recommend_pipeline", {
-        instruction: "fast forced sync run",
-        execution_mode: "sync",
-        confirmation: {
-          job_confirmed: true,
-          job_value: "mock job",
-          final_confirmed: true
-        }
-      }),
-      process.cwd()
-    );
-    const syncPayload = await readToolPayload(syncResponse);
-    assert.equal(syncPayload.status, "COMPLETED");
-    assert.equal(typeof syncPayload.result.run_id, "string");
-    assert.equal(syncPayload.result.processed_count, 40);
-
-    const failedSyncResponse = await handleRequest(
-      makeToolCall(8, "run_recommend_pipeline", {
-        instruction: "force fail",
-        execution_mode: "sync",
-        confirmation: {
-          job_confirmed: true,
-          job_value: "mock job",
-          final_confirmed: true
-        }
+    const unknownToolResponse = await handleRequest(
+      makeToolCall(12, "run_recommend_pipeline", {
+        instruction: "legacy tool should be removed"
       }),
       process.cwd()
     );
-    const syncFailedPayload = await readToolPayload(failedSyncResponse);
-    assert.equal(syncFailedPayload.status, "FAILED");
-    assert.equal(typeof syncFailedPayload.diagnostics?.run_id, "string");
-    assert.equal(typeof syncFailedPayload.diagnostics?.last_stage, "string");
+    assert.equal(unknownToolResponse?.error?.code, -32602);
+    assert.match(String(unknownToolResponse?.error?.message || ""), /Unknown tool/i);
 
     assert.equal(activeAsyncRuns.size >= 0, true);
   } finally {
@@ -236,7 +201,7 @@ async function testAsyncStartStatusCancelAndSyncCompatibility() {
 }
 
 async function main() {
-  await testAsyncStartStatusCancelAndSyncCompatibility();
+  await testAsyncStartStatusAndCancel();
   console.log("index async tests passed");
 }
 

package/vendor/boss-recommend-screen-cli/boss-recommend-screen-cli.cjs

@@ -1008,23 +1008,7 @@ const jsClickCloseFallback = `(() => {
 })()`;
 
 const jsReloadRecommendFrame = `(() => {
-  const frame = document.querySelector('iframe[name="recommendFrame"]')
-    || document.querySelector('iframe[src*="/web/frame/recommend/"]')
-    || document.querySelector('iframe');
-  if (!frame || !frame.contentWindow) {
-    return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
-  }
-  try {
-    const current = String(frame.contentWindow.location.href || '');
-    if (current.includes('/web/frame/recommend/')) {
-      frame.contentWindow.location.reload();
-    } else {
-      frame.contentWindow.location.href = 'https://www.zhipin.com/web/frame/recommend/';
-    }
-    return { ok: true };
-  } catch (error) {
-    return { ok: false, error: String(error && error.message ? error.message : error) };
-  }
+  return { ok: false, error: 'RELOAD_DISABLED_BY_POLICY' };
 })()`;
 
 class RecommendScreenCli {
@@ -1201,7 +1185,20 @@ class RecommendScreenCli {
     );
   }
 
-  async maximizeWindowIfPossible(reason = "unknown") {
+  async getCurrentWindowState() {
+    if (!this.Browser || !this.windowId || typeof this.Browser.getWindowBounds !== "function") {
+      return null;
+    }
+    try {
+      const info = await this.Browser.getWindowBounds({ windowId: this.windowId });
+      const state = String(info?.bounds?.windowState || "").toLowerCase();
+      return state || null;
+    } catch {
+      return null;
+    }
+  }
+
+  async setWindowStateIfPossible(windowState, reason = "unknown") {
     if (!this.Browser || !this.windowId || typeof this.Browser.setWindowBounds !== "function") {
       return false;
     }
@@ -1209,17 +1206,38 @@ class RecommendScreenCli {
       await this.Browser.setWindowBounds({
         windowId: this.windowId,
         bounds: {
-          windowState: "maximized"
+          windowState
         }
       });
-      log(`[视口恢复] 已尝试最大化 Chrome 窗口，原因: ${reason}`);
+      log(`[视口恢复] 已设置窗口状态为 ${windowState}，原因: ${reason}`);
       return true;
     } catch (error) {
-      log(`[视口恢复] 最大化窗口失败: ${error.message || error}`);
+      log(`[视口恢复] 设置窗口状态 ${windowState} 失败: ${error.message || error}`);
       return false;
     }
   }
 
+  async toggleWindowStateForViewportRecovery(reason = "unknown") {
+    const currentState = await this.getCurrentWindowState();
+    const sequence = currentState === "normal"
+      ? ["maximized", "normal"]
+      : ["normal", "maximized"];
+    let applied = false;
+    for (const state of sequence) {
+      const ok = await this.setWindowStateIfPossible(state, reason);
+      if (ok) {
+        applied = true;
+        await sleep(humanDelay(520, 80));
+      }
+    }
+    if (applied && this.Page && typeof this.Page.bringToFront === "function") {
+      try {
+        await this.Page.bringToFront();
+      } catch {}
+    }
+    return applied;
+  }
+
   async ensureHealthyListViewport(reason = "unknown") {
     let state = await this.getListState();
     if (!this.isListViewportCollapsed(state)) {
@@ -1227,24 +1245,13 @@ class RecommendScreenCli {
     }
 
     log(`[视口恢复] 检测到推荐列表视口异常缩小，尝试自动恢复。原因: ${reason}`);
-    await this.maximizeWindowIfPossible(reason);
-    await sleep(humanDelay(800, 120));
+    await this.toggleWindowStateForViewportRecovery(reason);
+    await sleep(humanDelay(900, 130));
     state = await this.getListState();
     if (!this.isListViewportCollapsed(state)) {
       return { ok: true, recovered: true, state };
     }
 
-    const reloaded = await this.evaluate(jsReloadRecommendFrame);
-    if (reloaded?.ok) {
-      log("[视口恢复] 已触发 recommendFrame reload。");
-      await this.waitForListReady(45);
-      await sleep(humanDelay(900, 150));
-      state = await this.getListState();
-      if (!this.isListViewportCollapsed(state)) {
-        return { ok: true, recovered: true, state };
-      }
-    }
-
     return {
       ok: false,
       recovered: false,
@@ -1597,35 +1604,21 @@ class RecommendScreenCli {
       }
     }
 
-    log(`[关闭详情] 常规关闭失败，进入强制恢复。最后状态: ${state?.reason || "unknown"}`);
+    log(`[关闭详情] 常规关闭失败，进入额外 ESC 重试（禁用刷新/跳转）。最后状态: ${state?.reason || "unknown"}`);
     for (let retry = 0; retry < 2; retry += 1) {
+      await sleep(2000);
       await this.pressEsc();
-      await sleep(900 + retry * 250);
+      await sleep(humanDelay(260, 60));
       state = await this.getDetailClosedState();
       if (state?.closed) {
-        log(`[关闭详情] 强制ESC成功: ${state.reason || "closed"}`);
+        log(`[关闭详情] 额外ESC成功: ${state.reason || "closed"}`);
         return true;
       }
     }
 
-    const reloaded = await this.evaluate(jsReloadRecommendFrame);
-    if (reloaded?.ok) {
-      log("[关闭详情] 已触发 recommendFrame reload，等待列表恢复。");
-      const listReady = await this.waitForListReady(45);
-      if (listReady) {
-        state = await this.getDetailClosedState();
-        if (state?.closed) {
-          log(`[关闭详情] reload 后恢复成功: ${state.reason || "closed"}`);
-          return true;
-        }
-      }
-    } else {
-      log(`[关闭详情] recommendFrame reload 失败: ${reloaded?.error || "unknown"}`);
-    }
-
     state = await this.getDetailClosedState();
-    log(`[关闭详情] 失败，当前状态: ${state?.reason || "unknown"}`);
-    return false;
+    log(`[关闭详情] 连续 ESC 后仍未确认关闭（${state?.reason || "unknown"}），按策略视为检测误差并继续下一位。`);
+    return true;
   }
 
   async waitForListReady(maxRounds = 30) {