@reconcrap/boss-recommend-mcp 2.1.23 → 2.1.25

package/src/core/greet-quota/index.js

@@ -1,71 +1,71 @@
-import { normalizeText } from "../screening/index.js";
-
-export const GREET_CREDITS_EXHAUSTED_CODE = "GREET_CREDITS_EXHAUSTED";
-
-function coerceQuota(quota) {
-  if (!quota || typeof quota !== "object") return null;
-  return {
-    found: Boolean(quota.found),
-    text: normalizeText(quota.text),
-    numerator: Number.isFinite(Number(quota.numerator)) ? Number(quota.numerator) : null,
-    denominator: Number.isFinite(Number(quota.denominator)) ? Number(quota.denominator) : null,
-    exhausted: Boolean(quota.exhausted)
-  };
-}
-
-export function parseGreetQuota(label = "") {
-  const text = normalizeText(label);
-  const match = text.match(/立即沟通\s*[\(（]\s*(\d+)\s*[/／]\s*(\d+)\s*[\)）]/);
-  if (!match) {
-    return {
-      found: false,
-      text,
-      numerator: null,
-      denominator: null,
-      exhausted: false
-    };
-  }
-  const numerator = Number(match[1]);
-  const denominator = Number(match[2]);
-  return {
-    found: true,
-    text,
-    numerator,
-    denominator,
-    exhausted: numerator > denominator
-  };
-}
-
-export function normalizeGreetQuotaSource(source = "") {
-  return coerceQuota(source) || parseGreetQuota(source);
-}
-
-export function assertGreetQuotaAvailable(source = "") {
-  const quota = normalizeGreetQuotaSource(source);
-  if (quota.exhausted) {
-    const error = new Error(
-      `Greet credits exhausted according to Boss quota text: ${quota.numerator}/${quota.denominator}`
-    );
-    error.code = GREET_CREDITS_EXHAUSTED_CODE;
-    error.greet_quota = quota;
-    throw error;
-  }
-  return quota;
-}
-
-export function describeGreetQuotaAfterSpend(source = "") {
-  const quota = normalizeGreetQuotaSource(source);
-  if (!quota.found || quota.numerator === null || quota.denominator === null) {
-    return {
-      ...quota,
-      remaining_after_spend: null,
-      exhausted_after_spend: false
-    };
-  }
-  const remaining = quota.denominator - quota.numerator;
-  return {
-    ...quota,
-    remaining_after_spend: remaining,
-    exhausted_after_spend: remaining < quota.numerator
-  };
-}
+import { normalizeText } from "../screening/index.js";
+
+export const GREET_CREDITS_EXHAUSTED_CODE = "GREET_CREDITS_EXHAUSTED";
+
+function coerceQuota(quota) {
+  if (!quota || typeof quota !== "object") return null;
+  return {
+    found: Boolean(quota.found),
+    text: normalizeText(quota.text),
+    numerator: Number.isFinite(Number(quota.numerator)) ? Number(quota.numerator) : null,
+    denominator: Number.isFinite(Number(quota.denominator)) ? Number(quota.denominator) : null,
+    exhausted: Boolean(quota.exhausted)
+  };
+}
+
+export function parseGreetQuota(label = "") {
+  const text = normalizeText(label);
+  const match = text.match(/立即沟通\s*[\(（]\s*(\d+)\s*[/／]\s*(\d+)\s*[\)）]/);
+  if (!match) {
+    return {
+      found: false,
+      text,
+      numerator: null,
+      denominator: null,
+      exhausted: false
+    };
+  }
+  const numerator = Number(match[1]);
+  const denominator = Number(match[2]);
+  return {
+    found: true,
+    text,
+    numerator,
+    denominator,
+    exhausted: numerator > denominator
+  };
+}
+
+export function normalizeGreetQuotaSource(source = "") {
+  return coerceQuota(source) || parseGreetQuota(source);
+}
+
+export function assertGreetQuotaAvailable(source = "") {
+  const quota = normalizeGreetQuotaSource(source);
+  if (quota.exhausted) {
+    const error = new Error(
+      `Greet credits exhausted according to Boss quota text: ${quota.numerator}/${quota.denominator}`
+    );
+    error.code = GREET_CREDITS_EXHAUSTED_CODE;
+    error.greet_quota = quota;
+    throw error;
+  }
+  return quota;
+}
+
+export function describeGreetQuotaAfterSpend(source = "") {
+  const quota = normalizeGreetQuotaSource(source);
+  if (!quota.found || quota.numerator === null || quota.denominator === null) {
+    return {
+      ...quota,
+      remaining_after_spend: null,
+      exhausted_after_spend: false
+    };
+  }
+  const remaining = quota.denominator - quota.numerator;
+  return {
+    ...quota,
+    remaining_after_spend: remaining,
+    exhausted_after_spend: remaining < quota.numerator
+  };
+}

package/src/core/infinite-list/index.js

@@ -889,13 +889,13 @@ export async function detectInfiniteListBottomMarker(client, {
   };
 }
 
-export async function readVisibleInfiniteListItems({
-  nodeIds = [],
-  readCandidate,
-  keyForCandidate = candidateKeyFromProfile,
-  state = null,
-  shouldRethrowReadError = null
-} = {}) {
+export async function readVisibleInfiniteListItems({
+  nodeIds = [],
+  readCandidate,
+  keyForCandidate = candidateKeyFromProfile,
+  state = null,
+  shouldRethrowReadError = null
+} = {}) {
   if (typeof readCandidate !== "function") {
     throw new Error("readVisibleInfiniteListItems requires readCandidate");
   }
@@ -905,25 +905,25 @@ export async function readVisibleInfiniteListItems({
     let candidate;
     try {
       candidate = await readCandidate(nodeId, { visibleIndex });
-    } catch (error) {
-      if (state) {
-        state.read_error_count = (state.read_error_count || 0) + 1;
+    } catch (error) {
+      if (state) {
+        state.read_error_count = (state.read_error_count || 0) + 1;
         state.ledger?.push({
           at: nowIso(),
           event: "candidate_read_error",
           node_id: nodeId,
           visible_index: visibleIndex,
-          error: error?.message || String(error)
-        });
-      }
-      if (
-        typeof shouldRethrowReadError === "function"
-        && shouldRethrowReadError(error, { nodeId, visibleIndex })
-      ) {
-        throw error;
-      }
-      continue;
-    }
+          error: error?.message || String(error)
+        });
+      }
+      if (
+        typeof shouldRethrowReadError === "function"
+        && shouldRethrowReadError(error, { nodeId, visibleIndex })
+      ) {
+        throw error;
+      }
+      continue;
+    }
     const key = keyForCandidate(candidate, {
       nodeId,
       visibleIndex,
@@ -1139,9 +1139,9 @@ export async function getNextInfiniteListCandidate({
   state,
   findNodeIds,
   readCandidate,
-  detectBottomMarker = null,
-  keyForCandidate = candidateKeyFromProfile,
-  shouldRethrowReadError = null,
+  detectBottomMarker = null,
+  keyForCandidate = candidateKeyFromProfile,
+  shouldRethrowReadError = null,
   maxScrolls = 20,
   stableSignatureLimit = 2,
   minScrollsBeforeEnd = 3,
@@ -1164,13 +1164,13 @@ export async function getNextInfiniteListCandidate({
   const maxAttempts = Math.max(0, Number(maxScrolls) || 0);
   for (let scrollAttempt = 0; scrollAttempt <= maxAttempts; scrollAttempt += 1) {
     const nodeIds = await findNodeIds();
-    const items = await readVisibleInfiniteListItems({
-      nodeIds,
-      readCandidate,
-      keyForCandidate,
-      state,
-      shouldRethrowReadError
-    });
+    const items = await readVisibleInfiniteListItems({
+      nodeIds,
+      readCandidate,
+      keyForCandidate,
+      state,
+      shouldRethrowReadError
+    });
     const signature = updateInfiniteListVisibleSignature(state, items);
     const next = firstUnseenInfiniteListItem(state, items);
     attempts.push({

package/src/core/reporting/legacy-csv.js

@@ -41,18 +41,18 @@ export const LEGACY_RESULT_HEADER = [
 ];
 
 const SEARCH_PARAM_ORDER = [
-  "school_tag",
-  "degree",
-  "degrees",
-  "gender",
-  "recent_not_view",
-  "current_city_only",
-  "activity_level",
-  "city",
-  "schools",
-  "keyword",
-  "filter_recent_viewed",
-  "skip_recent_colleague_contacted",
+  "school_tag",
+  "degree",
+  "degrees",
+  "gender",
+  "recent_not_view",
+  "current_city_only",
+  "activity_level",
+  "city",
+  "schools",
+  "keyword",
+  "filter_recent_viewed",
+  "skip_recent_colleague_contacted",
   "job",
   "start_from",
   "target_count",

package/src/core/run/detached-launcher.js

@@ -0,0 +1,305 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const WINDOWS_WRAPPER_PATH = fileURLToPath(new URL("./windows-detached-worker.ps1", import.meta.url));
+const SAFE_DOMAIN_PATTERN = /^[a-z][a-z0-9_-]{0,31}$/;
+const SAFE_RUN_ID_PATTERN = /^[A-Za-z0-9._-]+$/;
+const SAFE_DOMAINS = new Set(["chat", "recommend", "recruit"]);
+
+function createLauncherError(code, message, cause = null) {
+  const error = new Error(message);
+  error.code = code;
+  if (cause) error.cause = cause;
+  return error;
+}
+
+function ensureLogFile(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.closeSync(fs.openSync(filePath, "a"));
+}
+
+function assertControlledPath(value, label, platform) {
+  const normalized = String(value || "");
+  const pathApi = platform === "win32" ? path.win32 : path;
+  if (!normalized || !pathApi.isAbsolute(normalized)) {
+    throw createLauncherError("DETACHED_WORKER_PATH_INVALID", `${label} must be an absolute path`);
+  }
+  if (/[\0\r\n"]/.test(normalized)) {
+    throw createLauncherError("DETACHED_WORKER_PATH_INVALID", `${label} contains unsupported characters`);
+  }
+  return normalized;
+}
+
+function assertControlledToken(value, label, pattern) {
+  const normalized = String(value || "");
+  if (!pattern.test(normalized)) {
+    throw createLauncherError("DETACHED_WORKER_ARGUMENT_INVALID", `${label} contains unsupported characters`);
+  }
+  return normalized;
+}
+
+export function quoteWindowsCommandLineArgument(value) {
+  const input = String(value ?? "");
+  if (input.includes("\0")) {
+    throw createLauncherError("DETACHED_WORKER_ARGUMENT_INVALID", "Windows command-line arguments cannot contain NUL");
+  }
+  if (input && !/[\s"]/.test(input)) return input;
+  let output = '"';
+  let backslashes = 0;
+  for (const character of input) {
+    if (character === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (character === '"') {
+      output += "\\".repeat((backslashes * 2) + 1);
+      output += '"';
+      backslashes = 0;
+      continue;
+    }
+    output += "\\".repeat(backslashes);
+    output += character;
+    backslashes = 0;
+  }
+  output += "\\".repeat(backslashes * 2);
+  output += '"';
+  return output;
+}
+
+function quotePowerShellLiteral(value) {
+  return `'${String(value ?? "").replaceAll("'", "''")}'`;
+}
+
+function windowsPowerShellPath(environment = process.env) {
+  const systemRoot = String(environment?.SystemRoot || environment?.WINDIR || "").trim();
+  return systemRoot
+    ? path.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+    : "powershell.exe";
+}
+
+export function buildWindowsDetachedWorkerCommand({
+  powershellPath,
+  wrapperScriptPath,
+  nodePath,
+  workerScriptPath,
+  domain,
+  runId,
+  stdoutPath,
+  stderrPath,
+  chatRuntimeHomePath = "",
+  screenConfigPath = ""
+}) {
+  const args = [
+    powershellPath,
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-WindowStyle",
+    "Hidden",
+    "-File",
+    wrapperScriptPath,
+    "-NodePath",
+    nodePath,
+    "-WorkerScriptPath",
+    workerScriptPath,
+    "-Domain",
+    domain,
+    "-RunId",
+    runId,
+    "-StdoutPath",
+    stdoutPath,
+    "-StderrPath",
+    stderrPath
+  ];
+  if (chatRuntimeHomePath) {
+    args.push("-ChatRuntimeHomePath", chatRuntimeHomePath);
+  }
+  if (screenConfigPath) {
+    args.push("-ScreenConfigPath", screenConfigPath);
+  }
+  return args.map(quoteWindowsCommandLineArgument).join(" ");
+}
+
+export function buildWindowsCimEncodedCommand(commandLine) {
+  const script = [
+    "$ErrorActionPreference = 'Stop'",
+    `$commandLine = ${quotePowerShellLiteral(commandLine)}`,
+    "$result = Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{ CommandLine = $commandLine }",
+    "$payload = [ordered]@{ return_value = [int]$result.ReturnValue; process_id = [int]$result.ProcessId }",
+    "[Console]::Out.Write(($payload | ConvertTo-Json -Compress))",
+    "if ([int]$result.ReturnValue -ne 0) { exit 1 }"
+  ].join("; ");
+  return Buffer.from(script, "utf16le").toString("base64");
+}
+
+function parseCimPayload(stdout = "") {
+  const lines = String(stdout || "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    try {
+      const parsed = JSON.parse(lines[index]);
+      if (parsed && typeof parsed === "object") return parsed;
+    } catch {
+      // PowerShell may emit non-JSON diagnostics before the compact payload.
+    }
+  }
+  return null;
+}
+
+function launchWindowsDetachedWorker(options) {
+  const {
+    nodePath,
+    workerScriptPath,
+    domain,
+    runId,
+    stdoutPath,
+    stderrPath,
+    chatRuntimeHomePath,
+    screenConfigPath,
+    wrapperScriptPath = WINDOWS_WRAPPER_PATH,
+    powershellPath = windowsPowerShellPath(options.environment),
+    spawnSyncImpl = spawnSync
+  } = options;
+  const commandLine = buildWindowsDetachedWorkerCommand({
+    powershellPath,
+    wrapperScriptPath,
+    nodePath,
+    workerScriptPath,
+    domain,
+    runId,
+    stdoutPath,
+    stderrPath,
+    chatRuntimeHomePath,
+    screenConfigPath
+  });
+  const encodedCommand = buildWindowsCimEncodedCommand(commandLine);
+  const result = spawnSyncImpl(powershellPath, [
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-EncodedCommand",
+    encodedCommand
+  ], {
+    encoding: "utf8",
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result?.error) {
+    throw createLauncherError(
+      "WINDOWS_CIM_LAUNCH_FAILED",
+      `Unable to invoke the Windows detached-worker launcher: ${result.error.message || result.error}`,
+      result.error
+    );
+  }
+  const payload = parseCimPayload(result?.stdout);
+  const returnValue = Number(payload?.return_value);
+  const workerPid = Number(payload?.process_id);
+  if (Number.isFinite(returnValue) && returnValue !== 0) {
+    throw createLauncherError(
+      "WINDOWS_CIM_CREATE_FAILED",
+      `Win32_Process.Create returned ${returnValue} while launching the detached worker.`
+    );
+  }
+  if (result?.signal || !Number.isInteger(result?.status) || result.status !== 0) {
+    const stderr = String(result?.stderr || "").trim();
+    throw createLauncherError(
+      "WINDOWS_CIM_LAUNCH_FAILED",
+      stderr || `PowerShell CIM launcher exited with status ${result?.status ?? "unknown"}.`
+    );
+  }
+  if (!Number.isInteger(workerPid) || workerPid <= 0 || returnValue !== 0) {
+    throw createLauncherError(
+      "WINDOWS_CIM_RESULT_INVALID",
+      "Win32_Process.Create did not return a valid detached worker PID."
+    );
+  }
+  return {
+    pid: workerPid,
+    unref() {}
+  };
+}
+
+function launchPosixDetachedWorker({
+  nodePath,
+  workerScriptPath,
+  domain,
+  runId,
+  stdoutPath,
+  stderrPath,
+  spawnImpl = spawn,
+  environment = process.env
+}) {
+  const stdoutFd = fs.openSync(stdoutPath, "a");
+  const stderrFd = fs.openSync(stderrPath, "a");
+  try {
+    return spawnImpl(nodePath, [
+      workerScriptPath,
+      "--domain",
+      domain,
+      "--run-id",
+      runId
+    ], {
+      detached: true,
+      stdio: ["ignore", stdoutFd, stderrFd],
+      windowsHide: true,
+      env: environment
+    });
+  } finally {
+    fs.closeSync(stdoutFd);
+    fs.closeSync(stderrFd);
+  }
+}
+
+export function launchDetachedWorker(options = {}) {
+  const platform = String(options.platform || process.platform);
+  const nodePath = assertControlledPath(options.nodePath || process.execPath, "nodePath", platform);
+  const workerScriptPath = assertControlledPath(options.workerScriptPath, "workerScriptPath", platform);
+  const stdoutPath = assertControlledPath(options.stdoutPath, "stdoutPath", platform);
+  const stderrPath = assertControlledPath(options.stderrPath, "stderrPath", platform);
+  const domain = assertControlledToken(options.domain, "domain", SAFE_DOMAIN_PATTERN);
+  if (!SAFE_DOMAINS.has(domain)) {
+    throw createLauncherError("DETACHED_WORKER_ARGUMENT_INVALID", "domain is not supported by the detached launcher");
+  }
+  const runId = assertControlledToken(options.runId, "runId", SAFE_RUN_ID_PATTERN);
+  const wrapperScriptPath = platform === "win32"
+    ? assertControlledPath(options.wrapperScriptPath || WINDOWS_WRAPPER_PATH, "wrapperScriptPath", platform)
+    : options.wrapperScriptPath;
+  const chatRuntimeHomePath = options.chatRuntimeHomePath
+    ? assertControlledPath(options.chatRuntimeHomePath, "chatRuntimeHomePath", platform)
+    : "";
+  const screenConfigPath = options.screenConfigPath
+    ? assertControlledPath(options.screenConfigPath, "screenConfigPath", platform)
+    : "";
+  const prepareLogFile = typeof options.prepareLogFileImpl === "function"
+    ? options.prepareLogFileImpl
+    : ensureLogFile;
+  prepareLogFile(stdoutPath);
+  prepareLogFile(stderrPath);
+  const normalized = {
+    ...options,
+    platform,
+    nodePath,
+    workerScriptPath,
+    stdoutPath,
+    stderrPath,
+    domain,
+    runId,
+    wrapperScriptPath,
+    chatRuntimeHomePath,
+    screenConfigPath
+  };
+  return platform === "win32"
+    ? launchWindowsDetachedWorker(normalized)
+    : launchPosixDetachedWorker(normalized);
+}
+
+export const __testables = {
+  WINDOWS_WRAPPER_PATH,
+  parseCimPayload,
+  quotePowerShellLiteral,
+  windowsPowerShellPath
+};