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): preserve SQLite constructor provenance
morlutofc847ffe35c2
diff --git a/src/application/javascript/JavaScriptArtifactGraphFindings.ts b/src/application/javascript/JavaScriptArtifactGraphFindings.tsindex 4699e08e6..823c81f7d 100644--- a/src/application/javascript/JavaScriptArtifactGraphFindings.ts+++ b/src/application/javascript/JavaScriptArtifactGraphFindings.ts@@ -278,6 +278,9 @@ const addStorage = (context: JavaScriptArtifactGraphContext,input: FindingInput<StaticStorage>,): void => {+ const candidate = input.value.interpretation === "candidate";+ const limitation =+ "The constructor name is only a candidate; an unchanged SQLite module API origin is unproven.";const source =sourceNodeFor(context,@@ -289,7 +292,7 @@ const addStorage = (kind: "storage",identity: artifactLocalIdentity(input.file.sha256,- input.value.kind,+ candidate ? `${input.value.kind}:candidate` : input.value.kind,input.value.name ?? input.value.mechanism,),observations: [@@ -299,14 +302,25 @@ const addStorage = (storage_kind: input.value.kind,name: input.value.name,mechanism: input.value.mechanism,+ ...(candidate ? { interpretation: "candidate" } : {}),},- evidence: astObservationEvidence({- sha256: input.file.sha256,- path: input.file.path,- range: input.value.location,- operation: "discover-static-storage",- coverage: input.coverage,- }),+ evidence: candidate+ ? staticInferenceEvidence({+ sha256: input.file.sha256,+ path: input.file.path,+ range: input.value.location,+ operation: "classify-static-storage-candidate",+ coverage: input.coverage,+ confidence: "low",+ limitations: [limitation],+ })+ : astObservationEvidence({+ sha256: input.file.sha256,+ path: input.file.path,+ range: input.value.location,+ operation: "discover-static-storage",+ coverage: input.coverage,+ }),},],});@@ -317,7 +331,13 @@ const addStorage = (range: input.value.location,coverage: input.coverage,relation: "persists_to",- properties: { mechanism: input.value.mechanism },+ properties: {+ mechanism: input.value.mechanism,+ ...(candidate ? { interpretation: "candidate" } : {}),+ },+ ...(candidate+ ? { confidence: "low" as const, limitations: [limitation] }+ : {}),});};diff --git a/src/domain/javascript/javascriptSemanticValues.ts b/src/domain/javascript/javascriptSemanticValues.tsindex 6c8321043..f3720815e 100644--- a/src/domain/javascript/javascriptSemanticValues.ts+++ b/src/domain/javascript/javascriptSemanticValues.ts@@ -227,6 +227,20 @@ export const evaluateSemanticExpression = ();};+/** Resolve an expression using the same alias and module provenance owner. */+export const evaluateSemanticExpressionProvenance = (+ node: t.Node,+ state: JavaScriptSemanticAnalysisState,+): JavaScriptBindingProvenance =>+ provenanceForExpression(node, {+ state,+ bindings: new Map(),+ expressionDepth: 0,+ primitiveBindingValues: primitiveBindingValuesFor(state),+ dependence: { lowest: CALLER_INDEPENDENT },+ memo: createEvaluationMemo(state),+ });+/** Follow module provenance through destructuring, members, and aliases. */export const evaluateSemanticProvenance = (binding: JavaScriptSemanticBindingState,@@ -963,7 +977,16 @@ const provenanceForBindingValue = (: "Catch binding provenance depends on the thrown value.",);if (binding.directOrigins.length > 0)- return semanticOriginsProvenance(binding.directOrigins);+ return binding.kind === "import" &&+ !binding.runtimeImport &&+ binding.directOrigins.every(+ ({ resolutionMode }) => resolutionMode !== "require",+ )+ ? semanticAmbiguousProvenance(+ binding.directOrigins,+ "A type-only import does not establish a runtime module value.",+ )+ : semanticOriginsProvenance(binding.directOrigins);if (binding.initializers.length === 0) return semanticLocalProvenance();if (binding.initializers.length > 1)return semanticAmbiguousProvenance(@@ -1151,8 +1174,10 @@ const isLocallyCreatedValue = (node: t.Node): boolean =>t.isObjectExpression(node) ||t.isArrayExpression(node) ||t.isFunctionExpression(node) ||+ t.isFunctionDeclaration(node) ||t.isArrowFunctionExpression(node) ||t.isClassExpression(node) ||+ t.isClassDeclaration(node) ||t.isTemplateLiteral(node) ||t.isUnaryExpression(node) ||t.isBinaryExpression(node) ||diff --git a/src/domain/javascript/javascriptStaticAnalysis.sqliteStorage.test.ts b/src/domain/javascript/javascriptStaticAnalysis.sqliteStorage.test.tsnew file mode 100644index 000000000..0e45dd610--- /dev/null+++ b/src/domain/javascript/javascriptStaticAnalysis.sqliteStorage.test.ts@@ -0,0 +1,49 @@+import { expect, it } from "vitest";+import { analyzeJavaScriptStaticSource } from "./javascriptStaticAnalysis.js";++it.each([+ 'class Database { constructor(name) { this.name = name; } } new Database("hello");',+ 'const Database = class {}; new Database("hello");',+ 'function Database(name) { return {name}; } new Database("hello");',+ 'class Local {} const Database = Local; new Database("hello");',+])("omits a proven local constructor: %s", (source) => {+ expect(analyzeJavaScriptStaticSource(source).storage).toEqual([]);+});++it.each([+ 'new Database("shared");',+ 'import type Database = require("better-sqlite3"); new Database("shared");',+ 'import * as sqlite from "sqlite3"; const alias = sqlite; alias.Database = Other; new sqlite.Database("shared");',+ 'import Database from "better-sqlite3"; expose(Database); new Database("shared");',+ 'import type TypeDatabase from "better-sqlite3"; const Database = TypeDatabase; new Database("shared");',+ 'import * as Database from "better-sqlite3"; new Database("shared");',+ 'const Database = require("better-sqlite3").default; new Database("shared");',+ 'const sqlite = require("sqlite3").default; new sqlite.Database("shared");',+ 'import type Database from "better-sqlite3"; new Database("shared");',+ 'import * as sqlite from "sqlite3"; new sqlite.default.default.Database("shared");',+ 'function run(Database) { return new Database("shared"); }',+ 'import Database from "unknown-library"; new Database("shared");',+ 'import Database from "better-sqlite3"; Database = Other; new Database("shared");',+ 'import * as sqlite from "sqlite3"; sqlite.Database = Other; new sqlite.Database("shared");',+])("retains uncertain SQLite names as candidates: %s", (source) => {+ expect(analyzeJavaScriptStaticSource(source).storage).toMatchObject([+ { kind: "sqlite", name: "shared", interpretation: "candidate" },+ ]);+});++it.each([+ 'import Database from "better-sqlite3"; new Database("known.db");',+ 'import Database = require("better-sqlite3"); new Database("known.db");',+ 'import sqlite = require("sqlite3"); new sqlite.Database("known.db");',+ 'const Database = require("better-sqlite3"); new Database("known.db");',+ 'import {Database} from "sqlite3"; new Database("known.db");',+ 'import * as sqlite from "sqlite3"; new sqlite.Database("known.db");',+])("retains proven SQLite API origins: %s", (source) => {+ const analysis = analyzeJavaScriptStaticSource(source);+ expect(analysis.storage).toHaveLength(1);+ expect(analysis.storage[0]).toMatchObject({+ kind: "sqlite",+ name: "known.db",+ });+ expect(analysis.storage[0]).not.toHaveProperty("interpretation");+});diff --git a/src/domain/javascript/javascriptStaticAnalysis.ts b/src/domain/javascript/javascriptStaticAnalysis.tsindex 6d6ca3e8a..758355af2 100644--- a/src/domain/javascript/javascriptStaticAnalysis.ts+++ b/src/domain/javascript/javascriptStaticAnalysis.ts@@ -23,6 +23,7 @@ import {addReference,addSourceMapDirectives,finishPartialNetworkEndpoints,+ finishSqliteStorageCalls,inspectCall,inspectRouteProperty,inspectRoleProperty,@@ -101,9 +102,13 @@ export function* analyzeParsedJavaScriptStaticSourceSteps(};yield* traverseStaticSourceSteps(file, findings, bindings);yield* finishElectronBrowserWindowsSteps(findings, index);- if (accumulator.pendingNetworkCalls.length > 0) {+ if (+ accumulator.pendingNetworkCalls.length > 0 ||+ accumulator.pendingSqliteCalls.length > 0+ ) {yield* index.indexMemberMutationFactsSteps();finishPartialNetworkEndpoints(findings, bindings, index);+ finishSqliteStorageCalls(findings, bindings, index);}accumulator.electronCallPaths = collectElectronWrappedCallPaths(file.program,diff --git a/src/domain/javascript/javascriptStaticAnalysisCalls.ts b/src/domain/javascript/javascriptStaticAnalysisCalls.tsindex 763861d70..04a504d6a 100644--- a/src/domain/javascript/javascriptStaticAnalysisCalls.ts+++ b/src/domain/javascript/javascriptStaticAnalysisCalls.ts@@ -42,7 +42,10 @@ import {isUnmodifiedGlobalReference,isUnmodifiedImportMetaUrl,} from "./javascriptSemanticAmbientWrites.js";-import { evaluateSemanticExpression } from "./javascriptSemanticValues.js";+import {+ evaluateSemanticExpression,+ evaluateSemanticExpressionProvenance,+} from "./javascriptSemanticValues.js";import { semanticTopLevelEffectFollowsCapture } from "./javascriptSemanticMutationInitializers.js";import {semanticFactoryLoaderMemberAt,@@ -747,6 +750,10 @@ const inspectStorageCall = (first: string | undefined,context: FindingContext,): void => {+ if (name === "Database" || name.endsWith(".Database")) {+ context.accumulator.pendingSqliteCalls.push({ node, name });+ return;+ }const receiverFact = context.openReceiverFacts?.get(node.start ?? -1);const storage =receiverFact === "local" ||@@ -773,6 +780,53 @@ const inspectStorageCall = (});};+/** Constructor spelling selects a candidate; source provenance owns certainty. */+export const finishSqliteStorageCalls = (+ context: FindingContext,+ bindings: JavaScriptSemanticAnalysisState,+ index: JavaScriptBindingIndex,+): void => {+ for (const { node, name } of context.accumulator.pendingSqliteCalls) {+ const callee = unwrapJavaScriptExpression(node.callee).node;+ const provenance = evaluateSemanticExpressionProvenance(callee, bindings);+ const changed = index.referenceMayHaveChangedAt(node, callee);+ if (!changed && t.isIdentifier(callee) && provenance.status === "local")+ continue;+ const origin =+ provenance.status === "module" ? provenance.origins[0] : undefined;+ const path = origin?.importedPath;+ const imported = origin?.resolutionMode !== "require";+ const known =+ !changed &&+ origin !== undefined &&+ ((origin.specifier === "better-sqlite3" &&+ ((origin.resolutionMode === "require" && path?.length === 0) ||+ (imported && path?.length === 1 && path[0] === "default"))) ||+ (origin.specifier === "sqlite3" &&+ ((path?.length === 1 && path[0] === "Database") ||+ (imported &&+ path?.length === 2 &&+ (path[0] === "default" || path[0] === "*") &&+ path[1] === "Database"))));+ const first = stringValue(node.arguments[0]);+ addLocatedFinding(context, {+ collection: context.accumulator.storage,+ key: `storage\0sqlite\0${known ? "api" : "candidate"}\0${first ?? ""}`,+ node,+ value: {+ kind: "sqlite",+ name: first ?? null,+ mechanism: `call:${name}`,+ ...(known ? {} : { interpretation: "candidate" as const }),+ module_key: null,+ location: range(node),+ },+ });+ }+ context.accumulator.pendingSqliteCalls.length = 0;+ context.accumulator.storage.sort((left, right) => left.offset - right.offset);+};+export const addReference = (context: FindingContext,input: ReferenceInput,diff --git a/src/domain/javascript/javascriptStaticAnalysisHelpers.ts b/src/domain/javascript/javascriptStaticAnalysisHelpers.tsindex 72a3d4079..952b2c7d0 100644--- a/src/domain/javascript/javascriptStaticAnalysisHelpers.ts+++ b/src/domain/javascript/javascriptStaticAnalysisHelpers.ts@@ -675,7 +675,6 @@ export const storageKind = (if (name.includes("sessionStorage.")) return "session-storage";if (name.endsWith("indexedDB.open")) return "indexed-db";if (name.endsWith("caches.open")) return "cache-storage";- if (name === "Database" || name.endsWith(".Database")) return "sqlite";return undefined;};diff --git a/src/domain/javascript/javascriptStaticAnalysisState.ts b/src/domain/javascript/javascriptStaticAnalysisState.tsindex 0e875e46a..d03580554 100644--- a/src/domain/javascript/javascriptStaticAnalysisState.ts+++ b/src/domain/javascript/javascriptStaticAnalysisState.ts@@ -50,6 +50,13 @@ export interface JavaScriptAnalysisAccumulator {| t.NewExpression;readonly name: string;}[];+ readonly pendingSqliteCalls: {+ readonly node:+ | t.CallExpression+ | t.OptionalCallExpression+ | t.NewExpression;+ readonly name: string;+ }[];readonly storage: LocatedJavaScriptFinding<JavaScriptStaticStorage>[];readonly roles: LocatedJavaScriptFinding<JavaScriptRolePath>[];readonly sourceMaps: JavaScriptStaticAnalysis["source_map_urls"][number][];@@ -117,6 +124,7 @@ export const createJavaScriptAnalysisAccumulator = (endpoints: [],pendingNetworkCalls: [],storage: [],+ pendingSqliteCalls: [],roles: [],sourceMaps: [],registrations: [],diff --git a/src/domain/javascript/javascriptStaticAnalysisTypes.ts b/src/domain/javascript/javascriptStaticAnalysisTypes.tsindex 7838d2ae3..b3a5fc8c0 100644--- a/src/domain/javascript/javascriptStaticAnalysisTypes.ts+++ b/src/domain/javascript/javascriptStaticAnalysisTypes.ts@@ -55,7 +55,7 @@ export interface JavaScriptStaticEndpoint {readonly location: JavaScriptSourceRange;}-/** A storage surface observed without executing application code. */+/** A storage API or explicitly uncertain candidate, without executing source. */export interface JavaScriptStaticStorage {readonly kind:| "local-storage"@@ -63,6 +63,7 @@ export interface JavaScriptStaticStorage {| "indexed-db"| "cache-storage"| "sqlite";+ readonly interpretation?: "candidate";readonly name: string | null;readonly mechanism: string;readonly module_key: string | null;diff --git a/src/javascript/analysis/JavaScriptAnalysisWorkerSchemas.ts b/src/javascript/analysis/JavaScriptAnalysisWorkerSchemas.tsindex 17be5e074..e3da83f93 100644--- a/src/javascript/analysis/JavaScriptAnalysisWorkerSchemas.ts+++ b/src/javascript/analysis/JavaScriptAnalysisWorkerSchemas.ts@@ -344,6 +344,7 @@ export const javaScriptWorkerStaticAnalysisSchema = z"cache-storage","sqlite",]),+ interpretation: z.literal("candidate").exactOptional(),name: z.string().nullable(),mechanism: z.string(),}),diff --git a/tests/acceptance/applications/javascriptEndpointCandidateCli.test.ts b/tests/acceptance/applications/javascriptEndpointCandidateCli.test.tsindex 38027906e..77823fc54 100644--- a/tests/acceptance/applications/javascriptEndpointCandidateCli.test.ts+++ b/tests/acceptance/applications/javascriptEndpointCandidateCli.test.ts@@ -80,3 +80,61 @@ it("reports a candidate endpoint through the worker boundary in the public CLI",);expect(edge?.properties).toMatchObject({ interpretation: "candidate" });}, 20_000);++it("preserves SQLite constructor certainty through the public worker and graph", async () => {+ const root = await createTestTempDirectory("rea-storage-candidate-cli-");+ await writeFile(+ join(root, "main.mjs"),+ `+ import Known from "better-sqlite3";+ class Database { constructor(name) { this.name = name; } }+ new Database("local");+ function uncertain(Database) { return new Database("shared"); }+ { const Database = Known; new Database("shared"); }+ `,+ );+ const { stdout } = await execute(+ process.execPath,+ ["scripts/rea.mjs", "analyze-javascript-application", root, "--json"],+ { cwd: process.cwd(), maxBuffer: 16 * 1024 * 1024 },+ );+ const result = javascriptApplicationAnalysisResultSchema.parse(+ parseEvidence(JSON.parse(stdout)).normalized_result,+ );+ const storage = result.graph.nodes.filter((node) => node.kind === "storage");+ expect(storage).toHaveLength(2);+ const candidate = storage.find(+ (node) => node.observations[0]?.properties.interpretation === "candidate",+ );+ const observed = storage.find(+ (node) => node.observations[0]?.properties.interpretation === undefined,+ );+ expect(candidate?.node_id).not.toBe(observed?.node_id);+ expect(candidate?.observations[0]).toMatchObject({+ properties: { storage_kind: "sqlite", name: "shared" },+ evidence: {+ state: "inferred",+ confidence: "low",+ limitations: expect.arrayContaining([+ expect.stringContaining("only a candidate"),+ ]),+ },+ });+ expect(observed?.observations[0]).toMatchObject({+ properties: { storage_kind: "sqlite", name: "shared" },+ evidence: { state: "observed", confidence: "exact" },+ });+ expect(+ result.graph.edges.find(+ (edge) => edge.target_node_id === candidate?.node_id,+ ),+ ).toMatchObject({+ properties: { interpretation: "candidate" },+ evidence: {+ confidence: "low",+ limitations: expect.arrayContaining([+ expect.stringContaining("only a candidate"),+ ]),+ },+ });+}, 20_000);