rea-agents 6.2.0 → 6.4.0

package/dist/process/ProcessRunTokenObservations.js

@@ -0,0 +1,48 @@
+const errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+/** Read only ownership tokens, using per-process fallback for missing batch rows. */
+export async function* readProcessRunTokens(host, processes, signal) {
+    signal?.throwIfAborted();
+    if (processes.length === 0)
+        return;
+    let batch;
+    let batchFailure;
+    if (host.runTokens !== undefined) {
+        try {
+            batch =
+                signal === undefined
+                    ? await host.runTokens(processes)
+                    : await host.runTokens(processes, signal);
+        }
+        catch (cause) {
+            signal?.throwIfAborted();
+            batchFailure = errorMessage(cause);
+        }
+    }
+    for (const process of processes) {
+        signal?.throwIfAborted();
+        let observation = batch?.get(process.pid);
+        if (observation === undefined) {
+            try {
+                const environment = signal === undefined
+                    ? await host.environment(process.pid)
+                    : await host.environment(process.pid, signal);
+                observation = {
+                    state: "readable",
+                    runId: environment.REA_PROCESS_RUN_ID,
+                };
+            }
+            catch (cause) {
+                signal?.throwIfAborted();
+                const reason = errorMessage(cause);
+                observation = {
+                    state: "unavailable",
+                    reason: batchFailure === undefined
+                        ? reason
+                        : `${reason}; run-token batch failed: ${batchFailure}`,
+                };
+            }
+        }
+        signal?.throwIfAborted();
+        yield { process, observation };
+    }
+}

package/dist/process/ProviderDiagnosticRedaction.js

@@ -0,0 +1,17 @@
+/** Redact explicit transport credentials from complete and budget-cut output. */
+export const redactCapturedTransportCredential = (stream, token, replacement) => {
+    if (token === undefined || token.length === 0)
+        return stream.text;
+    const { text } = stream;
+    const cutOff = stream.observedBytes > stream.bytes;
+    if (cutOff && !text.endsWith(token)) {
+        const maximumPrefixLength = Math.min(text.length, token.length - 1);
+        for (let prefixLength = maximumPrefixLength; prefixLength > 0; prefixLength -= 1) {
+            if (text.endsWith(token.slice(0, prefixLength)))
+                return `${text
+                    .slice(0, text.length - prefixLength)
+                    .replaceAll(token, replacement)}${replacement}`;
+        }
+    }
+    return text.replaceAll(token, replacement);
+};

package/dist/process/ProviderProcess.js

@@ -117,8 +117,8 @@ export class ProviderProcessSupervisor {
     snapshot() {
         return {
             ...(this.#diagnosticTruncated ? { diagnosticTruncated: true } : {}),
-            stdout: this.#stdout.snapshot(),
-            stderr: this.#stderr.snapshot(),
+            stdout: this.#stdout.snapshot(this.#stdoutObservedBytes),
+            stderr: this.#stderr.snapshot(this.#stderrObservedBytes),
             exitCode: this.#exitObservation?.code,
             signal: this.#exitObservation?.signal,
         };
@@ -301,11 +301,12 @@ class ProcessOutputCapture {
         this.#bytes += chunk.byteLength;
         this.#chunks.push(Buffer.from(chunk));
     }
-    snapshot() {
+    snapshot(observedBytes) {
         const text = Buffer.concat(this.#chunks, this.#bytes).toString("utf8");
         return {
             text,
             bytes: this.#bytes,
+            observedBytes,
         };
     }
 }

package/dist/process/capture/FilesystemSnapshot.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
-import { lstat, open, readdir, readlink } from "node:fs/promises";
+import { lstat, open, opendir, readlink } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
 const hasSameIdentity = (before, after, expected) => before.dev === after.dev &&
     before.ino === after.ino &&
@@ -13,6 +13,23 @@ const hasSameFileState = (before, after) => before.dev === after.dev &&
     before.size === after.size &&
     before.mtimeMs === after.mtimeMs &&
     before.ctimeMs === after.ctimeMs;
+const fileUnavailableSystemCode = (cause) => {
+    if (!(cause instanceof Error) || !("code" in cause))
+        return undefined;
+    const code = cause.code;
+    return typeof code === "string" &&
+        [
+            "EACCES",
+            "EISDIR",
+            "ELOOP",
+            "ENOTDIR",
+            "ENOENT",
+            "EPERM",
+            "ESTALE",
+        ].includes(code)
+        ? code
+        : undefined;
+};
 const lstatIfPresent = async (path) => {
     try {
         return await lstat(path);
@@ -26,15 +43,33 @@ const lstatIfPresent = async (path) => {
 /** Hash a file only when its opened descriptor still matches the captured path state. */
 export const hashFile = async (path, expected, maxBytes, signal) => {
     signal?.throwIfAborted();
-    const handle = await open(path, fsConstants.O_RDONLY |
-        (fsConstants.O_NOFOLLOW ?? 0) |
-        (fsConstants.O_NONBLOCK ?? 0));
+    let handle;
+    try {
+        handle = await open(path, fsConstants.O_RDONLY |
+            (fsConstants.O_NOFOLLOW ?? 0) |
+            (fsConstants.O_NONBLOCK ?? 0));
+    }
+    catch (cause) {
+        signal?.throwIfAborted();
+        const systemCode = fileUnavailableSystemCode(cause);
+        if (systemCode === undefined)
+            throw cause;
+        return {
+            state: "omitted",
+            reason: "file_unavailable",
+            system_code: systemCode,
+        };
+    }
     try {
         signal?.throwIfAborted();
         const stats = await handle.stat();
         signal?.throwIfAborted();
         if (!hasSameFileState(expected, stats) || stats.size > maxBytes)
-            return null;
+            return {
+                state: "omitted",
+                reason: "file_changed_or_short_read",
+                system_code: null,
+            };
         const hash = createHash("sha256");
         const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, maxBytes));
         let position = 0;
@@ -42,15 +77,34 @@ export const hashFile = async (path, expected, maxBytes, signal) => {
             signal?.throwIfAborted();
             const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, stats.size - position), position);
             if (bytesRead === 0)
-                return null;
+                return {
+                    state: "omitted",
+                    reason: "file_changed_or_short_read",
+                    system_code: null,
+                };
             hash.update(buffer.subarray(0, bytesRead));
             position += bytesRead;
         }
         const after = await handle.stat();
         signal?.throwIfAborted();
         if (!hasSameFileState(stats, after))
-            return null;
-        return hash.digest("hex");
+            return {
+                state: "omitted",
+                reason: "file_changed_or_short_read",
+                system_code: null,
+            };
+        return { state: "hashed", sha256: hash.digest("hex") };
+    }
+    catch (cause) {
+        signal?.throwIfAborted();
+        const systemCode = fileUnavailableSystemCode(cause);
+        if (systemCode === undefined)
+            throw cause;
+        return {
+            state: "omitted",
+            reason: "file_unavailable",
+            system_code: systemCode,
+        };
     }
     finally {
         await handle.close();
@@ -61,6 +115,7 @@ export const snapshotRoots = async (scenario, signal) => {
     const entries = [];
     const completeRoots = [];
     let remainingBytes = scenario.limits.file_bytes;
+    let pendingNames = 0;
     let truncated = false;
     const enumerationReasons = new Set();
     const hashOmissions = [];
@@ -98,20 +153,36 @@ export const snapshotRoots = async (scenario, signal) => {
             return true;
         }
         if (stats.isFile()) {
-            const sha256 = remainingBytes >= stats.size
-                ? await hashFile(path, stats, remainingBytes, signal)
-                : null;
-            remainingBytes -= sha256 === null ? 0 : stats.size;
-            if (sha256 === null) {
-                truncated = true;
-                hashOmissions.push({
+            let sha256 = null;
+            let omission;
+            if (remainingBytes < stats.size) {
+                omission = {
                     path: `${rootAlias}:${relativePath}`,
                     size_bytes: stats.size,
                     remaining_budget_bytes: remainingBytes,
-                    reason: remainingBytes < stats.size
-                        ? "file_bytes_budget"
-                        : "file_changed_or_short_read",
-                });
+                    reason: "file_bytes_budget",
+                    system_code: null,
+                };
+            }
+            else {
+                const outcome = await hashFile(path, stats, remainingBytes, signal);
+                if (outcome.state === "hashed") {
+                    sha256 = outcome.sha256;
+                    remainingBytes -= stats.size;
+                }
+                else {
+                    omission = {
+                        path: `${rootAlias}:${relativePath}`,
+                        size_bytes: stats.size,
+                        remaining_budget_bytes: remainingBytes,
+                        reason: outcome.reason,
+                        system_code: outcome.system_code,
+                    };
+                }
+            }
+            if (omission !== undefined) {
+                truncated = true;
+                hashOmissions.push(omission);
             }
             entries.push({
                 path: `${rootAlias}:${relativePath}`,
@@ -134,15 +205,38 @@ export const snapshotRoots = async (scenario, signal) => {
         });
         if (type !== "directory")
             return true;
-        const children = await readdir(path);
+        const children = [];
+        let complete = true;
+        const remainingEntries = scenario.limits.files - entries.length - pendingNames;
+        const directory = await opendir(path);
+        for await (const child of directory) {
+            signal?.throwIfAborted();
+            if (children.length >= remainingEntries ||
+                depth >= scenario.limits.filesystem_depth) {
+                truncated = true;
+                complete = false;
+                if (children.length >= remainingEntries)
+                    enumerationReasons.add("files_limit");
+                if (depth >= scenario.limits.filesystem_depth)
+                    enumerationReasons.add("depth_limit");
+                break;
+            }
+            children.push(child.name);
+            pendingNames += 1;
+        }
         const afterRead = await lstat(path);
         if (!hasSameIdentity(stats, afterRead, "directory")) {
+            pendingNames -= children.length;
             truncated = true;
             enumerationReasons.add("identity_changed");
             return false;
         }
-        let complete = true;
-        for (const child of children.sort()) {
+        children.sort().reverse();
+        while (children.length > 0) {
+            const child = children.pop();
+            if (child === undefined)
+                break;
+            pendingNames -= 1;
             if (!(await visit(root, rootAlias, join(path, child), depth + 1)))
                 complete = false;
         }