@reconcrap/boss-recommend-mcp 1.0.12 → 1.0.14

package/README.md

@@ -9,8 +9,8 @@ Boss 推荐页自动化流水线 MCP（stdio）服务。
 
 MCP 工具：
 
-- `run_recommend_pipeline`（默认异步启动；传 `execution_mode=sync` 时同步执行）
-- `start_recommend_pipeline_run`（异步启动，立即返回 run_id）
+- `run_recommend_pipeline`（默认异步，但会先执行与同步一致的前置门禁；仅门禁通过后返回 run_id）
+- `start_recommend_pipeline_run`（异步启动；同样先经过前置门禁，通过后返回 run_id）
 - `get_recommend_pipeline_run`（轮询 run_id 状态）
 - `cancel_recommend_pipeline_run`（取消运行中任务）
 
@@ -143,13 +143,14 @@ node src/cli.js run --instruction-file request.txt --confirmation-file confirmat
 
 当宿主 agent 对“长时间无回包”敏感（容易误判失败）时，建议改用异步工具：
 
-1. 优先直接调用 `run_recommend_pipeline`，默认会返回异步 `run_id`。
-2. 每 5~15 秒调用一次 `get_recommend_pipeline_run` 轮询。
-3. 若需终止，调用 `cancel_recommend_pipeline_run`。
+1. 优先调用 `run_recommend_pipeline`（默认异步）。
+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`。
+- `run_recommend_pipeline` 默认异步，但不会跳过同步确认流程；若确实需要阻塞式返回，可传 `execution_mode=sync`。
 - 定时心跳默认 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.12",
+  "version": "1.0.14",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",

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

@@ -117,7 +117,8 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
 
 长耗时宿主兼容（推荐）：
 
-- `run_recommend_pipeline` 现在默认直接异步启动。
+- `run_recommend_pipeline` 默认异步，但开始前会先走与同步一致的前置门禁（登录/页面就绪/岗位确认/最终确认）。
+- 只有门禁通过后才会返回 `ACCEPTED + run_id`；否则会先返回 `NEED_INPUT/NEED_CONFIRMATION/FAILED`，必须先按提示补齐。
 - 若宿主要显式拆成三步，也可使用：
   - `start_recommend_pipeline_run`
   - `get_recommend_pipeline_run`

package/src/index.js

@@ -221,12 +221,12 @@ function createToolsSchema() {
   return [
     {
       name: TOOL_RUN_PIPELINE,
-      description: "Boss 推荐页流水线：默认异步启动并返回 run_id；传 execution_mode=sync 时改为同步执行。",
+      description: "Boss 推荐页流水线：默认异步，但会先走与同步一致的前置确认/页面就绪门禁；仅在门禁通过后返回 run_id。传 execution_mode=sync 可改为全程同步执行。",
       inputSchema: createRunInputSchema()
     },
     {
       name: TOOL_START_RUN,
-      description: "异步启动 Boss 推荐页流水线，立即返回 run_id，后续通过 get_recommend_pipeline_run 轮询状态。",
+      description: "异步启动 Boss 推荐页流水线（含同步门禁预检）；只有在前置确认与页面就绪通过后才返回 run_id。",
       inputSchema: createRunInputSchema()
     },
     {
@@ -297,6 +297,43 @@ function normalizeExecutionMode(value) {
   return RUN_MODE_ASYNC;
 }
 
+function normalizeRequiredConfirmations(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item) => normalizeText(item))
+    .filter(Boolean);
+}
+
+function hasExplicitFinalConfirmation(args) {
+  return args?.confirmation?.final_confirmed === true;
+}
+
+function buildAsyncPrecheckConfirmation(confirmation) {
+  if (!confirmation || typeof confirmation !== "object") {
+    return {
+      final_confirmed: false
+    };
+  }
+  return {
+    ...confirmation,
+    final_confirmed: false
+  };
+}
+
+function buildAsyncPrecheckArgs(args) {
+  return {
+    instruction: args.instruction,
+    confirmation: buildAsyncPrecheckConfirmation(args.confirmation),
+    overrides: args.overrides
+  };
+}
+
+function isFinalReviewOnlyConfirmation(result) {
+  if (result?.status !== "NEED_CONFIRMATION") return false;
+  const required = normalizeRequiredConfirmations(result.required_confirmations);
+  return required.length > 0 && required.every((item) => item === "final_review");
+}
+
 function safeUpdateRunState(runId, updater) {
   try {
     return updateRunState(runId, updater);
@@ -540,7 +577,38 @@ async function handleSyncRunTool({ workspaceRoot, args }) {
   return attachSyncRunMetadata(tracked.result, runId, tracked.lastStage);
 }
 
-function handleStartRunTool({ workspaceRoot, args }) {
+async function handleStartRunTool({ workspaceRoot, args }) {
+  const precheckArgs = buildAsyncPrecheckArgs(args);
+  let precheckResult;
+  try {
+    precheckResult = await runPipelineImpl(
+      {
+        workspaceRoot,
+        instruction: precheckArgs.instruction,
+        confirmation: precheckArgs.confirmation,
+        overrides: precheckArgs.overrides
+      },
+      undefined,
+      null
+    );
+  } catch (error) {
+    precheckResult = {
+      status: "FAILED",
+      error: {
+        code: "UNEXPECTED_ERROR",
+        message: error?.message || "Unexpected error",
+        retryable: true
+      }
+    };
+  }
+
+  if (precheckResult?.status !== "NEED_CONFIRMATION") {
+    return precheckResult;
+  }
+  if (!hasExplicitFinalConfirmation(args) || !isFinalReviewOnlyConfirmation(precheckResult)) {
+    return precheckResult;
+  }
+
   cleanupExpiredRuns();
   const runId = createRunId();
   try {
@@ -719,9 +787,9 @@ async function handleRequest(message, workspaceRoot) {
         const executionMode = normalizeExecutionMode(args.execution_mode);
         payload = executionMode === RUN_MODE_SYNC
           ? await handleSyncRunTool({ workspaceRoot, args })
-          : handleStartRunTool({ workspaceRoot, args });
+          : await handleStartRunTool({ workspaceRoot, args });
       } else if (toolName === TOOL_START_RUN) {
-        payload = handleStartRunTool({ workspaceRoot, args });
+        payload = await handleStartRunTool({ workspaceRoot, args });
       } else if (toolName === TOOL_GET_RUN) {
         payload = handleGetRunTool(args);
       } else if (toolName === TOOL_CANCEL_RUN) {

package/src/test-index-async.js

@@ -52,6 +52,31 @@ async function testAsyncStartStatusCancelAndSyncCompatibility() {
   const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-index-async-"));
 
   setRunPipelineImplForTests(async (input, _deps, runtime) => {
+    if (input.confirmation?.job_confirmed !== true) {
+      return {
+        status: "NEED_CONFIRMATION",
+        required_confirmations: ["job"],
+        pending_questions: [
+          {
+            field: "job",
+            question: "请先确认岗位"
+          }
+        ]
+      };
+    }
+    if (input.confirmation?.final_confirmed !== true) {
+      return {
+        status: "NEED_CONFIRMATION",
+        required_confirmations: ["final_review"],
+        pending_questions: [
+          {
+            field: "final_review",
+            question: "请做最终确认"
+          }
+        ]
+      };
+    }
+
     runtime?.onStage?.({ stage: "preflight", message: "preflight started" });
     await sleep(50);
     if (input.instruction.includes("fail")) {
@@ -96,17 +121,33 @@ async function testAsyncStartStatusCancelAndSyncCompatibility() {
   process.env.BOSS_RECOMMEND_HOME = tempHome;
 
   try {
-    const startResponse = await handleRequest(
+    const gatedStartResponse = await handleRequest(
       makeToolCall(1, "start_recommend_pipeline_run", { instruction: "slow task for cancel" }),
       process.cwd()
     );
+    const gatedStartPayload = await readToolPayload(gatedStartResponse);
+    assert.equal(gatedStartPayload.status, "NEED_CONFIRMATION");
+    assert.deepEqual(gatedStartPayload.required_confirmations, ["job"]);
+    assert.equal(gatedStartPayload.run_id, undefined);
+
+    const startResponse = await handleRequest(
+      makeToolCall(2, "start_recommend_pipeline_run", {
+        instruction: "slow task for cancel",
+        confirmation: {
+          job_confirmed: true,
+          job_value: "mock job",
+          final_confirmed: true
+        }
+      }),
+      process.cwd()
+    );
     const started = await readToolPayload(startResponse);
     assert.equal(started.status, "ACCEPTED");
     assert.equal(typeof started.run_id, "string");
     assert.equal(started.poll_after_sec >= 5 && started.poll_after_sec <= 15, true);
 
     const statusResponse = await handleRequest(
-      makeToolCall(2, "get_recommend_pipeline_run", { run_id: started.run_id }),
+      makeToolCall(3, "get_recommend_pipeline_run", { run_id: started.run_id }),
       process.cwd()
     );
     const initialStatus = await readToolPayload(statusResponse);
@@ -114,7 +155,7 @@ async function testAsyncStartStatusCancelAndSyncCompatibility() {
     assert.equal(["queued", "running"].includes(initialStatus.run.state), true);
 
     const cancelResponse = await handleRequest(
-      makeToolCall(3, "cancel_recommend_pipeline_run", { run_id: started.run_id }),
+      makeToolCall(4, "cancel_recommend_pipeline_run", { run_id: started.run_id }),
       process.cwd()
     );
     const canceled = await readToolPayload(cancelResponse);
@@ -123,8 +164,23 @@ 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(4, "run_recommend_pipeline", { instruction: "fast sync run" }),
+      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);
@@ -133,22 +189,32 @@ async function testAsyncStartStatusCancelAndSyncCompatibility() {
     const completedDefaultAsyncRun = await waitForTerminalRunState(defaultAsyncPayload.run_id);
     assert.equal(completedDefaultAsyncRun.state, "completed");
 
-    const syncFailedResponse = await handleRequest(
-      makeToolCall(5, "run_recommend_pipeline", {
+    const syncResponse = await handleRequest(
+      makeToolCall(7, "run_recommend_pipeline", {
         instruction: "fast forced sync run",
-        execution_mode: "sync"
+        execution_mode: "sync",
+        confirmation: {
+          job_confirmed: true,
+          job_value: "mock job",
+          final_confirmed: true
+        }
       }),
       process.cwd()
     );
-    const syncPayload = await readToolPayload(syncFailedResponse);
+    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(6, "run_recommend_pipeline", {
+      makeToolCall(8, "run_recommend_pipeline", {
         instruction: "force fail",
-        execution_mode: "sync"
+        execution_mode: "sync",
+        confirmation: {
+          job_confirmed: true,
+          job_value: "mock job",
+          final_confirmed: true
+        }
       }),
       process.cwd()
     );

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) {