reverseport 0.0.0-stage → 1.2.0

package/dist/catalogIdentity.js

@@ -0,0 +1,65 @@
+import { createHash } from "node:crypto";
+import canonicalize from "canonicalize";
+import { z } from "zod";
+import { PROMPT_CONTRACTS } from "./contracts/promptContracts.js";
+import { TOOL_CONTRACTS } from "./contracts/toolContracts.js";
+import { CLI_COMMAND_NAMES } from "./cliCommandNames.js";
+import { compareUnicodeCodePoints } from "./domain/unicodeCodePointOrder.js";
+const sortedToolContracts = [...TOOL_CONTRACTS].sort((left, right) => compareUnicodeCodePoints(left.name, right.name));
+const createToolCatalog = () => sortedToolContracts.map((contract) => ({
+    name: contract.name,
+    title: contract.title,
+    surface: contract.kind,
+    description: contract.description,
+    effects: { ...contract.effects },
+    annotations: contract.annotations,
+    input_schema: {
+        type: "object",
+        ...z.toJSONSchema(contract.inputSchema, {
+            unrepresentable: "any",
+        }),
+    },
+    output_schema: {
+        type: "object",
+        ...z.toJSONSchema(contract.outputSchema, {
+            unrepresentable: "any",
+        }),
+    },
+}));
+const promptCatalog = PROMPT_CONTRACTS.map((contract) => ({
+    name: contract.name,
+    title: contract.title,
+    description: contract.description,
+    arguments: contract.arguments,
+    steps: contract.steps,
+})).sort((left, right) => compareUnicodeCodePoints(left.name, right.name));
+const digest = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Catalog is not canonical JSON");
+    return createHash("sha256").update(encoded).digest("hex");
+};
+const createCatalogDigests = () => {
+    const tools = createToolCatalog();
+    return {
+        tools_sha256: digest(tools),
+        prompts_sha256: digest(promptCatalog),
+        combined_sha256: digest({
+            cli: CLI_COMMAND_NAMES,
+            tools,
+            prompts: promptCatalog,
+        }),
+    };
+};
+let catalogDigests;
+/** Stable, schema-sensitive identity; schema digests are computed on first use. */
+export const CATALOG_IDENTITY = {
+    counts: {
+        cli_commands: CLI_COMMAND_NAMES.length,
+        mcp_tools: sortedToolContracts.length,
+        mcp_prompts: promptCatalog.length,
+    },
+    get digests() {
+        return (catalogDigests ??= createCatalogDigests());
+    },
+};

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/analysisSelector.js

@@ -0,0 +1,23 @@
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+/** Preserve a CLI selector supplied positionally or through its named option. */
+export const resolveCliAnalysisSelector = (positional, named, option, operation) => {
+    if (positional !== undefined && named !== undefined && positional !== named)
+        throw new AnalysisInputError(operation, undefined, [
+            {
+                path: [option],
+                reason: "invalid_value",
+                message: `The positional selector and --${option} select different objects; supply one selector.`,
+            },
+        ]);
+    const selected = named ?? positional;
+    if (selected === undefined)
+        throw new AnalysisInputError(operation, undefined, [
+            {
+                path: [option],
+                reason: "missing_argument",
+                message: `Supply a positional selector or --${option}=<value>. Use the named option for values beginning with a dash.`,
+                expected: "string",
+            },
+        ]);
+    return selected;
+};

package/dist/cli/analysisViewCommands.js

@@ -0,0 +1,74 @@
+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";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
+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, JavaScript application or native function Evidence JSON",
+        args: z.object({
+            inputJson: z.string().describe("Inline workflow JSON or JSON file path"),
+        }),
+        run: ({ args }) => logCliCommand(logger, CLI_COMMANDS.inspectAnalysisView, async () => {
+            const input = await parseCliJsonInput(args.inputJson, CLI_COMMANDS.inspectAnalysisView);
+            if (!input.ok)
+                return input.error;
+            const parsed = inspectAnalysisViewInputSchema.safeParse(input.value);
+            if (!parsed.success)
+                return {
+                    error: "Application workflow failed",
+                    ...projectAnalysisError(analysisInputErrorFromIssues(CLI_COMMANDS.inspectAnalysisView, parsed.error.issues, input.value)),
+                };
+            const result = inspectAnalysisViewValidated(parsed.data);
+            return result.ok
+                ? jsonValueSchema.parse(result.value)
+                : {
+                    error: "Application workflow failed",
+                    ...projectAnalysisError(result.error),
+                };
+        }),
+    });
+};

package/dist/cli/androidCommands.js

@@ -0,0 +1,91 @@
+import { z } from "incur";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { AndroidAnalysisService } from "../application/android/AndroidAnalysisService.js";
+import { createAndroidAnalysisProvider } from "../composition/android.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 APK requests through one-shot CLI commands. */
+export const registerAndroidCommands = (cli, logger, environment) => {
+    const provider = createAndroidAnalysisProvider(environment);
+    const service = new AndroidAnalysisService(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 path = z.string().describe("Local standalone APK path");
+    const className = z.string().describe("Exact fully qualified class name");
+    cli.command(CLI_COMMANDS.inspectAndroidPackage, {
+        description: "Inspect APK declarations and decoded manifest without executing it",
+        args: z.object({ path }),
+        run: ({ args }) => execute(CLI_COMMANDS.inspectAndroidPackage, "inspect_android_package", args),
+    });
+    cli.command(CLI_COMMANDS.searchAndroidClasses, {
+        description: "Search APK class names; empty query inventories all classes",
+        args: z.object({
+            path,
+            query: z
+                .string()
+                .describe("Case-sensitive class-name substring; empty lists all classes"),
+        }),
+        run: ({ args }) => execute(CLI_COMMANDS.searchAndroidClasses, "search_android_classes", args),
+    });
+    cli.command(CLI_COMMANDS.inspectAndroidClass, {
+        description: "Inspect one exact APK class's member inventory",
+        args: z.object({ path, className }),
+        run: ({ args }) => execute(CLI_COMMANDS.inspectAndroidClass, "inspect_android_class", {
+            path: args.path,
+            class_name: args.className,
+        }),
+    });
+    cli.command(CLI_COMMANDS.inspectAndroidMethod, {
+        description: "Decompile one APK method with explicit overload selection",
+        args: z.object({
+            path,
+            className,
+            methodName: z.string().describe("Exact declared method name"),
+        }),
+        options: z.object({
+            overloadIndex: z
+                .number()
+                .int()
+                .nonnegative()
+                .optional()
+                .describe("Explicit zero-based index among same-name methods; required when ambiguous"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.inspectAndroidMethod, "inspect_android_method", {
+            path: args.path,
+            class_name: args.className,
+            method_name: args.methodName,
+            ...(options.overloadIndex === undefined
+                ? {}
+                : { overload_index: options.overloadIndex }),
+        }),
+    });
+    cli.command(CLI_COMMANDS.traceAndroidReferences, {
+        description: "Trace incoming APK class or unique-method references",
+        args: z.object({ path, className }),
+        options: z.object({
+            methodName: z
+                .string()
+                .optional()
+                .describe("Unique declared method name; omit for class references"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.traceAndroidReferences, "trace_android_references", {
+            path: args.path,
+            class_name: args.className,
+            ...(options.methodName === undefined
+                ? {}
+                : { method_name: options.methodName }),
+        }),
+    });
+};

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 }),
+        }),
+    });
+};