rea-agents 3.0.0 → 3.2.0

package/dist/process/ProviderDeadline.js

@@ -26,8 +26,7 @@ export class ProviderStartupDeadline {
     #externalSignal;
     #onExternalAbort;
     #timer;
-    #timedOut = false;
-    #cancelled = false;
+    #interruption;
     constructor(timeoutMs, signal) {
         this.timeoutMs = timeoutMs;
         if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
@@ -38,11 +37,11 @@ export class ProviderStartupDeadline {
             if (this.#controller.signal.aborted)
                 return;
             if (Date.now() >= this.#deadlineAt) {
-                this.#timedOut = true;
+                this.#interruption = "timeout";
                 this.#abort(new DOMException("Provider startup deadline elapsed", "TimeoutError"));
                 return;
             }
-            this.#cancelled = true;
+            this.#interruption = "cancelled";
             this.#abort(signal?.reason);
         };
         if (signal?.aborted === true) {
@@ -53,7 +52,7 @@ export class ProviderStartupDeadline {
         this.#timer = setTimeout(() => {
             if (this.#controller.signal.aborted)
                 return;
-            this.#timedOut = true;
+            this.#interruption = "timeout";
             this.#abort(new DOMException("Provider startup deadline elapsed", "TimeoutError"));
         }, timeoutMs);
     }
@@ -61,13 +60,10 @@ export class ProviderStartupDeadline {
     get signal() {
         return this.#controller.signal;
     }
-    /** True only when the external caller signal initiated cancellation. */
-    get cancelled() {
-        return this.#cancelled;
-    }
-    /** True when the absolute startup deadline has elapsed. */
-    get timedOut() {
-        return (this.#timedOut || (!this.#cancelled && Date.now() >= this.#deadlineAt));
+    /** First control path that interrupted startup, if any. */
+    get interruption() {
+        return (this.#interruption ??
+            (Date.now() >= this.#deadlineAt ? "timeout" : undefined));
     }
     /** Milliseconds still available to the next startup phase. */
     remainingMs() {

package/dist/process/ProviderProcess.js

@@ -1,5 +1,4 @@
 import { spawn } from "node:child_process";
-const DEFAULT_OUTPUT_BYTES = 64 * 1024;
 const DEFAULT_TERMINATION_GRACE_MS = 250;
 const DEFAULT_KILL_GRACE_MS = 1_000;
 /**
@@ -47,8 +46,8 @@ export const spawnOwnedProviderProcess = async (options) => {
 export class ProviderProcessSupervisor {
     launch;
     #options;
-    #stdout;
-    #stderr;
+    #stdout = new ProcessOutputCapture();
+    #stderr = new ProcessOutputCapture();
     #exit = deferred();
     #onStdout = (chunk) => {
         this.#capture("stdout", this.#stdout, chunk);
@@ -71,11 +70,6 @@ export class ProviderProcessSupervisor {
     constructor(launch, options = {}) {
         this.launch = launch;
         this.#options = options;
-        const limit = options.maxOutputBytesPerStream ?? DEFAULT_OUTPUT_BYTES;
-        if (!Number.isSafeInteger(limit) || limit <= 0)
-            throw new RangeError("Provider output limit must be a positive integer");
-        this.#stdout = new BoundedByteCapture(limit);
-        this.#stderr = new BoundedByteCapture(limit);
         this.#attach(launch.process.stdout, "stdout");
         this.#attach(launch.process.stderr, "stderr");
         launch.process.once("exit", this.#onExit);
@@ -84,7 +78,7 @@ export class ProviderProcessSupervisor {
         if (launch.process.exitCode !== null || launch.process.signalCode !== null)
             this.#recordExit(launch.process.exitCode, launch.process.signalCode);
     }
-    /** Latest bounded output and exit observation. */
+    /** Latest complete output and exit observation. */
     snapshot() {
         return {
             stdout: this.#stdout.snapshot(),
@@ -203,7 +197,6 @@ export class ProviderProcessSupervisor {
             stream,
             bytes: bytes.byteLength,
             totalBytes: capture.bytes,
-            truncated: capture.truncated,
         });
     }
     #recordExit(code, signal) {
@@ -219,35 +212,21 @@ export class ProviderProcessSupervisor {
         });
     }
 }
-class BoundedByteCapture {
-    limit;
+class ProcessOutputCapture {
     #chunks = [];
     #bytes = 0;
-    #retainedBytes = 0;
-    constructor(limit) {
-        this.limit = limit;
-    }
     get bytes() {
         return this.#bytes;
     }
-    get truncated() {
-        return this.#bytes > this.#retainedBytes;
-    }
     append(chunk) {
         this.#bytes += chunk.byteLength;
-        const remaining = this.limit - this.#retainedBytes;
-        if (remaining <= 0)
-            return;
-        const retained = Buffer.from(chunk.subarray(0, remaining));
-        this.#chunks.push(retained);
-        this.#retainedBytes += retained.byteLength;
+        this.#chunks.push(Buffer.from(chunk));
     }
     snapshot() {
+        const text = Buffer.concat(this.#chunks, this.#bytes).toString("utf8");
         return {
-            text: Buffer.concat(this.#chunks, this.#retainedBytes).toString("utf8"),
+            text,
             bytes: this.#bytes,
-            retainedBytes: this.#retainedBytes,
-            truncated: this.truncated,
         };
     }
 }

package/dist/process/WindowsAuthority.js

@@ -0,0 +1,32 @@
+/** Stable explanation used whenever the native Windows authority is absent. */
+export const WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON = "Verified Windows native authority is unavailable: Job Object process ownership, private runtime DACL enforcement, and reparse-safe path admission are not implemented; chmod(0700) is insufficient for Windows private DACL proof, and taskkill is not a Job Object security proof";
+/**
+ * Describe native Windows controls without inferring them from taskkill,
+ * chmod, symlink creation, or a numeric POSIX open flag.
+ */
+export const windowsNativeCapabilities = (platform) => {
+    if (platform !== "win32") {
+        const notApplicable = {
+            available: false,
+            reason: "Windows native authority is not applicable on this host",
+            proof: "not-applicable",
+        };
+        return {
+            job_object_process_ownership: notApplicable,
+            private_runtime_dacl: notApplicable,
+            reparse_safe_path_admission: notApplicable,
+        };
+    }
+    const notProven = {
+        available: false,
+        reason: WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON,
+        proof: "not-proven",
+    };
+    return {
+        job_object_process_ownership: notProven,
+        private_runtime_dacl: notProven,
+        reparse_safe_path_admission: notProven,
+    };
+};
+/** Whether every native control needed for Windows isolation is proven. */
+export const hasWindowsNativeAuthority = (platform) => Object.values(windowsNativeCapabilities(platform)).every(({ available }) => available);

package/dist/reference/ReferenceSourceReader.js

@@ -1,61 +1,45 @@
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 import { err, ok } from "../domain/result.js";
 import { traverseDirectory } from "./ReferenceSourceReaderEntries.js";
-import { compareNames } from "./ReferenceSourceReaderPaths.js";
 import {} from "./ReferenceSourceReaderTypes.js";
 import { isAborted, noFollowOpenSupported, prepareRoot, } from "./ReferenceSourceReaderValidate.js";
-const DEFAULT_LIMITS = {
-    maxBytes: 16 * 1024 * 1024,
-    maxEntries: 10_000,
-    maxDepth: 32,
-    maxPathBytes: 4_096,
-};
 const PATH_RACE_LIMITATION = "Path identity is revalidated around operations; Node lacks portable descriptor-relative openat traversal, so a syscall-boundary pathname race remains.";
-/** Read a bounded source tree without intentionally following symbolic links. */
-export const readReferenceSource = async (root, limits = DEFAULT_LIMITS, options = {}) => {
+/** Read a source tree without intentionally following symbolic links. */
+export const readReferenceSource = async (root, options = {}) => {
     if (!noFollowOpenSupported())
         return err({
             tag: "reference-source-reader",
             code: "unsupported",
             message: "Safe no-follow file opens are unavailable",
         });
-    const prepared = await prepareRoot(root, limits, options.signal);
+    const prepared = await prepareRoot(root, options.signal);
     if (!prepared.ok)
         return prepared;
     const { canonicalRoot, rootIdentity } = prepared.value;
     const state = {
         root: canonicalRoot,
         rootIdentity,
-        limits,
         ...(options.signal === undefined ? {} : { signal: options.signal }),
         ...(options.shouldExclude === undefined
             ? {}
             : { shouldExclude: options.shouldExclude }),
         entries: [],
-        pending: [{ path: canonicalRoot, depth: 0 }],
+        pending: [{ path: canonicalRoot }],
         bytesRead: 0,
-        filesSeen: 0,
-        truncated: false,
-        stopped: false,
     };
     const traversal = await traverse(state);
     if (!traversal.ok)
         return traversal;
-    state.entries.sort((left, right) => compareNames(left.path, right.path));
+    state.entries.sort((left, right) => compareUnicodeCodePoints(left.path, right.path));
     return ok({
         root: canonicalRoot,
         entries: state.entries,
         bytesRead: state.bytesRead,
-        truncated: state.truncated,
-        limitations: [
-            PATH_RACE_LIMITATION,
-            ...(state.stopped
-                ? ["Traversal stopped because the entry limit was reached."]
-                : []),
-        ],
+        limitations: [PATH_RACE_LIMITATION],
     });
 };
 const traverse = async (state) => {
-    while (state.pending.length > 0 && !state.stopped) {
+    while (state.pending.length > 0) {
         if (isAborted(state.signal))
             return err({
                 tag: "reference-source-reader",

package/dist/reference/ReferenceSourceReaderEntries.js

@@ -1,7 +1,9 @@
 import { readdir, readlink, realpath } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 import { entryFailure, safeSize } from "./ReferenceSourceReaderErrors.js";
-import { compareNames, pathFromRoot, withinRoot, } from "./ReferenceSourceReaderPaths.js";
+import { isPathWithinRoot } from "../domain/localPath.js";
+import { pathFromRoot } from "./ReferenceSourceReaderPaths.js";
 import { readStableFile } from "./ReferenceSourceReaderFile.js";
 import { isAborted, sameFile, validateDirectory, bigLstat, } from "./ReferenceSourceReaderValidate.js";
 import {} from "./ReferenceSourceReaderTypes.js";
@@ -35,8 +37,6 @@ export const traverseDirectory = async (state, current) => {
         const result = await processEntry(state, current, name, directories);
         if (!result.ok)
             return result;
-        if (state.stopped)
-            break;
     }
     directories.reverse();
     state.pending.push(...directories);
@@ -44,7 +44,10 @@ export const traverseDirectory = async (state, current) => {
 };
 const readDirectoryNames = async (path) => {
     try {
-        return { ok: true, value: (await readdir(path)).sort(compareNames) };
+        return {
+            ok: true,
+            value: (await readdir(path)).sort(compareUnicodeCodePoints),
+        };
     }
     catch {
         return { ok: false, message: "Directory could not be read" };
@@ -82,13 +85,6 @@ const processEntry = async (state, current, name, directories) => {
         };
     if (excluded.value)
         return { ok: true, value: undefined };
-    if (!reserveEntry(state))
-        return { ok: true, value: undefined };
-    if (Buffer.byteLength(path) > state.limits.maxPathBytes) {
-        state.entries.push(entryFailure(path, "unknown", "limit", "Path exceeds maxPathBytes"));
-        state.truncated = true;
-        return { ok: true, value: undefined };
-    }
     const metadata = await readMetadata(absolute);
     if (!metadata.ok) {
         state.entries.push(entryFailure(path, "unknown", "io", metadata.message));
@@ -106,14 +102,8 @@ const processEntry = async (state, current, name, directories) => {
     if (metadata.value.isSymbolicLink())
         state.entries.push(await describeSymlink(state.root, absolute, path));
     else if (metadata.value.isDirectory()) {
-        if (current.depth < state.limits.maxDepth) {
-            state.entries.push({ status: "read", kind: "directory", path });
-            directories.push({ path: absolute, depth: current.depth + 1 });
-        }
-        else {
-            state.entries.push(entryFailure(path, "directory", "limit", "Directory exceeds maxDepth"));
-            state.truncated = true;
-        }
+        state.entries.push({ status: "read", kind: "directory", path });
+        directories.push({ path: absolute });
     }
     else if (!metadata.value.isFile())
         state.entries.push(entryFailure(path, "other", "unsupported", "Entry is not a regular file", safeSize(metadata.value.size)));
@@ -122,32 +112,23 @@ const processEntry = async (state, current, name, directories) => {
     return { ok: true, value: undefined };
 };
 const processFileEntry = async (state, absolute, path, metadata) => {
-    const remaining = state.limits.maxBytes - state.bytesRead;
-    if (metadata.size > BigInt(remaining)) {
-        state.entries.push(entryFailure(path, "file", "limit", "File exceeds remaining maxBytes", safeSize(metadata.size)));
-        state.truncated = true;
-        return;
-    }
     const result = await readStableFile({
         root: state.root,
         rootIdentity: state.rootIdentity,
         absolute,
         path,
         expected: metadata,
-        remaining,
         ...(state.signal === undefined ? {} : { signal: state.signal }),
     });
     if (result.status === "read" && result.kind === "file")
         state.bytesRead += result.bytes.byteLength;
-    else if (result.status === "failed" && result.code === "limit")
-        state.truncated = true;
     state.entries.push(result);
 };
 const describeSymlink = async (root, absolute, path) => {
     try {
         const rawTarget = await readlink(absolute);
         const lexicalTarget = resolve(dirname(absolute), rawTarget);
-        if (!withinRoot(root, lexicalTarget))
+        if (!isPathWithinRoot(root, lexicalTarget))
             return {
                 status: "read",
                 kind: "symlink",
@@ -157,7 +138,7 @@ const describeSymlink = async (root, absolute, path) => {
             };
         try {
             const canonicalTarget = await realpath(lexicalTarget);
-            return withinRoot(root, canonicalTarget)
+            return isPathWithinRoot(root, canonicalTarget)
                 ? {
                     status: "read",
                     kind: "symlink",
@@ -195,12 +176,3 @@ const applyExclusion = (shouldExclude, path) => {
         return { ok: false };
     }
 };
-const reserveEntry = (state) => {
-    if (state.filesSeen < state.limits.maxEntries) {
-        state.filesSeen += 1;
-        return true;
-    }
-    state.truncated = true;
-    state.stopped = true;
-    return false;
-};

package/dist/reference/ReferenceSourceReaderFile.js

@@ -5,17 +5,9 @@ import { entryFailure, safeSize } from "./ReferenceSourceReaderErrors.js";
 import { isAborted, sameFile, validateDirectory, } from "./ReferenceSourceReaderValidate.js";
 import {} from "./ReferenceSourceReaderTypes.js";
 const READ_CHUNK_BYTES = 64 * 1024;
-const prepareFileRead = async (request) => {
-    const { root, rootIdentity, absolute, path, expected, signal } = request;
-    const parentBefore = await validateDirectory(root, rootIdentity, dirname(absolute));
-    if (!parentBefore.ok)
-        return {
-            status: "failed",
-            entry: entryFailure(path, "file", parentBefore.code, parentBefore.message, safeSize(expected.size)),
-        };
-    const handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW);
+const prepareFileRead = async (request, handle) => {
+    const { path, expected, signal } = request;
     if (isAborted(signal)) {
-        await handle.close().catch(() => undefined);
         return {
             status: "failed",
             entry: entryFailure(path, "file", "cancelled", "File read cancelled", safeSize(expected.size)),
@@ -23,16 +15,15 @@ const prepareFileRead = async (request) => {
     }
     const before = await handle.stat({ bigint: true });
     if (!sameFile(expected, before)) {
-        await handle.close().catch(() => undefined);
         return {
             status: "failed",
             entry: entryFailure(path, "file", "changed", "File changed before it was read", safeSize(before.size)),
         };
     }
-    return { status: "ready", handle, before, parentBefore };
+    return { status: "ready", before };
 };
 const readFileContents = async (request) => {
-    const { handle, path, remaining, signal } = request;
+    const { handle, path, signal } = request;
     const chunks = [];
     let total = 0;
     for (;;) {
@@ -41,14 +32,8 @@ const readFileContents = async (request) => {
                 status: "failed",
                 entry: entryFailure(path, "file", "cancelled", "File read cancelled", total),
             };
-        const capacity = Math.min(READ_CHUNK_BYTES, remaining + 1 - total);
-        if (capacity <= 0)
-            return {
-                status: "failed",
-                entry: entryFailure(path, "file", "limit", "File exceeds remaining maxBytes", total),
-            };
-        const chunk = Buffer.allocUnsafe(capacity);
-        const read = await handle.read(chunk, 0, capacity, null);
+        const chunk = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+        const read = await handle.read(chunk, 0, chunk.byteLength, null);
         if (isAborted(signal))
             return {
                 status: "failed",
@@ -57,11 +42,6 @@ const readFileContents = async (request) => {
         if (read.bytesRead === 0)
             break;
         total += read.bytesRead;
-        if (total > remaining)
-            return {
-                status: "failed",
-                entry: entryFailure(path, "file", "limit", "File exceeds remaining maxBytes", total),
-            };
         chunks.push(chunk.subarray(0, read.bytesRead));
     }
     return { status: "ok", chunks, total };
@@ -83,17 +63,19 @@ const finalizeFileRead = async (request) => {
     };
 };
 export const readStableFile = async (request) => {
-    const { root, rootIdentity, absolute, path, expected, remaining, signal } = request;
+    const { root, rootIdentity, absolute, path, expected, signal } = request;
     let handle;
     try {
-        const prepared = await prepareFileRead(request);
+        const parentBefore = await validateDirectory(root, rootIdentity, dirname(absolute));
+        if (!parentBefore.ok)
+            return entryFailure(path, "file", parentBefore.code, parentBefore.message, safeSize(expected.size));
+        handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW);
+        const prepared = await prepareFileRead(request, handle);
         if (prepared.status === "failed")
             return prepared.entry;
-        handle = prepared.handle;
         const contents = await readFileContents({
             handle,
             path,
-            remaining,
             ...(signal === undefined ? {} : { signal }),
         });
         if (contents.status === "failed")
@@ -105,7 +87,7 @@ export const readStableFile = async (request) => {
             path,
             handle,
             before: prepared.before,
-            parentBefore: prepared.parentBefore,
+            parentBefore,
             chunks: contents.chunks,
             total: contents.total,
         });

package/dist/reference/ReferenceSourceReaderPaths.js

@@ -1,23 +1,8 @@
-import { isAbsolute, relative, sep } from "node:path";
-export const withinRoot = (root, path) => {
-    const value = relative(root, path);
-    return (value === "" ||
-        (value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value)));
-};
+import { relative, sep } from "node:path";
+import { isPathWithinRoot } from "../domain/localPath.js";
 export const pathFromRoot = (root, path) => {
     const value = relative(root, path);
-    return withinRoot(root, path)
+    return isPathWithinRoot(root, path)
         ? value.split(sep).join("/") || "."
         : "<outside-root>";
 };
-export const compareNames = (left, right) => {
-    const leftPoints = [...left].map((value) => value.codePointAt(0) ?? 0);
-    const rightPoints = [...right].map((value) => value.codePointAt(0) ?? 0);
-    const length = Math.min(leftPoints.length, rightPoints.length);
-    for (let index = 0; index < length; index += 1) {
-        const difference = (leftPoints[index] ?? 0) - (rightPoints[index] ?? 0);
-        if (difference !== 0)
-            return difference;
-    }
-    return leftPoints.length - rightPoints.length;
-};

package/dist/reference/ReferenceSourceReaderValidate.js

@@ -2,7 +2,7 @@ import { constants } from "node:fs";
 import { lstat, realpath } from "node:fs/promises";
 import { err, ok } from "../domain/result.js";
 import { cancelled, failure } from "./ReferenceSourceReaderErrors.js";
-import { withinRoot } from "./ReferenceSourceReaderPaths.js";
+import { isPathWithinRoot } from "../domain/localPath.js";
 import {} from "./ReferenceSourceReaderTypes.js";
 export const bigLstat = (path) => lstat(path, { bigint: true });
 export const sameFile = (left, right) => left.dev === right.dev &&
@@ -11,7 +11,6 @@ export const sameFile = (left, right) => left.dev === right.dev &&
     left.mtimeNs === right.mtimeNs &&
     left.ctimeNs === right.ctimeNs;
 export const isAborted = (signal) => signal?.aborted === true;
-const validLimits = (limits) => Object.values(limits).every((value) => Number.isSafeInteger(value) && value > 0);
 export const noFollowOpenSupported = () => Number.isSafeInteger(constants.O_NOFOLLOW) && constants.O_NOFOLLOW !== 0;
 export const validateDirectory = async (root, rootIdentity, path) => {
     try {
@@ -32,7 +31,7 @@ export const validateDirectory = async (root, rootIdentity, path) => {
                 message: "Directory identity changed",
             };
         const canonical = await realpath(path);
-        if (canonical !== path || !withinRoot(root, canonical))
+        if (canonical !== path || !isPathWithinRoot(root, canonical))
             return {
                 ok: false,
                 code: "changed",
@@ -48,9 +47,7 @@ export const validateDirectory = async (root, rootIdentity, path) => {
         };
     }
 };
-export const prepareRoot = async (root, limits, signal) => {
-    if (!validLimits(limits))
-        return err(failure("invalid-limits", "Reader limits must be positive integers"));
+export const prepareRoot = async (root, signal) => {
     if (isAborted(signal))
         return err(cancelled());
     try {