@reconcrap/boss-recommend-mcp 2.1.23 → 2.1.25

package/src/core/run/index.js

@@ -32,32 +32,55 @@ function clone(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
-function errorDiagnostic(error) {
-  if (!error) return null;
-  const diagnostic = {
-    name: error?.name || "Error",
-    message: error?.message || String(error)
+const SAFE_CDP_ERROR_FIELDS = [
+  "cdp_method",
+  "cdp_at",
+  "cdp_node_id",
+  "cdp_backend_node_id",
+  "cdp_search_id",
+  "cdp_connection_epoch",
+  "cdp_replay_policy",
+  "cdp_reconnected",
+  "cdp_reconnected_epoch",
+  "cdp_replayed_after_reconnect",
+  "cdp_replay_suppressed",
+  "cdp_outcome_unknown",
+  "cdp_reconnect_error"
+];
+
+function appendSafeCdpDiagnostics(diagnostic, error) {
+  for (const field of SAFE_CDP_ERROR_FIELDS) {
+    if (error?.[field] !== undefined) diagnostic[field] = error[field];
+  }
+  if (Array.isArray(error?.cdp_param_keys)) {
+    diagnostic.cdp_param_keys = error.cdp_param_keys
+      .filter((key) => typeof key === "string")
+      .slice(0, 20);
+  }
+  return diagnostic;
+}
+
+function errorDiagnostic(error, phase = null) {
+  if (!error) return null;
+  const diagnostic = {
+    name: error?.name || "Error",
+    message: error?.message || String(error)
   };
   if (error?.code) diagnostic.code = error.code;
-  if (error?.cdp_method) diagnostic.cdp_method = error.cdp_method;
-  if (error?.cdp_at) diagnostic.cdp_at = error.cdp_at;
-  if (Number.isInteger(error?.cdp_node_id)) diagnostic.cdp_node_id = error.cdp_node_id;
-  if (Number.isInteger(error?.cdp_backend_node_id)) diagnostic.cdp_backend_node_id = error.cdp_backend_node_id;
-  if (error?.cdp_search_id) diagnostic.cdp_search_id = error.cdp_search_id;
-  if (Array.isArray(error?.cdp_param_keys)) diagnostic.cdp_param_keys = error.cdp_param_keys.slice(0, 20);
+  const diagnosticPhase = error?.phase || phase;
+  if (diagnosticPhase) diagnostic.phase = diagnosticPhase;
+  appendSafeCdpDiagnostics(diagnostic, error);
   if (error?.stack) diagnostic.stack = String(error.stack).split(/\r?\n/).slice(0, 12).join("\n");
   if (error?.cause && error.cause !== error) {
-    diagnostic.cause = {
+    diagnostic.cause = appendSafeCdpDiagnostics({
       name: error.cause?.name || "Error",
       message: error.cause?.message || String(error.cause),
-      code: error.cause?.code || undefined,
-      cdp_method: error.cause?.cdp_method || undefined,
-      cdp_at: error.cause?.cdp_at || undefined,
-      cdp_node_id: Number.isInteger(error.cause?.cdp_node_id) ? error.cause.cdp_node_id : undefined
-    };
+      ...(error.cause?.code ? { code: error.cause.code } : {}),
+      ...((error.cause?.phase || diagnosticPhase) ? { phase: error.cause?.phase || diagnosticPhase } : {})
+    }, error.cause);
   }
   return diagnostic;
-}
+}
 
 function createDeferred() {
   let resolve;
@@ -98,17 +121,18 @@ export function createRunLifecycleManager({
 } = {}) {
   const runs = new Map();
 
-  function emitSnapshot(entry, event = {}) {
-    if (typeof onSnapshot !== "function") return;
-    try {
-      onSnapshot(snapshotFromEntry(entry), {
-        type: event.type || "update",
-        at: now(),
-        ...event
-      });
-    } catch {
-      // Snapshot hooks must never interrupt an active browser run.
-    }
+  function emitSnapshot(entry, event = {}, { required = false } = {}) {
+    if (typeof onSnapshot !== "function") return;
+    try {
+      onSnapshot(snapshotFromEntry(entry), {
+        type: event.type || "update",
+        at: now(),
+        ...event
+      });
+    } catch (error) {
+      if (required) throw error;
+      // Snapshot hooks must never interrupt an active browser run.
+    }
   }
 
   function getEntry(runId) {
@@ -150,16 +174,30 @@ export function createRunLifecycleManager({
         emitSnapshot(entry, { type: "progress", progressPatch });
         return snapshotFromEntry(entry);
       },
-      checkpoint(checkpointPatch = {}) {
-        entry.run.checkpoint = {
-          ...entry.run.checkpoint,
-          ...checkpointPatch,
-          updatedAt: now()
+      checkpoint(checkpointPatch = {}) {
+        entry.run.checkpoint = {
+          ...entry.run.checkpoint,
+          ...checkpointPatch,
+          updatedAt: now()
         };
         touch(entry);
-        emitSnapshot(entry, { type: "checkpoint", checkpointPatch });
-        return snapshotFromEntry(entry);
-      },
+        emitSnapshot(entry, { type: "checkpoint", checkpointPatch });
+        return snapshotFromEntry(entry);
+      },
+      checkpointCritical(checkpointPatch = {}) {
+        entry.run.checkpoint = {
+          ...entry.run.checkpoint,
+          ...checkpointPatch,
+          updatedAt: now()
+        };
+        touch(entry);
+        emitSnapshot(entry, {
+          type: "checkpoint",
+          checkpointPatch,
+          required: true
+        }, { required: true });
+        return snapshotFromEntry(entry);
+      },
       async waitIfPaused() {
         if (entry.controller.signal.aborted) {
           throw new RunCanceledError();
@@ -180,19 +218,34 @@ export function createRunLifecycleManager({
         }
         setStatus(entry, RUN_STATUS_RUNNING);
       },
-      async sleep(ms) {
-        if (entry.controller.signal.aborted) {
-          throw new RunCanceledError();
-        }
-        await new Promise((resolve, reject) => {
-          const timer = setTimeout(resolve, ms);
-          const onAbort = () => {
-            clearTimeout(timer);
-            reject(new RunCanceledError());
-          };
-          entry.controller.signal.addEventListener("abort", onAbort, { once: true });
-        });
-      },
+      async sleep(ms) {
+        if (entry.controller.signal.aborted) {
+          throw new RunCanceledError();
+        }
+        await new Promise((resolve, reject) => {
+          let settled = false;
+          let timer = null;
+          const cleanup = () => {
+            entry.controller.signal.removeEventListener("abort", onAbort);
+          };
+          const onTimer = () => {
+            if (settled) return;
+            settled = true;
+            cleanup();
+            resolve();
+          };
+          const onAbort = () => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            cleanup();
+            reject(new RunCanceledError());
+          };
+          timer = setTimeout(onTimer, Math.max(0, Number(ms) || 0));
+          entry.controller.signal.addEventListener("abort", onAbort, { once: true });
+          if (entry.controller.signal.aborted) onAbort();
+        });
+      },
       throwIfCanceled() {
         if (entry.controller.signal.aborted) {
           throw new RunCanceledError();
@@ -219,14 +272,15 @@ export function createRunLifecycleManager({
       if (error instanceof RunCanceledError || entry.controller.signal.aborted || entry.cancelRequested) {
         setStatus(entry, RUN_STATUS_CANCELED, {
           completedAt: now(),
-          error: error instanceof RunCanceledError ? null : errorDiagnostic(error)
+          error: error instanceof RunCanceledError ? null : errorDiagnostic(error, entry.run.phase)
         });
         return;
       }
-      setStatus(entry, RUN_STATUS_FAILED, {
-        completedAt: now(),
-        error: errorDiagnostic(error)
-      });
+      setStatus(entry, RUN_STATUS_FAILED, {
+        completedAt: now(),
+        error: errorDiagnostic(error, entry.run.phase),
+        summary: error?.run_summary || entry.run.summary
+      });
     }
   }
 

package/src/core/run/timing.js

@@ -1,33 +1,33 @@
-import path from "node:path";
-
-export function addTiming(timings, key, value) {
-  if (!timings || !key) return;
-  const numeric = Number(value);
-  if (!Number.isFinite(numeric) || numeric < 0) return;
-  timings[key] = (Number(timings[key]) || 0) + Math.round(numeric);
-}
-
-export async function measureTiming(timings, key, task) {
-  const started = Date.now();
-  try {
-    return await task();
-  } finally {
-    addTiming(timings, key, Date.now() - started);
-  }
-}
-
-export function imageEvidenceFilePath({
-  imageOutputDir = "",
-  domain = "candidate",
-  runId = "",
-  index = 0,
-  extension = "png"
-} = {}) {
-  const dir = String(imageOutputDir || "").trim();
-  if (!dir) return "";
-  const safeDomain = String(domain || "candidate").replace(/[^\w.-]+/g, "_");
-  const safeRunId = String(runId || `${safeDomain}-run`).replace(/[^\w.-]+/g, "_");
-  const safeIndex = String((Number(index) || 0) + 1).padStart(3, "0");
-  const safeExt = String(extension || "png").replace(/^\./, "") || "png";
-  return path.join(dir, safeRunId, `${safeDomain}-candidate-${safeIndex}.${safeExt}`);
-}
+import path from "node:path";
+
+export function addTiming(timings, key, value) {
+  if (!timings || !key) return;
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric < 0) return;
+  timings[key] = (Number(timings[key]) || 0) + Math.round(numeric);
+}
+
+export async function measureTiming(timings, key, task) {
+  const started = Date.now();
+  try {
+    return await task();
+  } finally {
+    addTiming(timings, key, Date.now() - started);
+  }
+}
+
+export function imageEvidenceFilePath({
+  imageOutputDir = "",
+  domain = "candidate",
+  runId = "",
+  index = 0,
+  extension = "png"
+} = {}) {
+  const dir = String(imageOutputDir || "").trim();
+  if (!dir) return "";
+  const safeDomain = String(domain || "candidate").replace(/[^\w.-]+/g, "_");
+  const safeRunId = String(runId || `${safeDomain}-run`).replace(/[^\w.-]+/g, "_");
+  const safeIndex = String((Number(index) || 0) + 1).padStart(3, "0");
+  const safeExt = String(extension || "png").replace(/^\./, "") || "png";
+  return path.join(dir, safeRunId, `${safeDomain}-candidate-${safeIndex}.${safeExt}`);
+}

package/src/core/run/windows-detached-worker.ps1

@@ -0,0 +1,106 @@
+param(
+  [Parameter(Mandatory = $true)]
+  [string]$NodePath,
+
+  [Parameter(Mandatory = $true)]
+  [string]$WorkerScriptPath,
+
+  [Parameter(Mandatory = $true)]
+  [ValidateSet('chat', 'recruit', 'recommend')]
+  [string]$Domain,
+
+  [Parameter(Mandatory = $true)]
+  [ValidatePattern('^[A-Za-z0-9._-]+$')]
+  [string]$RunId,
+
+  [Parameter(Mandatory = $true)]
+  [string]$StdoutPath,
+
+  [Parameter(Mandatory = $true)]
+  [string]$StderrPath,
+
+  [Parameter(Mandatory = $false)]
+  [string]$ChatRuntimeHomePath = '',
+
+  [Parameter(Mandatory = $false)]
+  [string]$ScreenConfigPath = ''
+)
+
+$ErrorActionPreference = 'Stop'
+$utf8 = [System.Text.UTF8Encoding]::new($false)
+
+function Assert-ControlledPath([string]$Value, [string]$Label) {
+  if (-not $Value -or -not [System.IO.Path]::IsPathRooted($Value)) {
+    throw "$Label must be an absolute path."
+  }
+  if ($Value.IndexOf([char]0) -ge 0 -or $Value -match '[\r\n"]') {
+    throw "$Label contains unsupported characters."
+  }
+}
+
+try {
+  Assert-ControlledPath $NodePath 'NodePath'
+  Assert-ControlledPath $WorkerScriptPath 'WorkerScriptPath'
+  Assert-ControlledPath $StdoutPath 'StdoutPath'
+  Assert-ControlledPath $StderrPath 'StderrPath'
+  if ($ChatRuntimeHomePath) {
+    Assert-ControlledPath $ChatRuntimeHomePath 'ChatRuntimeHomePath'
+  }
+  if ($ScreenConfigPath) {
+    Assert-ControlledPath $ScreenConfigPath 'ScreenConfigPath'
+  }
+  if (-not (Test-Path -LiteralPath $NodePath -PathType Leaf)) {
+    throw 'NodePath does not exist.'
+  }
+  if (-not (Test-Path -LiteralPath $WorkerScriptPath -PathType Leaf)) {
+    throw 'WorkerScriptPath does not exist.'
+  }
+  [System.IO.Directory]::CreateDirectory([System.IO.Path]::GetDirectoryName($StdoutPath)) | Out-Null
+  [System.IO.Directory]::CreateDirectory([System.IO.Path]::GetDirectoryName($StderrPath)) | Out-Null
+
+  $startInfo = New-Object System.Diagnostics.ProcessStartInfo
+  $startInfo.FileName = $NodePath
+  $startInfo.Arguments = ('"{0}" --domain {1} --run-id {2}' -f $WorkerScriptPath, $Domain, $RunId)
+  $startInfo.WorkingDirectory = [System.IO.Path]::GetDirectoryName($WorkerScriptPath)
+  $startInfo.UseShellExecute = $false
+  $startInfo.CreateNoWindow = $true
+  $startInfo.WindowStyle = [System.Diagnostics.ProcessWindowStyle]::Hidden
+  $startInfo.RedirectStandardOutput = $true
+  $startInfo.RedirectStandardError = $true
+  if ($ChatRuntimeHomePath) {
+    $startInfo.EnvironmentVariables['BOSS_CHAT_HOME'] = $ChatRuntimeHomePath
+  }
+  if ($ScreenConfigPath) {
+    $startInfo.EnvironmentVariables['BOSS_RECOMMEND_SCREEN_CONFIG'] = $ScreenConfigPath
+  }
+
+  $worker = New-Object System.Diagnostics.Process
+  $worker.StartInfo = $startInfo
+  if (-not $worker.Start()) {
+    throw 'Node detached worker did not start.'
+  }
+  $stdoutTask = $worker.StandardOutput.ReadToEndAsync()
+  $stderrTask = $worker.StandardError.ReadToEndAsync()
+  $worker.WaitForExit()
+  $stdout = $stdoutTask.GetAwaiter().GetResult()
+  $stderr = $stderrTask.GetAwaiter().GetResult()
+  if ($stdout) {
+    [System.IO.File]::AppendAllText($StdoutPath, $stdout, $utf8)
+  }
+  if ($stderr) {
+    [System.IO.File]::AppendAllText($StderrPath, $stderr, $utf8)
+  }
+  exit [int]$worker.ExitCode
+} catch {
+  try {
+    [System.IO.Directory]::CreateDirectory([System.IO.Path]::GetDirectoryName($StderrPath)) | Out-Null
+    [System.IO.File]::AppendAllText(
+      $StderrPath,
+      "[windows-detached-worker] $($_.Exception.Message)$([Environment]::NewLine)",
+      $utf8
+    )
+  } catch {
+    # No additional recovery is available if even the controlled log path is unavailable.
+  }
+  exit 1
+}