@reconcrap/boss-recommend-mcp 1.0.2 → 1.0.4

package/README.md

@@ -90,6 +90,7 @@ npx -y @reconcrap/boss-recommend-mcp@latest run --instruction "推荐页筛选98
 注意：
 
 - `install` / `postinstall` 会自动创建 `screening-config.json` 模板（若目标路径可写）
+- 当当前目录是系统目录（例如 `C:\\Windows\\System32`）、用户主目录根（例如 `C:\\Users\\<name>`）或磁盘根目录时，不会再写入 `<cwd>/config`，而是回退到 `~/.boss-recommend-mcp/screening-config.json`
 - 首次运行时，若仍检测到默认占位词（如 `replace-with-openai-api-key`），pipeline 会返回配置目录并要求用户修改后确认“已修改完成”再继续
 - 在 `npx` 临时目录（如 `AppData\\Local\\npm-cache\\_npx\\...`）执行时，不会再把该临时目录当作 `screening-config.json` 目标路径
 

package/package.json

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

package/src/adapters.js

@@ -58,9 +58,50 @@ function parsePositiveInteger(raw) {
   return Number.isFinite(value) && value > 0 ? value : null;
 }
 
+function isRootDirectory(targetPath) {
+  const resolved = path.resolve(String(targetPath || ""));
+  const parsed = path.parse(resolved);
+  return resolved.toLowerCase() === String(parsed.root || "").toLowerCase();
+}
+
+function isSystemDirectoryWorkspaceRoot(workspaceRoot) {
+  const root = path.resolve(String(workspaceRoot || ""));
+  const normalized = root.replace(/\\/g, "/").toLowerCase();
+  if (process.platform === "win32") {
+    return (
+      normalized.endsWith("/windows")
+      || normalized.endsWith("/windows/system32")
+      || normalized.endsWith("/windows/syswow64")
+      || normalized.endsWith("/program files")
+      || normalized.endsWith("/program files (x86)")
+    );
+  }
+  return (
+    normalized === "/system"
+    || normalized.startsWith("/system/")
+    || normalized === "/usr"
+    || normalized.startsWith("/usr/")
+    || normalized === "/bin"
+    || normalized.startsWith("/bin/")
+    || normalized === "/sbin"
+    || normalized.startsWith("/sbin/")
+  );
+}
+
+function shouldIgnoreWorkspaceConfigRoot(workspaceRoot) {
+  const root = path.resolve(String(workspaceRoot || process.cwd()));
+  const home = path.resolve(os.homedir());
+  return (
+    isEphemeralNpxWorkspaceRoot(root)
+    || isRootDirectory(root)
+    || root.toLowerCase() === home.toLowerCase()
+    || isSystemDirectoryWorkspaceRoot(root)
+  );
+}
+
 function resolveWorkspaceConfigCandidates(workspaceRoot) {
   const root = path.resolve(String(workspaceRoot || process.cwd()));
-  if (isEphemeralNpxWorkspaceRoot(root)) {
+  if (shouldIgnoreWorkspaceConfigRoot(root)) {
     return [];
   }
   const directPath = path.join(root, "config", "screening-config.json");
@@ -174,11 +215,13 @@ export function getScreenConfigResolution(workspaceRoot) {
   const candidateMap = buildScreenConfigCandidateMap(workspaceRoot);
   const candidate_paths = resolveScreenConfigCandidates(workspaceRoot);
   const resolved_path = resolveScreenConfigPath(workspaceRoot) || null;
+  const workspace_root = path.resolve(String(workspaceRoot || process.cwd()));
   return {
     resolved_path,
     candidate_paths,
-    workspace_root: path.resolve(String(workspaceRoot || process.cwd())),
+    workspace_root,
     workspace_ephemeral: isEphemeralNpxWorkspaceRoot(workspaceRoot),
+    workspace_ignored_for_config: shouldIgnoreWorkspaceConfigRoot(workspace_root),
     writable_path: resolveWritableScreenConfigPath(workspaceRoot),
     legacy_path: candidateMap.legacy_path
   };

package/vendor/boss-recommend-search-cli/src/cli.js

@@ -85,6 +85,16 @@ function selectionEquals(left, right) {
   if (left.length !== right.length) return false;
   return left.every((value, index) => value === right[index]);
 }
+
+function uniqueNormalizedLabels(values) {
+  return Array.from(
+    new Set(
+      (values || [])
+        .map((item) => normalizeText(item))
+        .filter(Boolean)
+    )
+  );
+}
 
 function expandDegreeAtOrAbove(value) {
   const normalized = normalizeDegree(value);
@@ -1083,43 +1093,99 @@ class RecommendSearchCli {
     return false;
   }
 
-  async getSchoolFilterState() {
-    return this.evaluate(`(() => {
-      const frame = document.querySelector('iframe[name="recommendFrame"]')
-        || document.querySelector('iframe[src*="/web/frame/recommend/"]')
-        || document.querySelector('iframe');
-      if (!frame || !frame.contentDocument) {
-        return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
-      }
-      const doc = frame.contentDocument;
-      const normalize = (value) => String(value || '').replace(/\\s+/g, '').trim();
-      const groups = Array.from(doc.querySelectorAll('.check-box'));
-      const group = doc.querySelector('.check-box.school')
-        || groups.find((item) => {
-          const set = new Set(
-            Array.from(item.querySelectorAll('.default.option, .options .option, .option'))
-              .map((node) => normalize(node.textContent))
-              .filter(Boolean)
-          );
-          return set.has('985') || set.has('211') || set.has('双一流院校');
-        });
-      if (!group) {
-        return { ok: false, error: 'GROUP_NOT_FOUND' };
-      }
-      const labels = ${JSON.stringify(SCHOOL_TAG_OPTIONS)};
-      const activeLabels = labels.filter((label) => {
-        const node = Array.from(group.querySelectorAll('.options .option, .option'))
-          .find((item) => normalize(item.textContent) === normalize(label));
-        return Boolean(node && node.classList.contains('active'));
-      });
-      const defaultOption = group.querySelector('.default.option');
-      return {
-        ok: true,
-        defaultActive: Boolean(defaultOption && defaultOption.classList.contains('active')),
-        activeLabels
-      };
-    })()`);
-  }
+  async getFilterGroupState(groupClass) {
+    return this.evaluate(`((groupClass) => {
+      const frame = document.querySelector('iframe[name="recommendFrame"]')
+        || document.querySelector('iframe[src*="/web/frame/recommend/"]')
+        || document.querySelector('iframe');
+      if (!frame || !frame.contentDocument) {
+        return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
+      }
+      const doc = frame.contentDocument;
+      const normalize = (value) => String(value || '').replace(/\\s+/g, '').trim();
+      const groupCandidates = Array.from(doc.querySelectorAll('.check-box'));
+      const getOptionSet = (group) => new Set(
+        Array.from(group.querySelectorAll('.default.option, .options .option, .option'))
+          .map((item) => normalize(item.textContent))
+          .filter(Boolean)
+      );
+      const findGroup = () => {
+        const direct = doc.querySelector('.check-box.' + groupClass);
+        if (direct) return direct;
+        if (groupClass === 'school') {
+          return groupCandidates.find((group) => {
+            const set = getOptionSet(group);
+            return set.has('985') || set.has('211') || set.has('双一流院校');
+          }) || null;
+        }
+        if (groupClass === 'degree') {
+          return groupCandidates.find((group) => {
+            const set = getOptionSet(group);
+            return set.has('大专') || set.has('本科') || set.has('硕士') || set.has('博士');
+          }) || null;
+        }
+        if (groupClass === 'gender') {
+          return groupCandidates.find((group) => {
+            const set = getOptionSet(group);
+            return set.has('男') || set.has('女');
+          }) || null;
+        }
+        if (groupClass === 'recentNotView') {
+          return groupCandidates.find((group) => {
+            const set = getOptionSet(group);
+            return set.has('近14天没有');
+          }) || null;
+        }
+        return null;
+      };
+
+      const group = findGroup();
+      if (!group) {
+        return { ok: false, error: 'GROUP_NOT_FOUND' };
+      }
+
+      const defaultOption = group.querySelector('.default.option');
+      const options = Array.from(group.querySelectorAll('.default.option, .options .option, .option'));
+      const byLabel = new Map();
+      for (const node of options) {
+        const label = normalize(node.textContent);
+        if (!label) continue;
+        const className = String(node.className || '').trim();
+        const active = node.classList.contains('active');
+        const existing = byLabel.get(label);
+        if (existing) {
+          existing.active = existing.active || active;
+          if (className && !existing.classNames.includes(className)) {
+            existing.classNames.push(className);
+          }
+        } else {
+          byLabel.set(label, {
+            label,
+            active,
+            classNames: className ? [className] : []
+          });
+        }
+      }
+
+      const normalizedOptions = Array.from(byLabel.values()).map((item) => ({
+        label: item.label,
+        active: item.active,
+        class_name: item.classNames.join(' | ')
+      }));
+      return {
+        ok: true,
+        group_class: groupClass,
+        defaultActive: Boolean(defaultOption && defaultOption.classList.contains('active')),
+        defaultClassName: defaultOption ? String(defaultOption.className || '').trim() : '',
+        options: normalizedOptions,
+        activeLabels: normalizedOptions.filter((item) => item.active).map((item) => item.label)
+      };
+    })(${JSON.stringify(groupClass)})`);
+  }
+
+  async getSchoolFilterState() {
+    return this.getFilterGroupState("school");
+  }
 
   async selectSchoolFilter(labels) {
     const ensure = await this.ensureGroupReady("school");
@@ -1169,43 +1235,17 @@ class RecommendSearchCli {
     throw new Error(`SCHOOL_FILTER_VERIFY_FAILED:${JSON.stringify(lastState || {})}`);
   }
 
-  async getDegreeFilterState() {
-    return this.evaluate(`(() => {
-      const frame = document.querySelector('iframe[name="recommendFrame"]')
-        || document.querySelector('iframe[src*="/web/frame/recommend/"]')
-        || document.querySelector('iframe');
-      if (!frame || !frame.contentDocument) {
-        return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
-      }
-      const doc = frame.contentDocument;
-      const normalize = (value) => String(value || '').replace(/\\s+/g, '').trim();
-      const groups = Array.from(doc.querySelectorAll('.check-box'));
-      const group = doc.querySelector('.check-box.degree')
-        || groups.find((item) => {
-          const set = new Set(
-            Array.from(item.querySelectorAll('.default.option, .options .option, .option'))
-              .map((node) => normalize(node.textContent))
-              .filter(Boolean)
-          );
-          return set.has('大专') || set.has('本科') || set.has('硕士') || set.has('博士');
-        });
-      if (!group) {
-        return { ok: false, error: 'GROUP_NOT_FOUND' };
-      }
-      const labels = ${JSON.stringify(DEGREE_OPTIONS)};
-      const activeLabels = labels.filter((label) => {
-        const node = Array.from(group.querySelectorAll('.options .option'))
-          .find((item) => normalize(item.textContent) === normalize(label));
-        return Boolean(node && node.classList.contains('active'));
-      });
-      const defaultOption = group.querySelector('.default.option');
-      return {
-        ok: true,
-        defaultActive: Boolean(defaultOption && defaultOption.classList.contains('active')),
-        activeLabels
-      };
-    })()`);
-  }
+  async getDegreeFilterState() {
+    return this.getFilterGroupState("degree");
+  }
+
+  async getGenderFilterState() {
+    return this.getFilterGroupState("gender");
+  }
+
+  async getRecentNotViewFilterState() {
+    return this.getFilterGroupState("recentNotView");
+  }
 
   async selectDegreeFilter(labels) {
     const ensure = await this.ensureGroupReady("degree");
@@ -1254,6 +1294,112 @@ class RecommendSearchCli {
 
     throw new Error(`DEGREE_FILTER_VERIFY_FAILED:${JSON.stringify(lastState || {})}`);
   }
+
+  buildGroupClassVerification(groupName, state, expectedLabels, availableOptions, sortFn) {
+    if (!state?.ok) {
+      return {
+        group: groupName,
+        ok: false,
+        reason: state?.error || "GROUP_STATE_UNAVAILABLE",
+        expected_labels: expectedLabels,
+        state: state || null
+      };
+    }
+
+    const expectedSorted = sortFn(uniqueNormalizedLabels(expectedLabels));
+    const expectedSet = new Set(expectedSorted);
+    const allowedSet = new Set(uniqueNormalizedLabels(availableOptions));
+    const optionMap = new Map();
+    for (const option of state.options || []) {
+      optionMap.set(normalizeText(option.label), option);
+    }
+
+    const selectedNotActive = [];
+    const unselectedButActive = [];
+    for (const label of expectedSorted) {
+      const option = optionMap.get(label);
+      if (!option || option.active !== true) {
+        selectedNotActive.push(label);
+      }
+    }
+    for (const label of allowedSet) {
+      if (expectedSet.has(label)) continue;
+      const option = optionMap.get(label);
+      if (option?.active === true) {
+        unselectedButActive.push(label);
+      }
+    }
+
+    const expectDefault = expectedSet.has("不限");
+    const defaultMismatch = expectDefault ? !state.defaultActive : Boolean(state.defaultActive);
+    const ok = (
+      selectedNotActive.length === 0
+      && unselectedButActive.length === 0
+      && !defaultMismatch
+    );
+
+    return {
+      group: groupName,
+      ok,
+      expected_labels: expectedSorted,
+      actual_active_labels: sortFn(uniqueNormalizedLabels(state.activeLabels || [])),
+      default_active: Boolean(state.defaultActive),
+      selected_not_active: selectedNotActive,
+      unselected_but_active: unselectedButActive,
+      default_mismatch: defaultMismatch,
+      options: state.options || []
+    };
+  }
+
+  async verifyFilterDomClassStates(expected) {
+    const schoolState = await this.getSchoolFilterState();
+    const degreeState = await this.getDegreeFilterState();
+    const genderState = await this.getGenderFilterState();
+    const recentState = await this.getRecentNotViewFilterState();
+
+    const checks = [
+      this.buildGroupClassVerification(
+        "school",
+        schoolState,
+        Array.isArray(expected?.schoolTag) && expected.schoolTag.length > 0 ? expected.schoolTag : ["不限"],
+        SCHOOL_TAG_OPTIONS,
+        sortSchoolSelection
+      ),
+      this.buildGroupClassVerification(
+        "degree",
+        degreeState,
+        Array.isArray(expected?.degree) && expected.degree.length > 0 ? expected.degree : ["不限"],
+        DEGREE_OPTIONS,
+        sortDegreeSelection
+      ),
+      this.buildGroupClassVerification(
+        "gender",
+        genderState,
+        [normalizeText(expected?.gender || "不限")],
+        GENDER_OPTIONS,
+        uniqueNormalizedLabels
+      ),
+      this.buildGroupClassVerification(
+        "recent_not_view",
+        recentState,
+        [normalizeText(expected?.recentNotView || "不限")],
+        RECENT_NOT_VIEW_OPTIONS,
+        uniqueNormalizedLabels
+      )
+    ];
+    const failures = checks.filter((item) => item.ok === false);
+    return {
+      ok: failures.length === 0,
+      checks,
+      failures,
+      states: {
+        school: schoolState,
+        degree: degreeState,
+        gender: genderState,
+        recent_not_view: recentState
+      }
+    };
+  }
 
   async countCandidates() {
     return this.evaluate(`(() => {
@@ -1350,8 +1496,15 @@ class RecommendSearchCli {
       await this.selectOption("gender", this.args.gender);
       await this.selectOption("recentNotView", this.args.recentNotView);
       await this.selectDegreeFilter(this.args.degree);
-      const verifiedSchoolState = await this.getSchoolFilterState();
-      const verifiedDegreeState = await this.getDegreeFilterState();
+      const domClassVerification = await this.verifyFilterDomClassStates({
+        schoolTag: this.args.schoolTag,
+        degree: this.args.degree,
+        gender: this.args.gender,
+        recentNotView: this.args.recentNotView
+      });
+      if (!domClassVerification.ok) {
+        throw new Error(`FILTER_DOM_CLASS_VERIFY_FAILED:${JSON.stringify(domClassVerification.failures)}`);
+      }
       await this.closeFilterPanel();
       const candidateInfo = await this.waitForCandidateCountStable();
 
@@ -1365,8 +1518,14 @@ class RecommendSearchCli {
             recent_not_view: this.args.recentNotView
           },
           verified_filters: {
-            school: verifiedSchoolState,
-            degree: verifiedDegreeState
+            school: domClassVerification.states.school,
+            degree: domClassVerification.states.degree,
+            gender: domClassVerification.states.gender,
+            recent_not_view: domClassVerification.states.recent_not_view,
+            dom_class_check: {
+              ok: domClassVerification.ok,
+              checks: domClassVerification.checks
+            }
           },
           selected_job: selectedJob,
           candidate_count: candidateInfo?.candidateCount ?? null,