Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(javascript): parse plain TypeScript artifact dialects (#1102)

Rudy Mizrahi Celekli3db46813f80f
diff --git a/docs/javascript-artifact-reconstruction.md b/docs/javascript-artifact-reconstruction.md
index 8014def27..5238f42be 100644
--- a/docs/javascript-artifact-reconstruction.md
+++ b/docs/javascript-artifact-reconstruction.md
@@ -140,6 +140,9 @@ missing bytes. This allows static JavaScript/Electron reconstruction to proceed
for the embedded files while preserving the missing native/resource bytes as an
unknown instead of silently treating them as absent or verified.
+Plain `.ts` artifact sources use TypeScript syntax without JSX, including
+angle-bracket type assertions. `.tsx` and `.jsx` retain JSX parsing.
+
Selected bounded text is then parsed as inert data to recover:
- `package.json` metadata and declared main or renderer entrypoints;
diff --git a/src/application/javascript/JavaScriptArtifactAnalysis.ts b/src/application/javascript/JavaScriptArtifactAnalysis.ts
index cb5eb7149..09c834745 100644
--- a/src/application/javascript/JavaScriptArtifactAnalysis.ts
+++ b/src/application/javascript/JavaScriptArtifactAnalysis.ts
@@ -166,7 +166,7 @@ const analyzeArtifactFile = <SemanticIr extends JavaScriptModuleSemanticIr>(
state.files.push({ file, javascript: null, semantic: null });
return;
}
- const parsed = parseJavaScriptSource(file.text.value);
+ const parsed = parseJavaScriptSource(file.text.value, file.path);
if (parsed === null) {
const analysis = failedJavaScriptStaticAnalysis();
state.files.push({ file, javascript: analysis, semantic: null });
diff --git a/src/domain/javascript/javascriptSourceParser.ts b/src/domain/javascript/javascriptSourceParser.ts
index b68cedcad..e86b1bca3 100644
--- a/src/domain/javascript/javascriptSourceParser.ts
+++ b/src/domain/javascript/javascriptSourceParser.ts
@@ -6,6 +6,7 @@ export type ParsedJavaScriptSource = ReturnType<typeof parse>;
/** Parse JavaScript or TypeScript once without attaching comments to AST nodes. */
export const parseJavaScriptSource = (
source: string,
+ sourcePath?: string,
): ParsedJavaScriptSource | null => {
try {
return parse(source, {
@@ -16,7 +17,12 @@ export const parseJavaScriptSource = (
// forms, including parameter decorators. Without it a decorated
// TypeScript source fails to parse at all rather than reporting
// recovered syntax, which loses every fact derived from that source.
- plugins: ["decorators-legacy", "jsx", "typescript"],
+ // Plain .ts artifacts admit angle-bracket type assertions instead of JSX.
+ // Unknown paths retain the existing JSX-capable parser contract.
+ plugins:
+ sourcePath?.toLowerCase().endsWith(".ts") === true
+ ? ["decorators-legacy", "typescript"]
+ : ["decorators-legacy", "jsx", "typescript"],
});
} catch (cause: unknown) {
// Unparseable source is represented by the null return.
diff --git a/tests/boundary/cli/javascriptArtifactTypeScriptDialect.test.ts b/tests/boundary/cli/javascriptArtifactTypeScriptDialect.test.ts
new file mode 100644
index 000000000..06a28c27c
--- /dev/null
+++ b/tests/boundary/cli/javascriptArtifactTypeScriptDialect.test.ts
@@ -0,0 +1,38 @@
+import { expect } from "vitest";
+
+import { parseEvidence } from "../../../src/domain/evidence.js";
+import { javascriptApplicationAnalysisResultSchema } from "../../../src/domain/javascript/javascriptApplicationAnalysis.js";
+import {
+ typeScriptDialectCases,
+ createTypeScriptDialectArtifact,
+ expectTypeScriptDialectReference,
+ expectValidTypeScriptInput,
+} from "../../fixtures/javascriptArtifactTypeScriptDialect.js";
+import { cliTest } from "../../support/cli/cliFixture.js";
+
+for (const format of ["directory", "asar"] as const) {
+ for (const command of ["analyze-javascript-application", "analyze"]) {
+ cliTest(
+ `${command} retains TypeScript dialect reference facts for ${format}`,
+ async ({ cli }) => {
+ for (const fixture of typeScriptDialectCases)
+ await expectValidTypeScriptInput(fixture.path, fixture.source);
+ const input = await createTypeScriptDialectArtifact(
+ format,
+ typeScriptDialectCases,
+ );
+ const output = await cli.run({ arguments: [command, input, "--json"] });
+ expect(output.exitCode).toBe(0);
+ const result = javascriptApplicationAnalysisResultSchema.parse(
+ parseEvidence(output.json).normalized_result,
+ );
+ expect(result.statistics).toMatchObject({
+ parse_failures: 0,
+ invalid_utf8_files: 0,
+ });
+ for (const fixture of typeScriptDialectCases)
+ expectTypeScriptDialectReference(result.graph, fixture);
+ },
+ );
+ }
+}
diff --git a/tests/boundary/filesystem/javascriptArtifactTypeScriptDialect.test.ts b/tests/boundary/filesystem/javascriptArtifactTypeScriptDialect.test.ts
new file mode 100644
index 000000000..b266dde87
--- /dev/null
+++ b/tests/boundary/filesystem/javascriptArtifactTypeScriptDialect.test.ts
@@ -0,0 +1,39 @@
+import { parse } from "@babel/parser";
+import { expect, it } from "vitest";
+
+import { reconstructJavaScriptArtifact } from "../../../src/application/javascript/JavaScriptArtifactReconstruction.js";
+import {
+ typeScriptDialectCases,
+ createTypeScriptDialectArtifact,
+ expectTypeScriptDialectReference,
+ expectValidTypeScriptInput,
+} from "../../fixtures/javascriptArtifactTypeScriptDialect.js";
+
+for (const format of ["directory", "asar"] as const) {
+ for (const fixture of typeScriptDialectCases) {
+ it(`${format} retains ${fixture.path} syntax-derived reference facts`, async () => {
+ await expectValidTypeScriptInput(fixture.path, fixture.source);
+ const input = await createTypeScriptDialectArtifact(format, [fixture]);
+ const result = await reconstructJavaScriptArtifact({ input_path: input });
+ expect(result.statistics).toMatchObject({
+ parse_failures: 0,
+ invalid_utf8_files: 0,
+ });
+ expectTypeScriptDialectReference(result.graph, fixture);
+ });
+ }
+}
+
+for (const extension of ["mts", "cts"] as const) {
+ it(`establishes the valid disambiguated ${extension} producer syntax`, async () => {
+ const source =
+ 'const identity = <T,>(value: T): T => value;\nimport "./dep.js";';
+ await expectValidTypeScriptInput(`control.${extension}`, source);
+ expect(
+ parse(source, {
+ sourceType: "unambiguous",
+ plugins: [["typescript", { disallowAmbiguousJSXLike: true }]],
+ }).errors,
+ ).toEqual([]);
+ });
+}
diff --git a/tests/fixtures/javascriptArtifactTypeScriptDialect.ts b/tests/fixtures/javascriptArtifactTypeScriptDialect.ts
new file mode 100644
index 000000000..f0677b175
--- /dev/null
+++ b/tests/fixtures/javascriptArtifactTypeScriptDialect.ts
@@ -0,0 +1,176 @@
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { promisify } from "node:util";
+
+import { createPackageWithOptions } from "@electron/asar";
+import { parse } from "@babel/parser";
+import { expect } from "vitest";
+
+import type { JavaScriptApplicationGraph } from "../../src/domain/javascript/javascriptApplicationGraph.js";
+import { createTestTempDirectory } from "./temporaryDirectory.js";
+
+export const typeScriptDialectCases = [
+ {
+ path: "assertion.ts",
+ kind: "static-import",
+ source: 'const value = <number>1;\nimport "./dep.js";',
+ },
+ {
+ path: "wrapped.ts",
+ kind: "require",
+ source: 'const value = <unknown>require("./dep.js");',
+ },
+ {
+ path: "as.ts",
+ kind: "static-import",
+ source: 'const value = 1 as number;\nimport "./dep.js";',
+ },
+ {
+ path: "wrapped-as.ts",
+ kind: "require",
+ source: 'const value = require("./dep.js") as unknown;',
+ },
+ {
+ path: "generic.ts",
+ kind: "static-import",
+ source: 'const identity = <T>(value: T): T => value;\nimport "./dep.js";',
+ },
+ {
+ path: "component.tsx",
+ kind: "static-import",
+ source: 'const element = <section />;\nimport "./dep.js";',
+ },
+ {
+ path: "component.jsx",
+ kind: "static-import",
+ source: 'const element = <section />;\nimport "./dep.js";',
+ },
+] as const;
+
+const execute = promisify(execFile);
+
+/** Establish syntax and emitted bytes with the actual locked native compiler. */
+export const expectValidTypeScriptInput = async (
+ path: string,
+ source: string,
+): Promise<void> => {
+ const directory = await createTestTempDirectory("rea-typescript-producer-");
+ const compiler = resolve("node_modules/typescript/bin/tsc");
+ const input = join(directory, path);
+ await Promise.all([
+ writeFile(input, source),
+ writeFile(join(directory, "dep.js"), "export const dependency = true;"),
+ ]);
+ const output = join(directory, "emitted");
+ // --noCheck isolates syntax/emit from ambient React/Node/module type facts.
+ // This supplemental oracle does not claim complete TypeScript type validity.
+ await execute(process.execPath, [
+ compiler,
+ "--ignoreConfig",
+ "--noCheck",
+ "--allowJs",
+ "--target",
+ "es2022",
+ "--module",
+ "esnext",
+ "--jsx",
+ "preserve",
+ "--outDir",
+ output,
+ input,
+ ]);
+ const suffix = path.endsWith(".mts")
+ ? ".mjs"
+ : path.endsWith(".cts")
+ ? ".cjs"
+ : path.endsWith(".tsx") || path.endsWith(".jsx")
+ ? ".jsx"
+ : ".js";
+ const emitted = await readFile(
+ join(output, path.replace(/\.(?:mts|cts|tsx|jsx|ts)$/u, suffix)),
+ "utf8",
+ );
+ expect(
+ parse(emitted, { sourceType: "unambiguous", plugins: ["jsx"] }).errors,
+ ).toEqual([]);
+};
+
+/** Build actual directory or ASAR input without evaluating any source. */
+export const createTypeScriptDialectArtifact = async (
+ format: "directory" | "asar",
+ cases: readonly (typeof typeScriptDialectCases)[number][],
+): Promise<string> => {
+ const root = await createTestTempDirectory("rea-typescript-dialect-");
+ const directory = join(root, "source");
+ await mkdir(directory);
+ await Promise.all([
+ writeFile(join(directory, "dep.js"), "export const dependency = true;"),
+ ...cases.map(({ path, source }) =>
+ writeFile(join(directory, path), source),
+ ),
+ ]);
+ if (format === "directory") return directory;
+ const archive = join(root, "app.asar");
+ await createPackageWithOptions(directory, archive, {});
+ return archive;
+};
+
+/** Compare digest-bound graph evidence with the producer's actual reference. */
+export const expectTypeScriptDialectReference = (
+ graph: JavaScriptApplicationGraph,
+ fixture: (typeof typeScriptDialectCases)[number],
+): void => {
+ const parsed = parse(fixture.source, {
+ sourceType: "unambiguous",
+ plugins: fixture.path.endsWith(".ts")
+ ? ["typescript"]
+ : ["typescript", "jsx"],
+ });
+ const statement = parsed.program.body[0];
+ const initializer =
+ statement?.type === "VariableDeclaration"
+ ? statement.declarations[0]?.init
+ : undefined;
+ const target =
+ fixture.kind === "require"
+ ? initializer?.type === "TSTypeAssertion" ||
+ initializer?.type === "TSAsExpression"
+ ? initializer.expression
+ : undefined
+ : parsed.program.body.find(({ type }) => type === "ImportDeclaration");
+ if (target?.loc === undefined || target.loc === null)
+ throw new Error("Missing producer reference location");
+ const edges = graph.edges.filter(
+ ({ relation, properties, evidence }) =>
+ relation === "imports" &&
+ properties.kind === fixture.kind &&
+ properties.specifier === "./dep.js" &&
+ evidence.location.available &&
+ evidence.location.value.kind === "source-range" &&
+ evidence.location.value.source === fixture.path,
+ );
+ expect(edges).toHaveLength(1);
+ expect(edges[0]).toMatchObject({
+ properties: { resolved_path: "dep.js" },
+ evidence: {
+ artifact: {
+ available: true,
+ sha256: createHash("sha256").update(fixture.source).digest("hex"),
+ },
+ location: {
+ available: true,
+ value: {
+ kind: "source-range",
+ source: fixture.path,
+ start: {
+ line: target.loc.start.line,
+ column: target.loc.start.column,
+ },
+ end: { line: target.loc.end.line, column: target.loc.end.column },
+ },
+ },
+ },
+ });
+};