@reconcrap/boss-recruit-mcp 1.0.16 → 1.0.18

package/README.md

@@ -234,6 +234,7 @@ boss-recruit-mcp doctor --port <port>
 - 确认后自动执行：搜索 CLI -> 点击搜索 -> 勾选“过滤近14天查看”（按轮次规则） -> 筛选 CLI
 - 返回摘要：目标数、已处理、通过数、耗时、输出 CSV
 - 执行前会先做本地依赖预检查，若目录 / 入口 / 配置文件缺失则返回 `PIPELINE_PREFLIGHT_FAILED`
+- preflight 会检查 Node.js 与 npm 依赖（`chrome-remote-interface` / `ws`）；失败时会返回 `diagnostics.recovery`（含有序修复步骤与 `agent_prompt`）
 - 若缺少 `favorite-calibration.json`，会返回 `CALIBRATION_REQUIRED`
 - 若某轮搜索返回可筛选候选人但筛选 `processed_count` 非法或为 0，会先导出当前累计 CSV，再返回 `SCREEN_NO_PROGRESS`
 - 若当前运行环境不允许启动子进程，会返回更明确的权限错误码而不是笼统失败

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recruit-mcp",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Unified MCP pipeline for boss-search-cli and boss-screen-cli",
   "keywords": [
     "boss",

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

@@ -289,6 +289,8 @@ description: "Use when users ask to recruit candidates on Boss Zhipin via the bo
 - 不要把底层 stderr 原样大段贴给用户，只提炼关键错误和下一步。
 - 如果失败原因明显是环境问题，要直接说明不是用户输入有误。
 - 如果工具已经返回 `diagnostics.checks`，优先基于这些检查项生成排障建议。
+- 如果返回 `PIPELINE_PREFLIGHT_FAILED` 且含 `diagnostics.recovery.agent_prompt`，优先把该提示词直接交给 AI agent 自动修复依赖。
+- 自动修复依赖必须严格串行：先 Node.js，再 npm 依赖；若涉及 Python / Pillow，先 Python 再 Pillow。
 - 如果工具返回 `output_csv`，在摘要里给出路径，避免重复解释内部流程。
 - 如果端口还没确认，必须先问用户“是否使用推荐的 `9222`，还是你已经有别的远程调试端口”，不能直接把 `9222` 当成已确认值。
 - 用户确认端口后，先执行一次 `boss-recruit-mcp set-port --port <port>`，让后续 `doctor / launch-chrome / calibrate / run` 自动复用同一端口。

package/src/adapters.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import CDP from "chrome-remote-interface";
 const currentFilePath = fileURLToPath(import.meta.url);
@@ -156,6 +156,117 @@ function runProcess({ command, args, cwd, timeoutMs }) {
   });
 }
 
+function runProcessSync({ command, args, cwd }) {
+  try {
+    const result = spawnSync(command, args, {
+      cwd,
+      windowsHide: true,
+      shell: false,
+      env: process.env,
+      encoding: "utf8"
+    });
+    const stdout = String(result.stdout || "").trim();
+    const stderr = String(result.stderr || "").trim();
+    return {
+      ok: result.status === 0,
+      status: result.status,
+      stdout,
+      stderr,
+      output: [stdout, stderr].filter(Boolean).join("\n").trim(),
+      error_code: result.error?.code || null,
+      error_message: result.error?.message || null
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      status: -1,
+      stdout: "",
+      stderr: "",
+      output: "",
+      error_code: error.code || "SPAWN_FAILED",
+      error_message: error.message || String(error)
+    };
+  }
+}
+
+function parseMajorVersion(raw) {
+  const match = String(raw || "").match(/v?(\d+)(?:\.\d+){0,2}/);
+  if (!match) return null;
+  const major = Number.parseInt(match[1], 10);
+  return Number.isFinite(major) ? major : null;
+}
+
+function buildNodeCommandCheck() {
+  const probe = runProcessSync({
+    command: "node",
+    args: ["--version"]
+  });
+  const major = parseMajorVersion(probe.output);
+  const versionOk = Number.isInteger(major) && major >= 18;
+  return {
+    key: "node_cli",
+    ok: probe.ok && versionOk,
+    path: "node --version",
+    message: probe.ok
+      ? (versionOk
+        ? `Node 命令可用 (${probe.output || "unknown version"})`
+        : `Node 版本过低 (${probe.output || "unknown version"})，要求 >= 18`)
+      : `未找到 node 命令，请先安装 Node.js >= 18。${probe.error_message ? ` (${probe.error_message})` : ""}`
+  };
+}
+
+function buildNodePackageCheck({ key, moduleName, cwd, missingMessage }) {
+  if (!cwd || !pathExists(cwd)) {
+    return {
+      key,
+      ok: false,
+      path: moduleName,
+      module: moduleName,
+      install_cwd: null,
+      message: missingMessage
+    };
+  }
+  const probe = runProcessSync({
+    command: "node",
+    args: ["-e", `require.resolve(${JSON.stringify(moduleName)});`],
+    cwd
+  });
+  return {
+    key,
+    ok: probe.ok,
+    path: moduleName,
+    module: moduleName,
+    install_cwd: cwd,
+    message: probe.ok
+      ? `${moduleName} npm 依赖可用`
+      : `缺少 npm 依赖 ${moduleName}，请在 boss-recruit-mcp 目录执行 npm install。`
+  };
+}
+
+function buildRuntimeDependencyChecks({ searchDir, screenDir }) {
+  return [
+    buildNodeCommandCheck(),
+    buildNodePackageCheck({
+      key: "npm_dep_chrome_remote_interface_search",
+      moduleName: "chrome-remote-interface",
+      cwd: searchDir,
+      missingMessage: "无法校验 chrome-remote-interface：boss-search-cli 目录不存在。"
+    }),
+    buildNodePackageCheck({
+      key: "npm_dep_chrome_remote_interface_screen",
+      moduleName: "chrome-remote-interface",
+      cwd: screenDir,
+      missingMessage: "无法校验 chrome-remote-interface：boss-screen-cli 目录不存在。"
+    }),
+    buildNodePackageCheck({
+      key: "npm_dep_ws",
+      moduleName: "ws",
+      cwd: screenDir,
+      missingMessage: "无法校验 ws：boss-screen-cli 目录不存在。"
+    })
+  ];
+}
+
 function parseSearchCount(output) {
   const m = output.match(/找到\s*(\d+)\s*个候选人/);
   if (!m) return null;
@@ -351,13 +462,18 @@ export function runPipelinePreflight(workspaceRoot) {
       message: "favorite-calibration.json 不存在（可选，仅在旧页面回退点击时需要）"
     }
   ];
+  checks.push(...buildRuntimeDependencyChecks({ searchDir, screenDir }));
 
   const requiredCheckKeys = new Set([
     "search_cli_dir",
     "search_cli_entry",
     "screen_cli_dir",
     "screen_cli_entry",
-    "screen_config"
+    "screen_config",
+    "node_cli",
+    "npm_dep_chrome_remote_interface_search",
+    "npm_dep_chrome_remote_interface_screen",
+    "npm_dep_ws"
   ]);
 
   return {

package/src/index.js

@@ -8,11 +8,18 @@ const require = createRequire(import.meta.url);
 const { version: SERVER_VERSION } = require("../package.json");
 const TOOL_NAME = "run_recruit_pipeline";
 const SERVER_NAME = "boss-recruit-mcp";
+const FRAMING_UNKNOWN = "unknown";
+const FRAMING_HEADER = "header";
+const FRAMING_LINE = "line";
 
-function writeMessage(message) {
+function writeMessage(message, framing = FRAMING_LINE) {
   const body = JSON.stringify(message);
-  const header = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n`;
-  process.stdout.write(header + body);
+  if (framing === FRAMING_HEADER) {
+    const header = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n`;
+    process.stdout.write(header + body);
+    return;
+  }
+  process.stdout.write(`${body}\n`);
 }
 
 function createJsonRpcError(id, code, message) {
@@ -178,42 +185,91 @@ export function startServer() {
   const mcpRoot = path.resolve(path.dirname(thisFile), "..");
   const workspaceRoot = envRoot ? path.resolve(envRoot) : path.resolve(mcpRoot, "..");
   let buffer = Buffer.alloc(0);
+  let framing = FRAMING_UNKNOWN;
 
   process.stdin.on("data", async (chunk) => {
     buffer = Buffer.concat([buffer, chunk]);
+    if (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
+      buffer = buffer.slice(3);
+    }
 
     while (true) {
-      const headerEnd = buffer.indexOf("\r\n\r\n");
-      if (headerEnd === -1) break;
+      const crlfHeaderEnd = buffer.indexOf("\r\n\r\n");
+      const lfHeaderEnd = buffer.indexOf("\n\n");
+      const crHeaderEnd = buffer.indexOf("\r\r");
+      let headerEnd = -1;
+      let headerSeparatorLength = 0;
+      if (
+        crlfHeaderEnd !== -1
+        && (lfHeaderEnd === -1 || crlfHeaderEnd < lfHeaderEnd)
+        && (crHeaderEnd === -1 || crlfHeaderEnd < crHeaderEnd)
+      ) {
+        headerEnd = crlfHeaderEnd;
+        headerSeparatorLength = 4;
+      } else if (lfHeaderEnd !== -1 && (crHeaderEnd === -1 || lfHeaderEnd < crHeaderEnd)) {
+        headerEnd = lfHeaderEnd;
+        headerSeparatorLength = 2;
+      } else if (crHeaderEnd !== -1) {
+        headerEnd = crHeaderEnd;
+        headerSeparatorLength = 2;
+      }
+      if (headerEnd !== -1) {
+        const headerText = buffer.slice(0, headerEnd).toString("utf8");
+        const contentLengthLine = headerText
+          .split(/\r\n|\n|\r/)
+          .find((line) => line.toLowerCase().startsWith("content-length:"));
 
-      const headerText = buffer.slice(0, headerEnd).toString("utf8");
-      const contentLengthLine = headerText
-        .split("\r\n")
-        .find((line) => line.toLowerCase().startsWith("content-length:"));
+        if (!contentLengthLine) {
+          buffer = buffer.slice(headerEnd + headerSeparatorLength);
+          continue;
+        }
+
+        const contentLength = Number.parseInt(contentLengthLine.split(":")[1].trim(), 10);
+        if (!Number.isFinite(contentLength) || contentLength < 0) {
+          buffer = buffer.slice(headerEnd + headerSeparatorLength);
+          continue;
+        }
 
-      if (!contentLengthLine) {
-        buffer = buffer.slice(headerEnd + 4);
+        const bodyStart = headerEnd + headerSeparatorLength;
+        const bodyEnd = bodyStart + contentLength;
+        if (buffer.length < bodyEnd) break;
+
+        const body = buffer.slice(bodyStart, bodyEnd).toString("utf8");
+        buffer = buffer.slice(bodyEnd);
+        framing = FRAMING_HEADER;
+
+        let message;
+        try {
+          message = JSON.parse(body);
+        } catch {
+          writeMessage(createJsonRpcError(null, -32700, "Parse error"), FRAMING_HEADER);
+          continue;
+        }
+
+        const response = await handleRequest(message, workspaceRoot);
+        if (response) writeMessage(response, framing);
         continue;
       }
 
-      const contentLength = Number.parseInt(contentLengthLine.split(":")[1].trim(), 10);
-      const bodyStart = headerEnd + 4;
-      const bodyEnd = bodyStart + contentLength;
-      if (buffer.length < bodyEnd) break;
-
-      const body = buffer.slice(bodyStart, bodyEnd).toString("utf8");
-      buffer = buffer.slice(bodyEnd);
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) break;
+      const rawLine = buffer.slice(0, newlineIndex).toString("utf8").replace(/\r$/, "");
+      if (/^\s*content-length:/i.test(rawLine)) break;
+      buffer = buffer.slice(newlineIndex + 1);
+      const line = rawLine.trim();
+      if (!line) continue;
+      framing = FRAMING_LINE;
 
       let message;
       try {
-        message = JSON.parse(body);
+        message = JSON.parse(line);
       } catch {
-        writeMessage(createJsonRpcError(null, -32700, "Parse error"));
+        writeMessage(createJsonRpcError(null, -32700, "Parse error"), FRAMING_LINE);
         continue;
       }
 
       const response = await handleRequest(message, workspaceRoot);
-      if (response) writeMessage(response);
+      if (response) writeMessage(response, framing);
     }
   });
 }

package/src/pipeline.js

@@ -8,6 +8,126 @@ import {
   runScreenCli
 } from "./adapters.js";
 
+function dedupe(values = []) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function failedCheckSet(checks = []) {
+  const failed = checks
+    .filter((item) => item && item.ok === false && typeof item.key === "string")
+    .map((item) => item.key);
+  return new Set(failed);
+}
+
+function collectNpmInstallDirs(checks = [], workspaceRoot) {
+  const npmCheckKeys = new Set([
+    "npm_dep_chrome_remote_interface_search",
+    "npm_dep_chrome_remote_interface_screen",
+    "npm_dep_ws"
+  ]);
+  const dirs = checks
+    .filter((item) => item && item.ok === false && npmCheckKeys.has(item.key))
+    .map((item) => item.install_cwd)
+    .filter((value) => typeof value === "string" && value.trim());
+  if (dirs.length > 0) return dedupe(dirs);
+  return workspaceRoot ? [workspaceRoot] : [];
+}
+
+function buildNpmInstallCommands(checks = [], workspaceRoot) {
+  const dirs = collectNpmInstallDirs(checks, workspaceRoot);
+  const commands = [];
+  for (const dir of dirs) {
+    const escaped = String(dir).replace(/'/g, "''");
+    commands.push(`Set-Location '${escaped}'`);
+    commands.push("npm install");
+  }
+  return commands;
+}
+
+function formatCommandBlock(commands = []) {
+  return commands.map((command) => `- ${command}`).join("\n");
+}
+
+function buildPreflightRecovery(checks = [], workspaceRoot) {
+  const failed = failedCheckSet(checks);
+  if (failed.size === 0) return null;
+
+  const needNode = failed.has("node_cli");
+  const needNpm = (
+    failed.has("npm_dep_chrome_remote_interface_search")
+    || failed.has("npm_dep_chrome_remote_interface_screen")
+    || failed.has("npm_dep_ws")
+  );
+  const needPython = failed.has("python_cli");
+  const needPillow = failed.has("python_pillow");
+
+  const ordered_steps = [];
+  if (needNode) {
+    ordered_steps.push({
+      id: "install_nodejs",
+      title: "安装 Node.js >= 18",
+      blocked_by: [],
+      commands: [
+        "winget install OpenJS.NodeJS.LTS",
+        "node --version"
+      ]
+    });
+  }
+  if (needNpm) {
+    ordered_steps.push({
+      id: "install_npm_dependencies",
+      title: "安装 npm 依赖（chrome-remote-interface / ws）",
+      blocked_by: needNode ? ["install_nodejs"] : [],
+      commands: buildNpmInstallCommands(checks, workspaceRoot)
+    });
+  }
+  if (needPython) {
+    ordered_steps.push({
+      id: "install_python",
+      title: "安装 Python（确保 python 命令可用）",
+      blocked_by: [],
+      commands: [
+        "winget install Python.Python.3.12",
+        "python --version"
+      ]
+    });
+  }
+  if (needPillow) {
+    ordered_steps.push({
+      id: "install_pillow",
+      title: "安装 Pillow",
+      blocked_by: needPython ? ["install_python"] : [],
+      commands: [
+        "python -m pip install --upgrade pip",
+        "python -m pip install pillow"
+      ]
+    });
+  }
+
+  const promptLines = [
+    "你是环境修复 agent。请先读取 diagnostics.checks，再严格按下面顺序执行，不要并行跳步：",
+    "1) node_cli 失败 -> 先安装 Node.js，未成功前禁止执行 npm install。",
+    "2) npm_dep_* 失败 -> 再安装 npm 依赖（chrome-remote-interface / ws）。",
+    "3) python_cli 失败 -> 安装 Python 并确保 python 命令可用。",
+    "4) python_pillow 失败 -> 最后安装 Pillow。",
+    "每一步完成后都重新运行 doctor，直到所有检查通过后再重试 run_recruit_pipeline。"
+  ];
+
+  if (needNpm) {
+    const npmCommands = buildNpmInstallCommands(checks, workspaceRoot);
+    if (npmCommands.length > 0) {
+      promptLines.push("建议执行的 npm 命令：");
+      promptLines.push(formatCommandBlock(npmCommands));
+    }
+  }
+
+  return {
+    failed_check_keys: [...failed],
+    ordered_steps,
+    agent_prompt: promptLines.join("\n")
+  };
+}
+
 function buildRequiredConfirmations(parsedResult) {
   const confirmations = [];
 
@@ -280,6 +400,7 @@ export async function runRecruitPipeline({
 
   const preflight = runPreflight(workspaceRoot);
   if (!preflight.ok) {
+    const recovery = buildPreflightRecovery(preflight.checks, workspaceRoot);
     return buildFailedResponse(
       "PIPELINE_PREFLIGHT_FAILED",
       "招聘流水线运行前检查失败，请先修复缺失的本地依赖或配置文件。",
@@ -289,7 +410,8 @@ export async function runRecruitPipeline({
         diagnostics: {
           checks: preflight.checks,
           debug_port: preflight.debug_port,
-          calibration_path: preflight.calibration_path
+          calibration_path: preflight.calibration_path,
+          recovery
         }
       }
     );

package/src/test-pipeline.js

@@ -420,6 +420,45 @@ async function testNeedInputGateStillWorks() {
   assert.equal(preflightCalled, false);
 }
 
+async function testPreflightRecoveryPlanOrder() {
+  const tempDir = createTempDir("preflight-recovery");
+  const parsed = createParsed();
+  const deps = {
+    parseRecruitInstruction: () => parsed,
+    runPipelinePreflight: () => ({
+      ok: false,
+      debug_port: 9222,
+      calibration_path: null,
+      checks: [
+        { key: "node_cli", ok: false },
+        { key: "npm_dep_ws", ok: false, install_cwd: "C:/workspace/boss-recruit-mcp" }
+      ]
+    }),
+    ensureBossSearchPageReady: async () => ({ ok: true, state: "SEARCH_READY", debug_port: 9222, page_state: {} }),
+    runSearchCli: async () => buildSearchOk(0),
+    runScreenCli: async () => buildScreenOk({ processedCount: 0, passedCount: 0, outputCsv: null })
+  };
+
+  const result = await runRecruitPipeline(
+    {
+      workspaceRoot: tempDir,
+      instruction: "test",
+      confirmation: {},
+      overrides: {}
+    },
+    deps
+  );
+
+  assert.equal(result.status, "FAILED");
+  assert.equal(result.error.code, "PIPELINE_PREFLIGHT_FAILED");
+  assert.deepEqual(
+    result.diagnostics.recovery.ordered_steps.map((item) => item.id),
+    ["install_nodejs", "install_npm_dependencies"]
+  );
+  assert.deepEqual(result.diagnostics.recovery.ordered_steps[1].blocked_by, ["install_nodejs"]);
+  assert.equal(result.diagnostics.recovery.agent_prompt.includes("不要并行跳步"), true);
+}
+
 async function main() {
   await testSearchExhaustedCompletesAndMergesCsv();
   await testSearchExhaustedByTipNodataEvenWhenCandidateCountPositive();
@@ -427,6 +466,7 @@ async function main() {
   await testScreenNoProgressWithZeroProcessedExportsBeforeFail();
   await testScreenNoProgressWithInvalidProcessedAndNoCsv();
   await testNeedInputGateStillWorks();
+  await testPreflightRecoveryPlanOrder();
   // eslint-disable-next-line no-console
   console.log("pipeline tests passed");
 }