@reconcrap/boss-recommend-mcp 2.1.24 → 2.1.25

package/src/domains/recommend/filters.js

@@ -764,7 +764,7 @@ export async function confirmFilterPanel(client, frameNodeId, {
   };
 }
 
-function normalizeStickyVerificationSpecs(options = {}) {
+function normalizeStickyVerificationSpecs(options = {}) {
   const source = Array.isArray(options.filterGroups) && options.filterGroups.length
     ? options.filterGroups
     : [options];
@@ -774,7 +774,18 @@ function normalizeStickyVerificationSpecs(options = {}) {
     selectAllLabels: spec.selectAllLabels !== false,
     allowUnlimited: spec.allowUnlimited === true
   })).filter((spec) => spec.group && spec.labels.length);
-}
+}
+
+function normalizeUniqueFilterLabels(labels = []) {
+  return [...new Set(labels.map(normalizeFilterOptionLabel).filter(Boolean))];
+}
+
+function activeFilterLabelsMatchRequestedExactly(requestedLabels = [], activeLabels = []) {
+  const requested = normalizeUniqueFilterLabels(requestedLabels);
+  const active = normalizeUniqueFilterLabels(activeLabels);
+  return requested.length === active.length
+    && requested.every((label) => active.includes(label));
+}
 
 function findUnavailableGroup(unavailableGroups = [], group = "") {
   return unavailableGroups.find((item) => item?.group === group) || null;
@@ -802,20 +813,27 @@ export async function verifyFilterGroupsSticky(client, frameNodeId, {
 } = {}) {
   const normalizedSpecs = specs.filter((spec) => spec?.group && Array.isArray(spec.labels) && spec.labels.length);
   const groups = [];
-  const availableSpecs = [];
-  for (const spec of normalizedSpecs) {
-    const unavailable = findUnavailableGroup(unavailableGroups, spec.group);
-    if (unavailable) {
-      groups.push({
-        group: spec.group,
-        requested_labels: spec.labels,
-        active_labels: [],
-        verified: true,
-        unavailable: true,
-        reason: unavailable.reason || "control_unavailable_default"
-      });
-    } else {
-      availableSpecs.push(spec);
+  const availableSpecs = [];
+  for (const spec of normalizedSpecs) {
+    const unavailable = findUnavailableGroup(unavailableGroups, spec.group);
+    if (unavailable) {
+      const requestedLabels = normalizeUniqueFilterLabels(spec.labels);
+      const reason = unavailable.reason || "control_unavailable_default";
+      const unavailableDefaultVerified = spec.group === RECOMMEND_ACTIVITY_GROUP
+        && spec.allowUnlimited === true
+        && requestedLabels.length === 1
+        && requestedLabels[0] === normalizeFilterOptionLabel("不限")
+        && /control_unavailable_default$/.test(reason);
+      groups.push({
+        group: spec.group,
+        requested_labels: requestedLabels,
+        active_labels: [],
+        verified: unavailableDefaultVerified,
+        unavailable: true,
+        reason
+      });
+    } else {
+      availableSpecs.push(spec);
     }
   }
 
@@ -824,18 +842,18 @@ export async function verifyFilterGroupsSticky(client, frameNodeId, {
   if (availableSpecs.length) {
     reopen = await openFilterPanel(client, frameNodeId);
     for (const spec of availableSpecs) {
-      const options = await listFilterOptions(client, frameNodeId, {
-        groupOrder: [spec.group]
-      });
-      const requestedLabels = spec.labels.map(normalizeFilterOptionLabel).filter(Boolean);
-      const activeLabels = options
-        .filter((option) => option.group === spec.group && option.active)
-        .map((option) => normalizeFilterOptionLabel(option.label));
-      const verified = spec.selectAllLabels === false
-        ? requestedLabels.length === 1
-          && activeLabels.length === 1
-          && activeLabels[0] === requestedLabels[0]
-        : requestedLabels.every((label) => activeLabels.includes(label));
+      const options = await listFilterOptions(client, frameNodeId, {
+        groupOrder: [spec.group]
+      });
+      const requestedLabels = normalizeUniqueFilterLabels(spec.labels);
+      const activeLabels = normalizeUniqueFilterLabels(options
+        .filter((option) => option.group === spec.group && option.active)
+        .map((option) => option.label));
+      const verified = requestedLabels.length > 0 && (
+        spec.selectAllLabels === false
+          ? activeLabels.length === 1 && requestedLabels.includes(activeLabels[0])
+          : activeFilterLabelsMatchRequestedExactly(requestedLabels, activeLabels)
+      );
       groups.push({
         group: spec.group,
         requested_labels: requestedLabels,

package/src/domains/recommend/jobs.js

@@ -36,17 +36,46 @@ function trimSalarySuffix(label) {
   return stripSalaryText(label);
 }
 
+function splitStructuredJobLabel(label) {
+  const withoutSalary = normalizeText(stripSalaryText(label));
+  const separatorIndex = withoutSalary.lastIndexOf(" _ ");
+  if (separatorIndex < 0) {
+    return {
+      full: normalizeJobText(withoutSalary),
+      role: normalizeJobText(withoutSalary),
+      location: ""
+    };
+  }
+  return {
+    full: normalizeJobText(withoutSalary),
+    role: normalizeJobText(withoutSalary.slice(0, separatorIndex)),
+    location: normalizeJobText(withoutSalary.slice(separatorIndex + 3))
+  };
+}
+
 export function jobLabelMatches(optionLabel, targetLabel) {
   const option = normalizeJobText(optionLabel);
   const target = normalizeJobText(targetLabel);
   const optionWithoutSalary = normalizeJobText(stripSalaryText(optionLabel));
   const targetWithoutSalary = normalizeJobText(stripSalaryText(targetLabel));
   if (!option || !target) return false;
-  return option === target
-    || option.startsWith(target)
+  if (option === target
     || optionWithoutSalary === target
     || option === targetWithoutSalary
-    || optionWithoutSalary === targetWithoutSalary;
+    || optionWithoutSalary === targetWithoutSalary) {
+    return true;
+  }
+
+  const optionParts = splitStructuredJobLabel(optionLabel);
+  const targetParts = splitStructuredJobLabel(targetLabel);
+  // A caller may provide only the role name while Boss renders the option as
+  // "role _ city [salary]".  Accept only that structured metadata suffix;
+  // never restore arbitrary startsWith matching between two role names.
+  return Boolean(
+    !targetParts.location
+    && optionParts.location
+    && optionParts.role === targetParts.role
+  );
 }
 
 function isVisibleBox(box) {

package/src/domains/recommend/location.js

@@ -478,40 +478,84 @@ async function openRecommendLocationPopover(client, frameNodeId, {
   };
 }
 
-async function confirmRecommendLocationPopover(client, frameNodeId, {
-  timeoutMs = 1800,
-  intervalMs = 150,
-  controlNodeId
-} = {}) {
+async function confirmRecommendLocationPopover(client, frameNodeId, {
+  timeoutMs = 1800,
+  intervalMs = 150,
+  controlNodeId,
+  stableCloseMs = 300
+} = {}) {
   const candidates = await findExactLocationConfirmCandidates(client, frameNodeId, { controlNodeId });
   if (!candidates.length) {
     throw new Error("Recommend location exact 确认 button was not found");
   }
-  const clickErrors = [];
-  for (const candidate of candidates) {
-    try {
-      const box = await clickNodeCenter(client, candidate.node_id, DETERMINISTIC_CLICK_OPTIONS);
-      const started = Date.now();
-      while (Date.now() - started <= timeoutMs) {
-        const control = await findRecommendCurrentCityControl(client, frameNodeId);
-        if (!control) {
-          return {
-            confirmed: true,
-            label: "确认",
-            node_id: candidate.node_id,
-            box
-          };
-        }
-        if (intervalMs > 0) await sleep(intervalMs);
-      }
-    } catch (error) {
-      clickErrors.push({
-        node_id: candidate.node_id,
-        message: error?.message || String(error)
-      });
-    }
-  }
-  const error = new Error("Recommend location popover did not close after exact 确认 click");
+  const clickErrors = [];
+  for (const candidate of candidates) {
+    let box;
+    try {
+      box = await clickNodeCenter(client, candidate.node_id, DETERMINISTIC_CLICK_OPTIONS);
+    } catch (error) {
+      clickErrors.push({
+        node_id: candidate.node_id,
+        message: error?.message || String(error)
+      });
+      continue;
+    }
+
+    const started = Date.now();
+    const requiredStableCloseMs = Math.max(0, Number(stableCloseMs) || 0);
+    let absentSince = null;
+    let absentObservations = 0;
+    let lastObservation = null;
+    while (Date.now() - started <= timeoutMs) {
+      try {
+        const [control, popover] = await Promise.all([
+          findRecommendCurrentCityControl(client, frameNodeId),
+          findVisibleRecommendLocationPopover(client, frameNodeId)
+        ]);
+        const observedAt = Date.now();
+        lastObservation = {
+          control_visible: Boolean(control),
+          popover_visible: Boolean(popover),
+          observed_after_ms: observedAt - started
+        };
+        if (!control && !popover) {
+          absentSince ??= observedAt;
+          absentObservations += 1;
+          if (observedAt - absentSince >= requiredStableCloseMs) {
+            return {
+              confirmed: true,
+              label: "确认",
+              node_id: candidate.node_id,
+              box,
+              stable_close_ms: observedAt - absentSince,
+              stable_close_observations: absentObservations,
+              control_absent: true,
+              popover_invisible: true
+            };
+          }
+        } else {
+          absentSince = null;
+          absentObservations = 0;
+        }
+      } catch (error) {
+        const uncertain = new Error("Recommend location popover close state was uncertain after exact 确认 click");
+        uncertain.cause = error;
+        uncertain.confirm_node_id = candidate.node_id;
+        uncertain.last_observation = lastObservation;
+        throw uncertain;
+      }
+      if (intervalMs > 0) await sleep(intervalMs);
+    }
+
+    const error = new Error("Recommend location popover did not close after exact 确认 click");
+    error.confirm_node_id = candidate.node_id;
+    error.last_observation = lastObservation;
+    error.stable_close_ms = absentSince === null ? 0 : Date.now() - absentSince;
+    error.stable_close_observations = absentObservations;
+    error.click_errors = clickErrors;
+    throw error;
+  }
+  const error = new Error("Recommend location popover did not close after exact 确认 click");
   error.click_errors = clickErrors;
   throw error;
 }
@@ -575,14 +619,15 @@ function unavailableResult({ requested, currentCityLabel, reason, attempts }) {
   };
 }
 
-export async function ensureRecommendCurrentCityOnly(client, frameNodeId, {
-  enabled = false,
-  timeoutMs = 1800,
-  intervalMs = 150,
-  attemptsLimit = 2,
-  openAttemptsLimit = 3,
-  settleMs = 250
-} = {}) {
+export async function ensureRecommendCurrentCityOnly(client, frameNodeId, {
+  enabled = false,
+  timeoutMs = 1800,
+  intervalMs = 150,
+  attemptsLimit = 2,
+  openAttemptsLimit = 3,
+  settleMs = 250,
+  closeStableMs = 300
+} = {}) {
   const requested = enabled === true;
   const attempts = [];
   for (let attempt = 1; attempt <= attemptsLimit; attempt += 1) {
@@ -646,10 +691,11 @@ export async function ensureRecommendCurrentCityOnly(client, frameNodeId, {
         }
       }
       const afterToggle = compactControlState(afterToggleControl);
-      const confirmation = await confirmRecommendLocationPopover(client, frameNodeId, {
-        timeoutMs,
-        intervalMs,
-        controlNodeId: afterToggleControl.node_id
+      const confirmation = await confirmRecommendLocationPopover(client, frameNodeId, {
+        timeoutMs,
+        intervalMs,
+        controlNodeId: afterToggleControl.node_id,
+        stableCloseMs: closeStableMs
       });
       if (!confirmation.confirmed) {
         throw new Error("Recommend location state was not confirmed");
@@ -668,10 +714,11 @@ export async function ensureRecommendCurrentCityOnly(client, frameNodeId, {
         throw new Error("Recommend current-city checkbox was visible but unreadable during sticky verification");
       }
       const actual = reopened.control.state.checked;
-      const stickyClose = await confirmRecommendLocationPopover(client, frameNodeId, {
-        timeoutMs,
-        intervalMs,
-        controlNodeId: reopened.control.node_id
+      const stickyClose = await confirmRecommendLocationPopover(client, frameNodeId, {
+        timeoutMs,
+        intervalMs,
+        controlNodeId: reopened.control.node_id,
+        stableCloseMs: closeStableMs
       });
       if (!stickyClose.confirmed) {
         throw new Error("Recommend location sticky verification was not confirmed");