rea-agents 6.3.0 → 6.4.0

package/dist/application/javascript/JavaScriptArtifactGraphStructure.js

@@ -1,7 +1,10 @@
 import { completeApplicationCoverage } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
-import { addArtifactContainsEdge, addUnavailableStaticParseScope, artifactFileNodeKind, artifactLocalIdentity, createElectronRoleNode, linkElectronRoleToAsset, } from "./JavaScriptArtifactGraphContext.js";
-import { artifactObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { freezeJsonSnapshot } from "../../domain/immutableJson.js";
+import { addArtifactContainsEdge, addUnavailableStaticParseScope, artifactFileNodeKind, artifactLocalIdentity, javascriptAnalysisCoverage, createElectronRoleNode, linkElectronRoleToAsset, } from "./JavaScriptArtifactGraphContext.js";
+import { artifactObservationEvidence, astObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
+import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
 /** Create the exact root artifact node from the inventory manifest. */
 export const createJavaScriptArtifactRootNode = (accumulator, snapshot) => {
     const root = snapshot.nodes.find(({ artifact_id: id }) => id === snapshot.manifest.root_artifact_id);
@@ -77,9 +80,39 @@ export const addJavaScriptArtifactContainers = (context) => {
 };
 /** Project relevant files, ASAR entries, and explicit unavailable parse scopes. */
 export const addJavaScriptArtifactFiles = (context) => {
+    const packagesByPath = indexFirstByPath(context.analysis.packages);
+    const jsonModulesByPath = indexFirstByPath(context.analysis.json_modules);
+    const sourceMapsByPath = indexFirstByPath(context.analysis.source_maps);
     for (const analyzed of context.analysis.files) {
         const { file } = analyzed;
-        const target = createFileTarget(context, file, analyzed.javascript);
+        const jsonValue = jsonModulesByPath.get(file.path);
+        const target = createFileTarget(context, file, analyzed.javascript, jsonValue);
+        if (analyzed.application_projection_failure !== undefined &&
+            analyzed.javascript !== null)
+            context.accumulator.addNode({
+                kind: target.kind,
+                identity: target.identity,
+                observations: [
+                    {
+                        label: file.path,
+                        properties: {
+                            static_analysis: freezeJsonSnapshot(jsonValueSchema.parse(analyzed.javascript)),
+                            semantic_module_analysis: analyzed.semantic === null
+                                ? null
+                                : freezeJsonSnapshot(jsonValueSchema.parse(analyzed.semantic.ir)),
+                            application_projection_failure: analyzed.application_projection_failure.error,
+                        },
+                        evidence: astObservationEvidence({
+                            sha256: file.sha256,
+                            path: file.path,
+                            operation: "retain-unexpanded-static-findings",
+                            range: sourceFileRange(file),
+                            coverage: javascriptAnalysisCoverage(analyzed.javascript),
+                            limitations: [analyzed.application_projection_failure.reason],
+                        }),
+                    },
+                ],
+            });
         context.fileNodes.set(file.path, target);
         if (file.kind === "javascript")
             context.assetNodes.set(file.path, target);
@@ -112,7 +145,16 @@ export const addJavaScriptArtifactFiles = (context) => {
                 }),
             });
         }
-        if (file.kind === "javascript" &&
+        if (analyzed.analysis_failure !== undefined)
+            addUnavailableStaticParseScope(context, {
+                file,
+                asset: target,
+                operation: "analyze-javascript-source",
+                limitation: analyzed.analysis_failure.reason,
+                failure: analyzed.analysis_failure.error,
+                limits: javaScriptAnalysisCoverageLimits(analyzed.analysis_failure.limits),
+            });
+        else if (file.kind === "javascript" &&
             (analyzed.javascript === null ||
                 analyzed.javascript.parse_status === "failed"))
             addUnavailableStaticParseScope(context, {
@@ -123,7 +165,16 @@ export const addJavaScriptArtifactFiles = (context) => {
                     ? "JavaScript syntax could not be parsed."
                     : `JavaScript text was unavailable: ${file.text.reason}.`,
             });
-        const packageValue = context.analysis.packages.find(({ path }) => path === file.path);
+        if (analyzed.application_projection_failure !== undefined)
+            addUnavailableStaticParseScope(context, {
+                file,
+                asset: target,
+                operation: "project-javascript-application",
+                limitation: analyzed.application_projection_failure.reason,
+                failure: analyzed.application_projection_failure.error,
+                limits: javaScriptAnalysisCoverageLimits(analyzed.application_projection_failure.limits),
+            });
+        const packageValue = packagesByPath.get(file.path);
         if (packageValue !== undefined && packageValue.status !== "included")
             addUnavailableStaticParseScope(context, {
                 file,
@@ -131,7 +182,6 @@ export const addJavaScriptArtifactFiles = (context) => {
                 operation: "parse-package-json",
                 limitation: packageValue.limitation,
             });
-        const jsonValue = context.analysis.json_modules.find(({ path }) => path === file.path);
         if (jsonValue !== undefined && jsonValue.status !== "included")
             addUnavailableStaticParseScope(context, {
                 file,
@@ -139,7 +189,7 @@ export const addJavaScriptArtifactFiles = (context) => {
                 operation: "parse-json-module",
                 limitation: jsonValue.limitation,
             });
-        const sourceMap = context.analysis.source_maps.find(({ path }) => path === file.path);
+        const sourceMap = sourceMapsByPath.get(file.path);
         if (sourceMap !== undefined && sourceMap.status === "invalid")
             addUnavailableStaticParseScope(context, {
                 file,
@@ -149,9 +199,24 @@ export const addJavaScriptArtifactFiles = (context) => {
             });
     }
 };
+const sourceFileRange = (file) => {
+    if (!file.text.included)
+        throw new TypeError("Retained static facts require their source text");
+    let line = 1;
+    let lastLineStart = 0;
+    for (const match of file.text.value.matchAll(/\r\n|[\n\r\u2028\u2029]/gu)) {
+        line += 1;
+        lastLineStart = match.index + match[0].length;
+    }
+    return {
+        start: { line: 1, column: 0 },
+        end: { line, column: file.text.value.length - lastLineStart },
+    };
+};
 /** Project package metadata and its declared Electron roles. */
 export const addJavaScriptPackageNodes = (context) => {
     const roots = [];
+    const rootPath = applicationManifestPath(context);
     for (const packageValue of context.analysis.packages) {
         const file = context.filesByPath.get(packageValue.path);
         if (file === undefined)
@@ -180,7 +245,7 @@ export const addJavaScriptPackageNodes = (context) => {
                 },
             ],
         });
-        if (roots.length === 0) {
+        if (file.path === rootPath) {
             roots.push(node);
             context.accumulator.addEdge({
                 source_node_id: node.node_id,
@@ -202,6 +267,8 @@ export const addJavaScriptPackageNodes = (context) => {
                 file,
                 operation: "inventory-package",
             });
+        if (dependencyManifest(file.path))
+            continue;
         addPackageRole(context, {
             packageNode: node,
             packageFile: file,
@@ -217,9 +284,15 @@ export const addJavaScriptPackageNodes = (context) => {
     }
     return roots;
 };
-const createFileTarget = (context, file, javascript) => {
+/** Dependency-only artifacts retain their inventory root. */
+const applicationManifestPath = (context) => context.analysis.packages
+    .map(({ path }) => path)
+    .filter((path) => context.filesByPath.has(path) && !dependencyManifest(path))
+    .sort((left, right) => left.split("/").length - right.split("/").length ||
+    compareUnicodeCodePoints(left, right))[0];
+const dependencyManifest = (path) => path.split("/").slice(0, -1).includes("node_modules");
+const createFileTarget = (context, file, javascript, json) => {
     const kind = artifactFileNodeKind(file.kind);
-    const json = context.analysis.json_modules.find(({ path }) => path === file.path);
     return context.accumulator.addNode({
         kind,
         identity: {
@@ -253,6 +326,14 @@ const createFileTarget = (context, file, javascript) => {
         ],
     });
 };
+const indexFirstByPath = (values) => {
+    const index = new Map();
+    for (const value of values) {
+        if (!index.has(value.path))
+            index.set(value.path, value);
+    }
+    return index;
+};
 const createAsarEntry = (context, file) => {
     const isAsar = context.snapshot.manifest.root_format === "asar" ||
         file.container_sha256 !== context.snapshot.manifest.root_sha256;
@@ -333,3 +414,4 @@ const containerProperties = (container) => ({
     bytes: container.bytes,
     inventory_artifact_id: container.inventory_artifact_id,
 });
+import { javaScriptAnalysisCoverageLimits } from "../../domain/javascript/javascriptAnalysisResourceControls.js";