reverseport 0.0.0-stage → 1.2.0

package/dist/cli/utilityCommands.js

@@ -0,0 +1,226 @@
+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";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { projectInputIssues } from "../domain/inputIssueProjection.js";
+import { safeParseJson } from "../domain/safeJson.js";
+import { nativeUiScenarioInputSchema } from "../domain/native/nativeUiObservation.js";
+import { PRODUCT_IDENTITY } from "../identity.js";
+import { logCliCommand } from "../cliLogging.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { swiftSymbolsSchema } from "../contracts/native/nativeToolContracts.js";
+import { isReferenceSourceImportCliFailure } from "./referenceSourceImportStatus.js";
+import { registerNativeCallCommands } from "./nativeCallCommands.js";
+export const registerUtilityCommands = (cli, logger, environment, analysis) => {
+    const { runProviderAnalysis } = analysis;
+    registerCapabilityCommands(cli, logger, analysis);
+    registerNativeCommands(cli, logger, runProviderAnalysis);
+    registerNativeCallCommands(cli, logger, runProviderAnalysis);
+    for (const [command, operation] of [
+        [CLI_COMMANDS.observeNativeUi, "observe_native_ui"],
+        [CLI_COMMANDS.captureNativeUiScenario, "capture_native_ui_scenario"],
+    ]) {
+        cli.command(command, {
+            description: "Observe or run a scenario in one exact native application window",
+            args: z.object({
+                path: z.string().describe("Local native executable or app path"),
+            }),
+            options: z.object({
+                pid: z.number().int().positive().describe("Existing application PID"),
+                windowId: z
+                    .number()
+                    .int()
+                    .positive()
+                    .describe("Exact selected application window ID"),
+                steps: z
+                    .string()
+                    .optional()
+                    .describe("JSON array of declarative AX actions or waits"),
+                screenshot: z
+                    .boolean()
+                    .default(true)
+                    .describe("Capture only the selected window"),
+                accessibility: z
+                    .boolean()
+                    .default(true)
+                    .describe("Read the selected window accessibility tree"),
+                maxNodes: z
+                    .number()
+                    .int()
+                    .positive()
+                    .safe()
+                    .default(500)
+                    .describe("Maximum accessibility nodes per capture"),
+            }),
+            run: ({ args, options }) => logCliCommand(logger, command, async () => {
+                const parameters = {
+                    pid: options.pid,
+                    window_id: options.windowId,
+                    screenshot: options.screenshot,
+                    accessibility: options.accessibility,
+                    max_nodes: options.maxNodes,
+                };
+                if (operation === "capture_native_ui_scenario") {
+                    const decoded = options.steps === undefined
+                        ? { ok: true, value: undefined }
+                        : safeParseJson(options.steps);
+                    if (!decoded.ok)
+                        return invalidNativeUiScenarioInput(operation, [
+                            { path: ["steps"], reason: "invalid_format", expected: "JSON" },
+                        ]);
+                    const parsed = nativeUiScenarioInputSchema.safeParse({
+                        ...parameters,
+                        steps: decoded.value,
+                    });
+                    if (!parsed.success)
+                        return invalidNativeUiScenarioInput(operation, projectInputIssues(parsed.error.issues, {
+                            ...parameters,
+                            ...(options.steps === undefined
+                                ? {}
+                                : { steps: decoded.value }),
+                        }));
+                    return runProviderAnalysis(args.path, operation, parsed.data, logger);
+                }
+                return runProviderAnalysis(args.path, operation, parameters, logger);
+            }),
+        });
+    }
+    registerReferenceSourceCommand(cli, logger, environment);
+};
+const invalidNativeUiScenarioInput = (operation, issues) => ({
+    error: "Application workflow failed",
+    ...projectAnalysisError(new AnalysisInputError(operation, undefined, issues)),
+});
+const registerCapabilityCommands = (cli, logger, { runSessionStatus }) => {
+    for (const command of [
+        CLI_COMMANDS.capabilities,
+        CLI_COMMANDS.providers,
+    ]) {
+        cli.command(command, {
+            description: command === "capabilities"
+                ? "List provider capabilities and side effects"
+                : "List configured analysis providers",
+            run: () => logCliCommand(logger, command, () => runSessionStatus(logger)),
+        });
+    }
+};
+const registerNativeCommands = (cli, logger, runProviderAnalysis) => {
+    for (const [command, tool] of [
+        [CLI_COMMANDS.inspectMacho, "inspect_macho"],
+        [CLI_COMMANDS.inspectSignature, "inspect_signature"],
+        [CLI_COMMANDS.listArchitectures, "list_architectures"],
+    ]) {
+        cli.command(command, {
+            description: `Run ${tool} without launching Hopper`,
+            args: z.object({ path: z.string().describe("Mach-O or app path") }),
+            run: ({ args }) => logCliCommand(logger, command, () => runProviderAnalysis(args.path, tool, {}, logger)),
+        });
+    }
+    cli.command(CLI_COMMANDS.inspectPlist, {
+        description: "Parse app plist metadata without launching Hopper",
+        args: z.object({ path: z.string().describe("App or Mach-O path") }),
+        options: z.object({
+            relativePath: z
+                .string()
+                .optional()
+                .describe("Plist path relative to the app root, or an absolute path (default: the bundle's Info.plist)"),
+        }),
+        run: ({ args, options }) => logCliCommand(logger, "inspect-plist", () => runProviderAnalysis(args.path, "inspect_plist", options.relativePath === undefined
+            ? {}
+            : { path: options.relativePath }, logger)),
+    });
+    cli.command(CLI_COMMANDS.demangleSwift, {
+        description: "Demangle Swift symbols without Hopper",
+        args: z.object({
+            path: z.string().describe("Artifact path used for evidence identity"),
+            symbols: swiftSymbolsSchema.describe("Swift mangled symbols to demangle"),
+        }),
+        run: ({ args }) => logCliCommand(logger, "demangle-swift", () => runProviderAnalysis(args.path, "demangle_swift", { symbols: args.symbols }, logger)),
+    });
+};
+const registerReferenceSourceCommand = (cli, logger, environment) => {
+    cli.command(CLI_COMMANDS.importReferenceSource, {
+        description: "Import a source tree as historical reference only",
+        args: z.object({
+            root: z
+                .string()
+                .describe("Local source directory to import as historical reference"),
+        }),
+        run: ({ args }) => logCliCommand(logger, "import-reference-source", async () => {
+            const config = parseConfig(environment);
+            if (!config.ok)
+                return {
+                    error: "Import failed",
+                    ...projectAnalysisError(config.error),
+                };
+            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,
+                importer: PRODUCT_IDENTITY.packageName,
+                importerVersion: null,
+            }, 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/wasmCommands.js

@@ -0,0 +1,44 @@
+import { z } from "incur";
+import { resolve } from "node:path";
+import { createWasmArtifactService } from "../composition/wasm.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** Resolve all caller-selected artifact paths through the shared workflow. */
+export const registerWasmCommands = (cli, logger, environment) => {
+    const service = createWasmArtifactService(environment);
+    cli.command(CLI_COMMANDS.inspectWasmArtifact, {
+        description: "Inspect an explicit local WASM artifact with WABT",
+        args: z.object({
+            path: z.string().describe("Local WASM artifact"),
+        }),
+        options: z.object({
+            glue_paths: z
+                .array(z.string())
+                .optional()
+                .describe("Selected local JavaScript glue paths"),
+            candidate_paths: z
+                .array(z.string())
+                .optional()
+                .describe("Explicit local WASM candidates"),
+        }),
+        run: ({ args, options }) => withCommandCancellation(async (signal) => {
+            try {
+                return await logCliCommand(logger, CLI_COMMANDS.inspectWasmArtifact, async () => {
+                    const result = await service.inspect({
+                        path: resolve(args.path),
+                        glue_paths: options.glue_paths?.map((path) => resolve(path)),
+                        candidate_paths: options.candidate_paths?.map((path) => resolve(path)),
+                    }, { signal });
+                    return result.ok
+                        ? result.value
+                        : projectAnalysisError(result.error);
+                });
+            }
+            finally {
+                await service.close();
+            }
+        }),
+    });
+};

package/dist/cli/webModuleCommands.js

@@ -0,0 +1,60 @@
+import { z } from "incur";
+import { createWebModuleTraceService } from "../composition/webModules.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { webModuleTraceInputSchema } from "../domain/webModuleTrace.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+const importMapInputSchema = webModuleTraceInputSchema.shape.import_map.unwrap();
+/** Expose the same selected-context module trace through the CLI. */
+export const registerWebModuleCommands = (cli, logger, environment) => {
+    const service = createWebModuleTraceService(environment);
+    cli.command(CLI_COMMANDS.traceWebModuleImports, {
+        description: "Trace one captured script's native imports to URLs and captured source candidates",
+        args: z.object({
+            manifestPath: webModuleTraceInputSchema.shape.manifest_path,
+            scriptIndex: z.coerce
+                .number()
+                .int()
+                .min(0)
+                .describe("Zero-based manifest script index"),
+        }),
+        options: z.object({
+            importerUrl: webModuleTraceInputSchema.shape.importer_url,
+            importMapPath: importMapInputSchema.shape.path
+                .optional()
+                .describe("Absolute local import-map JSON path; requires --import-map-base-url"),
+            importMapBaseUrl: importMapInputSchema.shape.base_url
+                .optional()
+                .describe("HTTP(S) import-map base URL; requires --import-map-path"),
+        }),
+        run: ({ args, options }) => withCommandCancellation(async (signal) => {
+            try {
+                return await logCliCommand(logger, CLI_COMMANDS.traceWebModuleImports, async () => {
+                    const result = await service.trace({
+                        manifest_path: args.manifestPath,
+                        script_index: args.scriptIndex,
+                        ...(options.importerUrl === undefined
+                            ? {}
+                            : { importer_url: options.importerUrl }),
+                        ...(options.importMapPath === undefined &&
+                            options.importMapBaseUrl === undefined
+                            ? {}
+                            : {
+                                import_map: {
+                                    path: options.importMapPath,
+                                    base_url: options.importMapBaseUrl,
+                                },
+                            }),
+                    }, { signal });
+                    return result.ok
+                        ? result.value
+                        : projectAnalysisError(result.error);
+                });
+            }
+            finally {
+                await service.close();
+            }
+        }),
+    });
+};

package/dist/cli/webNetworkCaptureCommands.js

@@ -0,0 +1,40 @@
+import { z } from "incur";
+import { createWebNetworkCaptureService } from "../composition/webNetworkCaptures.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** Expose offline historical capture inspection with the same selection contract as MCP. */
+export const registerWebNetworkCaptureCommands = (cli, logger, environment) => {
+    const service = createWebNetworkCaptureService(environment);
+    cli.command(CLI_COMMANDS.inspectWebNetworkCapture, {
+        description: "Inspect retained HAR or native mitmproxy records without fetching recorded URLs",
+        args: z.object({
+            capturePath: z.string().describe("Absolute local capture path"),
+            format: z.enum(["har", "mitmproxy"]).describe("Producer capture format"),
+        }),
+        options: z.object({
+            record: z
+                .array(z.coerce.number().int().nonnegative())
+                .optional()
+                .describe("Zero-based producer ordinals; repeat to select several"),
+            sensitiveValue: z
+                .array(z.string().min(1))
+                .default([])
+                .describe("Literal string values explicitly marked sensitive; repeat as needed"),
+        }),
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectWebNetworkCapture, async () => {
+            const result = await service.inspect({
+                capture_path: args.capturePath,
+                format: args.format,
+                sensitive_values: options.sensitiveValue,
+                ...(options.record === undefined
+                    ? {}
+                    : { record_ordinals: options.record }),
+            }, { signal });
+            return result.ok
+                ? result.value
+                : projectAnalysisError(result.error);
+        })),
+    });
+};

package/dist/cli/webRuntimeCommands.js

@@ -0,0 +1,60 @@
+import { Cli, z } from "incur";
+import { createWebRuntimeService } from "../composition/webRuntime.js";
+import { browserCliError } from "../cliBrowserContext.js";
+import { browserScopeOptions, observationDuration, } from "../cliObservationOptions.js";
+import { logCliCommand } from "../cliLogging.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** CLI progress exposes the actual armed point on stderr without corrupting JSON results. */
+const runtimeProgress = {
+    report: async (update) => {
+        process.stderr.write(`${JSON.stringify({ rea_progress: update })}\n`);
+    },
+};
+/** Register public equivalents of the two modular website runtime tools. */
+export const registerWebRuntimeCommands = (cli, logger) => {
+    cli.command(CLI_COMMANDS.observeWebExecution, {
+        description: "Observe precise page execution; resets counters and temporarily disables optimization",
+        args: z.object({
+            endpoint: z.string().describe("Existing loopback browser CDP endpoint"),
+            targetId: z
+                .string()
+                .describe("Selected page target ID from list-browser-targets"),
+        }),
+        options: z.object({
+            ...browserScopeOptions,
+            observationMs: observationDuration(10_000, 1),
+        }),
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, "observe-web-execution", async () => {
+            const result = await createWebRuntimeService().observe({
+                cdp_endpoint: args.endpoint,
+                target_id: args.targetId,
+                allowed_origins: options.allowedOrigins,
+                observation_ms: options.observationMs,
+            }, { progress: runtimeProgress, signal });
+            return result.ok ? result.value : browserCliError(result.error);
+        })),
+    });
+    cli.command(CLI_COMMANDS.inspectWebEventListeners, {
+        description: "Inspect native listener source locations on the first main-document CSS match",
+        args: z.object({
+            endpoint: z.string().describe("Existing loopback browser CDP endpoint"),
+            targetId: z
+                .string()
+                .describe("Selected page target ID from list-browser-targets"),
+            selector: z
+                .string()
+                .describe("Native CSS selector; inspect the first main-document match"),
+        }),
+        options: z.object({ ...browserScopeOptions }),
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, "inspect-web-event-listeners", async () => {
+            const result = await createWebRuntimeService().inspect({
+                cdp_endpoint: args.endpoint,
+                target_id: args.targetId,
+                selector: args.selector,
+                allowed_origins: options.allowedOrigins,
+            }, { signal });
+            return result.ok ? result.value : browserCliError(result.error);
+        })),
+    });
+};

package/dist/cli/webScriptCommands.js

@@ -0,0 +1,50 @@
+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, {
+        description: "Export retained website scripts into an absent directory for static JavaScript analysis",
+        args: z.object({
+            capturePath: z
+                .string()
+                .describe("Absolute path to saved page or scenario capture JSON"),
+            outputDirectory: z
+                .string()
+                .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
+                : {
+                    error: "Script export failed",
+                    ...projectAnalysisError(result.error),
+                };
+        }),
+    });
+};

package/dist/cli/webSourceLocationCommands.js

@@ -0,0 +1,54 @@
+import { z } from "incur";
+import { createWebSourceLocationService } from "../composition/webSourceLocations.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 selected map/point contract through the CLI. */
+export const registerWebSourceLocationCommands = (cli, logger, environment) => {
+    const service = createWebSourceLocationService(environment);
+    cli.command(CLI_COMMANDS.traceWebSourceLocation, {
+        description: "Trace one retained script position through an explicitly selected local source map",
+        args: z.object({
+            manifestPath: z
+                .string()
+                .describe("Absolute export_web_scripts manifest path"),
+            scriptIndex: z.coerce
+                .number()
+                .int()
+                .min(0)
+                .describe("Zero-based manifest script index"),
+            sourceMapPath: z.string().describe("Absolute local source-map path"),
+            sourceMapUrl: z
+                .string()
+                .describe("Absolute source-map URL context; no fetch"),
+            line: z.coerce.number().int().min(1).describe("One-based generated line"),
+            column: z.coerce
+                .number()
+                .int()
+                .min(0)
+                .describe("Zero-based UTF-16 generated column"),
+        }),
+        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-runtime/AnalysisProvider-CeyX2u-b.js

@@ -0,0 +1,25 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { init_jsonValue, jsonValueSchema } from "./providerOperationHealth-DSTcYPJe.js";
+import { init_relationshipCoverage, relationshipCoverageSchema } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+
+//#region dist/application/AnalysisProvider.js
+var createAnalysisExecution;
+function init_AnalysisProvider() {
+	return (init_AnalysisProvider = __esmMin((() => {
+		init_jsonValue();
+		init_relationshipCoverage();
+		createAnalysisExecution = (result, provider, options = {}) => ({
+			result: jsonValueSchema.parse(result),
+			rawResult: options.rawResult === undefined ? null : jsonValueSchema.parse(options.rawResult),
+			provider,
+			...options.analysisProfile === undefined ? {} : { analysisProfile: structuredClone(options.analysisProfile) },
+			limitations: [...options.limitations ?? []],
+			...options.relationshipCoverage === undefined ? {} : { relationshipCoverage: relationshipCoverageSchema.parse(options.relationshipCoverage) },
+			locations: [...options.locations ?? []],
+			subject: options.subject ?? null
+		});
+	})))();
+}
+
+//#endregion
+export { createAnalysisExecution, init_AnalysisProvider };