@yeaft/webchat-agent 1.0.413 → 1.0.415

package/browser-runtime/protocol.js

@@ -0,0 +1,71 @@
+export const BROWSER_PROTOCOL_VERSION = 1;
+export const BROWSER_CONTROL_CHANNEL = 'browser.control.v1';
+export const BROWSER_POINTER_CHANNEL = 'browser.pointer.v1';
+export const BROWSER_STATE_CHANNEL = 'browser.state.v1';
+
+function positiveInteger(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+
+/**
+ * Per-producer sequence fencing. Reliable control and lossy pointer traffic
+ * intentionally have independent sequence spaces: pointer loss or reordering
+ * must never advance or block reliable keyboard/click/navigation actions.
+ */
+export class ProducerSequenceState {
+  /** @param {{producerId:string, producerGeneration:number}} identity */
+  constructor({ producerId, producerGeneration }) {
+    if (typeof producerId !== 'string' || !producerId) throw new Error('producerId required');
+    if (!positiveInteger(producerGeneration)) throw new Error('producerGeneration must be a positive integer');
+    this.producerId = producerId;
+    this.producerGeneration = producerGeneration;
+    this.lastAcceptedControlSeq = 0;
+    this.lastAcceptedPointerSeq = 0;
+  }
+
+  #matches(envelope) {
+    return envelope?.producerId === this.producerId
+      && envelope?.producerGeneration === this.producerGeneration;
+  }
+
+  /**
+   * Accept only the next gap-free reliable sequence number.
+   * @returns {{accepted:boolean, code:string, expectedControlSeq:number}}
+   */
+  acceptControl(envelope) {
+    const expectedControlSeq = this.lastAcceptedControlSeq + 1;
+    if (!this.#matches(envelope)) return { accepted: false, code: 'producer_stale', expectedControlSeq };
+    if (!positiveInteger(envelope.controlSeq)) return { accepted: false, code: 'control_seq_invalid', expectedControlSeq };
+    if (envelope.controlSeq < expectedControlSeq) return { accepted: false, code: 'control_duplicate', expectedControlSeq };
+    if (envelope.controlSeq > expectedControlSeq) return { accepted: false, code: 'control_gap', expectedControlSeq };
+    this.lastAcceptedControlSeq = envelope.controlSeq;
+    return { accepted: true, code: 'accepted', expectedControlSeq: this.lastAcceptedControlSeq + 1 };
+  }
+
+  /**
+   * Accept any strictly newer lossy pointer sequence number. Gaps are expected.
+   * @returns {{accepted:boolean, code:string, pointerHighWater:number}}
+   */
+  acceptPointer(envelope) {
+    if (!this.#matches(envelope)) {
+      return { accepted: false, code: 'producer_stale', pointerHighWater: this.lastAcceptedPointerSeq };
+    }
+    if (!positiveInteger(envelope.pointerSeq)) {
+      return { accepted: false, code: 'pointer_seq_invalid', pointerHighWater: this.lastAcceptedPointerSeq };
+    }
+    if (envelope.pointerSeq <= this.lastAcceptedPointerSeq) {
+      return { accepted: false, code: 'pointer_stale', pointerHighWater: this.lastAcceptedPointerSeq };
+    }
+    this.lastAcceptedPointerSeq = envelope.pointerSeq;
+    return { accepted: true, code: 'accepted', pointerHighWater: this.lastAcceptedPointerSeq };
+  }
+
+  snapshot() {
+    return Object.freeze({
+      producerId: this.producerId,
+      producerGeneration: this.producerGeneration,
+      lastAcceptedControlSeq: this.lastAcceptedControlSeq,
+      lastAcceptedPointerSeq: this.lastAcceptedPointerSeq,
+    });
+  }
+}

package/browser-runtime/service.js

@@ -0,0 +1,132 @@
+import { randomUUID } from 'node:crypto';
+import { normaliseBrowserRuntimeSection } from './config.js';
+import { defaultBrowserCacheDir } from './browser-install.js';
+import { probeBrowserRuntime } from './probe.js';
+import { BrowserRuntimeError } from './errors.js';
+
+/**
+ * Agent-local Browser Runtime lifecycle owner. Phase 0 exposes startup probe and
+ * capacity semantics only; Browser Sessions remain unavailable until the later
+ * owner-checked control-plane phase lands.
+ */
+export class BrowserRuntimeService {
+  constructor({ yeaftDir, config, probe = probeBrowserRuntime } = {}) {
+    if (!yeaftDir) throw new Error('yeaftDir required');
+    this.yeaftDir = yeaftDir;
+    this.config = normaliseBrowserRuntimeSection(config);
+    this.config.cacheDir ||= defaultBrowserCacheDir(yeaftDir);
+    this.probe = probe;
+    this.sessions = new Map();
+    this.probeResult = null;
+    this.state = this.config.enabled ? 'unprobed' : 'disabled';
+    this.#probePromise = null;
+    this.#probeAbort = null;
+    this.#shutdownPromise = null;
+  }
+
+  #probePromise;
+  #probeAbort;
+  #shutdownPromise;
+
+  get enabled() { return this.config.enabled === true; }
+  get ready() { return this.state === 'ready' && this.probeResult?.ok === true; }
+
+  capabilities() {
+    // Phase 0 is a local spike only. Advertising the Phase 1 feature before
+    // owner-checked create/attach/signaling exists would expose a dead route.
+    return [];
+  }
+
+  async startupProbe() {
+    if (!this.enabled) return { ok: false, code: 'browser_runtime_disabled' };
+    if (this.#probePromise) return this.#probePromise;
+    this.state = 'probing';
+    this.#probeAbort = new AbortController();
+    this.#probePromise = this.probe({
+      executablePath: this.config.executablePath,
+      cacheDir: this.config.cacheDir,
+      headless: this.config.headless,
+      timeoutMs: this.config.startupProbeTimeoutMs,
+      profileParent: `${this.config.cacheDir}-profiles`,
+      signal: this.#probeAbort.signal,
+    }).then(result => {
+      this.probeResult = Object.freeze({ ...result });
+      this.state = result.ok ? 'ready' : 'unavailable';
+      return this.probeResult;
+    }).catch(error => {
+      this.probeResult = Object.freeze({
+        ok: false,
+        code: error?.code || 'browser_probe_failed',
+        safeError: String(error?.message || error).slice(0, 500),
+      });
+      this.state = 'unavailable';
+      return this.probeResult;
+    });
+    return this.#probePromise;
+  }
+
+  assertCanCreateSession() {
+    if (!this.ready) throw new BrowserRuntimeError('browser_runtime_unavailable');
+    if (this.sessions.size >= this.config.maxSessions) {
+      throw new BrowserRuntimeError('browser_session_limit');
+    }
+  }
+
+  /** Phase 0 test hook for lifecycle/capacity ownership. */
+  reserveSession(ownerUserId) {
+    this.assertCanCreateSession();
+    if (!ownerUserId) throw new BrowserRuntimeError('browser_owner_required');
+    const browserSessionId = randomUUID();
+    this.sessions.set(browserSessionId, Object.freeze({
+      browserSessionId,
+      ownerUserId,
+      state: 'reserved',
+      createdAt: Date.now(),
+    }));
+    return this.sessions.get(browserSessionId);
+  }
+
+  releaseSession(browserSessionId) {
+    return this.sessions.delete(browserSessionId);
+  }
+
+  snapshot() {
+    return Object.freeze({
+      enabled: this.enabled,
+      ready: this.ready,
+      state: this.state,
+      activeSessions: this.sessions.size,
+      maxSessions: this.config.maxSessions,
+      probe: this.probeResult,
+    });
+  }
+
+  async shutdown() {
+    if (this.#shutdownPromise) return this.#shutdownPromise;
+    this.#probeAbort?.abort(new BrowserRuntimeError('browser_runtime_shutdown'));
+    this.#shutdownPromise = Promise.resolve(this.#probePromise).catch(() => {}).then(() => {
+      this.sessions.clear();
+      this.state = 'closed';
+    });
+    return this.#shutdownPromise;
+  }
+}
+
+let runtime = null;
+
+export function getBrowserRuntime() {
+  return runtime;
+}
+
+export async function bootBrowserRuntime(options) {
+  if (runtime) return runtime;
+  runtime = new BrowserRuntimeService(options);
+  await runtime.startupProbe();
+  return runtime;
+}
+
+export async function shutdownBrowserRuntime() {
+  const current = runtime;
+  runtime = null;
+  await current?.shutdown();
+}

package/browser-runtime/windows-version-job.ps1

@@ -0,0 +1,233 @@
+param(
+  [Parameter(Mandatory = $true)][string]$NodePath,
+  [Parameter(Mandatory = $true)][string]$WorkerPath,
+  [Parameter(Mandatory = $true)][string]$ExecutablePath,
+  [int]$CleanupTimeoutMs = 500
+)
+
+$ErrorActionPreference = 'Stop'
+
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public static class YeaftBrowserJob {
+    public const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x00002000;
+    public const int JobObjectBasicAccountingInformation = 1;
+    public const int JobObjectExtendedLimitInformation = 9;
+    public const uint PROCESS_SET_QUOTA = 0x0100;
+    public const uint PROCESS_TERMINATE = 0x0001;
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct IO_COUNTERS {
+        public UInt64 ReadOperationCount;
+        public UInt64 WriteOperationCount;
+        public UInt64 OtherOperationCount;
+        public UInt64 ReadTransferCount;
+        public UInt64 WriteTransferCount;
+        public UInt64 OtherTransferCount;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct JOBOBJECT_BASIC_LIMIT_INFORMATION {
+        public Int64 PerProcessUserTimeLimit;
+        public Int64 PerJobUserTimeLimit;
+        public UInt32 LimitFlags;
+        public UIntPtr MinimumWorkingSetSize;
+        public UIntPtr MaximumWorkingSetSize;
+        public UInt32 ActiveProcessLimit;
+        public UIntPtr Affinity;
+        public UInt32 PriorityClass;
+        public UInt32 SchedulingClass;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
+        public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
+        public IO_COUNTERS IoInfo;
+        public UIntPtr ProcessMemoryLimit;
+        public UIntPtr JobMemoryLimit;
+        public UIntPtr PeakProcessMemoryUsed;
+        public UIntPtr PeakJobMemoryUsed;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct JOBOBJECT_BASIC_ACCOUNTING_INFORMATION {
+        public Int64 TotalUserTime;
+        public Int64 TotalKernelTime;
+        public Int64 ThisPeriodTotalUserTime;
+        public Int64 ThisPeriodTotalKernelTime;
+        public UInt32 TotalPageFaultCount;
+        public UInt32 TotalProcesses;
+        public UInt32 ActiveProcesses;
+        public UInt32 TotalTerminatedProcesses;
+    }
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    public static extern IntPtr CreateJobObject(IntPtr securityAttributes, string name);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool SetInformationJobObject(
+        IntPtr job,
+        int infoClass,
+        IntPtr info,
+        UInt32 length
+    );
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool TerminateJobObject(IntPtr job, UInt32 exitCode);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool QueryInformationJobObject(
+        IntPtr job,
+        int infoClass,
+        IntPtr info,
+        UInt32 length,
+        out UInt32 returnLength
+    );
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern IntPtr OpenProcess(UInt32 desiredAccess, bool inheritHandle, UInt32 processId);
+
+    [DllImport("kernel32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool CloseHandle(IntPtr handle);
+
+    public static string QuoteArgument(string value) {
+        if (value.Length > 0 && value.IndexOfAny(new[] { ' ', '\t', '\n', '\v', '"' }) < 0) {
+            return value;
+        }
+        var output = new StringBuilder();
+        output.Append('"');
+        var slashes = 0;
+        foreach (var ch in value) {
+            if (ch == '\\') {
+                slashes++;
+            } else if (ch == '"') {
+                output.Append('\\', slashes * 2 + 1);
+                output.Append('"');
+                slashes = 0;
+            } else {
+                output.Append('\\', slashes);
+                slashes = 0;
+                output.Append(ch);
+            }
+        }
+        output.Append('\\', slashes * 2);
+        output.Append('"');
+        return output.ToString();
+    }
+}
+'@
+
+function Throw-Win32Error([string]$Operation) {
+  $code = [Runtime.InteropServices.Marshal]::GetLastWin32Error()
+  throw "$Operation failed with Win32 error $code"
+}
+
+$job = [IntPtr]::Zero
+$workerHandle = [IntPtr]::Zero
+$worker = $null
+$resultLine = $null
+try {
+  $job = [YeaftBrowserJob]::CreateJobObject([IntPtr]::Zero, $null)
+  if ($job -eq [IntPtr]::Zero) { Throw-Win32Error 'CreateJobObject' }
+
+  $limit = New-Object YeaftBrowserJob+JOBOBJECT_EXTENDED_LIMIT_INFORMATION
+  $basicLimit = $limit.BasicLimitInformation
+  $basicLimit.LimitFlags = [YeaftBrowserJob]::JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+  $limit.BasicLimitInformation = $basicLimit
+  $limitSize = [Runtime.InteropServices.Marshal]::SizeOf($limit)
+  $limitPtr = [Runtime.InteropServices.Marshal]::AllocHGlobal($limitSize)
+  try {
+    [Runtime.InteropServices.Marshal]::StructureToPtr($limit, $limitPtr, $false)
+    if (-not [YeaftBrowserJob]::SetInformationJobObject(
+      $job,
+      [YeaftBrowserJob]::JobObjectExtendedLimitInformation,
+      $limitPtr,
+      [uint32]$limitSize
+    )) { Throw-Win32Error 'SetInformationJobObject' }
+  } finally {
+    [Runtime.InteropServices.Marshal]::FreeHGlobal($limitPtr)
+  }
+
+  $start = New-Object System.Diagnostics.ProcessStartInfo
+  $start.FileName = $NodePath
+  $start.Arguments = [YeaftBrowserJob]::QuoteArgument($WorkerPath) + ' ' + [YeaftBrowserJob]::QuoteArgument($ExecutablePath)
+  $start.UseShellExecute = $false
+  $start.CreateNoWindow = $true
+  $start.RedirectStandardInput = $true
+  $start.RedirectStandardOutput = $true
+  $start.RedirectStandardError = $true
+
+  $worker = New-Object System.Diagnostics.Process
+  $worker.StartInfo = $start
+  if (-not $worker.Start()) { throw 'Windows version worker did not start' }
+  $workerHandle = [YeaftBrowserJob]::OpenProcess(
+    [YeaftBrowserJob]::PROCESS_SET_QUOTA -bor [YeaftBrowserJob]::PROCESS_TERMINATE,
+    $false,
+    [uint32]$worker.Id
+  )
+  if ($workerHandle -eq [IntPtr]::Zero) { Throw-Win32Error 'OpenProcess' }
+  if (-not [YeaftBrowserJob]::AssignProcessToJobObject($job, $workerHandle)) {
+    Throw-Win32Error 'AssignProcessToJobObject'
+  }
+
+  $worker.StandardInput.WriteLine('go')
+  $worker.StandardInput.Close()
+  $resultLine = $worker.StandardOutput.ReadLine()
+  if ([string]::IsNullOrWhiteSpace($resultLine)) {
+    if (-not $worker.HasExited) {
+      [void][YeaftBrowserJob]::TerminateJobObject($job, 1)
+      $worker.WaitForExit()
+    }
+    $workerError = $worker.StandardError.ReadToEnd()
+    throw "Windows version worker returned no result ($($worker.ExitCode)): $workerError"
+  }
+
+  if (-not [YeaftBrowserJob]::TerminateJobObject($job, 1)) {
+    Throw-Win32Error 'TerminateJobObject'
+  }
+
+  $accounting = New-Object YeaftBrowserJob+JOBOBJECT_BASIC_ACCOUNTING_INFORMATION
+  $accountingSize = [Runtime.InteropServices.Marshal]::SizeOf($accounting)
+  $accountingPtr = [Runtime.InteropServices.Marshal]::AllocHGlobal($accountingSize)
+  try {
+    $deadline = [DateTime]::UtcNow.AddMilliseconds([Math]::Max(1, $CleanupTimeoutMs))
+    do {
+      [uint32]$returned = 0
+      if (-not [YeaftBrowserJob]::QueryInformationJobObject(
+        $job,
+        [YeaftBrowserJob]::JobObjectBasicAccountingInformation,
+        $accountingPtr,
+        [uint32]$accountingSize,
+        [ref]$returned
+      )) { Throw-Win32Error 'QueryInformationJobObject' }
+      $accounting = [Runtime.InteropServices.Marshal]::PtrToStructure(
+        $accountingPtr,
+        [type][YeaftBrowserJob+JOBOBJECT_BASIC_ACCOUNTING_INFORMATION]
+      )
+      if ($accounting.ActiveProcesses -eq 0) { break }
+      Start-Sleep -Milliseconds 10
+    } while ([DateTime]::UtcNow -lt $deadline)
+    if ($accounting.ActiveProcesses -ne 0) {
+      throw "Windows Browser Runtime job still has $($accounting.ActiveProcesses) active process(es)"
+    }
+  } finally {
+    [Runtime.InteropServices.Marshal]::FreeHGlobal($accountingPtr)
+  }
+
+  [Console]::Out.WriteLine($resultLine)
+} finally {
+  if ($workerHandle -ne [IntPtr]::Zero) { [void][YeaftBrowserJob]::CloseHandle($workerHandle) }
+  if ($job -ne [IntPtr]::Zero) { [void][YeaftBrowserJob]::CloseHandle($job) }
+  if ($null -ne $worker) { $worker.Dispose() }
+}

package/browser-runtime/windows-version-worker.js

@@ -0,0 +1,75 @@
+import { spawn } from 'node:child_process';
+
+const MAX_OUTPUT_BYTES = 64 * 1024;
+
+function writeResult(result) {
+  process.stdout.write(`${JSON.stringify(result)}\n`, () => process.exit(0));
+}
+
+function capture(chunks, chunk, state) {
+  const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+  const remaining = MAX_OUTPUT_BYTES - state.bytes;
+  if (remaining <= 0) {
+    state.truncated = true;
+    return;
+  }
+  const bounded = buffer.length > remaining ? buffer.subarray(0, remaining) : buffer;
+  chunks.push(bounded);
+  state.bytes += bounded.length;
+  if (bounded.length !== buffer.length) state.truncated = true;
+}
+
+function run(executablePath) {
+  return new Promise(resolve => {
+    let child;
+    try {
+      child = spawn(executablePath, ['--version'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+      });
+    } catch (error) {
+      resolve({ ok: false, error: String(error?.message || error) });
+      return;
+    }
+    const stdout = [];
+    const stderr = [];
+    const stdoutState = { bytes: 0, truncated: false };
+    const stderrState = { bytes: 0, truncated: false };
+    const stopOnOverflow = state => {
+      if (!state.truncated) return;
+      try { child.kill('SIGKILL'); } catch {}
+    };
+    child.stdout.on('data', chunk => {
+      capture(stdout, chunk, stdoutState);
+      stopOnOverflow(stdoutState);
+    });
+    child.stderr.on('data', chunk => {
+      capture(stderr, chunk, stderrState);
+      stopOnOverflow(stderrState);
+    });
+    let settled = false;
+    const finish = result => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+    child.once('error', error => finish({ ok: false, error: String(error?.message || error) }));
+    child.once('close', code => finish({
+      ok: true,
+      code: code ?? 1,
+      stdout: Buffer.concat(stdout).toString('utf8').replace(/\r/g, ''),
+      stderr: Buffer.concat(stderr).toString('utf8').replace(/\r/g, ''),
+      truncated: stdoutState.truncated || stderrState.truncated,
+    }));
+  });
+}
+
+let started = false;
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', async chunk => {
+  if (started || !String(chunk).split(/\r?\n/).includes('go')) return;
+  started = true;
+  const result = await run(process.argv[2]);
+  writeResult(result);
+});
+process.stdin.resume();

package/browser-runtime/windows-version.js

@@ -0,0 +1,85 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runProcess } from '../yeaft/tools/process-runner.js';
+
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const WINDOWS_JOB_SCRIPT = join(MODULE_DIR, 'windows-version-job.ps1');
+const WINDOWS_WORKER = join(MODULE_DIR, 'windows-version-worker.js');
+const DEFAULT_WINDOWS_CLEANUP_MS = 500;
+
+export function resolveWindowsPowerShell({ env = process.env, fileExists = existsSync } = {}) {
+  const systemRoot = env.SystemRoot || env.WINDIR || 'C:\\Windows';
+  const candidates = [
+    join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+    'powershell.exe',
+  ];
+  return candidates.find(candidate => candidate === 'powershell.exe' || fileExists(candidate));
+}
+
+function remaining(deadline, fallback) {
+  if (!Number.isFinite(deadline)) return fallback;
+  return Math.max(1, deadline - Date.now());
+}
+
+export async function readWindowsBrowserExecutableVersion(executablePath, {
+  signal = null,
+  terminationDeadline = null,
+  run = runProcess,
+  powershellPath = resolveWindowsPowerShell(),
+  nodePath = process.execPath,
+  workerPath = WINDOWS_WORKER,
+  jobScriptPath = WINDOWS_JOB_SCRIPT,
+  env = process.env,
+} = {}) {
+  const cleanupMs = Number.isFinite(terminationDeadline)
+    ? Math.min(DEFAULT_WINDOWS_CLEANUP_MS, remaining(terminationDeadline, DEFAULT_WINDOWS_CLEANUP_MS))
+    : DEFAULT_WINDOWS_CLEANUP_MS;
+  const timeoutMs = remaining(terminationDeadline, 20_000);
+  const result = await run(powershellPath, [
+    '-NoLogo',
+    '-NoProfile',
+    '-NonInteractive',
+    '-ExecutionPolicy',
+    'Bypass',
+    '-File',
+    jobScriptPath,
+    '-NodePath',
+    nodePath,
+    '-WorkerPath',
+    workerPath,
+    '-ExecutablePath',
+    executablePath,
+    '-CleanupTimeoutMs',
+    String(cleanupMs),
+  ], {
+    signal,
+    timeoutMs,
+    maxBytes: 128 * 1024,
+    env,
+    killGraceMs: 0,
+    gracefulTerminationDeadline: terminationDeadline,
+    terminationDeadline,
+    forceSettleMs: cleanupMs,
+    treeKillTimeoutMs: cleanupMs,
+    requireExitConfirmation: true,
+  });
+  if (result.code !== 0) {
+    const termination = result.terminationError ? ` ${result.terminationError}` : '';
+    throw new Error(`Managed Chrome version job failed (${result.code}): ${result.stderr.slice(0, 500)}${termination}`);
+  }
+
+  const line = result.stdout.trim().split(/\r?\n/).at(-1);
+  let payload;
+  try {
+    payload = JSON.parse(line);
+  } catch {
+    throw new Error(`Managed Chrome version job returned invalid output: ${result.stdout.slice(0, 500)}`);
+  }
+  if (!payload?.ok) throw new Error(`Managed Chrome version check failed: ${payload?.error || 'unknown worker error'}`);
+  if (payload.code !== 0) {
+    throw new Error(`Managed Chrome version check failed (${payload.code}): ${String(payload.stderr || '').slice(0, 200)}`);
+  }
+  if (payload.truncated) throw new Error('Managed Chrome version output exceeded its bounded capture');
+  return String(payload.stdout || '').trim();
+}