rea-agents 3.0.0 → 3.2.0

package/dist/dotnet/ManagedStaticProvider.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { readFile, stat } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
 import { MANAGED_STATIC_PROVIDER } from "../application/InvestigationProviders.js";
 import { MANAGED_TOOL_CONTRACTS, managedArtifactInputSchema, managedMemberInputSchema, managedNativeBoundaryInputSchema, } from "../contracts/managedToolContracts.js";
@@ -15,12 +15,8 @@ export class ManagedStaticProvider {
     #capabilities = Object.freeze(MANAGED_TOOL_CONTRACTS.map((contract) => Object.freeze({
         provider: IDENTITY,
         operation: contract.name,
-        inputContractVersion: 1,
-        outputContractVersion: 1,
         available: true,
         reason: null,
-        pagination: "offset",
-        exhaustive: false,
         effects: Object.freeze({
             mutatesArtifact: false,
             launchesProcess: false,
@@ -30,11 +26,6 @@ export class ManagedStaticProvider {
             changesPermissions: false,
             requiresRoot: false,
         }),
-        limits: Object.freeze({
-            maxResults: 500,
-            maxPayloadBytes: 4 * 1024 * 1024,
-            timeoutMs: null,
-        }),
         limitations: limitationsFor(contract.name),
     })));
     identity() {
@@ -63,16 +54,10 @@ class ManagedStaticClient {
         try {
             if (options?.signal?.aborted === true)
                 return err(new AnalysisCancelledError(operation));
-            const maxFileBytes = maxRequestedFileBytes(operation, parameters);
-            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 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.`));
             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;
@@ -113,6 +98,8 @@ const hashManagedSource = async (path, signal) => {
     for await (const chunk of stream) {
         if (!Buffer.isBuffer(chunk))
             throw new TypeError("Managed source stream returned non-buffer data");
+        if (chunk.length > Number.MAX_SAFE_INTEGER - byteLength)
+            throw new RangeError("Managed source byte length overflowed");
         byteLength += chunk.length;
         digest.update(chunk);
     }
@@ -121,7 +108,7 @@ const hashManagedSource = async (path, signal) => {
 const isManagedOperation = (operation) => MANAGED_TOOL_CONTRACTS.some(({ name }) => name === operation);
 const limitationsFor = (operation) => Object.freeze(operation === "inspect_managed_artifact"
     ? [
-        "This capability inventories PE/CLI identity only; inspect_managed_members admits bounded metadata members, signatures, and CIL anchors.",
+        "This capability inventories PE/CLI identity only; inspect_managed_members admits metadata members, signatures, and CIL anchors.",
         "It never loads the target assembly, resolves dependencies through a CLR, decompiles C#, or executes target code.",
     ]
     : operation === "inspect_managed_native_boundaries"
@@ -130,64 +117,20 @@ const limitationsFor = (operation) => Object.freeze(operation === "inspect_manag
             "It never loads the target assembly, resolves dependencies through a CLR, decompiles C#, or executes target code.",
         ]
         : [
-            "This capability decodes bounded PE/CLI metadata members, signatures, and file-backed method bodies; decompiled C# and cross-build matching are separate future contracts.",
+            "This capability decodes PE/CLI metadata members, signatures, and file-backed method bodies; decompiled C# reconstruction and cross-build member comparison are separate operations.",
             "It never loads the target assembly, resolves dependencies through a CLR, decompiles C#, or executes target code.",
         ]);
-const maxRequestedFileBytes = (operation, parameters) => {
-    if (operation === "inspect_managed_artifact")
-        return managedArtifactInputSchema.parse(parameters).max_file_bytes;
-    if (operation === "inspect_managed_native_boundaries")
-        return managedNativeBoundaryInputSchema.parse(parameters).max_file_bytes;
-    return managedMemberInputSchema.parse(parameters).max_file_bytes;
-};
 const inspectManagedOperation = (operation, parameters, bytes, target) => {
     if (operation === "inspect_managed_artifact") {
-        const input = managedArtifactInputSchema.parse(parameters);
-        return inspectManagedArtifactBytes(bytes, target, {
-            referenceOffset: input.reference_offset,
-            referenceLimit: input.reference_limit,
-            resourceOffset: input.resource_offset,
-            resourceLimit: input.resource_limit,
-            attributeOffset: input.attribute_offset,
-            attributeLimit: input.attribute_limit,
-            maxMetadataBytes: input.max_metadata_bytes,
-            maxTableRows: input.max_table_rows,
-            maxHeapItemBytes: input.max_heap_item_bytes,
-        });
+        managedArtifactInputSchema.parse(parameters);
+        return inspectManagedArtifactBytes(bytes, target);
     }
     if (operation === "inspect_managed_native_boundaries") {
-        const input = managedNativeBoundaryInputSchema.parse(parameters);
-        return inspectManagedNativeBoundariesBytes(bytes, target, {
-            moduleRefOffset: input.module_ref_offset,
-            moduleRefLimit: input.module_ref_limit,
-            importOffset: input.import_offset,
-            importLimit: input.import_limit,
-            implementationOffset: input.implementation_offset,
-            implementationLimit: input.implementation_limit,
-            maxMetadataBytes: input.max_metadata_bytes,
-            maxTableRows: input.max_table_rows,
-            maxHeapItemBytes: input.max_heap_item_bytes,
-        });
+        managedNativeBoundaryInputSchema.parse(parameters);
+        return inspectManagedNativeBoundariesBytes(bytes, target);
     }
-    const input = managedMemberInputSchema.parse(parameters);
-    return inspectManagedMembersBytes(bytes, target, {
-        typeOffset: input.type_offset,
-        typeLimit: input.type_limit,
-        methodOffset: input.method_offset,
-        methodLimit: input.method_limit,
-        fieldOffset: input.field_offset,
-        fieldLimit: input.field_limit,
-        memberRefOffset: input.member_ref_offset,
-        memberRefLimit: input.member_ref_limit,
-        edgeOffset: input.edge_offset,
-        edgeLimit: input.edge_limit,
-        instructionAnchorLimit: input.instruction_anchor_limit,
-        maxMetadataBytes: input.max_metadata_bytes,
-        maxTableRows: input.max_table_rows,
-        maxHeapItemBytes: input.max_heap_item_bytes,
-        maxMethodBodyBytes: input.max_method_body_bytes,
-        maxMethodInstructions: input.max_method_instructions,
-    });
+    managedMemberInputSchema.parse(parameters);
+    return inspectManagedMembersBytes(bytes, target);
 };
 const managedLocations = (result) => {
     if ("pe" in result) {
@@ -212,9 +155,8 @@ const managedLocations = (result) => {
             ...(result.module === null
                 ? [{ kind: "file-offset", offset: 0 }]
                 : [{ kind: "file-offset", offset: result.module.row_offset }]),
-            ...result.methods.items
+            ...result.methods
                 .filter((method) => method.body.file_offset !== null)
-                .slice(0, 8)
                 .map((method) => ({
                 kind: "file-offset",
                 offset: method.body.file_offset ?? 0,
@@ -224,7 +166,7 @@ const managedLocations = (result) => {
         ...(result.module === null
             ? [{ kind: "file-offset", offset: 0 }]
             : [{ kind: "file-offset", offset: result.module.row_offset }]),
-        ...result.pinvoke_imports.items.slice(0, 8).map((mapping) => ({
+        ...result.pinvoke_imports.map((mapping) => ({
             kind: "file-offset",
             offset: mapping.row_offset,
         })),