@reconcrap/boss-recommend-mcp 2.0.56 → 2.1.0

package/src/cli.js

@@ -63,12 +63,13 @@ const installConfigDefaults = Object.freeze({
   llmMaxRetries: 3,
   llmImageLimit: 8,
   llmImageDetail: "low",
-  humanRestEnabled: true,
-  humanBehavior: {
-    enabled: true,
-    profile: "paced_with_rests"
-  }
-});
+  humanRestEnabled: true,
+  humanBehavior: {
+    enabled: true,
+    profile: "paced_with_rests",
+    restLevel: "low"
+  }
+});
 const bossChatRuntimeChildDirs = ["logs", "runs", "profiles", "reports", "artifacts", "state"];
 const bossChatCliUnsupportedStartCode = "CHAT_CLI_ASYNC_UNSUPPORTED_CDP_ONLY";
 const calibrateUnsupportedCode = "CALIBRATE_UNSUPPORTED_CDP_ONLY";
@@ -613,14 +614,20 @@ function parseBossChatTargetCountOption(raw) {
   return parsed ?? text;
 }
 
-function parseBooleanOption(raw, fallback = undefined) {
-  if (raw === undefined || raw === null || raw === "") return fallback;
-  if (raw === true) return true;
-  const normalized = String(raw).trim().toLowerCase();
-  if (["true", "1", "yes", "y", "on"].includes(normalized)) return true;
-  if (["false", "0", "no", "n", "off"].includes(normalized)) return false;
-  return fallback;
-}
+function parseBooleanOption(raw, fallback = undefined) {
+  if (raw === undefined || raw === null || raw === "") return fallback;
+  if (raw === true) return true;
+  const normalized = String(raw).trim().toLowerCase();
+  if (["true", "1", "yes", "y", "on"].includes(normalized)) return true;
+  if (["false", "0", "no", "n", "off"].includes(normalized)) return false;
+  return fallback;
+}
+
+function parseRestLevelOption(raw) {
+  if (raw === undefined || raw === null || raw === "") return undefined;
+  const normalized = String(raw).trim().toLowerCase();
+  return ["low", "medium", "high"].includes(normalized) ? normalized : undefined;
+}
 
 function normalizePageScope(value) {
   const normalized = String(value || "").trim().toLowerCase();
@@ -1271,20 +1278,33 @@ async function resolveCliConfigTarget(options = {}) {
   };
 }
 
-function applyMissingInstallConfigDefaults(config = {}) {
-  const nextConfig = { ...config };
-  const patchedKeys = [];
-  for (const [key, defaultValue] of Object.entries(installConfigDefaults)) {
+function applyMissingInstallConfigDefaults(config = {}) {
+  const nextConfig = { ...config };
+  const patchedKeys = [];
+  for (const [key, defaultValue] of Object.entries(installConfigDefaults)) {
     if (!Object.prototype.hasOwnProperty.call(nextConfig, key)) {
       nextConfig[key] = defaultValue;
-      patchedKeys.push(key);
-    }
-  }
-  return {
-    nextConfig,
-    patchedKeys
-  };
-}
+      patchedKeys.push(key);
+    }
+  }
+  if (
+    nextConfig.humanBehavior
+    && typeof nextConfig.humanBehavior === "object"
+    && !Array.isArray(nextConfig.humanBehavior)
+    && !Object.prototype.hasOwnProperty.call(nextConfig.humanBehavior, "restLevel")
+    && !Object.prototype.hasOwnProperty.call(nextConfig.humanBehavior, "rest_level")
+  ) {
+    nextConfig.humanBehavior = {
+      ...nextConfig.humanBehavior,
+      restLevel: "low"
+    };
+    patchedKeys.push("humanBehavior.restLevel");
+  }
+  return {
+    nextConfig,
+    patchedKeys
+  };
+}
 
 async function ensureUserConfig(options = {}) {
   const { configPath, workspacePreferred } = await resolveCliConfigTarget(options);
@@ -2721,19 +2741,30 @@ async function runPipelineOnce(options = {}) {
   const workspaceRoot = getWorkspaceRoot(options);
   const port = parsePositivePort(options.port) || parsePositivePort(process.env.BOSS_RECOMMEND_CHROME_PORT) || 9222;
 
-  const args = {
-    instruction,
-    confirmation: confirmation ?? undefined,
-    overrides: overrides ?? undefined,
-    follow_up: followUp ?? undefined,
+  const args = {
+    instruction,
+    confirmation: confirmation ?? undefined,
+    overrides: overrides ?? undefined,
+    follow_up: followUp ?? undefined,
     host: typeof options.host === "string" && options.host.trim() ? options.host.trim() : undefined,
     port,
     target_url_includes: typeof options["target-url-includes"] === "string" && options["target-url-includes"].trim()
       ? options["target-url-includes"].trim()
       : undefined,
     allow_navigate: !(options["no-navigate"] === true || options.noNavigate === true || options.allow_navigate === false),
-    slow_live: options["slow-live"] === true || options.slowLive === true || options.slow_live === true
-  };
+    slow_live: options["slow-live"] === true || options.slowLive === true || options.slow_live === true
+  };
+  const restLevel = parseRestLevelOption(
+    options["rest-level"]
+    ?? options.rest_level
+    ?? options["human-behavior-rest-level"]
+    ?? options.human_behavior_rest_level
+  );
+  if (restLevel) {
+    args.human_behavior = {
+      restLevel
+    };
+  }
 
   const optionalPassthrough = [
     "detail_limit",
@@ -2810,16 +2841,22 @@ async function listRecommendJobsCli(options = {}) {
   }));
 }
 
-function buildBossChatCliInput(options = {}) {
-  const greetingTextRaw =
-    options["greeting-text"]
-    ?? options.greeting_text
-    ?? options.greetingText
-    ?? options.greeting;
-  const greetingText = typeof greetingTextRaw === "string" ? greetingTextRaw.trim() : undefined;
-  const targetUrlIncludes = String(options["target-url-includes"] || options.target_url_includes || "").trim();
-  const host = String(options.host || "").trim();
-  return {
+function buildBossChatCliInput(options = {}) {
+  const greetingTextRaw =
+    options["greeting-text"]
+    ?? options.greeting_text
+    ?? options.greetingText
+    ?? options.greeting;
+  const greetingText = typeof greetingTextRaw === "string" ? greetingTextRaw.trim() : undefined;
+  const targetUrlIncludes = String(options["target-url-includes"] || options.target_url_includes || "").trim();
+  const host = String(options.host || "").trim();
+  const restLevel = parseRestLevelOption(
+    options["rest-level"]
+    ?? options.rest_level
+    ?? options["human-behavior-rest-level"]
+    ?? options.human_behavior_rest_level
+  );
+  return {
     profile: typeof options.profile === "string" ? options.profile.trim() : undefined,
     job: typeof options.job === "string" ? options.job.trim() : undefined,
     start_from: String(options["start-from"] || options.start_from || "").trim().toLowerCase() || undefined,
@@ -2837,13 +2874,18 @@ function buildBossChatCliInput(options = {}) {
     dry_run: options["dry-run"] === true || options.dryRun === true,
     no_state: options["no-state"] === true || options.noState === true,
     human_behavior_enabled: parseBooleanOption(options["human-behavior-enabled"] ?? options.human_behavior_enabled),
-    human_behavior_profile: typeof (options["human-behavior-profile"] ?? options.human_behavior_profile) === "string"
-      ? (options["human-behavior-profile"] ?? options.human_behavior_profile).trim()
-      : undefined,
-    safe_pacing: parseBooleanOption(options["safe-pacing"] ?? options.safe_pacing),
-    batch_rest_enabled: parseBooleanOption(options["batch-rest"] ?? options.batch_rest_enabled)
-  };
-}
+    human_behavior_profile: typeof (options["human-behavior-profile"] ?? options.human_behavior_profile) === "string"
+      ? (options["human-behavior-profile"] ?? options.human_behavior_profile).trim()
+      : undefined,
+    human_behavior: restLevel
+      ? {
+          restLevel
+        }
+      : undefined,
+    safe_pacing: parseBooleanOption(options["safe-pacing"] ?? options.safe_pacing),
+    batch_rest_enabled: parseBooleanOption(options["batch-rest"] ?? options.batch_rest_enabled)
+  };
+}
 
 function getBossChatCliRunTarget(options = {}) {
   return {

package/src/core/browser/index.js

@@ -86,6 +86,46 @@ const HUMAN_BEHAVIOR_PROFILE_ALIASES = Object.freeze({
   rests: "paced_with_rests",
   rest: "paced_with_rests"
 });
+const DEFAULT_HUMAN_REST_LEVEL = "low";
+const HUMAN_REST_LEVEL_ALIASES = Object.freeze({
+  default: "low",
+  light: "low",
+  normal: "medium",
+  med: "medium",
+  heavy: "high"
+});
+const HUMAN_REST_LEVEL_PROFILES = Object.freeze({
+  medium: Object.freeze({
+    targetRestMs: 30 * 60 * 1000,
+    targetCandidateCount: 700,
+    targetWindowMs: 5 * 60 * 60 * 1000,
+    intervalMin: 4,
+    intervalMax: 16,
+    longRestProbability: 0.22,
+    shortRestMinMs: 8000,
+    shortRestMaxMs: 45000,
+    longRestMinMs: 60000,
+    longRestMaxMs: 180000,
+    minDebtToRestMs: 8000,
+    forceDebtMs: 90000,
+    maxOverspendMs: 15000
+  }),
+  high: Object.freeze({
+    targetRestMs: 60 * 60 * 1000,
+    targetCandidateCount: 700,
+    targetWindowMs: 5 * 60 * 60 * 1000,
+    intervalMin: 3,
+    intervalMax: 12,
+    longRestProbability: 0.28,
+    shortRestMinMs: 12000,
+    shortRestMaxMs: 75000,
+    longRestMinMs: 90000,
+    longRestMaxMs: 300000,
+    minDebtToRestMs: 12000,
+    forceDebtMs: 150000,
+    maxOverspendMs: 25000
+  })
+});
 
 function clampNumber(value, min, max) {
   const number = Number(value);
@@ -152,6 +192,14 @@ export function normalizeHumanBehaviorProfile(raw, fallback = "baseline") {
     : fallback;
 }
 
+export function normalizeHumanRestLevel(raw, fallback = DEFAULT_HUMAN_REST_LEVEL) {
+  const normalized = String(raw || "").trim().toLowerCase().replace(/[\s-]+/g, "_");
+  const level = HUMAN_REST_LEVEL_ALIASES[normalized] || normalized;
+  return level === "low" || level === "medium" || level === "high"
+    ? level
+    : fallback;
+}
+
 export function normalizeHumanBehaviorOptions(raw = null, {
   legacyEnabled = false,
   safePacing = null,
@@ -231,6 +279,10 @@ export function normalizeHumanBehaviorOptions(raw = null, {
     readFirstOption(rawObject, ["batchRest", "batch_rest", "batchRestEnabled", "batch_rest_enabled"]),
     profileDefaults.batchRest
   );
+  const restLevel = normalizeHumanRestLevel(
+    readFirstOption(rawObject, ["restLevel", "rest_level"]),
+    DEFAULT_HUMAN_REST_LEVEL
+  );
   if (batchRestFlag !== null) {
     batchRest = batchRestFlag;
     if (batchRestFlag === true && readFirstOption(rawObject, ["shortRest", "short_rest", "randomRest", "random_rest"]) === undefined) {
@@ -248,6 +300,7 @@ export function normalizeHumanBehaviorOptions(raw = null, {
     shortRest: enabled && shortRest === true,
     batchRest: enabled && batchRest === true,
     actionCooldown: enabled && actionCooldown === true,
+    restLevel,
     restEnabled: enabled && (shortRest === true || batchRest === true)
   };
 }
@@ -404,6 +457,8 @@ export function createHumanRestController({
   shortRestEnabled = true,
   batchRestEnabled = true,
   random = Math.random,
+  nowFn = Date.now,
+  restLevel = DEFAULT_HUMAN_REST_LEVEL,
   shortRestProbability = 0.08,
   shortRestMinMs = 3000,
   shortRestMaxMs = 7000,
@@ -413,12 +468,26 @@ export function createHumanRestController({
   batchRestMaxMs = 30000
 } = {}) {
   const nextRandom = normalizeRandom(random);
+  const readNow = typeof nowFn === "function" ? nowFn : Date.now;
+  const normalizedRestLevel = normalizeHumanRestLevel(restLevel);
+  const budgetProfile = (shortRestEnabled !== false || batchRestEnabled !== false)
+    ? HUMAN_REST_LEVEL_PROFILES[normalizedRestLevel] || null
+    : null;
+  const nextBudgetRestInterval = () => budgetProfile
+    ? randomIntegerBetween(nextRandom, budgetProfile.intervalMin, budgetProfile.intervalMax)
+    : 0;
   const state = {
     enabled: enabled === true,
+    rest_level: normalizedRestLevel,
     short_rest_enabled: enabled === true && shortRestEnabled !== false,
     batch_rest_enabled: enabled === true && batchRestEnabled !== false,
     rest_counter: 0,
     rest_threshold: Math.max(1, Math.floor(Number(batchThresholdBase) || 25) + Math.floor(nextRandom() * Math.max(1, Number(batchThresholdJitter) || 1))),
+    processed_count: 0,
+    candidates_since_last_rest: 0,
+    candidates_until_next_rest: nextBudgetRestInterval(),
+    active_elapsed_ms: 0,
+    last_active_at_ms: Number(readNow()) || 0,
     rest_count: 0,
     total_rest_ms: 0
   };
@@ -427,6 +496,67 @@ export function createHumanRestController({
     state.rest_threshold = Math.max(1, Math.floor(Number(batchThresholdBase) || 25) + Math.floor(nextRandom() * Math.max(1, Number(batchThresholdJitter) || 1)));
   }
 
+  function updateActiveElapsed() {
+    const now = Number(readNow()) || 0;
+    if (state.last_active_at_ms >= 0 && now >= state.last_active_at_ms) {
+      state.active_elapsed_ms += now - state.last_active_at_ms;
+    }
+    state.last_active_at_ms = now;
+    return now;
+  }
+
+  function getBudgetTargetMs() {
+    if (!budgetProfile) return 0;
+    const candidateTarget = state.processed_count * (budgetProfile.targetRestMs / budgetProfile.targetCandidateCount);
+    const elapsedTarget = state.active_elapsed_ms * (budgetProfile.targetRestMs / budgetProfile.targetWindowMs);
+    return Math.max(candidateTarget, elapsedTarget);
+  }
+
+  function chooseBudgetRestPause(debtMs) {
+    const longRest = nextRandom() < budgetProfile.longRestProbability;
+    const minMs = longRest ? budgetProfile.longRestMinMs : budgetProfile.shortRestMinMs;
+    const maxMs = longRest ? budgetProfile.longRestMaxMs : budgetProfile.shortRestMaxMs;
+    const scaleMin = longRest ? 0.75 : 0.38;
+    const scaleMax = longRest ? 1.1 : 0.78;
+    const desiredMs = debtMs * randomBetween(nextRandom, scaleMin, scaleMax);
+    const randomizedMs = randomBetween(nextRandom, minMs, maxMs);
+    const blendedMs = Math.max(minMs, Math.min(maxMs, (desiredMs + randomizedMs) / 2));
+    const maxAllowedMs = Math.max(minMs, debtMs + budgetProfile.maxOverspendMs);
+    return {
+      pauseMs: Math.round(Math.min(blendedMs, maxAllowedMs)),
+      restSize: longRest ? "long" : "short"
+    };
+  }
+
+  async function takeBudgetBreakIfNeeded(sleeper) {
+    state.processed_count += 1;
+    state.candidates_since_last_rest += 1;
+    state.candidates_until_next_rest -= 1;
+    const debtMs = getBudgetTargetMs() - state.total_rest_ms;
+    const intervalDue = state.candidates_until_next_rest <= 0;
+    const forceDue = debtMs >= budgetProfile.forceDebtMs;
+    if (!intervalDue && !forceDue) {
+      return null;
+    }
+    if (debtMs < budgetProfile.minDebtToRestMs) {
+      if (intervalDue) state.candidates_until_next_rest = nextBudgetRestInterval();
+      return null;
+    }
+    const { pauseMs, restSize } = chooseBudgetRestPause(debtMs);
+    await sleeper(pauseMs);
+    const event = {
+      kind: "random_rest",
+      rest_level: normalizedRestLevel,
+      rest_size: restSize,
+      pause_ms: pauseMs,
+      processed_since_last_rest: state.candidates_since_last_rest,
+      rest_budget_debt_ms: Math.round(Math.max(0, debtMs))
+    };
+    state.candidates_since_last_rest = 0;
+    state.candidates_until_next_rest = nextBudgetRestInterval();
+    return event;
+  }
+
   async function takeBreakIfNeeded({ sleepFn = sleep } = {}) {
     if (!state.enabled) {
       return {
@@ -438,18 +568,44 @@ export function createHumanRestController({
       };
     }
     const sleeper = typeof sleepFn === "function" ? sleepFn : sleep;
+    updateActiveElapsed();
+    if (budgetProfile) {
+      const budgetEvent = await takeBudgetBreakIfNeeded(sleeper);
+      const pauseMs = budgetEvent?.pause_ms || 0;
+      if (pauseMs > 0) {
+        state.rest_count += 1;
+        state.total_rest_ms += pauseMs;
+        state.last_active_at_ms = Number(readNow()) || state.last_active_at_ms;
+      }
+      return {
+        enabled: true,
+        rested: Boolean(budgetEvent),
+        pause_ms: pauseMs,
+        rest_level: normalizedRestLevel,
+        rest_counter: state.rest_counter,
+        rest_threshold: state.rest_threshold,
+        processed_count: state.processed_count,
+        candidates_until_next_rest: state.candidates_until_next_rest,
+        active_elapsed_ms: state.active_elapsed_ms,
+        rest_count: state.rest_count,
+        total_rest_ms: state.total_rest_ms,
+        events: budgetEvent ? [budgetEvent] : []
+      };
+    }
     state.rest_counter += 1;
+    state.processed_count += 1;
     const events = [];
     if (state.short_rest_enabled && nextRandom() < Math.max(0, Number(shortRestProbability) || 0)) {
       const pauseMs = Math.round(randomBetween(nextRandom, shortRestMinMs, shortRestMaxMs));
       await sleeper(pauseMs);
-      events.push({ kind: "random_rest", pause_ms: pauseMs });
+      events.push({ kind: "random_rest", rest_level: normalizedRestLevel, pause_ms: pauseMs });
     }
     if (state.batch_rest_enabled && state.rest_counter >= state.rest_threshold) {
       const pauseMs = Math.round(randomBetween(nextRandom, batchRestMinMs, batchRestMaxMs));
       await sleeper(pauseMs);
       events.push({
         kind: "batch_rest",
+        rest_level: normalizedRestLevel,
         pause_ms: pauseMs,
         processed_since_last_batch_rest: state.rest_counter
       });
@@ -460,13 +616,17 @@ export function createHumanRestController({
     if (pauseMs > 0) {
       state.rest_count += events.length;
       state.total_rest_ms += pauseMs;
+      state.last_active_at_ms = Number(readNow()) || state.last_active_at_ms;
     }
     return {
       enabled: true,
       rested: events.length > 0,
       pause_ms: pauseMs,
+      rest_level: normalizedRestLevel,
       rest_counter: state.rest_counter,
       rest_threshold: state.rest_threshold,
+      processed_count: state.processed_count,
+      active_elapsed_ms: state.active_elapsed_ms,
       rest_count: state.rest_count,
       total_rest_ms: state.total_rest_ms,
       events
@@ -743,6 +903,7 @@ export function buildBossChromeLaunchArgs({
     ...LID_CLOSED_SAFE_CHROME_ARGS,
     ...parseExtraChromeArgs(process.env.BOSS_MCP_EXTRA_CHROME_ARGS),
     ...extraArgs,
+    "--start-maximized",
     "--new-window",
     url
   ];

package/src/core/self-heal/viewport.js

@@ -326,7 +326,7 @@ export async function toggleWindowStateForViewportRecovery(client, {
   const currentInfo = await getCurrentWindowInfo(client);
   const currentState = normalizeText(currentInfo?.bounds?.windowState || "").toLowerCase();
   const sequence = currentState === "normal"
-    ? ["maximized", "normal"]
+    ? ["maximized"]
     : ["normal", "maximized"];
   const attempts = [];
 

package/src/detached-worker.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import {
+  markBossChatDetachedWorkerFailed,
+  runBossChatDetachedWorker
+} from "./chat-mcp.js";
+import {
+  markBossRecruitDetachedWorkerFailed,
+  runBossRecruitDetachedWorker
+} from "./recruit-mcp.js";
+
+function normalizeText(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+
+function parseArgs(argv = []) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const item = argv[index];
+    if (item === "--domain") {
+      args.domain = normalizeText(argv[index + 1]).toLowerCase();
+      index += 1;
+    } else if (item === "--run-id") {
+      args.runId = normalizeText(argv[index + 1]);
+      index += 1;
+    }
+  }
+  return args;
+}
+
+function markFailed(domain, runId, error, options = {}) {
+  if (domain === "chat") {
+    return markBossChatDetachedWorkerFailed(runId, error, options);
+  }
+  if (domain === "recruit") {
+    return markBossRecruitDetachedWorkerFailed(runId, error, options);
+  }
+  return null;
+}
+
+function installFailureHandlers(domain, runId) {
+  let handled = false;
+  const failOnce = (error, options = {}) => {
+    if (handled) return;
+    handled = true;
+    try {
+      markFailed(domain, runId, error, options);
+    } catch (markError) {
+      console.error("[boss-recommend-mcp] failed to persist detached worker failure", markError);
+    }
+  };
+
+  process.on("uncaughtException", (error) => {
+    console.error("[boss-recommend-mcp] detached worker uncaught exception", error);
+    failOnce(error, { code: "DETACHED_WORKER_UNCAUGHT_EXCEPTION" });
+    process.exit(1);
+  });
+
+  process.on("unhandledRejection", (reason) => {
+    console.error("[boss-recommend-mcp] detached worker unhandled rejection", reason);
+    const error = reason instanceof Error ? reason : new Error(normalizeText(reason) || "Unhandled promise rejection");
+    failOnce(error, { code: "DETACHED_WORKER_UNHANDLED_REJECTION" });
+    process.exit(1);
+  });
+
+  for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+    process.on(signal, () => {
+      const error = new Error(`detached ${domain} worker received ${signal}`);
+      console.error("[boss-recommend-mcp] detached worker received signal", signal);
+      failOnce(error, { code: "DETACHED_WORKER_SIGNAL" });
+      const signalExitCodes = { SIGHUP: 129, SIGINT: 130, SIGTERM: 143 };
+      process.exit(signalExitCodes[signal] || 1);
+    });
+  }
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (!options.domain || !options.runId) {
+    console.error("[boss-recommend-mcp] detached worker requires --domain and --run-id");
+    process.exitCode = 1;
+    return;
+  }
+  installFailureHandlers(options.domain, options.runId);
+  const result = options.domain === "chat"
+    ? await runBossChatDetachedWorker({ runId: options.runId })
+    : options.domain === "recruit"
+      ? await runBossRecruitDetachedWorker({ runId: options.runId })
+      : { ok: false, error: `Unsupported detached worker domain: ${options.domain}` };
+  if (!result?.ok) {
+    process.exitCode = 1;
+  }
+}
+
+await main().catch((error) => {
+  const options = parseArgs(process.argv.slice(2));
+  console.error("[boss-recommend-mcp] detached worker failed", error);
+  markFailed(options.domain, options.runId, error, { code: "DETACHED_WORKER_FAILED" });
+  process.exitCode = 1;
+});