rea-agents 6.3.0 → 6.4.0

package/dist/cli/utilityCommands.js

@@ -1,4 +1,6 @@
 import { z } from "incur";
+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
+import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
 import { importReferenceSource } from "../application/ReferenceSourceImport.js";
 import { projectReferenceSourceImportError } from "../application/ReferenceSourceImportTypes.js";
 import { parseConfig } from "../config/parseConfig.js";
@@ -54,10 +56,6 @@ export const registerUtilityCommands = (cli, logger, environment, analysis) => {
                     .default(500)
                     .describe("Maximum accessibility nodes per capture"),
             }),
-            alias: {
-                windowId: "window-id",
-                maxNodes: "max-nodes",
-            },
             run: ({ args, options }) => logCliCommand(logger, command, async () => {
                 const parameters = {
                     pid: options.pid,
@@ -129,9 +127,8 @@ const registerNativeCommands = (cli, logger, runProviderAnalysis) => {
             relativePath: z
                 .string()
                 .optional()
-                .describe("Plist path relative to the app root (default: Contents/Info.plist)"),
+                .describe("Plist path relative to the app root, or an absolute path (default: the bundle's Info.plist)"),
         }),
-        alias: { relativePath: "relative-path" },
         run: ({ args, options }) => logCliCommand(logger, "inspect-plist", () => runProviderAnalysis(args.path, "inspect_plist", options.relativePath === undefined
             ? {}
             : { path: options.relativePath }, logger)),
@@ -160,19 +157,70 @@ const registerReferenceSourceCommand = (cli, logger, environment) => {
                     error: "Import failed",
                     ...projectAnalysisError(config.error),
                 };
-            const imported = await importReferenceSource({
-                root: args.root,
+            return runReferenceSourceImport(args.root, config.value.referenceSourcePolicy);
+        }, isReferenceSourceImportCliFailure),
+    });
+};
+const runReferenceSourceImport = async (root, policy) => {
+    const resources = new ArtifactResourceScope();
+    let outcome;
+    try {
+        outcome = {
+            kind: "result",
+            imported: await importReferenceSource({
+                root,
                 caller: "rea-cli",
-                policy: config.value.referenceSourcePolicy,
+                policy,
                 importer: PRODUCT_IDENTITY.packageName,
                 importerVersion: null,
-            });
-            return imported.ok
-                ? imported.value
-                : {
-                    error: "Import failed",
-                    ...projectReferenceSourceImportError(imported.error),
-                };
-        }, isReferenceSourceImportCliFailure),
-    });
+            }, resources),
+        };
+    }
+    catch (cause) {
+        outcome = { kind: "thrown", cause };
+    }
+    let closeOutcome;
+    try {
+        await resources.close();
+        closeOutcome = { kind: "closed" };
+    }
+    catch (cause) {
+        closeOutcome = { kind: "failed", cause };
+    }
+    if (outcome.kind === "thrown") {
+        if (closeOutcome.kind === "failed")
+            throw new AggregateError([outcome.cause, closeOutcome.cause], "Reference source import and cleanup both failed", { cause: outcome.cause });
+        throw outcome.cause;
+    }
+    const imported = outcome.imported;
+    if (!imported.ok) {
+        const cleanup = closeOutcome.kind === "closed"
+            ? imported.error.cleanup
+            : mergeReferenceSourceCleanup(imported.error.cleanup, ArtifactReaderFailure.cleanupObservation(closeOutcome.cause, "reference source"));
+        return {
+            error: "Import failed",
+            ...projectReferenceSourceImportError({
+                ...imported.error,
+                ...(cleanup === undefined ? {} : { cleanup }),
+            }),
+        };
+    }
+    if (closeOutcome.kind === "failed")
+        return {
+            error: "Import failed",
+            ...projectReferenceSourceImportError({
+                tag: "reference-source-import",
+                code: "io",
+                message: "Reference source cleanup failed after import",
+                cleanup: ArtifactReaderFailure.cleanupObservation(closeOutcome.cause, "reference source"),
+                cause: closeOutcome.cause,
+            }),
+        };
+    return imported.value;
 };
+const mergeReferenceSourceCleanup = (first, second) => first === undefined
+    ? second
+    : {
+        reason: `${first.reason}; ${second.reason}`,
+        resources: [...new Set([...first.resources, ...second.resources])],
+    };

package/dist/cli/webScriptCommands.js

@@ -1,8 +1,12 @@
 import { Cli, z } from "incur";
 import { exportWebScripts } from "../application/WebScriptExportService.js";
+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
+import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 /** Register the local captured-script export CLI workflow. */
 export const registerWebScriptCommands = (cli, logger) => {
     cli.command(CLI_COMMANDS.exportWebScripts, {
@@ -16,10 +20,25 @@ export const registerWebScriptCommands = (cli, logger) => {
                 .describe("Absolute absent directory for verified scripts and manifest"),
         }),
         run: ({ args }) => logCliCommand(logger, CLI_COMMANDS.exportWebScripts, async () => {
+            const resources = new ArtifactResourceScope();
             const result = await exportWebScripts({
                 capture_path: args.capturePath,
                 output_directory: args.outputDirectory,
-            });
+            }, resources);
+            try {
+                await resources.close();
+            }
+            catch (cause) {
+                const cleanup = ArtifactReaderFailure.cleanupObservation(cause, "Web script export resources");
+                const failure = new ProviderCleanupError("web-script-export", cleanup.resources, { reason: cleanup.reason }, { cause, operation: "export_web_scripts" });
+                const error = result.ok
+                    ? failure
+                    : analysisErrorWithCleanupFailure(result.error, failure, "export_web_scripts");
+                return {
+                    error: "Script export failed",
+                    ...projectAnalysisError(error),
+                };
+            }
             return result.ok
                 ? result.value
                 : {

package/dist/cli/webSourceLocationCommands.js

@@ -29,14 +29,26 @@ export const registerWebSourceLocationCommands = (cli, logger, environment) => {
                 .min(0)
                 .describe("Zero-based UTF-16 generated column"),
         }),
-        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.traceWebSourceLocation, async () => {
-            const result = await service.trace({
-                manifest_path: args.manifestPath,
-                script_index: args.scriptIndex,
-                source_map: { path: args.sourceMapPath, url: args.sourceMapUrl },
-                generated_position: { line: args.line, column: args.column },
-            }, { signal });
-            return result.ok ? result.value : projectAnalysisError(result.error);
-        })),
+        run: ({ args }) => withCommandCancellation(async (signal) => {
+            try {
+                return await logCliCommand(logger, CLI_COMMANDS.traceWebSourceLocation, async () => {
+                    const result = await service.trace({
+                        manifest_path: args.manifestPath,
+                        script_index: args.scriptIndex,
+                        source_map: {
+                            path: args.sourceMapPath,
+                            url: args.sourceMapUrl,
+                        },
+                        generated_position: { line: args.line, column: args.column },
+                    }, { signal });
+                    return result.ok
+                        ? result.value
+                        : projectAnalysisError(result.error);
+                });
+            }
+            finally {
+                await service.close();
+            }
+        }),
     });
 };

package/dist/cli.js

@@ -14,6 +14,9 @@ import { registerArtifactCommands } from "./cli/artifactCommands.js";
 import { registerManagedCommands } from "./cli/managedCommands.js";
 import { registerFirmwareCommands } from "./cli/firmwareCommands.js";
 import { registerAndroidCommands } from "./cli/androidCommands.js";
+import { registerApktoolCommands } from "./cli/apktoolCommands.js";
+import { registerJebCommands } from "./cli/jebCommands.js";
+import { registerAdbCommands } from "./cli/adbCommands.js";
 import { registerEvidenceCommands } from "./cliEvidenceCommands.js";
 import { registerProcessCommands } from "./cli/processCommands.js";
 import { registerBrowserCommands } from "./cli/browserCommands.js";
@@ -57,6 +60,9 @@ export const createCli = (selectedEnvironment = process.env, resultOutput) => {
     registerArtifactCommands(cli, logger, analysis.runProviderAnalysis);
     registerManagedCommands(cli, logger, analysis.runProviderAnalysis);
     registerAndroidCommands(cli, logger, environment);
+    registerApktoolCommands(cli, logger, environment);
+    registerJebCommands(cli, logger, environment);
+    registerAdbCommands(cli, logger, environment);
     registerFirmwareCommands(cli, logger, environment);
     registerBinaryDiagnosticsCommands(cli, logger, environment);
     registerAnalysisViewCommands(cli, logger);

package/dist/cliBrowserScenarioCommands.js

@@ -1,7 +1,6 @@
 import { Cli } from "incur";
 import { z } from "zod";
 import { captureBrowserScenario } from "./application/BrowserScenarioCaptureService.js";
-import { createBrowserScenarioProvider } from "./composition/browserScenario.js";
 import { CLI_COMMANDS } from "./cliCommandNames.js";
 import { parseCliJsonInput, resolveCliJsonPaths } from "./cliJsonInput.js";
 import { logCliCommand } from "./cliLogging.js";
@@ -26,6 +25,8 @@ export const registerBrowserScenarioCommands = (cli, logger, environment) => {
             const scenario = browserScenarioSchema.safeParse(resolveCliJsonPaths(input.value, [["browser", "executable_path"]]));
             if (!scenario.success)
                 return cliError(new AnalysisInputError(OPERATION, { cause: scenario.error }, projectInputIssues(scenario.error.issues, input.value)));
+            // Load Playwright only for this command, not during CLI startup.
+            const { createBrowserScenarioProvider } = await import("./composition/browserScenario.js");
             const result = await captureBrowserScenario(createBrowserScenarioProvider(environment), scenario.data);
             return result.ok ? result.value : cliError(result.error);
         }),

package/dist/cliCommandNames.js

@@ -41,14 +41,46 @@ export const CLI_COMMANDS = Object.freeze({
     inspectManagedArtifact: "inspect-managed-artifact",
     inspectRecordedCrash: "inspect-recorded-crash",
     inspectBinaryLayout: "inspect-binary-layout",
+    inspectPeResources: "inspect-pe-resources",
     inspectAnalysisView: "inspect-analysis-view",
+    inspectEvidenceBundle: "inspect-evidence-bundle",
     inspectFirmwareRegions: "inspect-firmware-regions",
     extractFirmware: "extract-firmware",
     inspectAndroidPackage: "inspect-android-package",
+    inspectApktoolClient: "inspect-apktool-client",
+    decodeAndroidResources: "decode-android-resources",
+    inspectAdbClient: "inspect-adb-client",
+    listAdbDevices: "list-adb-devices",
+    inspectAdbDevice: "inspect-adb-device",
+    listAdbPackages: "list-adb-packages",
+    pullAdbPackage: "pull-adb-package",
+    readAdbLogcat: "read-adb-logcat",
+    inspectAdbPackage: "inspect-adb-package",
+    pullAdbFile: "pull-adb-file",
+    pushAdbFile: "push-adb-file",
+    captureAdbScreen: "capture-adb-screen",
+    listAdbProcesses: "list-adb-processes",
+    listAdbDirectory: "list-adb-directory",
+    listAdbFeatures: "list-adb-features",
+    listAdbServices: "list-adb-services",
+    inspectAdbDisplay: "inspect-adb-display",
+    inspectAdbWindow: "inspect-adb-window",
+    readAdbSetting: "read-adb-setting",
+    collectAdbBugreport: "collect-adb-bugreport",
+    resolveAdbPackages: "resolve-adb-packages",
+    installAdbPackage: "install-adb-package",
+    uninstallAdbPackage: "uninstall-adb-package",
+    startAdbApp: "start-adb-app",
+    startAdbActivity: "start-adb-activity",
+    stopAdbApp: "stop-adb-app",
     searchAndroidClasses: "search-android-classes",
     inspectAndroidClass: "inspect-android-class",
     inspectAndroidMethod: "inspect-android-method",
     traceAndroidReferences: "trace-android-references",
+    inspectJebClient: "inspect-jeb-client",
+    openJebProject: "open-jeb-project",
+    listJebUnits: "list-jeb-units",
+    decompileJebItem: "decompile-jeb-item",
     inspectManagedMembers: "inspect-managed-members",
     inspectManagedNativeBoundaries: "inspect-managed-native-boundaries",
     compareManagedMembers: "compare-managed-members",

package/dist/cliJsonInput.js

@@ -1,5 +1,5 @@
 import { resolve } from "node:path";
-import { readCliJsonFile } from "./cliJsonFile.js";
+import { readJsonInputFile } from "./application/JsonInputFile.js";
 import { NonRegularFileReadError } from "./filesystem/RegularFile.js";
 import { AnalysisAccessDeniedError, AnalysisInputError, } from "./domain/analysisErrorCore.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
@@ -10,7 +10,7 @@ export const parseCliJsonInput = async (value, operation) => {
     if (inline.ok)
         return { ok: true, value: inline.value };
     try {
-        const parsed = await readCliJsonFile(value, operation);
+        const parsed = await readJsonInputFile(value, operation);
         return parsed.ok
             ? { ok: true, value: parsed.value }
             : {

package/dist/cliObservationOptions.js

@@ -1,4 +1,5 @@
 import { z } from "incur";
+import { javaScriptAnalysisResourceControlsSchema } from "./domain/javascript/javascriptAnalysisResourceControls.js";
 /** Accept an agent-selected browser observation duration without an artificial ceiling. */
 export const observationDuration = (fallback, minimum = 0) => z
     .number()
@@ -53,6 +54,8 @@ export const electronPageInspectionOptions = z.object({
         .describe("Include JavaScript source text"),
 });
 export const javascriptApplicationOptions = z.object({
+    maxHeapMb: javaScriptAnalysisResourceControlsSchema.shape.max_heap_mb,
+    analysisTimeoutMs: javaScriptAnalysisResourceControlsSchema.shape.analysis_timeout_ms,
     artifactFormat: z
         .enum(["auto", "asar", "directory"])
         .default("auto")

package/dist/composition/adb.js

@@ -0,0 +1,3 @@
+import { AdbProvider } from "../adb/AdbProvider.js";
+/** Construct one ADB provider bound to the caller-selected binary. */
+export const createAdbDeviceAnalysisProvider = (environment = process.env) => new AdbProvider({ environment });

package/dist/composition/apktool.js

@@ -0,0 +1,3 @@
+import { ApktoolProvider } from "../apktool/ApktoolProvider.js";
+/** Construct one Apktool provider bound to the caller-selected launcher. */
+export const createApktoolResourceAnalysisProvider = (environment = process.env) => new ApktoolProvider({ environment });

package/dist/composition/binaryDiagnostics.js

@@ -2,6 +2,10 @@ import { RecordedCrashService } from "../application/binaryDiagnostics/RecordedC
 import { PwntoolsRecordedCrashProvider } from "../native/pwntools/PwntoolsRecordedCrashProvider.js";
 import { BinaryLayoutService } from "../application/binaryDiagnostics/BinaryLayoutService.js";
 import { PwntoolsLayoutProvider } from "../native/pwntools/PwntoolsLayoutProvider.js";
+import { PeResourcesService } from "../application/binaryDiagnostics/PeResourcesService.js";
+import { PeResourcesProvider } from "../native/pe/PeResourcesProvider.js";
+/** Portable PE inspection with no engine, installation or target acquisition. */
+export const createPeResourcesService = () => new PeResourcesService(new PeResourcesProvider());
 /** Compose the offline adapter without import-time I/O or dependency acquisition. */
 export const createBinaryLayoutService = (environment = process.env) => new BinaryLayoutService(new PwntoolsLayoutProvider(environment));
 /** Compose recorded-core inspection without acquiring a debugger or toolchain. */

package/dist/composition/directAnalysis.js

@@ -2,14 +2,19 @@ import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { parseConfig } from "../config/parseConfig.js";
 import { runDirectAnalysis as executeDirectAnalysis, runProviderAnalysis as executeProviderAnalysis, runManagedProviderExecution as executeManagedProvider, } from "../application/DirectAnalysis.js";
 import { runSessionStatus as executeSessionStatus } from "../application/DirectAnalysisStatus.js";
-import { createBinarySession, createManagedBinarySession } from "./binary.js";
 /** Bind one-shot analysis and status commands to one caller-selected environment. */
 export const createDirectAnalysis = (selectedEnvironment) => {
     const environment = snapshotEnvironment(selectedEnvironment);
     const dependencies = {
         readConfiguration: () => parseConfig(environment),
-        createBinarySession: (config, logger) => createBinarySession(config, logger, environment),
-        createManagedBinarySession,
+        createBinarySession: async (config, logger) => {
+            const { createBinarySession } = await import("./binary.js");
+            return createBinarySession(config, logger, environment);
+        },
+        createManagedBinarySession: async () => {
+            const { createManagedBinarySession } = await import("./binary.js");
+            return createManagedBinarySession();
+        },
     };
     return {
         runDirectAnalysis: executeDirectAnalysis.bind(undefined, dependencies),
@@ -19,5 +24,8 @@ export const createDirectAnalysis = (selectedEnvironment) => {
 };
 /** Execute managed metadata without configuration or native provider candidates. */
 export const runManagedProviderExecution = executeManagedProvider.bind(undefined, {
-    createManagedBinarySession,
+    createManagedBinarySession: async () => {
+        const { createManagedBinarySession } = await import("./binary.js");
+        return createManagedBinarySession();
+    },
 });

package/dist/composition/javascriptAnalysisWorkerProcess.js

@@ -0,0 +1,48 @@
+import { parseJavaScriptSource } from "../domain/javascript/javascriptSourceParser.js";
+import { analyzeParsedJavaScriptStaticSourceSteps } from "../domain/javascript/javascriptStaticAnalysis.js";
+import { analyzeParsedJavaScriptSemanticsSteps, classifyParsedJavaScriptOpenReceiversSteps, } from "../domain/javascript/javascriptSemanticAnalysis.js";
+import { failedJavaScriptStaticAnalysis } from "../domain/javascript/javascriptStaticAnalysisHelpers.js";
+import { projectJavaScriptModuleSemantics } from "../domain/javascript/javascriptModuleSemanticIr.js";
+import { measureJavaScriptModuleTransfer } from "../javascript/analysis/JavaScriptAnalysisTransfer.js";
+import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
+import { projectJavaScriptSemanticFileSteps } from "../application/javascript/JavaScriptSemanticGraphBuilder.js";
+import { completeJavaScriptAnalysisSteps } from "../application/javascript/JavaScriptAnalysisControl.js";
+import { serveJavaScriptAnalysisWorker, } from "../javascript/analysis/JavaScriptAnalysisWorkerServer.js";
+const analyze = async (file, nodeBudget, callbacks) => {
+    if (!file.text.included)
+        throw new TypeError("JavaScript worker requires decoded source text");
+    await callbacks.phase("parse");
+    let parsed = parseJavaScriptSource(file.text.value, file.path);
+    if (parsed === null) {
+        await callbacks.checkpoint(failedJavaScriptStaticAnalysis());
+        return null;
+    }
+    await callbacks.phase("static");
+    const receivers = await completeJavaScriptAnalysisSteps(classifyParsedJavaScriptOpenReceiversSteps(parsed));
+    const facts = await completeJavaScriptAnalysisSteps(analyzeParsedJavaScriptStaticSourceSteps(file.text.value, parsed, receivers));
+    const resultBudgetBytes = await callbacks.checkpoint(facts);
+    if (facts.parse_status === "failed")
+        return null;
+    if (resultBudgetBytes === 0)
+        throw new AnalysisResourceConstraintError("analyze_javascript_application", "memory", `The parent reserved its remaining result capacity for static observations; semantic analysis of ${file.path} was not started`, { semantic_result_budget_bytes: 0 });
+    await callbacks.phase("semantic");
+    const ir = await completeJavaScriptAnalysisSteps(analyzeParsedJavaScriptSemanticsSteps(parsed));
+    parsed = null;
+    const module = projectJavaScriptModuleSemantics(ir);
+    const measured = measureJavaScriptModuleTransfer(module);
+    if (measured.retentionBytes > resultBudgetBytes)
+        throw new AnalysisResourceConstraintError("analyze_javascript_application", "memory", `Completed module facts for ${file.path} exceed the parent's offered result budget; static facts were retained`, {
+            semantic_result_budget_bytes: resultBudgetBytes,
+            module_transfer_bytes: measured.bytes,
+        });
+    await callbacks.phase("projection");
+    const projection = await completeJavaScriptAnalysisSteps(projectJavaScriptSemanticFileSteps(file, ir, nodeBudget));
+    return { module, projection };
+};
+try {
+    await serveJavaScriptAnalysisWorker(analyze);
+}
+catch (cause) {
+    process.stderr.write(`${cause instanceof Error ? cause.message : String(cause)}\n`);
+    process.exitCode = 1;
+}

package/dist/composition/jeb.js

@@ -0,0 +1,6 @@
+import { JebProvider } from "../jeb/JebProvider.js";
+/** Construct one JEB provider bound to the caller-selected MCP endpoint. */
+export const createJebAnalysisProvider = (environment = process.env, connectionFactory) => new JebProvider({
+    environment,
+    ...(connectionFactory === undefined ? {} : { connectionFactory }),
+});

package/dist/config/environment.js

@@ -3,11 +3,14 @@ import { isAbsolute } from "node:path";
 import { ConfigurationError } from "../domain/configurationErrors.js";
 import { err, ok } from "../domain/result.js";
 import { analysisProviderSelectorSchema } from "../contracts/providerSelection.js";
+import { ghidraCompilerSpecIdSchema, ghidraLanguageIdSchema, } from "./ghidraLanguageOverride.js";
 import { ghidraStartupTimeoutSchema } from "./ghidraStartupTimeout.js";
+import { mcpInputSchemaProfileSchema } from "./mcpInputSchemaProfile.js";
 import { mcpResponseBudgetSchema } from "./mcpResponseBudget.js";
 const environmentSchema = z.object({
     REA_ANALYSIS_PROVIDER: analysisProviderSelectorSchema.default("auto"),
     REA_MCP_MAX_RESPONSE_BYTES: mcpResponseBudgetSchema.optional(),
+    REA_MCP_INPUT_SCHEMA_PROFILE: mcpInputSchemaProfileSchema.optional(),
     REA_IDA_MCP_CONFIG: z
         .string()
         .min(1)
@@ -29,6 +32,13 @@ const environmentSchema = z.object({
         .refine(isAbsolute, "REA_GHIDRA_NATIVEAOT_JAR must be absolute")
         .optional(),
     REA_GHIDRA_STARTUP_TIMEOUT_MS: ghidraStartupTimeoutSchema,
+    REA_GHIDRA_LANGUAGE_ID: ghidraLanguageIdSchema.optional(),
+    REA_GHIDRA_COMPILER_SPEC_ID: ghidraCompilerSpecIdSchema.optional(),
+    REA_GHIDRA_SEED_FILE: z
+        .string()
+        .min(1)
+        .refine(isAbsolute, "REA_GHIDRA_SEED_FILE must be absolute")
+        .optional(),
     REA_ILSPY_CMD_PATH: z
         .string()
         .min(1)

package/dist/config/ghidraLanguageOverride.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+// Ghidra language IDs are four colon-separated fields; variants may contain
+// spaces ("x86:LE:16:Real Mode") but never leading or trailing whitespace.
+export const ghidraLanguageIdSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9_.+-]+:(?:LE|BE):[1-9]\d*:[A-Za-z0-9_.+-](?:[A-Za-z0-9_.+ -]*[A-Za-z0-9_.+-])?$/u, "must be a Ghidra language ID such as x86:LE:32:default");
+export const ghidraCompilerSpecIdSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9_.+-]+$/u, "must be a Ghidra compiler-spec ID such as default or borlandcpp");

package/dist/config/mcpInputSchemaProfile.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { ConfigurationError } from "../domain/configurationErrors.js";
+import { err, ok } from "../domain/result.js";
+// Moonshot's function-calling API rejects requests while any single tool
+// parameters schema exceeds its literal serialized size cap. Community
+// measurements bound the cap between ~13.7 KB (accepted) and ~15 KB
+// (rejected); 13 KiB leaves margin under the lower bound. See
+// https://github.com/morluto/rea/issues/1484 for the measured evidence.
+export const COMPACT_INPUT_SCHEMA_BUDGET_BYTES = 13 * 1024;
+export const mcpInputSchemaProfileSchema = z.enum(["full", "compact"]);
+const profileConstraint = 'REA_MCP_INPUT_SCHEMA_PROFILE must be "full" (default) or "compact". The compact profile advertises input schemas without nested annotation prose for providers that cap each tool schema\'s serialized size.';
+/** Parse the advertised input schema presentation selection. */
+export const parseMcpInputSchemaProfile = (value) => {
+    if (value === undefined)
+        return ok(undefined);
+    const parsed = mcpInputSchemaProfileSchema.safeParse(value);
+    return parsed.success
+        ? ok(parsed.data)
+        : err(new ConfigurationError(profileConstraint, {
+            settings: [
+                {
+                    setting: "REA_MCP_INPUT_SCHEMA_PROFILE",
+                    constraint: profileConstraint,
+                },
+            ],
+        }));
+};

package/dist/config/parseConfig.js

@@ -1,7 +1,7 @@
 import { accessSync, constants } from "node:fs";
 import { join } from "node:path";
 import { ConfigurationError } from "../domain/configurationErrors.js";
-import { ok } from "../domain/result.js";
+import { err, ok } from "../domain/result.js";
 import { parseEnvironment } from "./environment.js";
 import { homeDirectoryFromEnvironment } from "./homeDirectory.js";
 import { parseStringArray, parseLoaderArgs } from "./parsers.js";
@@ -36,10 +36,24 @@ export const parseConfig = (environment) => {
     const secretPatterns = parseStringArray(env.REA_REFERENCE_SECRET_PATTERNS_JSON, "REA_REFERENCE_SECRET_PATTERNS_JSON");
     if (!secretPatterns.ok)
         return secretPatterns;
+    // Ghidra's analyzeHeadless accepts -cspec only together with -processor.
+    if (env.REA_GHIDRA_COMPILER_SPEC_ID !== undefined &&
+        env.REA_GHIDRA_LANGUAGE_ID === undefined)
+        return err(new ConfigurationError("Invalid REA environment configuration", {
+            settings: [
+                {
+                    setting: "REA_GHIDRA_COMPILER_SPEC_ID",
+                    constraint: "requires REA_GHIDRA_LANGUAGE_ID",
+                },
+            ],
+        }));
     return ok({
         ...(env.REA_MCP_MAX_RESPONSE_BYTES === undefined
             ? {}
             : { mcpMaxResponseBytes: env.REA_MCP_MAX_RESPONSE_BYTES }),
+        ...(env.REA_MCP_INPUT_SCHEMA_PROFILE === undefined
+            ? {}
+            : { mcpInputSchemaProfile: env.REA_MCP_INPUT_SCHEMA_PROFILE }),
         analysisProvider: env.REA_ANALYSIS_PROVIDER,
         ...(env.REA_IDA_MCP_CONFIG === undefined
             ? {}
@@ -47,6 +61,19 @@ export const parseConfig = (environment) => {
         ghidraInstallDir: env.GHIDRA_INSTALL_DIR,
         ghidraJavaHome: env.JAVA_HOME,
         ghidraStartupTimeoutMs: env.REA_GHIDRA_STARTUP_TIMEOUT_MS,
+        ...(env.REA_GHIDRA_LANGUAGE_ID === undefined
+            ? {}
+            : {
+                ghidraLanguageOverride: {
+                    languageId: env.REA_GHIDRA_LANGUAGE_ID,
+                    ...(env.REA_GHIDRA_COMPILER_SPEC_ID === undefined
+                        ? {}
+                        : { compilerSpecId: env.REA_GHIDRA_COMPILER_SPEC_ID }),
+                },
+            }),
+        ...(env.REA_GHIDRA_SEED_FILE === undefined
+            ? {}
+            : { ghidraSeedFile: env.REA_GHIDRA_SEED_FILE }),
         ...(env.REA_GHIDRA_NATIVEAOT_JAR === undefined
             ? {}
             : { ghidraNativeAotJar: env.REA_GHIDRA_NATIVEAOT_JAR }),