rea-agents 6.3.0 → 6.4.0

package/dist/cli/adbCommands.js

@@ -0,0 +1,337 @@
+import { z } from "incur";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { AdbDeviceAnalysisService } from "../application/adb/AdbDeviceAnalysisService.js";
+import { createAdbDeviceAnalysisProvider } from "../composition/adb.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** Expose the same explicit ADB requests through one-shot CLI commands. */
+export const registerAdbCommands = (cli, logger, environment, provider = createAdbDeviceAnalysisProvider(environment)) => {
+    const service = new AdbDeviceAnalysisService(provider);
+    const execute = (name, operation, input) => withCommandCancellation((signal) => logCliCommand(logger, name, async () => {
+        const result = await service.execute(operation, input, { signal });
+        try {
+            await provider.close();
+        }
+        catch (cause) {
+            if (cause instanceof AnalysisError)
+                return projectAnalysisError(cause);
+            throw cause;
+        }
+        return result.ok ? result.value : projectAnalysisError(result.error);
+    }));
+    const serial = z
+        .string()
+        .min(1)
+        .describe("Device serial exactly as `adb devices` reports it");
+    cli.command(CLI_COMMANDS.inspectAdbClient, {
+        description: "Inspect the caller-selected adb client without contacting devices",
+        args: z.object({}),
+        run: () => execute(CLI_COMMANDS.inspectAdbClient, "inspect_adb_client", {}),
+    });
+    cli.command(CLI_COMMANDS.listAdbDevices, {
+        description: "List attached devices with serial, state, transport, and inferred kind",
+        args: z.object({}),
+        run: () => execute(CLI_COMMANDS.listAdbDevices, "list_adb_devices", {}),
+    });
+    cli.command(CLI_COMMANDS.inspectAdbDevice, {
+        description: "Inspect one device's build identity through a fixed getprop whitelist",
+        args: z.object({ serial }),
+        run: ({ args }) => execute(CLI_COMMANDS.inspectAdbDevice, "inspect_adb_device", args),
+    });
+    cli.command(CLI_COMMANDS.listAdbPackages, {
+        description: "List installed packages on one device with base APK device paths",
+        args: z.object({ serial }),
+        options: z.object({
+            scope: z
+                .enum(["all", "third_party", "system"])
+                .default("all")
+                .describe("Restrict to third-party or system packages"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.listAdbPackages, "list_adb_packages", {
+            serial: args.serial,
+            scope: options.scope,
+        }),
+    });
+    cli.command(CLI_COMMANDS.pullAdbPackage, {
+        description: "Pull one installed package's complete APK set with SHA-256 digests",
+        args: z.object({
+            serial,
+            package: z.string().min(1).describe("Installed package name"),
+        }),
+        options: z.object({
+            "output-directory": z
+                .string()
+                .min(1)
+                .describe("Local directory for the pulled APK set; a package-named subdirectory is created inside"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.pullAdbPackage, "pull_adb_package", {
+            serial: args.serial,
+            package: args.package,
+            output_directory: options["output-directory"],
+        }),
+    });
+    cli.command(CLI_COMMANDS.readAdbLogcat, {
+        description: "Read a bounded dump of the device log for one buffer",
+        args: z.object({ serial }),
+        options: z.object({
+            count: z
+                .number()
+                .int()
+                .min(1)
+                .max(10_000)
+                .default(500)
+                .describe("Number of most recent lines to read"),
+            buffer: z
+                .enum(["main", "system", "radio", "events", "crash"])
+                .default("main")
+                .describe("Log buffer to read"),
+            pid: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe("Restrict to one process id"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.readAdbLogcat, "read_adb_logcat", {
+            serial: args.serial,
+            count: options.count,
+            buffer: options.buffer,
+            ...(options.pid === undefined ? {} : { pid: options.pid }),
+        }),
+    });
+    cli.command(CLI_COMMANDS.inspectAdbPackage, {
+        description: "Inspect one installed package's version, installer, and flags through dumpsys",
+        args: z.object({ serial, package: z.string().min(1).describe("Package") }),
+        run: ({ args }) => execute(CLI_COMMANDS.inspectAdbPackage, "inspect_adb_package", {
+            serial: args.serial,
+            package: args.package,
+        }),
+    });
+    cli.command(CLI_COMMANDS.pullAdbFile, {
+        description: "Pull one device file to a local copy with a SHA-256 digest",
+        args: z.object({
+            serial,
+            "device-path": z.string().min(1).describe("Absolute device path to pull"),
+        }),
+        options: z.object({
+            "output-directory": z
+                .string()
+                .min(1)
+                .describe("Local directory for the pulled file"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.pullAdbFile, "pull_adb_file", {
+            serial: args.serial,
+            device_path: args["device-path"],
+            output_directory: options["output-directory"],
+        }),
+    });
+    cli.command(CLI_COMMANDS.pushAdbFile, {
+        description: "Push one local file to the device; refuses existing targets without --overwrite",
+        args: z.object({
+            serial,
+            "local-path": z.string().min(1).describe("Existing local file"),
+            "device-path": z.string().min(1).describe("Absolute device destination"),
+        }),
+        options: z.object({
+            overwrite: z
+                .boolean()
+                .default(false)
+                .describe("Allow replacing an existing device file"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.pushAdbFile, "push_adb_file", {
+            serial: args.serial,
+            local_path: args["local-path"],
+            device_path: args["device-path"],
+            overwrite: options.overwrite,
+        }),
+    });
+    cli.command(CLI_COMMANDS.captureAdbScreen, {
+        description: "Capture one screen frame as a digested PNG",
+        args: z.object({ serial }),
+        options: z.object({
+            "output-directory": z
+                .string()
+                .min(1)
+                .describe("Local directory for screen.png"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.captureAdbScreen, "capture_adb_screen", {
+            serial: args.serial,
+            output_directory: options["output-directory"],
+        }),
+    });
+    cli.command(CLI_COMMANDS.listAdbProcesses, {
+        description: "List running processes exactly as ps -A reports them",
+        args: z.object({ serial }),
+        run: ({ args }) => execute(CLI_COMMANDS.listAdbProcesses, "list_adb_processes", args),
+    });
+    cli.command(CLI_COMMANDS.listAdbDirectory, {
+        description: "List one device directory with kinds, permissions, and sizes",
+        args: z.object({
+            serial,
+            "device-path": z
+                .string()
+                .min(1)
+                .describe("Absolute device directory path to list"),
+        }),
+        run: ({ args }) => execute(CLI_COMMANDS.listAdbDirectory, "list_adb_directory", {
+            serial: args.serial,
+            device_path: args["device-path"],
+        }),
+    });
+    cli.command(CLI_COMMANDS.listAdbFeatures, {
+        description: "List the device's declared hardware and software features",
+        args: z.object({ serial }),
+        run: ({ args }) => execute(CLI_COMMANDS.listAdbFeatures, "list_adb_features", args),
+    });
+    cli.command(CLI_COMMANDS.listAdbServices, {
+        description: "List the device's binder services and interfaces",
+        args: z.object({ serial }),
+        run: ({ args }) => execute(CLI_COMMANDS.listAdbServices, "list_adb_services", args),
+    });
+    cli.command(CLI_COMMANDS.inspectAdbDisplay, {
+        description: "Report the display's declared size and density",
+        args: z.object({ serial }),
+        run: ({ args }) => execute(CLI_COMMANDS.inspectAdbDisplay, "inspect_adb_display", args),
+    });
+    cli.command(CLI_COMMANDS.inspectAdbWindow, {
+        description: "Report the window manager's current focus declarations",
+        args: z.object({ serial }),
+        run: ({ args }) => execute(CLI_COMMANDS.inspectAdbWindow, "inspect_adb_window", args),
+    });
+    cli.command(CLI_COMMANDS.readAdbSetting, {
+        description: "Read one settings value from system, secure, or global",
+        args: z.object({
+            serial,
+            namespace: z
+                .enum(["system", "secure", "global"])
+                .describe("Settings namespace to read"),
+            key: z.string().min(1).describe("Setting key to read"),
+        }),
+        run: ({ args }) => execute(CLI_COMMANDS.readAdbSetting, "read_adb_setting", {
+            serial: args.serial,
+            namespace: args.namespace,
+            key: args.key,
+        }),
+    });
+    cli.command(CLI_COMMANDS.collectAdbBugreport, {
+        description: "Collect and digest one device-generated bugreport archive",
+        args: z.object({ serial }),
+        options: z.object({
+            "output-directory": z
+                .string()
+                .min(1)
+                .describe("Local directory for the bugreport zip"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.collectAdbBugreport, "collect_adb_bugreport", {
+            serial: args.serial,
+            output_directory: options["output-directory"],
+        }),
+    });
+    cli.command(CLI_COMMANDS.resolveAdbPackages, {
+        description: "Find installed packages by case-insensitive name substring",
+        args: z.object({
+            serial,
+            query: z.string().min(2).describe("Package-name substring to find"),
+        }),
+        run: ({ args }) => execute(CLI_COMMANDS.resolveAdbPackages, "resolve_adb_packages", {
+            serial: args.serial,
+            query: args.query,
+        }),
+    });
+    cli.command(CLI_COMMANDS.installAdbPackage, {
+        description: "Install one local APK; --replace re-installs keeping the app's data",
+        args: z.object({
+            serial,
+            "apk-path": z.string().min(1).describe("Local APK file to install"),
+        }),
+        options: z.object({
+            replace: z
+                .boolean()
+                .default(false)
+                .describe("Replace an existing install and keep its data"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.installAdbPackage, "install_adb_package", {
+            serial: args.serial,
+            apk_path: args["apk-path"],
+            replace: options.replace,
+        }),
+    });
+    cli.command(CLI_COMMANDS.uninstallAdbPackage, {
+        description: "Uninstall one package and its data from the device",
+        args: z.object({
+            serial,
+            package: z.string().min(1).describe("Installed package to uninstall"),
+        }),
+        run: ({ args }) => execute(CLI_COMMANDS.uninstallAdbPackage, "uninstall_adb_package", {
+            serial: args.serial,
+            package: args.package,
+        }),
+    });
+    cli.command(CLI_COMMANDS.startAdbApp, {
+        description: "Start one installed app by resolving and launching its launcher activity",
+        args: z.object({
+            serial,
+            package: z.string().min(1).describe("Installed package to start"),
+        }),
+        run: ({ args }) => execute(CLI_COMMANDS.startAdbApp, "start_adb_app", {
+            serial: args.serial,
+            package: args.package,
+        }),
+    });
+    cli.command(CLI_COMMANDS.startAdbActivity, {
+        description: "Start an intent with am start (action, URI, component, extras)",
+        args: z.object({
+            serial,
+            action: z.string().min(1).describe("Intent action to start"),
+        }),
+        options: z.object({
+            "data-uri": z.string().min(1).optional().describe("Intent data URI (-d)"),
+            component: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Explicit component in package/activity form (-n)"),
+            extra: z
+                .array(z.string().min(1))
+                .default([])
+                .describe("Typed extra as type:key:value (string, boolean, int, long, float), repeatable"),
+        }),
+        run: ({ args, options }) => {
+            const extras = options.extra.map((entry) => {
+                const first = entry.indexOf(":");
+                const second = entry.indexOf(":", first + 1);
+                if (first === -1 || second === -1)
+                    throw new Error(`--extra expects type:key:value, received: ${entry}`);
+                return {
+                    type: entry.slice(0, first),
+                    key: entry.slice(first + 1, second),
+                    value: entry.slice(second + 1),
+                };
+            });
+            return execute(CLI_COMMANDS.startAdbActivity, "start_adb_activity", {
+                serial: args.serial,
+                action: args.action,
+                ...(options["data-uri"] === undefined
+                    ? {}
+                    : { data_uri: options["data-uri"] }),
+                ...(options.component === undefined
+                    ? {}
+                    : { component: options.component }),
+                extras,
+            });
+        },
+    });
+    cli.command(CLI_COMMANDS.stopAdbApp, {
+        description: "Force-stop every process of one package",
+        args: z.object({
+            serial,
+            package: z.string().min(1).describe("Package to force-stop"),
+        }),
+        run: ({ args }) => execute(CLI_COMMANDS.stopAdbApp, "stop_adb_app", {
+            serial: args.serial,
+            package: args.package,
+        }),
+    });
+};

package/dist/cli/analysisViewCommands.js

@@ -1,5 +1,8 @@
 import { z } from "incur";
 import { inspectAnalysisViewValidated } from "../application/analysisView/AnalysisViewService.js";
+import { readEvidenceBundle } from "../application/EvidenceBundleFiles.js";
+import { inspectEvidenceBundle } from "../application/investigation/InspectEvidenceBundle.js";
+import { getEvidenceBundleInputSchema, importEvidenceBundleInputSchema, } from "../contracts/sessionToolSchemas.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { parseCliJsonInput } from "../cliJsonInput.js";
 import { logCliCommand } from "../cliLogging.js";
@@ -9,8 +12,43 @@ import { jsonValueSchema } from "../domain/jsonValue.js";
 import { inspectAnalysisViewInputSchema } from "../domain/analysisView/analysisView.js";
 /** Project selected views of completed analysis Evidence through the CLI. */
 export const registerAnalysisViewCommands = (cli, logger) => {
+    cli.command(CLI_COMMANDS.inspectEvidenceBundle, {
+        description: "Inspect complete or selected discovery metadata from a local Evidence bundle",
+        args: z.object({
+            inputJson: z
+                .string()
+                .describe("JSON or JSON file with absolute path, detail and optional record filters"),
+        }),
+        run: ({ args }) => logCliCommand(logger, CLI_COMMANDS.inspectEvidenceBundle, async () => {
+            const input = await parseCliJsonInput(args.inputJson, CLI_COMMANDS.inspectEvidenceBundle);
+            if (!input.ok)
+                return input.error;
+            const schema = getEvidenceBundleInputSchema.safeExtend({
+                path: importEvidenceBundleInputSchema.shape.path,
+            });
+            const parsed = schema.safeParse(input.value);
+            if (!parsed.success)
+                return {
+                    error: "Evidence bundle inspection failed",
+                    ...projectAnalysisError(analysisInputErrorFromIssues(CLI_COMMANDS.inspectEvidenceBundle, parsed.error.issues, input.value)),
+                };
+            const loaded = await readEvidenceBundle(parsed.data.path);
+            if (!loaded.ok)
+                return {
+                    error: "Evidence bundle inspection failed",
+                    ...projectAnalysisError(loaded.error),
+                };
+            const result = inspectEvidenceBundle(loaded.value, parsed.data);
+            return result.ok
+                ? result.value
+                : {
+                    error: "Evidence bundle inspection failed",
+                    ...projectAnalysisError(result.error),
+                };
+        }),
+    });
     cli.command(CLI_COMMANDS.inspectAnalysisView, {
-        description: "Project a selected view of completed layout or JavaScript application Evidence JSON",
+        description: "Project a selected view of completed layout, JavaScript application or native function Evidence JSON",
         args: z.object({
             inputJson: z.string().describe("Inline workflow JSON or JSON file path"),
         }),

package/dist/cli/apktoolCommands.js

@@ -0,0 +1,53 @@
+import { z } from "incur";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { ApktoolResourceAnalysisService } from "../application/apktool/ApktoolResourceAnalysisService.js";
+import { createApktoolResourceAnalysisProvider } from "../composition/apktool.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** Expose the same explicit Apktool requests through one-shot CLI commands. */
+export const registerApktoolCommands = (cli, logger, environment, provider = createApktoolResourceAnalysisProvider(environment)) => {
+    const service = new ApktoolResourceAnalysisService(provider);
+    const execute = (name, operation, input) => withCommandCancellation((signal) => logCliCommand(logger, name, async () => {
+        const result = await service.execute(operation, input, { signal });
+        try {
+            await provider.close();
+        }
+        catch (cause) {
+            if (cause instanceof AnalysisError)
+                return projectAnalysisError(cause);
+            throw cause;
+        }
+        return result.ok ? result.value : projectAnalysisError(result.error);
+    }));
+    cli.command(CLI_COMMANDS.inspectApktoolClient, {
+        description: "Inspect the caller-selected apktool launcher without decoding anything",
+        args: z.object({}),
+        run: () => execute(CLI_COMMANDS.inspectApktoolClient, "inspect_apktool_client", {}),
+    });
+    cli.command(CLI_COMMANDS.decodeAndroidResources, {
+        description: "Decode one APK's manifest, metadata, and string resources with apktool",
+        args: z.object({
+            path: z.string().min(1).describe("Local APK file to decode"),
+        }),
+        options: z.object({
+            locale: z
+                .string()
+                .min(2)
+                .max(16)
+                .regex(/^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/u, "Locale must look like de or pt-BR")
+                .optional()
+                .describe("Project strings from res/values-<locale> instead of the default"),
+            "no-strings": z
+                .boolean()
+                .default(false)
+                .describe("Skip projecting string resources"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.decodeAndroidResources, "decode_android_resources", {
+            path: args.path,
+            include_strings: !options["no-strings"],
+            ...(options.locale === undefined ? {} : { locale: options.locale }),
+        }),
+    });
+};

package/dist/cli/artifactCommands.js

@@ -84,7 +84,6 @@ const registerAssetCatalogCommand = (cli, logger, runProviderAnalysis) => {
                 .default(1_000)
                 .describe("Maximum records to return"),
         }),
-        alias: {},
         run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.inspectAssetCatalog, () => runProviderAnalysis(args.path, "inspect_asset_catalog", { offset: options.offset, limit: options.limit }, logger)),
     });
 };
@@ -117,11 +116,6 @@ const registerInterfaceBuilderCommand = (cli, logger, runProviderAnalysis) => {
                 .default(40_000)
                 .describe("Maximum decoded connections"),
         }),
-        alias: {
-            maxDocuments: "max-documents",
-            maxObjects: "max-objects",
-            maxConnections: "max-connections",
-        },
         run: ({ args, options }) => logCliCommand(logger, "decode-interface-builder", () => runProviderAnalysis(args.path, "decode_interface_builder", {
             max_documents: options.maxDocuments,
             max_objects: options.maxObjects,
@@ -135,8 +129,14 @@ const registerExtractionCommand = (cli, logger, runProviderAnalysis) => {
         args: z.object({
             path: z.string().describe("Application or package path"),
         }),
-        options: z.object({}),
-        run: ({ args }) => logCliCommand(logger, "extract-artifact", () => runProviderAnalysis(args.path, "extract_artifact", {
+        options: z.object({
+            integrityPolicy: z
+                .enum(["fail", "record-and-continue"])
+                .default("fail")
+                .describe("Behavior when declared artifact integrity does not match"),
+        }),
+        run: ({ args, options }) => logCliCommand(logger, "extract-artifact", () => runProviderAnalysis(args.path, "extract_artifact", {
+            integrity_policy: options.integrityPolicy,
             output_root: createArtifactExtractionDestination(),
         }, logger)),
     });
@@ -153,9 +153,6 @@ const registerInspectionCommand = (cli, logger, runProviderAnalysis) => {
                 .default("fail")
                 .describe("Behavior when declared artifact integrity does not match"),
         }),
-        alias: {
-            integrityPolicy: "integrity-policy",
-        },
         run: ({ args, options }) => logCliCommand(logger, "inspect-artifact", () => runProviderAnalysis(args.path, "inspect_artifact", {
             integrity_policy: options.integrityPolicy,
         }, logger)),

package/dist/cli/binaryDiagnosticsCommands.js

@@ -1,12 +1,30 @@
 import { z } from "incur";
 import { resolve } from "node:path";
-import { createRecordedCrashService, createBinaryLayoutService, } from "../composition/binaryDiagnostics.js";
+import { createRecordedCrashService, createBinaryLayoutService, createPeResourcesService, } from "../composition/binaryDiagnostics.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { inspectPeResourcesInputSchema } from "../domain/native/peResources.js";
 /** Inspect operator-selected files through the same shared workflow as MCP. */
 export const registerBinaryDiagnosticsCommands = (cli, logger, environment) => {
+    const pe = createPeResourcesService();
+    cli.command(CLI_COMMANDS.inspectPeResources, {
+        description: "Inspect PE resource identities, payload ranges, hashes and icon-group relationships",
+        args: z.object({ path: z.string().describe("Local PE32/PE32+ image") }),
+        options: z.object({
+            maxFileBytes: inspectPeResourcesInputSchema.shape.max_file_bytes,
+            maxEntries: inspectPeResourcesInputSchema.shape.max_entries,
+        }),
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectPeResources, async () => {
+            const result = await pe.inspect({
+                path: resolve(args.path),
+                max_file_bytes: options.maxFileBytes,
+                max_entries: options.maxEntries,
+            }, { signal });
+            return result.ok ? result.value : projectAnalysisError(result.error);
+        })),
+    });
     const service = createBinaryLayoutService(environment);
     cli.command(CLI_COMMANDS.inspectBinaryLayout, {
         description: "Inspect binary file/linked layout without executing the selected object",