Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(javascript): exclude overwritten Electron API identities (#1664)
Ysopwnable29cc1b874660
diff --git a/docs/javascript-artifact-reconstruction.md b/docs/javascript-artifact-reconstruction.mdindex bd3b3a8f5..6446432d9 100644--- a/docs/javascript-artifact-reconstruction.md+++ b/docs/javascript-artifact-reconstruction.md@@ -270,6 +270,14 @@ substitute version-dependent Electron defaults for omitted `webPreferences`.Dynamic option objects, bridge keys, API objects, and IPC channel expressionsremain unknown and make coverage partial.+Electron API identity follows proven lexical module aliases. Reassigned bindings,+dynamic selections, and visibly overwritten namespace members are unresolved.+Direct and destructuring assignment, loop, update, and delete targets are checked+through namespace aliases; unrelated member writes do not discard observed API+identity. This static check does+not evaluate arbitrary call side effects or runtime registration. Missing findings+do not establish that an application has no Electron boundary usage.+IPC pairing is an inference, not an observation. A renderer `invoke` pairs onlywith one unique `ipcMain.handle`/`handleOnce` candidate on the same exact literalchannel; a renderer send pairs only with one unique `ipcMain.on`/`once`diff --git a/src/application/javascript/JavaScriptArtifactGraphBuilder.ts b/src/application/javascript/JavaScriptArtifactGraphBuilder.tsindex b10b92deb..d2227c7b4 100644--- a/src/application/javascript/JavaScriptArtifactGraphBuilder.ts+++ b/src/application/javascript/JavaScriptArtifactGraphBuilder.ts@@ -1,3 +1,4 @@+import { ELECTRON_IDENTITY_LIMITATION } from "../../domain/javascript/javascriptElectronMemberWrites.js";import type { ArtifactInventorySnapshot } from "../../domain/artifactInventorySnapshot.js";import {createJavaScriptApplicationGraph,@@ -255,6 +256,11 @@ const graphLimitations = ("CommonJS and ESM binding relationships were recovered from inert syntax and resolved only within the inventoried artifact container.","Webpack/Rspack factories were recovered from AST literals; REA did not invoke push handlers or bundle bootstrap code.","Static imports, entrypoints, workers, endpoints, and storage relationships do not prove runtime execution.",+ ...(context.analysis.files.some(({ javascript }) =>+ javascript?.limitations.includes(ELECTRON_IDENTITY_LIMITATION),+ )+ ? [ELECTRON_IDENTITY_LIMITATION]+ : []),...(electronFindings === 0? []: [diff --git a/src/application/javascript/JavaScriptArtifactPathResolution.test.ts b/src/application/javascript/JavaScriptArtifactPathResolution.test.tsindex 6eef8ced7..c83534ed9 100644--- a/src/application/javascript/JavaScriptArtifactPathResolution.test.ts+++ b/src/application/javascript/JavaScriptArtifactPathResolution.test.ts@@ -1015,6 +1015,7 @@ describe("contextual JavaScript module identity", () => {it("retains CommonJS and ESM file-base identity during inert extraction", () => {const analysis = analyzeJavaScriptStaticSource(`+ import { BrowserWindow } from "electron";new BrowserWindow({ webPreferences: {preload: path.resolve("ignored", __dirname, "preload.cjs")}});diff --git a/src/domain/javascript/javascriptAstValues.ts b/src/domain/javascript/javascriptAstValues.tsindex 5479c8d1f..f89eabb05 100644--- a/src/domain/javascript/javascriptAstValues.ts+++ b/src/domain/javascript/javascriptAstValues.ts@@ -86,6 +86,31 @@ export const semanticObjectPatternKeys = (return key === null ? [] : [key];});+/** Visit member write targets in direct and destructuring assignment forms. */+export function* semanticMemberWriteTargets(+ root: t.Node,+): Generator<t.MemberExpression | t.OptionalMemberExpression> {+ const pending = [root];+ while (pending.length > 0) {+ const next = pending.pop();+ if (next === undefined) break;+ const node = unwrapJavaScriptExpression(next).node;+ if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))+ yield node;+ else if (t.isRestElement(node)) pending.push(node.argument);+ else if (t.isAssignmentPattern(node)) pending.push(node.left);+ else if (t.isArrayPattern(node)) {+ for (const element of node.elements.toReversed())+ if (element !== null) pending.push(element);+ } else if (t.isObjectPattern(node)) {+ for (const property of node.properties.toReversed())+ pending.push(+ t.isRestElement(property) ? property.argument : property.value,+ );+ }+ }+}+/*** Display an exact JavaScript string as nonempty label text. Graph labels and* artifact-local keys are nonempty, so the legal empty value is shown as `""`;diff --git a/src/domain/javascript/javascriptElectronMemberWrites.ts b/src/domain/javascript/javascriptElectronMemberWrites.tsnew file mode 100644index 000000000..598133791--- /dev/null+++ b/src/domain/javascript/javascriptElectronMemberWrites.ts@@ -0,0 +1,61 @@+import * as t from "@babel/types";++import {+ semanticStaticPropertyKey,+ semanticMemberWriteTargets,+ unwrapJavaScriptExpression,+} from "./javascriptAstValues.js";+import { SemanticPropertyPathCoverage } from "./javascriptSemanticPropertyPaths.js";+import { traverseJavaScriptAstSteps } from "./javascriptSemanticTraversal.js";++/** Match Electron's supported module entry points. */+export const ELECTRON_MODULE =+ /^electron(?:\/(?:common|main|renderer|utility))?$/u;++/** Static identity recovery cannot establish the absence of Electron usage. */+export const ELECTRON_IDENTITY_LIMITATION =+ "Electron API identity follows proven lexical module aliases. Reassigned bindings, dynamic selections, and visibly overwritten namespace members are unresolved; missing findings do not establish absence. Arbitrary call side effects and runtime registration are not evaluated.";++/** Preserve exact property segments instead of flattening literal dotted keys. */+export const electronMemberPath = (+ node: t.Node,+): {+ readonly root: t.Node;+ readonly members: readonly (string | null)[];+} => {+ let root = unwrapJavaScriptExpression(node).node;+ const members: (string | null)[] = [];+ while (t.isMemberExpression(root) || t.isOptionalMemberExpression(root)) {+ members.push(semanticStaticPropertyKey(root.property, root.computed));+ root = unwrapJavaScriptExpression(root.object).node;+ }+ return { root, members: members.toReversed() };+};++/** Index visible writes through proven Electron aliases, without executing them. */+export function* collectElectronMemberWritesSteps(+ program: t.Program,+ origin: (root: t.Node) => readonly string[] | undefined,+): Generator<void, SemanticPropertyPathCoverage> {+ const writes = new SemanticPropertyPathCoverage();+ yield* traverseJavaScriptAstSteps(program, {+ enter: (node) => {+ const target = t.isAssignmentExpression(node)+ ? node.left+ : t.isUpdateExpression(node)+ ? node.argument+ : t.isUnaryExpression(node, { operator: "delete" })+ ? node.argument+ : t.isForOfStatement(node) || t.isForInStatement(node)+ ? node.left+ : undefined;+ if (target === undefined) return;+ for (const member of semanticMemberWriteTargets(target)) {+ const { root, members } = electronMemberPath(member);+ const exported = origin(root);+ if (exported !== undefined) writes.retain([...exported, ...members]);+ }+ },+ });+ return writes;+}diff --git a/src/domain/javascript/javascriptSemanticAnalysis.ts b/src/domain/javascript/javascriptSemanticAnalysis.tsindex c73f22da1..82f7e6244 100644--- a/src/domain/javascript/javascriptSemanticAnalysis.ts+++ b/src/domain/javascript/javascriptSemanticAnalysis.ts@@ -44,6 +44,11 @@ import {} from "./javascriptSemanticReturns.js";import { collectJavaScriptDerivedSemanticsSteps } from "./javascriptSemanticDerivedAnalysis.js";import { evaluateSemanticProvenance } from "./javascriptSemanticValues.js";+import {+ collectElectronMemberWritesSteps,+ electronMemberPath,+ ELECTRON_MODULE,+} from "./javascriptElectronMemberWrites.js";import { range } from "./javascriptStaticAnalysisHelpers.js";import { propertyName } from "./javascriptAstValues.js";import { semanticCoverage } from "./javascriptSemanticCoverage.js";@@ -311,8 +316,6 @@ const resolveGlobalAliasFact = (return openGlobalFact(name);};-const ELECTRON_MODULE = /^electron(?:\/(?:common|main|renderer|utility))?$/u;-/*** Proven Electron export path segments for call and construction roots, keyed by* root offset. Only proven Electron origins are present; callers must not@@ -331,6 +334,27 @@ export function* classifyParsedJavaScriptElectronBindingsSteps(const state = createState(file.program);yield* collectDefinitionsSteps(file.program, state);const exportsByBinding = new Map<string, readonly string[] | null>();+ const rootExport = (root: t.Node): readonly string[] | undefined => {+ if (t.isIdentifier(root)) {+ if (semanticResolutionBlocked(state, root, root.name)) return undefined;+ const binding = resolveSemanticBindingState(state, root, root.name);+ if (binding === undefined) return undefined;+ let exported = exportsByBinding.get(binding.bindingId);+ if (exported === undefined) {+ exported = electronExport(binding, state);+ exportsByBinding.set(binding.bindingId, exported);+ }+ return exported ?? undefined;+ }+ const origin = semanticRequireOrigin(root, state);+ return origin !== undefined && ELECTRON_MODULE.test(origin.specifier)+ ? origin.importedPath+ : undefined;+ };+ const writes = yield* collectElectronMemberWritesSteps(+ file.program,+ rootExport,+ );yield* traverseJavaScriptAstSteps(file.program, {enter: (node) => {if (@@ -339,35 +363,15 @@ export function* classifyParsedJavaScriptElectronBindingsSteps(!t.isNewExpression(node))return;- const root = calleeRoot(node.callee);- if (root === undefined) return;- if (t.isIdentifier(root)) {- const binding = resolveSemanticBindingState(state, root, root.name);- if (binding === undefined) return;- let exported = exportsByBinding.get(binding.bindingId);- if (exported === undefined) {- exported = electronExport(binding, state);- exportsByBinding.set(binding.bindingId, exported);- }- if (exported !== null) facts.set(root.start ?? -1, exported);- return;- }- const origin = semanticRequireOrigin(root, state);- if (origin !== undefined && ELECTRON_MODULE.test(origin.specifier))- facts.set(root.start ?? -1, origin.importedPath);+ const { root, members } = electronMemberPath(node.callee);+ const exported = rootExport(root);+ if (exported !== undefined && !writes.covers([...exported, ...members]))+ facts.set(root.start ?? -1, exported);},});return facts;}-const calleeRoot = (node: t.Node): t.Node | undefined => {- while (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {- if (!t.isNode(node.object)) return undefined;- node = node.object;- }- return node;-};-// Read import and require origins directly; general value evaluation is// unnecessary here and costly across large vendor bundles.const electronExport = (diff --git a/src/domain/javascript/javascriptSemanticMemberMutations.ts b/src/domain/javascript/javascriptSemanticMemberMutations.tsindex 245184e67..980ff197c 100644--- a/src/domain/javascript/javascriptSemanticMemberMutations.ts+++ b/src/domain/javascript/javascriptSemanticMemberMutations.ts@@ -28,6 +28,7 @@ import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";import { traverseJavaScriptAstSteps } from "./javascriptSemanticTraversal.js";import {semanticStaticPropertyKey,+ semanticMemberWriteTargets,unwrapJavaScriptExpression,} from "./javascriptAstValues.js";@@ -356,26 +357,14 @@ export function* collectSemanticMemberMutationsSteps(markEscaped(expression.object, mutation);};const markTarget = (node: t.Node, mutation: t.Node): void => {- if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))+ for (const target of semanticMemberWriteTargets(node))markValue(- node.object,- [semanticStaticPropertyKey(node.property, node.computed)],+ target.object,+ [semanticStaticPropertyKey(target.property, target.computed)],new Set(),"write",mutation,);- else if (t.isRestElement(node)) markTarget(node.argument, mutation);- else if (t.isAssignmentPattern(node)) markTarget(node.left, mutation);- else if (t.isArrayPattern(node)) {- for (const element of node.elements)- if (element !== null) markTarget(element, mutation);- } else if (t.isObjectPattern(node)) {- for (const property of node.properties)- markTarget(- t.isRestElement(property) ? property.argument : property.value,- mutation,- );- }};yield* traverseJavaScriptAstSteps(program, {enter: (node, parent) => {diff --git a/src/domain/javascript/javascriptSemanticPropertyPaths.ts b/src/domain/javascript/javascriptSemanticPropertyPaths.tsindex 95cbeef97..6d1fe6148 100644--- a/src/domain/javascript/javascriptSemanticPropertyPaths.ts+++ b/src/domain/javascript/javascriptSemanticPropertyPaths.ts@@ -60,23 +60,7 @@ export class SemanticPropertyPathCoverage {/** Retain a path only when no previously retained prefix covers it. */retain(path: JavaScriptSemanticPropertyPath): boolean {- const pending = [{ node: this.#root, offset: 0 }];- while (pending.length > 0) {- const current = pending.pop();- if (current === undefined) break;- if (current.node.terminal) return false;- const key = path[current.offset];- if (key === undefined) continue;- if (key !== null && typeof key !== "object") {- const exact = current.node.exact.get(String(key));- if (exact !== undefined)- pending.push({ node: exact, offset: current.offset + 1 });- }- for (const selected of current.node.selectors.values()) {- if (keyCovers(selected.key, key))- pending.push({ node: selected.node, offset: current.offset + 1 });- }- }+ if (this.covers(path)) return false;let node = this.#root;for (const key of path) {if (key !== null && typeof key !== "object") {@@ -102,6 +86,28 @@ export class SemanticPropertyPathCoverage {node.selectors.clear();return true;}++ /** Query retained prefixes without changing the coverage index. */+ covers(path: JavaScriptSemanticPropertyPath): boolean {+ const pending = [{ node: this.#root, offset: 0 }];+ while (pending.length > 0) {+ const current = pending.pop();+ if (current === undefined) break;+ if (current.node.terminal) return true;+ const key = path[current.offset];+ if (key === undefined) continue;+ if (key !== null && typeof key !== "object") {+ const exact = current.node.exact.get(String(key));+ if (exact !== undefined)+ pending.push({ node: exact, offset: current.offset + 1 });+ }+ for (const selected of current.node.selectors.values()) {+ if (keyCovers(selected.key, key))+ pending.push({ node: selected.node, offset: current.offset + 1 });+ }+ }+ return false;+ }}const keyCovers = (diff --git a/src/domain/javascript/javascriptStaticAnalysis.ts b/src/domain/javascript/javascriptStaticAnalysis.tsindex 0354e5355..8d306af25 100644--- a/src/domain/javascript/javascriptStaticAnalysis.ts+++ b/src/domain/javascript/javascriptStaticAnalysis.ts@@ -1,4 +1,8 @@import * as t from "@babel/types";+import {+ ELECTRON_IDENTITY_LIMITATION,+ ELECTRON_MODULE,+} from "./javascriptElectronMemberWrites.js";import {completeSemanticSteps,@@ -114,6 +118,12 @@ const finalizeStaticAnalysis = (: ["One or more static keys, expressions, or Electron boundary values were dynamic and remain unknown.",]),+ ...(accumulator.references.some(+ ({ value }) =>+ value.specifier !== null && ELECTRON_MODULE.test(value.specifier),+ )+ ? [ELECTRON_IDENTITY_LIMITATION]+ : []),"JavaScript syntax was parsed as data and was never evaluated.",];return {diff --git a/tests/acceptance/applications/applicationWorkflowCli.test.ts b/tests/acceptance/applications/applicationWorkflowCli.test.tsindex b6b402bc4..30c5b81f3 100644--- a/tests/acceptance/applications/applicationWorkflowCli.test.ts+++ b/tests/acceptance/applications/applicationWorkflowCli.test.ts@@ -24,6 +24,8 @@ import {import { parseJavaScriptApplicationGraph } from "../../../src/domain/javascript/javascriptApplicationGraph.js";import { z } from "zod";+import { ELECTRON_IDENTITY_LIMITATION } from "../../../src/domain/javascript/javascriptElectronMemberWrites.js";+const execute = promisify(execFile);const requireFixture = createRequire(import.meta.url);const temporary: string[] = [];@@ -201,6 +203,254 @@ const analyzeThroughStdioMcp = async (}};+describe("Electron alias identity CLI and MCP", () => {+ it.each([+ {+ name: "CommonJS binding chains",+ esm: false,+ main: 'const { BrowserWindow, ipcMain } = require("electron"); const First = BrowserWindow; const Win = First; const ipc = ipcMain;',+ preload:+ 'const { contextBridge, ipcRenderer } = require("electron"); const First = contextBridge; const bridge = First; const ipc = ipcRenderer;',+ },+ {+ name: "static namespace members",+ esm: false,+ main: 'const electron = require("electron"); const copied = electron; copied.unrelated = {}; const Win = copied["BrowserWindow"]; const ipc = copied.ipcMain;',+ preload:+ 'const electron = require("electron"); const copied = electron; const bridge = copied.contextBridge; const ipc = copied["ipcRenderer"];',+ },+ {+ name: "namespace destructuring",+ esm: false,+ main: 'const electron = require("electron"); const { BrowserWindow: Win, ipcMain: ipc } = electron;',+ preload:+ 'const electron = require("electron"); const { contextBridge: bridge, ipcRenderer: ipc } = electron;',+ },+ {+ name: "unwritten let and var bindings",+ esm: false,+ main: 'const { BrowserWindow, ipcMain } = require("electron"); let Win = BrowserWindow; var ipc = ipcMain;',+ preload:+ 'const { contextBridge, ipcRenderer } = require("electron"); var bridge = contextBridge; let ipc = ipcRenderer;',+ },+ {+ name: "ESM binding aliases",+ esm: true,+ main: 'import { BrowserWindow, ipcMain } from "electron"; const Win = BrowserWindow; const ipc = ipcMain;',+ preload:+ 'import { contextBridge, ipcRenderer } from "electron"; const bridge = contextBridge; const ipc = ipcRenderer;',+ },+ ])(+ "recovers Electron boundaries through $name in CLI and MCP (#1656)",+ async ({ main, preload, esm }) => {+ const root = await createTestTempDirectory("rea-electron-alias-cli-");+ temporary.push(root);+ await Promise.all([+ writeFile(+ join(root, "package.json"),+ JSON.stringify({+ name: "alias-repro",+ version: "1.0.0",+ main: "main.js",+ type: esm ? "module" : "commonjs",+ }),+ ),+ writeFile(+ join(root, "main.js"),+ `${main}\n${esm ? 'import { fileURLToPath } from "node:url";' : 'const path = require("node:path");'}\nnew Win({ webPreferences: { preload: ${esm ? 'fileURLToPath(new URL("./preload.js", import.meta.url))' : 'path.join(__dirname, "preload.js")'} } });\nipc.handle("ch:ping", async () => "pong");\nfunction shadow(Win, ipc) { new Win(); ipc.handle("ch:decoy", () => null); }\n`,+ ),+ writeFile(+ join(root, "preload.js"),+ `${preload}\nbridge.exposeInMainWorld("api", { ping: () => ipc.invoke("ch:ping") });\nfunction shadow(bridge, ipc) { bridge.exposeInMainWorld("decoy", {}); ipc.invoke("ch:decoy"); }\n`,+ ),+ ]);+ const cli = z+ .object({+ normalized_result: javascriptApplicationAnalysisResultSchema,+ })+ .parse(+ await runCli(["analyze-javascript-application", root, "--json"]),+ ).normalized_result;+ const mcp = await analyzeThroughStdioMcp(root);+ expect(cli.summary).toMatchObject({+ browser_windows: 1,+ explicit_web_preferences: 1,+ preload_entrypoints: 1,+ context_bridge_apis: 1,+ exposed_api_members: 1,+ ipc: {+ operations: 2,+ literal_channels: 1,+ main_handlers: 1,+ renderer_transmissions: 1,+ paired_renderer_transmissions: 1,+ },+ });+ expect(mcp.summary).toEqual(cli.summary);+ for (const result of [cli, mcp]) {+ expect(result.limitations).toContain(ELECTRON_IDENTITY_LIMITATION);+ expect(result.graph.nodes).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ kind: "ipc-channel",+ observations: expect.arrayContaining([+ expect.objectContaining({+ properties: expect.objectContaining({+ channel: "ch:ping",+ operation: "handle",+ }),+ evidence: expect.objectContaining({+ authority: "ast-static-analysis",+ location: expect.objectContaining({+ available: true,+ value: expect.objectContaining({+ kind: "source-range",+ source: "main.js",+ }),+ }),+ }),+ }),+ expect.objectContaining({+ properties: expect.objectContaining({+ channel: "ch:ping",+ operation: "invoke",+ }),+ evidence: expect.objectContaining({+ authority: "ast-static-analysis",+ location: expect.objectContaining({+ available: true,+ value: expect.objectContaining({+ kind: "source-range",+ source: "preload.js",+ }),+ }),+ }),+ }),+ ]),+ }),+ ]),+ );+ expect(result.graph.edges).toEqual(+ expect.arrayContaining([+ expect.objectContaining({ relation: "handles" }),+ expect.objectContaining({ relation: "invokes" }),+ expect.objectContaining({ relation: "loads" }),+ expect.objectContaining({ relation: "exposes" }),+ ]),+ );+ }+ },+ );+});++describe("Electron unavailable identity CLI and MCP", () => {+ it.each([+ {+ name: "reassigned aliases",+ main: 'const { BrowserWindow, ipcMain } = require("electron"); let Win = BrowserWindow; let ipc = ipcMain; Win = class {}; ipc = { handle() {} };',+ preload:+ 'const { contextBridge, ipcRenderer } = require("electron"); let bridge = contextBridge; let ipc = ipcRenderer; bridge = { exposeInMainWorld() {} }; ipc = { invoke() {} };',+ },+ {+ name: "conditional initializers",+ main: 'const { BrowserWindow, ipcMain } = require("electron"); if (enabled) { var Win = BrowserWindow; var ipc = ipcMain; }',+ preload:+ 'const { contextBridge, ipcRenderer } = require("electron"); if (enabled) { var bridge = contextBridge; var ipc = ipcRenderer; }',+ },+ {+ name: "dynamic property selections",+ main: 'const electron = require("electron"); const Win = electron[windowKey]; const ipc = electron[ipcKey];',+ preload:+ 'const electron = require("electron"); const bridge = electron[bridgeKey]; const ipc = electron[ipcKey];',+ },+ {+ name: "overwritten namespace exports",+ main: 'const electron = require("electron"); const copied = electron; copied.BrowserWindow = class {}; electron.ipcMain = { handle() {} }; const Win = electron.BrowserWindow; const ipc = copied.ipcMain;',+ preload:+ 'const electron = require("electron"); electron.contextBridge = { exposeInMainWorld() {} }; electron.ipcRenderer = { invoke() {} }; const bridge = electron.contextBridge; const ipc = electron.ipcRenderer;',+ },+ {+ name: "overwritten API methods",+ main: 'const electron = require("electron"); const ipc = electron.ipcMain; ipc.handle = () => null; const Win = electron[windowKey];',+ preload:+ 'const electron = require("electron"); const bridge = electron.contextBridge; delete bridge.exposeInMainWorld; const ipc = electron.ipcRenderer; ipc.invoke++;',+ },+ {+ name: "direct require namespace writes",+ main: 'require("electron").BrowserWindow = class {}; require("electron").ipcMain = {handle() {}}; const {BrowserWindow: Win, ipcMain: ipc} = require("electron");',+ preload:+ 'require("electron").contextBridge = {}; require("electron").ipcRenderer = {}; const {contextBridge: bridge, ipcRenderer: ipc} = require("electron");',+ },+ {+ name: "unknown namespace write keys",+ main: 'const electron = require("electron"); electron[unknownKey] = {}; const {BrowserWindow: Win, ipcMain: ipc} = electron;',+ preload:+ 'const electron = require("electron"); electron[unknownKey] = {}; const {contextBridge: bridge, ipcRenderer: ipc} = electron;',+ },+ {+ name: "destructuring assignment targets",+ main: 'const electron = require("electron"); ({ BrowserWindow: electron.BrowserWindow, ipcMain: electron.ipcMain } = replacement); const {BrowserWindow: Win, ipcMain: ipc} = electron;',+ preload:+ 'const electron = require("electron"); [electron.contextBridge, electron.ipcRenderer] = replacements; const {contextBridge: bridge, ipcRenderer: ipc} = electron;',+ },+ {+ name: "loop assignment targets",+ main: 'const electron = require("electron"); for ({ BrowserWindow: electron.BrowserWindow, ipcMain: electron.ipcMain } of replacements) {} const {BrowserWindow: Win, ipcMain: ipc} = electron;',+ preload:+ 'const electron = require("electron"); for (electron.contextBridge in replacements) {} for (electron.ipcRenderer of replacements) {} const {contextBridge: bridge, ipcRenderer: ipc} = electron;',+ },+ {+ name: "literal keys containing dots",+ main: 'const electron = require("electron"); const Win = electron["fake.BrowserWindow"]; const ipc = electron["fake.ipcMain"]; electron["ipcMain.handle"]("ch:literal", () => null);',+ preload:+ 'const electron = require("electron"); const bridge = electron["fake.contextBridge"]; const ipc = electron["fake.ipcRenderer"];',+ },+ ])(+ "keeps Electron identity unresolved for $name in CLI and MCP (#1656)",+ async ({ main, preload }) => {+ const root = await createTestTempDirectory("rea-electron-alias-unknown-");+ temporary.push(root);+ await Promise.all([+ writeFile(+ join(root, "package.json"),+ JSON.stringify({+ name: "alias-unknown",+ version: "1.0.0",+ main: "main.js",+ }),+ ),+ writeFile(+ join(root, "main.js"),+ `${main}\nnew Win(); ipc.handle("ch:ping", () => "pong");\n`,+ ),+ writeFile(+ join(root, "preload.js"),+ `${preload}\nbridge.exposeInMainWorld("api", { ping: () => ipc.invoke("ch:ping") });\n`,+ ),+ ]);+ const cli = z+ .object({+ normalized_result: javascriptApplicationAnalysisResultSchema,+ })+ .parse(+ await runCli(["analyze-javascript-application", root, "--json"]),+ ).normalized_result;+ const mcp = await analyzeThroughStdioMcp(root);+ for (const result of [cli, mcp]) {+ expect(result.summary).toMatchObject({+ browser_windows: 0,+ context_bridge_apis: 0,+ ipc: { operations: 0 },+ });+ expect(+ result.graph.nodes.some(({ kind }) => kind === "ipc-channel"),+ ).toBe(false);+ expect(result.limitations).toContain(ELECTRON_IDENTITY_LIMITATION);+ }+ },+ );+});+describe("JavaScript application path CLI", () => {it("accepts a relative local application path and preserves canonical Evidence identity", async () => {const root = await createTestTempDirectory("rea-relative-application-cli-");diff --git a/tests/acceptance/applications/electronPreloadOverridesCli.test.ts b/tests/acceptance/applications/electronPreloadOverridesCli.test.tsindex 7997a7d8c..9b0a3df2f 100644--- a/tests/acceptance/applications/electronPreloadOverridesCli.test.ts+++ b/tests/acceptance/applications/electronPreloadOverridesCli.test.ts@@ -67,7 +67,10 @@ cliTest.for(["CLI", "stdio MCP"] as const)(`new BrowserWindow({webPreferences:{${preferences}}});`,);await Promise.all([- writeFile(join(root, "main.js"), `${sourceLines.join("\n")}\n`),+ writeFile(+ join(root, "main.js"),+ `${sourceLines.join("\n")}\nimport { BrowserWindow } from "electron";\n`,+ ),writeFile(join(root, "first.js"), 'throw new Error("inert preload");\n'),writeFile(join(root, "last.js"), 'throw new Error("inert preload");\n'),]);diff --git a/tests/acceptance/applications/runtime.test.ts b/tests/acceptance/applications/runtime.test.tsindex bfa75b721..3c454258f 100644--- a/tests/acceptance/applications/runtime.test.ts+++ b/tests/acceptance/applications/runtime.test.ts@@ -218,7 +218,10 @@ describe("production stdio runtime", () => {record.level >= 50,);expect(fatal).toEqual([]);- }, 15_000);+ // Full catalog discovery and first-call SDK schema compilation take about+ // 8–9 seconds on one local CPU; the 15-second budget repeatedly expired in+ // parallel CI shards. Keep a finite budget for the complete workflow.+ }, 30_000);it.runIf(process.platform === "darwin")("serves a database-kind initial target without a fatal record on macOS",diff --git a/tests/composition/javascript-applications/electronOptionKeys.test.ts b/tests/composition/javascript-applications/electronOptionKeys.test.tsindex 16c1ce2cd..54cf4c11b 100644--- a/tests/composition/javascript-applications/electronOptionKeys.test.ts+++ b/tests/composition/javascript-applications/electronOptionKeys.test.ts@@ -164,8 +164,14 @@ const windowPreloadNodes = (result: Reconstruction) =>const reconstructSource = async (source: string): Promise<Reconstruction> => {const root = await createTestTempDirectory("rea-electron-option-keys-");await Promise.all([- writeFile(join(root, "package.json"), JSON.stringify({ main: "main.js" })),- writeFile(join(root, "main.js"), source),+ writeFile(+ join(root, "package.json"),+ JSON.stringify({ main: "main.js", type: "module" }),+ ),+ writeFile(+ join(root, "main.js"),+ `${source}\nimport { BrowserWindow, utilityProcess } from "electron";\n`,+ ),writeFile(join(root, "preload.js"), "void 0;"),writeFile(join(root, "worker.js"), "void 0;"),]);