rea-agents 2.0.0 → 2.2.0

package/dist/process/ProcessOwnership.js

@@ -2,6 +2,26 @@ import { execFile } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
+/**
+ * Terminate one Windows process tree through the platform utility.
+ *
+ * This is a bounded P0 cleanup mechanism, not Job Object ownership proof. The
+ * caller-visible Windows limitations must preserve that distinction.
+ */
+export const cleanupWindowsProcessTree = async (rootPid, host = systemWindowsProcessTreeHost) => {
+    if (!Number.isSafeInteger(rootPid) || rootPid <= 0)
+        return { cleaned: false, reason: "Windows process-tree PID is invalid" };
+    try {
+        const result = await host.terminateTree(rootPid);
+        return { cleaned: true, signaled: result === "terminated" };
+    }
+    catch {
+        return {
+            cleaned: false,
+            reason: "Windows P0 process-tree termination failed; Job Object ownership is unavailable",
+        };
+    }
+};
 /** Select the PTY root group and groups led by an observed captured process. */
 export const selectCapturedProcessGroupIds = (rootPid, samples) => {
     const processGroupIds = new Set([rootPid]);
@@ -58,6 +78,21 @@ const systemHost = {
         process.kill(-processGroupId, signal);
     },
 };
+const systemWindowsProcessTreeHost = {
+    async terminateTree(rootPid) {
+        try {
+            await execFileAsync("taskkill.exe", ["/pid", String(rootPid), "/t", "/f"], { windowsHide: true, timeout: 5_000 });
+            return "terminated";
+        }
+        catch (cause) {
+            if (cause instanceof Error &&
+                "code" in cause &&
+                (cause.code === 128 || cause.code === "ESRCH"))
+                return "missing";
+            throw cause;
+        }
+    },
+};
 /** Read the capture run token currently exposed by one live process. */
 export const readProcessRunId = async (pid, host = systemHost) => (await host.environment(pid)).REA_PROCESS_RUN_ID;
 /**

package/dist/process/ProviderProcess.js

@@ -11,8 +11,10 @@ const DEFAULT_KILL_GRACE_MS = 1_000;
 export const spawnOwnedProviderProcess = async (options) => {
     const child = spawn(options.command, [...options.arguments], {
         shell: false,
+        windowsHide: true,
         stdio: ["ignore", "pipe", "pipe"],
         detached: process.platform !== "win32",
+        windowsVerbatimArguments: options.windowsVerbatimArguments ?? false,
         env: {
             ...process.env,
             ...options.env,

package/dist/replay/JavaScriptReplayWorker.js

@@ -178,58 +178,72 @@ const requiredModule = (modules, alias) => {
 const normalizeFactorySource = (source) => /^\s*\d+\s*\(/u.test(source)
     ? source.replace(/^\s*\d+\s*\(/u, "function(")
     : source;
-const projectValue = (value, maximumDepth, maximumNodes) => {
-    let nodes = 0;
-    const visit = (candidate, depth, ancestors) => {
-        nodes += 1;
-        if (nodes > maximumNodes || depth > maximumDepth)
-            throw new RangeError("Replay result projection limit exceeded");
-        if (candidate === null ||
-            typeof candidate === "string" ||
-            typeof candidate === "boolean")
-            return candidate;
-        if (typeof candidate === "number") {
-            if (!Number.isFinite(candidate))
-                throw new TypeError("Non-finite replay result number");
-            return candidate;
-        }
-        if (typeof candidate !== "object")
-            throw new TypeError(`Unsupported replay result type: ${typeof candidate}`);
-        if (types.isProxy(candidate))
-            throw new TypeError("Proxy replay results are unavailable");
-        if (ancestors.has(candidate))
-            throw new TypeError("Cyclic replay result");
-        ancestors.add(candidate);
-        try {
-            const descriptors = Object.getOwnPropertyDescriptors(candidate);
-            const output = Array.isArray(candidate)
-                ? []
-                : {};
-            if (!Array.isArray(candidate)) {
-                const prototype = Object.getPrototypeOf(candidate);
-                if (prototype !== null && Object.getPrototypeOf(prototype) !== null)
-                    throw new TypeError("Unsupported replay result prototype");
-            }
-            for (const [key, descriptor] of Object.entries(descriptors)) {
-                if (key === "length" && Array.isArray(candidate))
-                    continue;
-                if (!("value" in descriptor))
-                    throw new TypeError("Replay result accessors are unavailable");
-                if (Array.isArray(output)) {
-                    if (!/^\d+$/u.test(key))
-                        throw new TypeError("Replay arrays may only contain indexed values");
-                    output[Number(key)] = visit(descriptor.value, depth + 1, ancestors);
-                }
-                else
-                    output[key] = visit(descriptor.value, depth + 1, ancestors);
-            }
-            return output;
+const projectValue = (value, maximumDepth, maximumNodes) => projectValueRecursive(value, 0, new Set(), {
+    maximumDepth,
+    maximumNodes,
+    nodes: 0,
+});
+const projectValueRecursive = (candidate, depth, ancestors, context) => {
+    context.nodes += 1;
+    if (context.nodes > context.maximumNodes || depth > context.maximumDepth)
+        throw new RangeError("Replay result projection limit exceeded");
+    const leaf = projectLeaf(candidate);
+    if (leaf !== undefined)
+        return leaf;
+    if (typeof candidate !== "object" || candidate === null)
+        throw new TypeError(`Unsupported replay result type: ${typeof candidate}`);
+    if (types.isProxy(candidate))
+        throw new TypeError("Proxy replay results are unavailable");
+    if (ancestors.has(candidate))
+        throw new TypeError("Cyclic replay result");
+    ancestors.add(candidate);
+    try {
+        assertSupportedPrototype(candidate);
+        return projectComplexValue(candidate, depth, ancestors, context);
+    }
+    finally {
+        ancestors.delete(candidate);
+    }
+};
+const projectLeaf = (candidate) => {
+    if (candidate === null ||
+        typeof candidate === "string" ||
+        typeof candidate === "boolean")
+        return candidate;
+    if (typeof candidate === "number") {
+        if (!Number.isFinite(candidate))
+            throw new TypeError("Non-finite replay result number");
+        return candidate;
+    }
+    return undefined;
+};
+const assertSupportedPrototype = (candidate) => {
+    if (Array.isArray(candidate))
+        return;
+    const prototype = Object.getPrototypeOf(candidate);
+    if (prototype !== null && Object.getPrototypeOf(prototype) !== null)
+        throw new TypeError("Unsupported replay result prototype");
+};
+const projectComplexValue = (candidate, depth, ancestors, context) => {
+    const descriptors = Object.getOwnPropertyDescriptors(candidate);
+    const output = Array.isArray(candidate)
+        ? []
+        : {};
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+        if (key === "length" && Array.isArray(candidate))
+            continue;
+        if (!("value" in descriptor))
+            throw new TypeError("Replay result accessors are unavailable");
+        if (Array.isArray(output)) {
+            if (!/^\d+$/u.test(key))
+                throw new TypeError("Replay arrays may only contain indexed values");
+            output[Number(key)] = projectValueRecursive(descriptor.value, depth + 1, ancestors, context);
         }
-        finally {
-            ancestors.delete(candidate);
+        else {
+            output[key] = projectValueRecursive(descriptor.value, depth + 1, ancestors, context);
         }
-    };
-    return visit(value, 0, new Set());
+    }
+    return output;
 };
 const exceptionOutcome = (replayCase, outcome, error, maximumBytes) => {
     const details = exceptionDetails(error);