@reconcrap/boss-recruit-mcp 1.0.0

package/src/index.js

@@ -0,0 +1,210 @@
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { runRecruitPipeline } from "./pipeline.js";
+
+const TOOL_NAME = "run_recruit_pipeline";
+const SERVER_NAME = "boss-recruit-mcp";
+const SERVER_VERSION = "1.0.0";
+
+function writeMessage(message) {
+  const body = JSON.stringify(message);
+  const header = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n`;
+  process.stdout.write(header + body);
+}
+
+function createJsonRpcError(id, code, message) {
+  return {
+    jsonrpc: "2.0",
+    id: id ?? null,
+    error: { code, message }
+  };
+}
+
+function createToolSchema() {
+  return {
+    name: TOOL_NAME,
+    description: "统一招聘流水线：解析招聘指令、校验条件、执行搜索与筛选并返回摘要。",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instruction: {
+          type: "string",
+          description: "用户自然语言招聘指令"
+        },
+        confirmation: {
+          type: "object",
+          properties: {
+            keyword_confirmed: { type: "boolean" },
+            keyword_value: { type: "string" }
+          },
+          additionalProperties: false
+        },
+        overrides: {
+          type: "object",
+          properties: {
+            target_count: { type: "integer", minimum: 1 }
+          },
+          additionalProperties: false
+        }
+      },
+      required: ["instruction"],
+      additionalProperties: false
+    }
+  };
+}
+
+async function handleRequest(message, workspaceRoot) {
+  if (!message || message.jsonrpc !== "2.0") {
+    return createJsonRpcError(null, -32600, "Invalid JSON-RPC request");
+  }
+
+  const { id, method, params } = message;
+
+  if (method === "initialize") {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: "2024-11-05",
+        capabilities: {
+          tools: {}
+        },
+        serverInfo: {
+          name: SERVER_NAME,
+          version: SERVER_VERSION
+        }
+      }
+    };
+  }
+
+  if (method === "notifications/initialized") {
+    return null;
+  }
+
+  if (method === "tools/list") {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        tools: [createToolSchema()]
+      }
+    };
+  }
+
+  if (method === "tools/call") {
+    if (!params || params.name !== TOOL_NAME) {
+      return createJsonRpcError(id, -32602, `Unknown tool: ${params?.name || ""}`);
+    }
+
+    const args = params.arguments || {};
+    if (!args.instruction || typeof args.instruction !== "string") {
+      return createJsonRpcError(id, -32602, "instruction is required and must be a string");
+    }
+
+    try {
+      const result = await runRecruitPipeline({
+        workspaceRoot,
+        instruction: args.instruction,
+        confirmation: args.confirmation,
+        overrides: args.overrides
+      });
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ],
+          structuredContent: result
+        }
+      };
+    } catch (error) {
+      const failed = {
+        status: "FAILED",
+        error: {
+          code: "UNEXPECTED_ERROR",
+          message: error.message || "Unexpected error",
+          retryable: true
+        }
+      };
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(failed, null, 2)
+            }
+          ],
+          structuredContent: failed,
+          isError: true
+        }
+      };
+    }
+  }
+
+  if (method === "ping") {
+    return { jsonrpc: "2.0", id, result: {} };
+  }
+
+  if (id === undefined || id === null) {
+    return null;
+  }
+  return createJsonRpcError(id, -32601, `Method not found: ${method}`);
+}
+
+export function startServer() {
+  const envRoot = process.env.BOSS_WORKSPACE_ROOT;
+  const thisFile = fileURLToPath(import.meta.url);
+  const mcpRoot = path.resolve(path.dirname(thisFile), "..");
+  const workspaceRoot = envRoot ? path.resolve(envRoot) : path.resolve(mcpRoot, "..");
+  let buffer = Buffer.alloc(0);
+
+  process.stdin.on("data", async (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+
+    while (true) {
+      const headerEnd = buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) break;
+
+      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 + 4);
+        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);
+
+      let message;
+      try {
+        message = JSON.parse(body);
+      } catch {
+        writeMessage(createJsonRpcError(null, -32700, "Parse error"));
+        continue;
+      }
+
+      const response = await handleRequest(message, workspaceRoot);
+      if (response) writeMessage(response);
+    }
+  });
+}
+
+const thisFilePath = fileURLToPath(import.meta.url);
+if (process.argv[1] && path.resolve(process.argv[1]) === thisFilePath) {
+  startServer();
+}

package/src/parser.js

@@ -0,0 +1,221 @@
+const SEARCH_SCHOOL_MAP = {
+  "985": "985院校",
+  "211": "211院校",
+  "qs100": "QS 100"
+};
+
+function normalizeText(input) {
+  return String(input || "").replace(/\s+/g, " ").trim();
+}
+
+function uniqueList(items) {
+  return Array.from(new Set(items.filter(Boolean)));
+}
+
+function extractCity(text) {
+  const explicitPatterns = [
+    /地点(?:在|是|为|:|：)?\s*([^\s，。；;、]+)/i,
+    /城市(?:在|是|为|:|：)?\s*([^\s，。；;、]+)/i
+  ];
+
+  for (const pattern of explicitPatterns) {
+    const m = text.match(pattern);
+    if (m && m[1]) {
+      return m[1].trim();
+    }
+  }
+
+  return null;
+}
+
+function extractDegree(text) {
+  if (/(博士及以上|博士)/.test(text)) return "博士";
+  if (/(硕士及以上|硕士以上)/.test(text)) return "硕士及以上";
+  if (/(本科及以上|本科以上)/.test(text)) return "本科及以上";
+  if (/本科/.test(text)) return "本科";
+  return null;
+}
+
+function extractSchools(text) {
+  const schools = [];
+  if (/(^|[^0-9])985([^0-9]|$)/.test(text)) schools.push(SEARCH_SCHOOL_MAP["985"]);
+  if (/(^|[^0-9])211([^0-9]|$)/.test(text)) schools.push(SEARCH_SCHOOL_MAP["211"]);
+  if (/(qs\s*100|QS\s*100|qs100|QS100)/.test(text)) schools.push(SEARCH_SCHOOL_MAP["qs100"]);
+  return uniqueList(schools);
+}
+
+function extractKeywordExplicit(text) {
+  const patterns = [
+    /搜索关键词(?:为|是|:|：)?\s*([^\n，。；;]+)/i,
+    /关键词(?:为|是|:|：)?\s*([^\n，。；;]+)/i,
+    /keyword(?:\s*[:：=]\s*|\s+is\s+)([^\n，。；;]+)/i
+  ];
+
+  for (const pattern of patterns) {
+    const m = text.match(pattern);
+    if (m && m[1]) {
+      const kw = m[1].trim();
+      if (kw) return kw;
+    }
+  }
+  return null;
+}
+
+function extractKeywordAuto(text) {
+  const patterns = [
+    /做过\s*([A-Za-z0-9+#./\-\s]{2,40}?)(?:的人选|的人|相关|并且|且|，|。|,|$)/i,
+    /有过\s*([A-Za-z0-9+#./\-\s]{2,40}?)(?:经验|背景|的人选|并且|且|，|。|,|$)/i,
+    /从事过\s*([A-Za-z0-9+#./\-\s]{2,40}?)(?:相关|的人选|并且|且|，|。|,|$)/i
+  ];
+
+  for (const pattern of patterns) {
+    const m = text.match(pattern);
+    if (m && m[1]) {
+      const kw = m[1].replace(/\s+/g, " ").trim();
+      if (kw.length >= 2) return kw;
+    }
+  }
+  return null;
+}
+
+function extractTargetCount(text) {
+  const patterns = [
+    /至少筛选\s*(\d+)\s*位?/i,
+    /目标(?:筛选)?(?:人数|数量)?(?:为|是|:|：)?\s*(\d+)/i,
+    /目标(?:筛选)?(?:人数|数量)?\s*(\d+)\s*人/i,
+    /筛选\s*(\d+)\s*位/i
+  ];
+
+  for (const pattern of patterns) {
+    const m = text.match(pattern);
+    if (m && m[1]) {
+      const n = Number.parseInt(m[1], 10);
+      if (Number.isFinite(n) && n > 0) return n;
+    }
+  }
+  return null;
+}
+
+function sanitizeClause(clause) {
+  return clause
+    .replace(/^使用boss-recruit-pipeline skills/i, "")
+    .replace(/^帮我(?:在boss上)?(?:找|筛选)/i, "")
+    .replace(/^请(?:在boss上)?(?:帮我)?(?:找|筛选)/i, "")
+    .replace(/^在boss上(?:帮我)?(?:找|筛选)/i, "")
+    .replace(/的人选$/, "")
+    .replace(/的人$/, "")
+    .trim();
+}
+
+function buildScreenCriteria(text, searchParams) {
+  const clauses = text
+    .split(/[，,。；;\n]/)
+    .map((s) => sanitizeClause(s))
+    .filter(Boolean);
+
+  const filtered = clauses.filter((clause) => {
+    if (/搜索关键词|关键词|keyword/i.test(clause)) return false;
+    if (/地点|城市/.test(clause)) return false;
+    if (/学历|本科|硕士|博士/.test(clause) && !/论文|项目|经验/.test(clause)) return false;
+    if (/985|211|qs\s*100|QS\s*100|院校/.test(clause) && !/论文|经验|项目/.test(clause)) return false;
+    if (/至少筛选|目标人数|目标数量|筛选\d+位/.test(clause)) return false;
+    return true;
+  });
+
+  const normalized = filtered
+    .map((clause) => clause.replace(/\s+/g, " ").trim())
+    .filter(Boolean);
+
+  if (searchParams?.keyword) {
+    const keywordClause = `候选人需有${searchParams.keyword}相关经历`;
+    const alreadyCovered = normalized.some((clause) =>
+      clause.toLowerCase().includes(String(searchParams.keyword).toLowerCase())
+    );
+    if (!alreadyCovered) {
+      normalized.unshift(keywordClause);
+    }
+  }
+
+  if (normalized.length === 0) {
+    return searchParams?.keyword
+      ? `候选人需有${searchParams.keyword}相关经历`
+      : text;
+  }
+  return uniqueList(normalized).join("；");
+}
+
+function resolveKeyword(parsed, confirmation) {
+  const explicit = parsed.keyword_explicit;
+  const auto = parsed.keyword_auto;
+  const confirmed = confirmation && confirmation.keyword_confirmed === true;
+  const rejected = confirmation && confirmation.keyword_confirmed === false;
+  const value = confirmation && typeof confirmation.keyword_value === "string"
+    ? confirmation.keyword_value.trim()
+    : "";
+
+  if (confirmed && value) {
+    return { keyword: value, needsConfirmation: false, proposedKeyword: null };
+  }
+
+  if (explicit) {
+    return { keyword: explicit, needsConfirmation: false, proposedKeyword: null };
+  }
+
+  if (rejected) {
+    return { keyword: value || null, needsConfirmation: false, proposedKeyword: null };
+  }
+
+  if (auto) {
+    if (confirmed) {
+      return { keyword: auto, needsConfirmation: false, proposedKeyword: null };
+    }
+    return { keyword: null, needsConfirmation: true, proposedKeyword: auto };
+  }
+
+  return { keyword: null, needsConfirmation: false, proposedKeyword: null };
+}
+
+export function parseRecruitInstruction({ instruction, confirmation, overrides }) {
+  const text = normalizeText(instruction);
+  const parsed = {
+    city: extractCity(text),
+    degree: extractDegree(text),
+    schools: extractSchools(text),
+    keyword_explicit: extractKeywordExplicit(text),
+    keyword_auto: extractKeywordAuto(text),
+    target_count: extractTargetCount(text)
+  };
+
+  if (overrides && Number.isFinite(overrides.target_count) && overrides.target_count > 0) {
+    parsed.target_count = Number.parseInt(String(overrides.target_count), 10);
+  }
+
+  const keywordResolution = resolveKeyword(parsed, confirmation);
+  const searchParams = {
+    city: parsed.city,
+    degree: parsed.degree,
+    schools: parsed.schools,
+    keyword: keywordResolution.keyword
+  };
+
+  const screenParams = {
+    criteria: buildScreenCriteria(text, searchParams),
+    target_count: parsed.target_count
+  };
+
+  const missing = [];
+  if (!searchParams.city) missing.push("city");
+  if (!searchParams.degree) missing.push("degree");
+  if (!searchParams.schools || searchParams.schools.length === 0) missing.push("schools");
+  if (!searchParams.keyword) missing.push("keyword");
+  if (!screenParams.target_count) missing.push("target_count");
+
+  return {
+    parsed,
+    searchParams,
+    screenParams,
+    missing_fields: missing,
+    needs_keyword_confirmation: keywordResolution.needsConfirmation,
+    proposed_keyword: keywordResolution.proposedKeyword
+  };
+}

package/src/pipeline.js

@@ -0,0 +1,215 @@
+import { parseRecruitInstruction } from "./parser.js";
+import { runPipelinePreflight, runSearchCli, runScreenCli } from "./adapters.js";
+
+function buildNeedInputResponse(parsedResult) {
+  return {
+    status: "NEED_INPUT",
+    missing_fields: parsedResult.missing_fields,
+    search_params: parsedResult.searchParams,
+    screen_params: parsedResult.screenParams,
+    error: {
+      code: "MISSING_REQUIRED_FIELDS",
+      message: "缺少必要字段，请一次性补充缺失项后再执行。",
+      retryable: true
+    }
+  };
+}
+
+function buildNeedConfirmationResponse(parsedResult) {
+  return {
+    status: "NEED_CONFIRMATION",
+    proposed_keyword: parsedResult.proposed_keyword,
+    search_params: {
+      ...parsedResult.searchParams,
+      keyword: parsedResult.proposed_keyword
+    },
+    screen_params: parsedResult.screenParams
+  };
+}
+
+function buildFailedResponse(code, message, extra = {}) {
+  return {
+    status: "FAILED",
+    error: {
+      code,
+      message,
+      retryable: true
+    },
+    ...extra
+  };
+}
+
+function classifySearchFailure(searchResult) {
+  const stderr = searchResult.stderr || "";
+  const errorCode = searchResult.error_code || "";
+
+  if (errorCode === "EPERM" || /spawn EPERM/i.test(stderr)) {
+    return {
+      code: "SEARCH_PROCESS_PERMISSION_DENIED",
+      message: "搜索工具无法启动子进程，当前运行环境拒绝了进程创建权限。请在本地终端直接运行 MCP 或放宽运行权限后重试。"
+    };
+  }
+
+  if (errorCode === "TIMEOUT" || /timed out/i.test(stderr)) {
+    return {
+      code: "SEARCH_TIMEOUT",
+      message: "搜索工具执行超时，可能是 Chrome 远程调试未就绪、Boss 页面未打开，或页面交互卡住。"
+    };
+  }
+
+  if (errorCode === "ENOENT" || /not recognized|Cannot find|MODULE_NOT_FOUND/i.test(stderr)) {
+    return {
+      code: "SEARCH_CLI_MISSING",
+      message: "搜索工具入口不存在或 Node 环境不可用，请检查 boss-search-cli 安装与路径配置。"
+    };
+  }
+
+  return {
+    code: "SEARCH_CLI_FAILED",
+    message: "搜索工具执行失败，请检查 Chrome 远程调试、Boss 登录状态和页面可访问性。"
+  };
+}
+
+function classifyScreenFailure(screenResult) {
+  const stderr = screenResult.stderr || "";
+  const errorCode = screenResult.error_code || "";
+
+  if (screenResult.config_error) {
+    return {
+      code: "SCREEN_CONFIG_ERROR",
+      message: "筛选工具配置缺失或格式错误，请检查 screening-config.json。"
+    };
+  }
+
+  if (errorCode === "EPERM" || /spawn EPERM/i.test(stderr)) {
+    return {
+      code: "SCREEN_PROCESS_PERMISSION_DENIED",
+      message: "筛选工具无法启动子进程，当前运行环境拒绝了进程创建权限。请在本地终端直接运行 MCP 或放宽运行权限后重试。"
+    };
+  }
+
+  if (errorCode === "TIMEOUT" || /timed out/i.test(stderr)) {
+    return {
+      code: "SCREEN_TIMEOUT",
+      message: "筛选工具执行超时，可能是 Boss 页面交互卡住、LLM 接口响应过慢，或候选人列表处理速度异常。"
+    };
+  }
+
+  if (errorCode === "ENOENT" || /not recognized|Cannot find|MODULE_NOT_FOUND/i.test(stderr)) {
+    return {
+      code: "SCREEN_CLI_MISSING",
+      message: "筛选工具入口不存在或 Node 环境不可用，请检查 boss-screen-cli 安装与路径配置。"
+    };
+  }
+
+  return {
+    code: "SCREEN_CLI_FAILED",
+    message: "筛选工具执行失败，请检查模型配置、Chrome 远程调试和页面状态。"
+  };
+}
+
+export async function runRecruitPipeline({
+  workspaceRoot,
+  instruction,
+  confirmation,
+  overrides
+}) {
+  const startedAt = Date.now();
+  const parsed = parseRecruitInstruction({
+    instruction,
+    confirmation,
+    overrides
+  });
+
+  if (parsed.needs_keyword_confirmation) {
+    return buildNeedConfirmationResponse(parsed);
+  }
+
+  if (parsed.missing_fields.length > 0) {
+    return buildNeedInputResponse(parsed);
+  }
+
+  const preflight = runPipelinePreflight(workspaceRoot);
+  if (!preflight.ok) {
+    return buildFailedResponse(
+      "PIPELINE_PREFLIGHT_FAILED",
+      "招聘流水线运行前检查失败，请先修复缺失的本地依赖或配置文件。",
+      {
+        search_params: parsed.searchParams,
+        screen_params: parsed.screenParams,
+        diagnostics: {
+          checks: preflight.checks
+        }
+      }
+    );
+  }
+
+  const searchResult = await runSearchCli({
+    workspaceRoot,
+    searchParams: parsed.searchParams
+  });
+
+  if (!searchResult.ok) {
+    const failure = classifySearchFailure(searchResult);
+    return buildFailedResponse(
+      failure.code,
+      failure.message,
+      {
+        search_params: parsed.searchParams,
+        screen_params: parsed.screenParams,
+        diagnostics: {
+          exit_code: searchResult.exit_code,
+          error_code: searchResult.error_code,
+          stderr: searchResult.stderr?.slice(0, 1200)
+        }
+      }
+    );
+  }
+
+  if (searchResult.candidate_count === 0) {
+    return buildFailedResponse(
+      "SEARCH_EMPTY_RESULT",
+      "搜索结果为空，已停止后续筛选。请调整搜索条件后重试。",
+      {
+        search_params: parsed.searchParams,
+        screen_params: parsed.screenParams,
+        diagnostics: {
+          candidate_count: 0
+        }
+      }
+    );
+  }
+
+  const screenResult = await runScreenCli({
+    workspaceRoot,
+    screenParams: parsed.screenParams
+  });
+
+  if (!screenResult.ok) {
+    const failure = classifyScreenFailure(screenResult);
+    return buildFailedResponse(failure.code, failure.message, {
+      search_params: parsed.searchParams,
+      screen_params: parsed.screenParams,
+      diagnostics: {
+        exit_code: screenResult.exit_code,
+        error_code: screenResult.error_code,
+        stderr: screenResult.stderr?.slice(0, 1200)
+      }
+    });
+  }
+
+  const durationSec = Math.max(1, Math.round((Date.now() - startedAt) / 1000));
+  const summary = screenResult.summary || {};
+  return {
+    status: "COMPLETED",
+    search_params: parsed.searchParams,
+    screen_params: parsed.screenParams,
+    result: {
+      target_count: summary.target_count ?? parsed.screenParams.target_count,
+      processed_count: summary.processed_count ?? null,
+      passed_count: summary.passed_count ?? null,
+      duration_sec: durationSec,
+      output_csv: summary.output_csv
+    }
+  };
+}