rea-agents 3.0.0 → 3.2.0

package/dist/generatedPackageMetadata.js

@@ -1,7 +1,7 @@
 /** Generated from package.json and package-lock.json; do not edit. */
 export const PACKAGE_METADATA = {
     name: "rea-agents",
-    version: "3.0.0", // x-release-please-version
+    version: "3.2.0", // x-release-please-version
     serverSdkVersion: "2.0.0",
     clientSdkVersion: "2.0.0",
     coreSdkVersion: "2.0.0",

package/dist/ghidra/GhidraAnalysisProfile.js

@@ -1,19 +1,17 @@
 import { createAnalysisProfile } from "../domain/analysisProfile.js";
 import { AnalysisCancelledError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
-import { GHIDRA_ANALYSIS_TIMEOUT_SECONDS, GHIDRA_MAX_CPU, GHIDRA_MAX_HEAP, } from "./GhidraDefaults.js";
 /** Resolve version-bound, deterministic semantics before Ghidra imports a target. */
 export const resolveGhidraAnalysisProfile = (target, identity, installation, signal) => {
     if (signal?.aborted === true)
         return Promise.resolve(err(new AnalysisCancelledError("open_binary")));
     if (target.kind !== "executable")
         return Promise.resolve(ok({ profile: null, compatibility: {} }));
-    const version = installation.providerVersion;
-    if (!installation.available || version === null)
+    if (installation.status === "unavailable")
         return Promise.resolve(err(new ProviderAdapterError(identity.id, "resolve_analysis_profile")));
-    const provider = { ...identity, version };
+    const provider = { ...identity, version: installation.providerVersion };
     return Promise.resolve(ok({
-        profile: createAnalysisProfile(provider, 1, {
+        profile: createAnalysisProfile(provider, {
             target_kind: target.kind,
             target_format: target.format,
             architecture: target.architecture ?? null,
@@ -25,9 +23,6 @@ export const resolveGhidraAnalysisProfile = (target, identity, installation, sig
             language_id: "auto-from-header",
             compiler_spec_id: "auto-default",
             analyzer_preset: "ghidra-default",
-            analysis_timeout_seconds: GHIDRA_ANALYSIS_TIMEOUT_SECONDS,
-            max_cpu: GHIDRA_MAX_CPU,
-            max_heap: GHIDRA_MAX_HEAP,
         }),
         compatibility: {
             languageId: "auto",

package/dist/ghidra/GhidraClient.js

@@ -8,7 +8,7 @@ import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
 import { ProviderStartupDeadline } from "../process/ProviderDeadline.js";
 import { ProviderRunLineage } from "../process/ProviderRunLineage.js";
 import { ProviderProcessSupervisor, } from "../process/ProviderProcess.js";
-import { GHIDRA_MAX_LINE_BYTES, GHIDRA_MAX_QUEUED_REQUESTS, GHIDRA_REQUEST_TIMEOUT_MS, GHIDRA_STARTUP_TIMEOUT_MS, } from "./GhidraDefaults.js";
+import { GHIDRA_STARTUP_TIMEOUT_MS } from "./GhidraDefaults.js";
 import { createGhidraDiagnostics } from "./GhidraDiagnostics.js";
 import { GhidraResponseBuffer } from "./GhidraResponseBuffer.js";
 import { GhidraResponseRouter } from "./GhidraResponseRouter.js";
@@ -54,9 +54,7 @@ export class GhidraClient {
         protocolFailure: (message, cause) => this.#abortProtocol(message, cause),
     });
     #responseBuffer = new GhidraResponseBuffer({
-        maxLineBytes: GHIDRA_MAX_LINE_BYTES,
         onLine: (line) => this.#responseRouter.route(line),
-        onFailure: (message) => this.#abortProtocol(message),
     });
     #onSocketData = (chunk) => this.#responseBuffer.push(chunk);
     #onSocketError = () => {
@@ -69,7 +67,6 @@ export class GhidraClient {
     constructor(options) {
         this.#options = {
             ...options,
-            requestTimeoutMs: options.requestTimeoutMs ?? GHIDRA_REQUEST_TIMEOUT_MS,
             startupTimeoutMs: options.startupTimeoutMs ?? GHIDRA_STARTUP_TIMEOUT_MS,
             transport: options.transport ?? "unix-socket",
         };
@@ -79,11 +76,10 @@ export class GhidraClient {
             getToken: () => this.#token,
             nextId: () => this.#nextId++,
             pending: this.#pending,
-            requestTimeoutMs: this.#options.requestTimeoutMs,
             logger: this.#logger,
             failure: this.#failure,
         });
-        this.#requestQueue = new GhidraRequestQueue(GHIDRA_MAX_QUEUED_REQUESTS, (method, parameters, requestOptions) => this.#wire.request(method, parameters, requestOptions), (kind, message, timeoutMs) => this.#failure(kind, message, undefined, timeoutMs === undefined ? {} : { timeoutMs }));
+        this.#requestQueue = new GhidraRequestQueue((method, parameters, requestOptions) => this.#wire.request(method, parameters, requestOptions), (kind, message) => this.#failure(kind, message));
     }
     /** Launch Ghidra once and require its exact post-analysis handshake. */
     start(signal) {
@@ -125,15 +121,12 @@ export class GhidraClient {
             return result;
         return this.#parseSessionInfo(result.value);
     }
-    /** Execute one admitted operation through the bounded per-Program queue. */
+    /** Execute one admitted operation through the serial per-Program queue. */
     async callTool(operation, parameters, options = {}) {
         const started = await this.start(options.signal);
         if (!started.ok)
             return started;
-        return this.#requestQueue.run(operation, parameters, {
-            ...(options.signal === undefined ? {} : { signal: options.signal }),
-            timeoutMs: options.timeoutMs ?? this.#options.requestTimeoutMs,
-        });
+        return this.#requestQueue.run(operation, parameters, options.signal === undefined ? {} : { signal: options.signal });
     }
     /** Stop the owned process group and remove all project/runtime artifacts. */
     close() {
@@ -339,7 +332,6 @@ export class GhidraClient {
                 stream: event.stream,
                 bytes: event.bytes,
                 totalBytes: event.totalBytes,
-                truncated: event.truncated,
             });
             return;
         }
@@ -369,7 +361,7 @@ export class GhidraClient {
         return err(failure);
     }
     #interruptionFailure(deadline) {
-        return deadline.cancelled
+        return deadline.interruption === "cancelled"
             ? this.#failure("cancelled", "Ghidra startup was cancelled")
             : this.#failure("timeout", "Ghidra startup deadline elapsed", undefined, {
                 timeoutMs: deadline.timeoutMs,

package/dist/ghidra/GhidraClientStartup.js

@@ -22,7 +22,7 @@ export async function completeGhidraStartupHandshake(options) {
     }
     return parsed;
 }
-const interruptionFailure = (options) => options.deadline.cancelled
+const interruptionFailure = (options) => options.deadline.interruption === "cancelled"
     ? options.failure("cancelled", "Ghidra startup was cancelled")
     : options.failure("timeout", "Ghidra startup deadline elapsed", undefined, {
         timeoutMs: options.startupTimeoutMs,

package/dist/ghidra/GhidraClientWire.js

@@ -14,13 +14,17 @@ export class GhidraWire {
         if (options.signal?.aborted === true)
             return err(this.#options.failure("cancelled", "Ghidra request was cancelled"));
         const id = this.#options.nextId();
-        const timeoutMs = options.timeoutMs ?? this.#options.requestTimeoutMs;
-        if (timeoutMs <= 0)
-            return err(this.#options.failure("timeout", "Ghidra request deadline elapsed", undefined, { timeoutMs }));
+        if (options.timeoutMs !== undefined && options.timeoutMs <= 0)
+            return err(this.#options.failure("timeout", "Ghidra request deadline elapsed", undefined, { timeoutMs: options.timeoutMs }));
+        const timeoutMs = options.timeoutMs;
         const response = this.#options.pending.wait(id, {
-            timeoutMs,
+            ...(timeoutMs === undefined
+                ? {}
+                : {
+                    timeoutMs,
+                    timeoutValue: () => err(this.#options.failure("timeout", "Ghidra bridge request timed out", undefined, { timeoutMs })),
+                }),
             ...(options.signal === undefined ? {} : { signal: options.signal }),
-            timeoutValue: () => err(this.#options.failure("timeout", "Ghidra bridge request timed out", undefined, { timeoutMs })),
             cancelledValue: () => err(this.#options.failure("cancelled", "Ghidra request was cancelled")),
         });
         socket.write(`${JSON.stringify({ id, token, method, params })}\n`, (cause) => {

package/dist/ghidra/GhidraDefaults.js

@@ -1,20 +1,2 @@
-/** Maximum wall-clock analysis time passed to Ghidra for one imported file. */
-export const GHIDRA_ANALYSIS_TIMEOUT_SECONDS = 300;
-/** Maximum CPU cores made available to one headless analysis. */
-export const GHIDRA_MAX_CPU = 2;
-/** Explicit JVM heap ceiling for one headless provider process. */
-export const GHIDRA_MAX_HEAP = "2G";
 /** Absolute import, analysis, bridge, and health startup deadline. */
 export const GHIDRA_STARTUP_TIMEOUT_MS = 330_000;
-/** Default bounded wait for one established bridge request. */
-export const GHIDRA_REQUEST_TIMEOUT_MS = 10_000;
-/** Per-function ceiling passed to Ghidra's native decompiler process. */
-export const GHIDRA_DECOMPILE_TIMEOUT_SECONDS = 30;
-/** Socket deadline leaves bounded time to project a native decompiler timeout. */
-export const GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS = 35_000;
-/** Maximum active plus queued calls for one serial headless Program. */
-export const GHIDRA_MAX_QUEUED_REQUESTS = 32;
-/** Maximum encoded response line accepted from the Java bridge. */
-export const GHIDRA_MAX_LINE_BYTES = 1024 * 1024;
-/** Version of REA's Java bridge handshake and request protocol. */
-export const GHIDRA_BRIDGE_VERSION = 6;

package/dist/ghidra/GhidraDiagnostics.js

@@ -44,6 +44,4 @@ export const createGhidraDiagnostics = (options) => {
 const boundedStream = (stream, redact) => ({
     text: redact(stream.text),
     bytes: stream.bytes,
-    retained_bytes: stream.retainedBytes,
-    truncated: stream.truncated,
 });

package/dist/ghidra/GhidraDoctor.js

@@ -3,14 +3,12 @@ import { inspectGhidraInstallation, } from "./GhidraInstallation.js";
 export const projectGhidraDoctorInspection = (inspection) => ({
     id: "ghidra",
     configured: inspection.installDir !== null,
-    available: inspection.available,
+    available: inspection.status === "available",
     providerVersion: inspection.providerVersion,
-    registrationEnvironment: inspection.available && inspection.installDir !== null
+    registrationEnvironment: inspection.status === "available"
         ? {
             GHIDRA_INSTALL_DIR: inspection.installDir,
-            ...(inspection.javaHome === null
-                ? {}
-                : { JAVA_HOME: inspection.javaHome }),
+            JAVA_HOME: inspection.javaHome,
         }
         : {},
     checks: selectedChecks(inspection).map((check) => projectCheck(check, inspection.installDir !== null)),
@@ -29,7 +27,7 @@ const selectedChecks = (inspection) => {
     const configuration = byName.get("configuration");
     if (configuration === undefined)
         return [];
-    if (!configuration.ok)
+    if (configuration.status === "failed")
         return [configuration];
     const installation = byName.get("installation");
     return [
@@ -37,21 +35,27 @@ const selectedChecks = (inspection) => {
         byName.get("platform"),
         byName.get("architecture"),
         installation,
-        ...(installation?.ok === true
-            ? [byName.get("version"), byName.get("headless")]
+        ...(installation?.status === "passed"
+            ? [
+                byName.get("version"),
+                byName.get("headless"),
+                byName.get("native_decompiler"),
+            ]
             : []),
         byName.get("java"),
     ].filter((candidate) => Boolean(candidate));
 };
 const projectCheck = (check, configured) => ({
     name: check.name,
-    ok: check.ok,
-    code: check.code,
+    ok: check.status === "passed",
+    code: check.status === "failed" ? check.code : null,
     detail: check.detail,
-    remediation: check.remediation,
+    remediation: check.status === "failed" ? check.remediation : null,
     classification: check.name === "platform" || check.name === "architecture"
         ? "unsupported_host"
-        : check.name === "java" && check.code === "runtime_missing"
+        : check.name === "java" &&
+            check.status === "failed" &&
+            check.code === "runtime_missing"
             ? "missing_dependency"
             : configured
                 ? "config_drift"

package/dist/ghidra/GhidraFunctionValues.js

@@ -1,10 +1,10 @@
 import { z } from "zod";
 import { AnalysisInputError, AnalysisOutputError } from "../domain/errors.js";
 import { functionInstructionWindowSchema, functionDossierSchema, } from "../domain/hopperValues.js";
-import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
 import { nativeApiBoundarySchema } from "../domain/nativeApiBoundary.js";
+import { nativeValueFlowSchema } from "../domain/nativeValueFlow.js";
 import { err, ok } from "../domain/result.js";
-import { ghidraBoundedIdentifierSchema, ghidraCanonicalAddressSchema, } from "./GhidraInventoryValues.js";
+import { ghidraIdentifierSchema, ghidraCanonicalAddressSchema, } from "./GhidraInventoryValues.js";
 /** Read-only function operations admitted by the Ghidra adapter. */
 export const GHIDRA_FUNCTION_OPERATIONS = [
     "analyze_function",
@@ -20,68 +20,21 @@ export const GHIDRA_FUNCTION_OPERATIONS = [
 const operationSet = new Set(GHIDRA_FUNCTION_OPERATIONS);
 /** Narrow an application operation to the Ghidra function-analysis surface. */
 export const isGhidraFunctionOperation = (operation) => operationSet.has(operation);
-const document = ghidraBoundedIdentifierSchema.nullable().default(null);
-const procedure = ghidraBoundedIdentifierSchema;
+const document = ghidraIdentifierSchema.nullable().default(null);
+const procedure = ghidraIdentifierSchema;
 const directProcedure = { document, procedure };
-const collectionOffsets = z
-    .object({
-    comments: z.number().int().min(0).default(0),
-    callers: z.number().int().min(0).default(0),
-    callees: z.number().int().min(0).default(0),
-    incoming_references: z.number().int().min(0).default(0),
-    outgoing_references: z.number().int().min(0).default(0),
-    referenced_strings: z.number().int().min(0).default(0),
-    referenced_names: z.number().int().min(0).default(0),
-    basic_blocks: z.number().int().min(0).default(0),
-})
-    .strict()
-    .default({
-    comments: 0,
-    callers: 0,
-    callees: 0,
-    incoming_references: 0,
-    outgoing_references: 0,
-    referenced_strings: 0,
-    referenced_names: 0,
-    basic_blocks: 0,
-});
 const inputSchemas = {
-    analyze_function: z
-        .object({
-        procedure,
-        include_assembly: z.boolean().default(false),
-        limit: z.number().int().min(1).max(500).default(100),
-        max_pseudocode_chars: z
-            .number()
-            .int()
-            .min(1)
-            .max(100_000)
-            .default(20_000),
-        max_instructions: z.number().int().min(1).max(5_000).default(500),
-        pseudocode_offset: z.number().int().min(0).default(0),
-        assembly_offset: z.number().int().min(0).default(0),
-        collection_offset: collectionOffsets,
-    })
-        .strict(),
+    analyze_function: z.object({ procedure }).strict(),
     procedure_assembly: z.object(directProcedure).strict(),
     procedure_callees: z.object(directProcedure).strict(),
     procedure_callers: z.object(directProcedure).strict(),
     procedure_info: z.object(directProcedure).strict(),
     procedure_pseudo_code: z.object(directProcedure).strict(),
-    read_function_instructions: z
-        .object({
-        ...directProcedure,
-        offset: z.number().int().min(0).max(100_000).default(0),
-        limit: z.number().int().min(1).max(500).default(64),
-    })
-        .strict(),
+    read_function_instructions: z.object(directProcedure).strict(),
     procedure_references: z
         .object({
         ...directProcedure,
         direction: z.enum(["incoming", "outgoing"]).default("outgoing"),
-        offset: z.number().int().min(0).default(0),
-        limit: z.number().int().min(1).max(500).default(100),
-        max_instructions: z.number().int().min(1).max(5_000).default(500),
     })
         .strict(),
     xrefs: z.object({ document, address: ghidraCanonicalAddressSchema }).strict(),
@@ -90,7 +43,7 @@ const inputSchemas = {
 export const parseGhidraFunctionInput = (operation, value) => {
     const parsed = inputSchemas[operation].safeParse(value);
     return parsed.success
-        ? ok(jsonObjectSchema.parse(parsed.data))
+        ? ok(parsed.data)
         : err(new AnalysisInputError(operation, { cause: parsed.error }));
 };
 const classification = z
@@ -143,42 +96,11 @@ const referenceEdge = z
     kind: referenceKind,
 })
     .strict();
-const boundedReferences = z
-    .object({
-    items: z.array(referenceEdge),
-    total: z.number().int().min(0).nullable(),
-    returned: z.number().int().min(0),
-    truncated: z.boolean(),
-    next_offset: z.number().int().min(0).nullable(),
-})
-    .strict()
-    .superRefine((value, context) => {
-    if (value.returned !== value.items.length)
-        context.addIssue({
-            code: "custom",
-            path: ["returned"],
-            message: "returned must equal the number of reference items",
-        });
-    if (value.total !== null && value.total < value.returned)
-        context.addIssue({
-            code: "custom",
-            path: ["total"],
-            message: "total cannot be smaller than returned",
-        });
-    if (value.next_offset !== null && !value.truncated)
-        context.addIssue({
-            code: "custom",
-            path: ["next_offset"],
-            message: "a continuation requires truncated output",
-        });
-});
 const procedureReferences = z
     .object({
     procedure: procedureIdentity,
     direction: z.enum(["incoming", "outgoing"]),
-    references: boundedReferences,
-    instructions_scanned: z.number().int().min(0),
-    instruction_scan_truncated: z.boolean(),
+    references: z.array(referenceEdge),
 })
     .strict();
 const procedureInfo = z
@@ -203,10 +125,7 @@ const ghidraNativeApiBoundary = nativeApiBoundarySchema.superRefine((value, cont
     const addresses = value.jump_tables.flatMap((table) => [
         table.dispatch_address,
         ...table.data_sources.map(({ address }) => address),
-        ...table.mappings.flatMap(({ target_address, data_addresses }) => [
-            target_address,
-            ...data_addresses,
-        ]),
+        ...table.mappings.map(({ target_address }) => target_address),
     ]);
     if (addresses.some((address) => !ghidraCanonicalAddressSchema.safeParse(address).success))
         context.addIssue({
@@ -214,23 +133,66 @@ const ghidraNativeApiBoundary = nativeApiBoundarySchema.superRefine((value, cont
             message: "Ghidra native API observation contains a non-canonical address",
         });
 });
+const ghidraNativeValueFlow = nativeValueFlowSchema.superRefine((value, context) => {
+    if (!value.available)
+        return;
+    const operations = value.operations;
+    const addresses = operations.flatMap((operation) => [
+        operation.address,
+        ...operation.inputs.flatMap(({ location }) => location === null ? [] : [location]),
+        ...(operation.output?.location == null
+            ? []
+            : [operation.output.location]),
+    ]);
+    if (addresses.some((address) => !ghidraCanonicalAddressSchema.safeParse(address).success))
+        context.addIssue({
+            code: "custom",
+            message: "Ghidra p-code flow contains a non-canonical address",
+        });
+    const operationIds = new Set(operations.map(({ id }) => id));
+    if (operationIds.size !== operations.length)
+        context.addIssue({
+            code: "custom",
+            message: "Ghidra p-code operation identifiers are not unique",
+        });
+    if (value.def_use.some(({ definition, use }) => !operationIds.has(definition) || !operationIds.has(use)) ||
+        value.effects.some(({ operation }) => !operationIds.has(operation)))
+        context.addIssue({
+            code: "custom",
+            message: "Ghidra p-code relationship references a missing operation",
+        });
+    if (value.truncated !==
+        (value.omitted_operations_lower_bound > 0 ||
+            value.known_omitted_inputs > 0 ||
+            value.known_omitted_edges > 0))
+        context.addIssue({
+            code: "custom",
+            message: "Ghidra p-code truncation flag contradicts omitted counts",
+        });
+});
 const ghidraFunctionDossier = functionDossierSchema
-    .extend({ native_api: ghidraNativeApiBoundary })
+    .extend({
+    native_api: ghidraNativeApiBoundary,
+    native_value_flow: ghidraNativeValueFlow,
+})
     .strict()
     .superRefine((value, context) => {
     const addresses = [
         value.procedure.address,
-        ...value.comments.items.map(({ address }) => address),
-        ...value.callers.items.map(({ address }) => address),
-        ...value.callees.items.map(({ address }) => address),
-        ...value.incoming_references.items.flatMap(referenceAddresses),
-        ...value.outgoing_references.items.flatMap(referenceAddresses),
-        ...value.referenced_strings.items.flatMap(({ address, source_address }) => [address, source_address]),
-        ...value.referenced_names.items.flatMap(({ address, source_address }) => [
+        ...value.comments.map(({ address }) => address),
+        ...value.callers.map(({ address }) => address),
+        ...value.callees.map(({ address }) => address),
+        ...value.incoming_references.flatMap(referenceAddresses),
+        ...value.outgoing_references.flatMap(referenceAddresses),
+        ...value.referenced_strings.flatMap(({ address, source_address }) => [
+            address,
+            source_address,
+        ]),
+        ...value.referenced_names.flatMap(({ address, source_address }) => [
             address,
             source_address,
         ]),
-        ...value.basic_blocks.items.flatMap(({ start, end, successors }) => [
+        ...value.basic_blocks.flatMap(({ start, end, successors }) => [
             start,
             end,
             ...successors,
@@ -243,10 +205,10 @@ const ghidraFunctionDossier = functionDossierSchema
         });
     const identities = [
         value.procedure,
-        ...value.callers.items,
-        ...value.callees.items,
-        ...value.incoming_references.items.flatMap(referenceProcedures),
-        ...value.outgoing_references.items.flatMap(referenceProcedures),
+        ...value.callers,
+        ...value.callees,
+        ...value.incoming_references.flatMap(referenceProcedures),
+        ...value.outgoing_references.flatMap(referenceProcedures),
     ];
     if (identities.some(({ classification: facts }) => !classification.safeParse(facts).success))
         context.addIssue({
@@ -254,10 +216,7 @@ const ghidraFunctionDossier = functionDossierSchema
             message: "Ghidra dossier omitted function classification",
         });
     if (value.procedure.locals.some((variable) => !localVariable.safeParse(variable).success) ||
-        [
-            ...value.incoming_references.items,
-            ...value.outgoing_references.items,
-        ].some(({ kind }) => !referenceKind.safeParse(kind).success))
+        [...value.incoming_references, ...value.outgoing_references].some(({ kind }) => !referenceKind.safeParse(kind).success))
         context.addIssue({
             code: "custom",
             message: "Ghidra dossier contains invalid provenance",
@@ -287,7 +246,7 @@ const resultSchemas = {
 export const parseGhidraFunctionResult = (operation, value) => {
     const parsed = resultSchemas[operation].safeParse(value);
     return parsed.success
-        ? ok(jsonValueSchema.parse(parsed.data))
+        ? ok(parsed.data)
         : err(new AnalysisOutputError(operation, "Ghidra bridge output did not match the function-analysis contract", { cause: parsed.error }));
 };
 const referenceAddresses = (edge) => [