@reconcrap/boss-recommend-mcp 1.0.1 → 1.0.3

package/package.json

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

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

@@ -76,9 +76,25 @@ function normalizeDegree(value) {
   return DEGREE_OPTIONS.includes(normalized) ? normalized : null;
 }
 
-function sortDegreeSelection(values) {
-  return Array.from(new Set(values.filter(Boolean))).sort((left, right) => DEGREE_ORDER.indexOf(left) - DEGREE_ORDER.indexOf(right));
-}
+function sortDegreeSelection(values) {
+  return Array.from(new Set(values.filter(Boolean))).sort((left, right) => DEGREE_ORDER.indexOf(left) - DEGREE_ORDER.indexOf(right));
+}
+
+function selectionEquals(left, right) {
+  if (!Array.isArray(left) || !Array.isArray(right)) return false;
+  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);
@@ -1077,141 +1093,313 @@ 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 selectSchoolFilter(labels) {
-    const ensure = await this.ensureGroupReady("school");
-    if (!ensure?.ok) {
-      throw new Error(ensure?.error || "GROUP_NOT_FOUND");
-    }
-
-    const targetLabels = Array.isArray(labels) && labels.length > 0 ? labels : ["不限"];
-    if (targetLabels.includes("不限")) {
-      await this.selectOption("school", "不限");
-      return;
-    }
-
-    const currentState = await this.getSchoolFilterState();
-    if (!currentState?.ok) {
-      throw new Error(currentState?.error || "SCHOOL_FILTER_STATE_FAILED");
-    }
-    const current = sortSchoolSelection(currentState.activeLabels || []);
-    const desired = sortSchoolSelection(targetLabels);
-    const same =
-      !currentState.defaultActive
-      && current.length === desired.length
-      && current.every((value, index) => value === desired[index]);
-    if (same) return;
-
-    await this.selectOption("school", "不限");
-    for (const label of desired) {
-      await this.selectOption("school", label);
-    }
-  }
-
-  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 selectDegreeFilter(labels) {
-    const ensure = await this.ensureGroupReady("degree");
-    if (!ensure?.ok) {
-      throw new Error(ensure?.error || "GROUP_NOT_FOUND");
-    }
+  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");
+  }
 
-    const targetLabels = Array.isArray(labels) && labels.length > 0 ? labels : ["不限"];
-    if (targetLabels.includes("不限")) {
-      await this.selectOption("degree", "不限");
-      return;
-    }
+  async selectSchoolFilter(labels) {
+    const ensure = await this.ensureGroupReady("school");
+    if (!ensure?.ok) {
+      throw new Error(ensure?.error || "GROUP_NOT_FOUND");
+    }
+
+    const targetLabels = Array.isArray(labels) && labels.length > 0 ? labels : ["不限"];
+    const desired = sortSchoolSelection(targetLabels);
+    const expectDefaultOnly = desired.includes("不限");
+    let lastState = null;
+
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      const state = await this.getSchoolFilterState();
+      if (!state?.ok) {
+        throw new Error(state?.error || "SCHOOL_FILTER_STATE_FAILED");
+      }
+      lastState = state;
+      const current = sortSchoolSelection(state.activeLabels || []);
+      const matched = expectDefaultOnly
+        ? Boolean(state.defaultActive)
+        : (!state.defaultActive && selectionEquals(current, desired));
+      if (matched) {
+        return;
+      }
+
+      if (expectDefaultOnly) {
+        await this.selectOption("school", "不限");
+        await sleep(humanDelay(180, 50));
+        continue;
+      }
+
+      if (state.defaultActive) {
+        const clearDefault = await this.clickOptionBySelector("school", "不限");
+        if (!clearDefault?.ok) {
+          throw new Error(clearDefault?.error || "SCHOOL_DEFAULT_CLEAR_FAILED");
+        }
+        await sleep(humanDelay(180, 50));
+      }
+      for (const label of desired) {
+        await this.selectOption("school", label);
+        await sleep(humanDelay(120, 40));
+      }
+      await sleep(humanDelay(180, 50));
+    }
+
+    throw new Error(`SCHOOL_FILTER_VERIFY_FAILED:${JSON.stringify(lastState || {})}`);
+  }
 
-    const currentState = await this.getDegreeFilterState();
-    if (!currentState?.ok) {
-      throw new Error(currentState?.error || "DEGREE_FILTER_STATE_FAILED");
-    }
-    const current = sortDegreeSelection(currentState.activeLabels || []);
-    const desired = sortDegreeSelection(targetLabels);
-    const same =
-      !currentState.defaultActive
-      && current.length === desired.length
-      && current.every((value, index) => value === desired[index]);
-    if (same) return;
+  async getDegreeFilterState() {
+    return this.getFilterGroupState("degree");
+  }
+
+  async getGenderFilterState() {
+    return this.getFilterGroupState("gender");
+  }
+
+  async getRecentNotViewFilterState() {
+    return this.getFilterGroupState("recentNotView");
+  }
 
-    await this.selectOption("degree", "不限");
-    for (const label of desired) {
-      await this.selectOption("degree", label);
-    }
-  }
+  async selectDegreeFilter(labels) {
+    const ensure = await this.ensureGroupReady("degree");
+    if (!ensure?.ok) {
+      throw new Error(ensure?.error || "GROUP_NOT_FOUND");
+    }
+
+    const targetLabels = Array.isArray(labels) && labels.length > 0 ? labels : ["不限"];
+    const desired = sortDegreeSelection(targetLabels);
+    const expectDefaultOnly = desired.includes("不限");
+    let lastState = null;
+
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      const state = await this.getDegreeFilterState();
+      if (!state?.ok) {
+        throw new Error(state?.error || "DEGREE_FILTER_STATE_FAILED");
+      }
+      lastState = state;
+      const current = sortDegreeSelection(state.activeLabels || []);
+      const matched = expectDefaultOnly
+        ? Boolean(state.defaultActive)
+        : (!state.defaultActive && selectionEquals(current, desired));
+      if (matched) {
+        return;
+      }
+
+      if (expectDefaultOnly) {
+        await this.selectOption("degree", "不限");
+        await sleep(humanDelay(180, 50));
+        continue;
+      }
+
+      if (state.defaultActive) {
+        const clearDefault = await this.clickOptionBySelector("degree", "不限");
+        if (!clearDefault?.ok) {
+          throw new Error(clearDefault?.error || "DEGREE_DEFAULT_CLEAR_FAILED");
+        }
+        await sleep(humanDelay(180, 50));
+      }
+      for (const label of desired) {
+        await this.selectOption("degree", label);
+        await sleep(humanDelay(120, 40));
+      }
+      await sleep(humanDelay(180, 50));
+    }
+
+    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(`(() => {
@@ -1306,20 +1494,39 @@ class RecommendSearchCli {
       await this.openFilterPanel();
       await this.selectSchoolFilter(this.args.schoolTag);
       await this.selectOption("gender", this.args.gender);
-      await this.selectOption("recentNotView", this.args.recentNotView);
-      await this.selectDegreeFilter(this.args.degree);
-      await this.closeFilterPanel();
-      const candidateInfo = await this.waitForCandidateCountStable();
-
-      console.log(JSON.stringify({
-        status: "COMPLETED",
-        result: {
+      await this.selectOption("recentNotView", this.args.recentNotView);
+      await this.selectDegreeFilter(this.args.degree);
+      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();
+
+      console.log(JSON.stringify({
+        status: "COMPLETED",
+        result: {
           applied_filters: {
             school_tag: this.args.schoolTag,
             degree: this.args.degree,
             gender: this.args.gender,
             recent_not_view: this.args.recentNotView
           },
+          verified_filters: {
+            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,
           page_state: {