rea-agents 2.5.0 → 3.1.0

package/dist/dotnet/ManagedStaticProvider.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
 import { MANAGED_STATIC_PROVIDER } from "../application/InvestigationProviders.js";
@@ -48,6 +49,7 @@ export class ManagedStaticProvider {
 }
 class ManagedStaticClient {
     target;
+    #snapshotBytes;
     constructor(target) {
         this.target = target;
     }
@@ -65,12 +67,18 @@ class ManagedStaticClient {
             const metadata = await stat(this.target.path);
             if (metadata.size > maxFileBytes)
                 return err(new AnalysisCapabilityUnavailableError(IDENTITY.id, operation, `Artifact size ${String(metadata.size)} exceeds max_file_bytes ${String(maxFileBytes)}.`));
-            const bytes = await readFile(this.target.path, options?.signal === undefined ? undefined : { signal: options.signal });
-            if (bytes.length > maxFileBytes)
+            const snapshot = this.#snapshotBytes;
+            const observed = snapshot === undefined
+                ? await readManagedSnapshot(this.target.path, options?.signal)
+                : await hashManagedSource(this.target.path, options?.signal);
+            if (observed.byteLength > maxFileBytes)
                 return err(new AnalysisCapabilityUnavailableError(IDENTITY.id, operation, `Artifact grew beyond max_file_bytes ${String(maxFileBytes)} while it was read.`));
-            const observedDigest = createHash("sha256").update(bytes).digest("hex");
-            if (observedDigest !== this.target.sha256)
-                return err(new EvidenceIntegrityError(`Managed artifact digest changed after open: expected ${this.target.sha256}, observed ${observedDigest} at ${this.target.path}`));
+            if (observed.sha256 !== this.target.sha256)
+                return err(new EvidenceIntegrityError(`Managed artifact digest changed after open: expected ${this.target.sha256}, observed ${observed.sha256} at ${this.target.path}`));
+            const bytes = snapshot ?? observed.bytes;
+            if (bytes === undefined)
+                throw new TypeError("Managed snapshot bytes are unavailable");
+            this.#snapshotBytes = bytes;
             const result = inspectManagedOperation(operation, parameters, bytes, this.target);
             return ok(createAnalysisExecution(result, IDENTITY, {
                 rawResult: null,
@@ -86,9 +94,30 @@ class ManagedStaticClient {
         }
     }
     close() {
+        this.#snapshotBytes = undefined;
         return Promise.resolve();
     }
 }
+const readManagedSnapshot = async (path, signal) => {
+    const bytes = await readFile(path, signal === undefined ? undefined : { signal });
+    return {
+        byteLength: bytes.length,
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+        bytes,
+    };
+};
+const hashManagedSource = async (path, signal) => {
+    const digest = createHash("sha256");
+    let byteLength = 0;
+    const stream = createReadStream(path, signal === undefined ? undefined : { signal });
+    for await (const chunk of stream) {
+        if (!Buffer.isBuffer(chunk))
+            throw new TypeError("Managed source stream returned non-buffer data");
+        byteLength += chunk.length;
+        digest.update(chunk);
+    }
+    return { byteLength, sha256: digest.digest("hex") };
+};
 const isManagedOperation = (operation) => MANAGED_TOOL_CONTRACTS.some(({ name }) => name === operation);
 const limitationsFor = (operation) => Object.freeze(operation === "inspect_managed_artifact"
     ? [