rea-agents 4.1.0 → 6.0.0

package/dist/cli/coreBinaryCommands.js

@@ -0,0 +1,211 @@
+import { z } from "incur";
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { runDirectAnalysis } from "../composition/directAnalysis.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { directAnalysisOptions, formatSelectionOption, providerSelectionOption, } from "./options.js";
+import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnalysis.js";
+/** Register provider-neutral binary overview and procedure CLI commands. */
+export const registerCoreBinaryCommands = (cli, logger, resultOutput) => {
+    registerOverviewCommands(cli, logger, resultOutput);
+    registerFunctionCommand(cli, logger);
+    registerInstructionsCommand(cli, logger);
+    registerSearchCommand(cli, logger);
+    registerXrefsCommand(cli, logger);
+    registerTraceCommand(cli, logger);
+};
+const registerOverviewCommands = (cli, logger, resultOutput) => {
+    const overviewOptions = z.object({
+        snapshot: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("Load and update a local analysis snapshot"),
+        "target-format": formatSelectionOption,
+        provider: providerSelectionOption,
+    });
+    cli.command(CLI_COMMANDS.analyze, {
+        description: "Get an overview of an app",
+        args: z.object({
+            path: z.string().describe("App, program, or analysis database path"),
+        }),
+        options: overviewOptions,
+        run: ({ args, options, format }) => logCliCommand(logger, "analyze", () => runRoutedOverview(args.path, options, logger, resultOutput === undefined
+            ? undefined
+            : { output: resultOutput, command: CLI_COMMANDS.analyze, format })),
+    });
+    cli.command(CLI_COMMANDS.inspect, {
+        description: "Inspect an app overview with evidence",
+        args: z.object({
+            path: z.string().describe("App, program, or analysis database path"),
+        }),
+        options: overviewOptions,
+        run: ({ args, options }) => logCliCommand(logger, "inspect", () => runDirectAnalysis(args.path, "binary_overview", {}, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
+    });
+    cli.command(CLI_COMMANDS.decompile, {
+        description: "Read one part of an app as code",
+        args: z.object({
+            path: z.string().describe("App or program path"),
+            address: z.string().describe("Procedure address"),
+        }),
+        options: z.object({
+            snapshot: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, "decompile", () => runDirectAnalysis(args.path, "procedure_pseudo_code", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
+    });
+};
+const runRoutedOverview = async (path, options, logger, output) => {
+    if (options.provider === undefined &&
+        options.snapshot === undefined &&
+        options["target-format"] === undefined &&
+        (await isJavaScriptApplicationPath(path)))
+        return runCliJavaScriptApplicationAnalysis({ input_path: resolve(path) }, output);
+    return runDirectAnalysis(path, "binary_overview", {}, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]));
+};
+const isJavaScriptApplicationPath = async (path) => {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".asar"))
+        return true;
+    if (lower.endsWith(".app"))
+        return false;
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch (cause) {
+        // A missing or unreadable path is not a JavaScript application directory;
+        // the caller falls through to direct binary analysis instead.
+        void cause;
+        return false;
+    }
+};
+const registerXrefsCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.xrefs, {
+        description: "List bounded references to an analyzed address",
+        args: z.object({
+            path: z.string().describe("App or program path"),
+            address: z.string().describe("Hexadecimal address"),
+        }),
+        options: z.object({
+            snapshot: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, "xrefs", () => runDirectAnalysis(args.path, "xrefs", { address: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
+    });
+};
+const registerTraceCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.trace, {
+        description: "Trace a literal feature through analyzed references",
+        args: z.object({
+            path: z.string().describe("App or program path"),
+            query: z.string().min(1).describe("Literal feature query"),
+        }),
+        options: z.object({
+            caseSensitive: z
+                .boolean()
+                .default(false)
+                .describe("Match the query with exact letter case"),
+            snapshot: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        alias: {
+            caseSensitive: "case-sensitive",
+        },
+        run: ({ args, options }) => logCliCommand(logger, "trace", () => runDirectAnalysis(args.path, "trace_feature", {
+            query: args.query,
+            case_sensitive: options.caseSensitive,
+        }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
+    });
+};
+const registerFunctionCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.function, {
+        description: "Analyze one complete function with evidence",
+        args: z.object({
+            path: z.string().describe("App or program path"),
+            address: z.string().describe("Procedure name or address"),
+        }),
+        options: z.object({
+            snapshot: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, "function", () => runDirectAnalysis(args.path, "analyze_function", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
+    });
+};
+const registerInstructionsCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.instructions, {
+        description: "Read every raw instruction without decompiling",
+        args: z.object({
+            path: z.string().describe("App or program path"),
+            address: z.string().describe("Procedure name or address"),
+        }),
+        options: z.object({
+            snapshot: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.instructions, () => runDirectAnalysis(args.path, "read_function_instructions", {
+            procedure: args.address,
+        }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
+    });
+};
+const registerSearchCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.search, {
+        description: "Search every analyzed string or procedure name",
+        args: z.object({
+            path: z.string().describe("App or program path"),
+            pattern: z.string().min(1).describe("Literal text or regex pattern"),
+        }),
+        options: z.object({
+            kind: z
+                .enum(["strings", "procedures"])
+                .default("strings")
+                .describe("Analyzed item kind to search"),
+            mode: z
+                .enum(["literal", "regex"])
+                .default("literal")
+                .describe("Interpret the pattern as literal text or a regex"),
+            caseSensitive: z
+                .boolean()
+                .default(false)
+                .describe("Match the pattern with exact letter case"),
+            snapshot: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        alias: { caseSensitive: "case-sensitive" },
+        run: ({ args, options }) => logCliCommand(logger, "search", () => runDirectAnalysis(args.path, options.kind === "strings" ? "search_strings" : "search_procedures", {
+            pattern: args.pattern,
+            mode: options.mode,
+            case_sensitive: options.caseSensitive,
+        }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
+    });
+};

package/dist/cli/coreNativeCommands.js

@@ -0,0 +1,293 @@
+import { z } from "incur";
+import { runDirectAnalysis } from "../composition/directAnalysis.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { directAnalysisOptions, formatSelectionOption, providerSelectionOption, } from "./options.js";
+/** Register native load-image, memory, and annotation CLI commands. */
+export const registerCoreNativeCommands = (cli, logger) => {
+    registerAnnotationCommand(cli, logger);
+    cli.command(CLI_COMMANDS.inspectNativeLoadImage, {
+        description: "Verify loaded native bytes, source mappings, relocations and entry",
+        args: z.object({ path: z.string().describe("Local executable path") }),
+        options: z.object({
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.inspectNativeLoadImage, () => runDirectAnalysis(args.path, "inspect_native_load_image", {}, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
+    });
+    cli.command(CLI_COMMANDS.readBytes, {
+        description: "Read exact provider memory bytes at one analysis address",
+        args: z.object({
+            path: z.string().describe("Local executable path"),
+            address: z.string().describe("Exact provider memory address"),
+        }),
+        options: z.object({
+            length: z
+                .number()
+                .int()
+                .min(1)
+                .default(256)
+                .describe("Requested byte count"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.readBytes, () => runDirectAnalysis(args.path, "read_bytes", { address: args.address, length: options.length }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
+    });
+    cli.command(CLI_COMMANDS.addressToFileOffset, {
+        description: "Resolve an analysis address to its original file byte offset",
+        args: z.object({
+            path: z.string().describe("Local executable path"),
+            address: z.string().describe("Exact provider memory address"),
+        }),
+        options: z.object({
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.addressToFileOffset, () => runDirectAnalysis(args.path, "address_to_file_offset", { address: args.address }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
+    });
+    cli.command(CLI_COMMANDS.traceNativeValues, {
+        description: "Trace bounded native def-use and call dependencies",
+        args: z.object({
+            path: z.string().describe("Local native executable or app path"),
+            procedure: z
+                .string()
+                .describe("Explicit native procedure symbol or address"),
+        }),
+        options: z.object({
+            maxDepth: z
+                .number()
+                .int()
+                .min(0)
+                .max(16)
+                .default(3)
+                .describe("Maximum call traversal depth"),
+            maxFunctions: z
+                .number()
+                .int()
+                .min(1)
+                .max(64)
+                .default(16)
+                .describe("Maximum function decompilations"),
+            maxCallSites: z
+                .number()
+                .int()
+                .min(1)
+                .max(4096)
+                .default(256)
+                .describe("Maximum static call-site resolutions"),
+            maxNodes: z
+                .number()
+                .int()
+                .min(1)
+                .max(20000)
+                .default(5000)
+                .describe("Maximum retained graph nodes"),
+            maxEdges: z
+                .number()
+                .int()
+                .min(1)
+                .max(40000)
+                .default(10000)
+                .describe("Maximum retained graph edges"),
+            offset: z
+                .number()
+                .int()
+                .min(0)
+                .default(0)
+                .describe("First graph node index"),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(5000)
+                .default(1000)
+                .describe("Maximum nodes on this page"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        alias: {
+            maxDepth: "max-depth",
+            maxFunctions: "max-functions",
+            maxCallSites: "max-call-sites",
+            maxNodes: "max-nodes",
+            maxEdges: "max-edges",
+        },
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.traceNativeValues, () => runDirectAnalysis(args.path, "trace_native_values", {
+            procedure: args.procedure,
+            max_depth: options.maxDepth,
+            max_functions: options.maxFunctions,
+            max_call_sites: options.maxCallSites,
+            max_nodes: options.maxNodes,
+            max_edges: options.maxEdges,
+            offset: options.offset,
+            limit: options.limit,
+        }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
+    });
+    cli.command(CLI_COMMANDS.inspectNativeDataType, {
+        description: "Inspect one recovered database type or typed data object",
+        args: z.object({
+            path: z.string().describe("Local native executable or app path"),
+        }),
+        options: z.object({
+            type: z.string().optional().describe("Exact database type category path"),
+            address: z.string().describe("Exact native address").optional(),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.inspectNativeDataType, () => runDirectAnalysis(args.path, "inspect_native_data_type", {
+            ...(options.type === undefined ? {} : { type: options.type }),
+            ...(options.address === undefined
+                ? {}
+                : { address: options.address }),
+        }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
+    });
+    for (const [command, operation] of [
+        [CLI_COMMANDS.inspectNativeInstruction, "inspect_native_instruction"],
+        [CLI_COMMANDS.resolveNativeCallTargets, "resolve_native_call_targets"],
+    ]) {
+        cli.command(command, {
+            description: operation === "inspect_native_instruction"
+                ? "Inspect one native instruction with decoded operand facts"
+                : "Resolve one static native call site",
+            args: z.object({
+                path: z.string().describe("Local native executable or app path"),
+                address: z.string().describe("Exact native address"),
+            }),
+            options: z.object({
+                "target-format": formatSelectionOption,
+                provider: providerSelectionOption,
+            }),
+            run: ({ args, options }) => logCliCommand(logger, command, () => runDirectAnalysis(args.path, operation, { address: args.address }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
+        });
+    }
+    registerNativeApiCommand(cli, logger);
+    registerNativeUiActionCommand(cli, logger);
+    registerNativeDispatchMetadataCommand(cli, logger);
+};
+const registerNativeDispatchMetadataCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.inspectNativeDispatchMetadata, {
+        description: "Inspect typed Objective-C and Swift dispatch metadata",
+        args: z.object({
+            path: z.string().describe("Target path used to bind the result evidence"),
+        }),
+        options: z.object({
+            maxRecords: z
+                .number()
+                .int()
+                .min(1)
+                .max(20_000)
+                .default(5_000)
+                .describe("Maximum symbol records to inspect"),
+            snapshot: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Load or update the local analysis snapshot"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        alias: { maxRecords: "max-records" },
+        run: async ({ args, options }) => logCliCommand(logger, "inspect-native-dispatch-metadata", () => runDirectAnalysis(args.path, "inspect_native_dispatch_metadata", { max_records: options.maxRecords }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
+    });
+};
+const registerNativeUiActionCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.traceNativeUiAction, {
+        description: "Trace a compiled UI action selector to its native handler and direct callees",
+        args: z.object({
+            path: z.string().describe("Target path used to bind the result evidence"),
+            action: z
+                .string()
+                .min(1)
+                .describe("A unique compiled UI action selector or interface object ID"),
+        }),
+        options: z.object({
+            maxDepth: z
+                .number()
+                .int()
+                .min(0)
+                .max(32)
+                .default(8)
+                .describe("Maximum relationship depth"),
+            maxNodes: z
+                .number()
+                .int()
+                .min(1)
+                .max(2_000)
+                .default(250)
+                .describe("Maximum returned graph nodes"),
+            maxEdges: z
+                .number()
+                .int()
+                .min(1)
+                .max(5_000)
+                .default(500)
+                .describe("Maximum returned graph edges"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        alias: {
+            maxDepth: "max-depth",
+            maxNodes: "max-nodes",
+            maxEdges: "max-edges",
+        },
+        run: async ({ args, options }) => logCliCommand(logger, "trace-native-ui-action", () => runDirectAnalysis(args.path, "trace_native_ui_action", {
+            action: args.action,
+            max_depth: options.maxDepth,
+            max_nodes: options.maxNodes,
+            max_edges: options.maxEdges,
+        }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
+    });
+};
+const registerNativeApiCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.inspectNativeApi, {
+        description: "Reconstruct one native function API boundary with evidence",
+        args: z.object({
+            path: z.string().describe("App or program path"),
+            address: z.string().describe("Procedure name or address"),
+        }),
+        options: z.object({
+            snapshot: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, "inspect-native-api", () => runDirectAnalysis(args.path, "inspect_native_api", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
+    });
+};
+const registerAnnotationCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.annotateNativeFunction, {
+        description: "Edit function annotations and return refreshed analysis",
+        args: z.object({
+            path: z.string().describe("Local executable path"),
+            procedure: z
+                .string()
+                .describe("Exact function entry address or unique name"),
+        }),
+        options: z.object({
+            name: z.string().min(1).optional().describe("Analyst function name"),
+            comment: z
+                .string()
+                .optional()
+                .describe("Regular entry comment; empty text clears it"),
+            "inline-comment": z
+                .string()
+                .optional()
+                .describe("Inline entry comment; empty text clears it"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.annotateNativeFunction, () => runDirectAnalysis(args.path, "annotate_native_function", {
+            procedure: args.procedure,
+            ...(options.name === undefined ? {} : { name: options.name }),
+            ...(options.comment === undefined
+                ? {}
+                : { comment: options.comment }),
+            ...(options["inline-comment"] === undefined
+                ? {}
+                : { inline_comment: options["inline-comment"] }),
+        }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
+    });
+};

package/dist/cli/electronCommands.js

@@ -1,23 +1,22 @@
 import { Cli, z } from "incur";
-import { inspectElectronPage, listElectronTargets, } from "../application/ElectronObservationService.js";
-import { captureElectronScenario } from "../application/ElectronActiveObservationService.js";
-import { reconcileJavaScriptRuntimeEvidence } from "../application/JavaScriptRuntimeReconciliationService.js";
-import { CdpElectronProvider } from "../browser/CdpElectronProvider.js";
-import { PlaywrightElectronActiveProvider } from "../browser/PlaywrightElectronActiveProvider.js";
+import { inspectElectronPage, listElectronTargets, } from "../application/javascript/ElectronObservationService.js";
+import { captureElectronScenario } from "../application/javascript/ElectronActiveObservationService.js";
+import { reconcileJavaScriptRuntimeEvidence } from "../application/javascript/JavaScriptRuntimeReconciliationService.js";
 import { logCliCommand } from "../cliLogging.js";
-import { inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "../domain/electronObservation.js";
-import { electronActiveObservationInputSchema } from "../domain/electronActiveObservation.js";
+import { inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "../domain/javascript/electronObservation.js";
+import { electronActiveObservationInputSchema } from "../domain/javascript/electronActiveObservation.js";
 import { AnalysisInputError } from "../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { projectInputIssues } from "../domain/inputIssueProjection.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
-import { parseCliJsonInput } from "../cliJsonInput.js";
+import { parseCliJsonInput, resolveCliJsonPaths } from "../cliJsonInput.js";
 import { electronPageInspectionOptions, javascriptApplicationOptions, } from "../cliObservationOptions.js";
 import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnalysis.js";
 /** Register CLI equivalents of the Electron MCP tools. */
-export const registerElectronCommands = (cli, logger) => {
+export const registerElectronCommands = (cli, logger, resultOutput) => {
     registerElectronObservationCommands(cli, logger);
     registerElectronActiveCommand(cli, logger);
-    registerJavaScriptApplicationCommand(cli, logger);
+    registerJavaScriptApplicationCommand(cli, logger, resultOutput);
     registerJavaScriptRuntimeReconciliationCommand(cli, logger);
 };
 const registerElectronActiveCommand = (cli, logger) => {
@@ -32,11 +31,15 @@ const registerElectronActiveCommand = (cli, logger) => {
             const input = await parseCliJsonInput(args.inputJson, "capture_electron_scenario");
             if (!input.ok)
                 return input.error;
-            const parsed = electronActiveObservationInputSchema.safeParse(input.value);
+            const parsed = electronActiveObservationInputSchema.safeParse(resolveCliJsonPaths(input.value, [
+                ["executable_path"],
+                ["application_path"],
+                ["application_root"],
+            ]));
             if (!parsed.success)
-                return inputError("capture_electron_scenario");
-            const context = await electronContext();
-            const result = await captureElectronScenario(context.activeProvider, parsed.data);
+                return inputError("capture_electron_scenario", parsed.error.issues, input.value);
+            const { createElectronScenarioProvider } = await import("../composition/electronScenario.js");
+            const result = await captureElectronScenario(createElectronScenarioProvider(), parsed.data);
             return result.ok ? result.value : cliError(result.error);
         }),
     });
@@ -103,28 +106,27 @@ const registerElectronPageInspection = (cli, logger) => {
         }),
     });
 };
-const registerJavaScriptApplicationCommand = (cli, logger) => {
+const registerJavaScriptApplicationCommand = (cli, logger, resultOutput) => {
     cli.command(CLI_COMMANDS.analyzeJavaScriptApplication, {
         description: "Statically reconstruct a local JavaScript/Electron application",
         args: z.object({
             path: z.string().describe("ASAR or extracted application path"),
         }),
         options: javascriptApplicationOptions,
-        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.analyzeJavaScriptApplication, () => runCliJavaScriptApplicationAnalysis({
-            input_path: args.path,
-            format: options.artifactFormat,
-        })),
+        run: ({ args, options, format }) => logCliCommand(logger, CLI_COMMANDS.analyzeJavaScriptApplication, () => runCliJavaScriptApplicationAnalysis({ input_path: args.path, format: options.artifactFormat }, resultOutput === undefined
+            ? undefined
+            : {
+                output: resultOutput,
+                command: CLI_COMMANDS.analyzeJavaScriptApplication,
+                format,
+            })),
     });
 };
-const electronContext = async () => {
-    return {
-        ok: true,
-        provider: new CdpElectronProvider(),
-        activeProvider: new PlaywrightElectronActiveProvider(),
-    };
+const electronObservationContext = async () => {
+    const { createElectronObservationProvider } = await import("../composition/electronObservation.js");
+    return { provider: createElectronObservationProvider() };
 };
-const electronObservationContext = electronContext;
-const inputError = (operation) => cliError(new AnalysisInputError(operation));
+const inputError = (operation, issues, input) => cliError(new AnalysisInputError(operation, undefined, issues === undefined ? [] : projectInputIssues(issues, input)));
 const cliError = (error) => ({
     error: "Electron analysis failed",
     ...projectAnalysisError(error),

package/dist/cli/evmCommands.js

@@ -0,0 +1,24 @@
+import { z } from "incur";
+import { resolve } from "node:path";
+import { createEvmInterfaceService } from "../composition/evm.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** Resolve operator paths and preserve explicit encoding through the shared workflow. */
+export const registerEvmCommands = (cli, logger, environment) => {
+    const service = createEvmInterfaceService(environment);
+    cli.command(CLI_COMMANDS.inspectEvmInterface, {
+        description: "Infer interface candidates from explicit local EVM bytecode",
+        args: z.object({
+            path: z.string().describe("Local bytecode carrier"),
+            encoding: z
+                .enum(["raw", "hex"])
+                .describe("Selected carrier representation"),
+        }),
+        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectEvmInterface, async () => {
+            const result = await service.inspect({ path: resolve(args.path), encoding: args.encoding }, { signal });
+            return result.ok ? result.value : projectAnalysisError(result.error);
+        })),
+    });
+};

package/dist/cli/firmwareCommands.js

@@ -1,13 +1,14 @@
 import { z } from "incur";
-import { FirmwareAnalysisService } from "../application/FirmwareAnalysisService.js";
-import { FirmwareProvider } from "../firmware/FirmwareProvider.js";
+import { resolve } from "node:path";
+import { FirmwareAnalysisService } from "../application/firmware/FirmwareAnalysisService.js";
+import { createFirmwareAnalysisProvider } from "../composition/firmware.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { withCommandCancellation } from "./commandCancellation.js";
 /** One-shot firmware CLI commands backed by the same workflows as MCP. */
 export const registerFirmwareCommands = (cli, logger, environment) => {
-    const service = new FirmwareAnalysisService(new FirmwareProvider(environment));
+    const service = new FirmwareAnalysisService(createFirmwareAnalysisProvider(environment));
     const execute = (name, operation, input) => withCommandCancellation((signal) => logCliCommand(logger, name, async () => {
         const result = await service.execute(operation, input, { signal });
         return result.ok ? result.value : projectAnalysisError(result.error);
@@ -16,7 +17,9 @@ export const registerFirmwareCommands = (cli, logger, environment) => {
     cli.command(CLI_COMMANDS.inspectFirmwareRegions, {
         description: "Inspect firmware signature candidates without extracting them",
         args: z.object({ path }),
-        run: ({ args }) => execute(CLI_COMMANDS.inspectFirmwareRegions, "inspect_firmware_regions", args),
+        run: ({ args }) => execute(CLI_COMMANDS.inspectFirmwareRegions, "inspect_firmware_regions", 
+        // CLI paths are operator-relative; resolve before shared validation.
+        { path: resolve(args.path) }),
     });
     cli.command(CLI_COMMANDS.extractFirmware, {
         description: "Extract selected firmware bytes and return verified files and provenance",
@@ -56,8 +59,8 @@ export const registerFirmwareCommands = (cli, logger, environment) => {
                 .describe("Staging entry budget; default 10000"),
         }),
         run: ({ args, options }) => execute(CLI_COMMANDS.extractFirmware, "extract_firmware", {
-            path: args.path,
-            output_directory: args.outputDirectory,
+            path: resolve(args.path),
+            output_directory: resolve(args.outputDirectory),
             ...(options.offset === undefined && options.length === undefined
                 ? {}
                 : { range: { offset: options.offset, length: options.length } }),