rea-agents 4.0.0 → 4.1.0

package/dist/browser/PlaywrightElectronActiveProvider.js

@@ -4,9 +4,13 @@ import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { _electron as electron } from "playwright-core";
 import { electronActiveObservationResultSchema, } from "../domain/electronActiveObservation.js";
-import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from "../domain/errors.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { err, ok } from "../domain/result.js";
-import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, observeOwnedProcessLineage, selectCapturedProcessGroupIds, verifyNoTokenOwnedProcesses, } from "../process/ProcessOwnership.js";
+import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, verifyNoTokenOwnedProcesses, } from "../process/ProcessOwnership.js";
+import { observeOwnedProcessLineage } from "../process/ProcessOwnershipObservation.js";
+import { selectCapturedProcessGroupIds } from "../process/ProcessOwnershipProcessTree.js";
 import { runElectronActions, readApplicationState, runWithExecutionLimits, } from "./PlaywrightElectronActiveActions.js";
 const OPERATION = "capture_electron_scenario";
 const STARTUP_TIMEOUT_MS = 60_000;

package/dist/browser/PlaywrightExecutionBoundary.js

@@ -1,4 +1,4 @@
-import { AnalysisCancelledError, AnalysisTimeoutError, } from "../domain/errors.js";
+import { AnalysisCancelledError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
 const OPERATION = "capture_browser_scenario";
 export const withPlaywrightExecutionBoundary = (work, timeoutMs, signal) => {
     if (timeoutMs !== undefined && timeoutMs <= 0)

package/dist/browser/PlaywrightScenarioArtifacts.js

@@ -44,7 +44,8 @@ const captureScreenshot = async (page) => {
             },
         };
     }
-    catch {
+    catch (cause) {
+        void cause;
         return missing("screenshot capture failed");
     }
 };
@@ -53,7 +54,8 @@ const captureDom = async (input) => {
     try {
         return textArtifact(secrets.redact(await page.content()));
     }
-    catch {
+    catch (cause) {
+        void cause;
         return missing("DOM capture failed");
     }
 };
@@ -63,7 +65,8 @@ const captureAccessibility = async (input) => {
         const text = await page.locator("html").ariaSnapshot();
         return textArtifact(secrets.redact(text));
     }
-    catch {
+    catch (cause) {
+        void cause;
         return missing("accessibility capture failed");
     }
 };
@@ -99,7 +102,8 @@ const captureHistory = async (page, secrets) => {
         };
         return { state: "captured", value };
     }
-    catch {
+    catch (cause) {
+        void cause;
         return missing("history capture failed");
     }
 };
@@ -135,7 +139,8 @@ const captureStorage = async (input) => {
         };
         return { state: "captured", value };
     }
-    catch {
+    catch (cause) {
+        void cause;
         return missing("storage capture failed");
     }
 };

package/dist/browser/PlaywrightScenarioBrowser.js

@@ -2,7 +2,7 @@ import { chmod, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { chromium, } from "playwright-core";
-import { BrowserObservationError } from "../domain/errors.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { withPlaywrightExecutionBoundary } from "./PlaywrightExecutionBoundary.js";
 const OPERATION = "capture_browser_scenario";
 const allowedBrowserEnvironment = (environment) => {
@@ -133,6 +133,8 @@ export const closePlaywrightScenarioBrowser = async ({ context, browser, profile
                 await rm(profilePath, { recursive: true, force: true, maxRetries: 3 });
         }
     })();
+    // best-effort cleanup: the bounded execution boundary below observes the
+    // same cleanup promise; this early attachment only prevents unhandled rejection.
     void cleanup.catch(() => undefined);
     // The shared execution boundary rejects cancellation/timeouts instead of
     // returning a successful capture whose browser or profile may still exist.

package/dist/browser/PlaywrightScenarioEvents.js

@@ -24,9 +24,10 @@ export class PlaywrightScenarioEvents {
                 try {
                     return this.pages.has(request.frame().page());
                 }
-                catch {
+                catch (cause) {
                     // Initial popup navigations can lack a frame. Never guess ownership
                     // from a URL in a shared context; connect captures are attach-limited.
+                    void cause;
                     return false;
                 }
             };
@@ -236,6 +237,9 @@ export class PlaywrightScenarioEvents {
             suggested_filename: this.secrets.redact(download.suggestedFilename()),
             url: this.safeUrl(download.url()),
         });
-        void download.cancel().catch(() => undefined);
+        void download.cancel().catch((cause) => {
+            // best-effort cleanup: download cancellation must not reject unhandled.
+            void cause;
+        });
     }
 }

package/dist/browser/PlaywrightScenarioSession.js

@@ -1,5 +1,5 @@
 import {} from "playwright-core";
-import { BrowserObservationError } from "../domain/errors.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { BrowserScenarioSecrets } from "./BrowserScenarioSecrets.js";
 import { closePlaywrightScenarioBrowser, openPlaywrightScenarioBrowser, } from "./PlaywrightScenarioBrowser.js";
 import { performPlaywrightScenarioAction } from "./PlaywrightScenarioActions.js";
@@ -95,7 +95,10 @@ export class PlaywrightScenarioSession {
         catch (cause) {
             void opening
                 .then((lateOpened) => closePlaywrightScenarioBrowser(lateOpened, options.signal))
-                .catch(() => undefined);
+                .catch((cause) => {
+                // best-effort cleanup: late-open cleanup must not mask the boundary failure.
+                void cause;
+            });
             throw cause;
         }
         try {

package/dist/browser/V8InspectorEndpoint.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { BrowserObservationError, } from "../domain/errors.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import {} from "../domain/browserObservationErrors.js";
 import { parseCdpEndpointValue, readCdpJson } from "./CdpEndpoint.js";
 const versionSchema = z
     .object({

package/dist/browser/V8InspectorProvider.js

@@ -1,5 +1,8 @@
 import { javascriptRuntimeObservationSchema, javascriptRuntimeTargetListSchema, } from "../domain/javascriptRuntimeObservation.js";
-import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from "../domain/errors.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import {} from "../domain/browserObservationErrors.js";
 import { err, ok } from "../domain/result.js";
 import { numberValue, recordValue, stringValue, delayWithCancellation, } from "./CdpCaptureValues.js";
 import { CdpConnection } from "./CdpConnection.js";
@@ -104,6 +107,8 @@ export class V8InspectorProvider {
 }
 export const closeInspectorConnection = async (connection, signal) => {
     const closing = connection.close();
+    // best-effort cleanup: the race below observes the close; this only prevents
+    // unhandled rejection when the caller abandons the close via cancellation.
     void closing.catch(() => undefined);
     // CdpConnection.close has its own one second transport bound. Do not make a
     // cancelled caller wait for that fallback.

package/dist/browser/WebSourceMapFetcher.js

@@ -1,11 +1,13 @@
 import * as t from "@babel/types";
 import { AnyMap, eachMapping } from "@jridgewell/trace-mapping";
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
+import { isUrlLikeModuleSpecifier } from "../domain/webBundleAnalyzerAst.js";
 import { analyzeParsedJavaScriptSemantics } from "../domain/javascriptSemanticAnalysis.js";
 import { parseJavaScriptSource } from "../domain/javascriptSourceParser.js";
 import { hasValidSourceMapContents } from "../domain/sourceMapContents.js";
 import { webSourceMapsSchema } from "../domain/webBundleAnalysis.js";
 import { createWebTextArtifact } from "../domain/webContentArtifact.js";
+import { safeParseJson } from "../domain/safeJson.js";
 /** Fetch and validate approved source maps without browser credentials. */
 export const fetchWebSourceMaps = async (requests, input, signal, host = { fetch: globalThis.fetch }) => {
     const items = [];
@@ -126,7 +128,8 @@ const normalizeSourceMap = (request, text, fetchedUrl) => {
                 limitation: `Module edges are incomplete: ${modules.incomplete.length} of ${originalSources.filter(({ artifact }) => artifact !== null).length} original sources could not be parsed in full (${modules.incomplete.join(", ")}).`,
             };
     }
-    catch {
+    catch (cause) {
+        void cause;
         return emptySourceMapItem(request, "invalid", "Source-map mappings could not be decoded safely.");
     }
 };
@@ -178,13 +181,10 @@ const originalModuleEdges = (sources) => {
     return { edges, incomplete };
 };
 const validSourceMapEnvelope = (text) => {
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch {
+    const parsedResult = safeParseJson(text);
+    if (!parsedResult.ok)
         return false;
-    }
+    const parsed = parsedResult.value;
     if (!isRecord(parsed) || parsed.version !== 3)
         return false;
     if (typeof parsed.mappings === "string")
@@ -194,7 +194,11 @@ const validSourceMapEnvelope = (text) => {
     const pending = [...parsed.sections];
     while (pending.length > 0) {
         const section = pending.pop();
-        if (!isRecord(section) || !isRecord(section.offset) || !("map" in section))
+        if (!isRecord(section) ||
+            !isRecord(section.offset) ||
+            !validSourceMapOffset(section.offset.line) ||
+            !validSourceMapOffset(section.offset.column) ||
+            !("map" in section))
             return false;
         const map = section.map;
         if (!isRecord(map) || map.version !== 3)
@@ -207,6 +211,7 @@ const validSourceMapEnvelope = (text) => {
     }
     return true;
 };
+const validSourceMapOffset = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 const validSourceMapLeaf = (map) => typeof map.mappings === "string" &&
     Array.isArray(map.sources) &&
     Array.isArray(map.names) &&
@@ -219,7 +224,9 @@ const approvedUrl = (value, allowedOrigins) => {
             parsed.password === "" &&
             allowedOrigins.includes(parsed.origin));
     }
-    catch {
+    catch (cause) {
+        // Non-URL input is not an approved source-map URL.
+        void cause;
         return false;
     }
 };
@@ -240,15 +247,21 @@ const sanitizeSource = (value) => {
     try {
         return sanitizeBrowserUrl(new URL(value).href).url;
     }
-    catch {
+    catch (cause) {
+        // Non-URL sources are preserved verbatim.
+        void cause;
         return value;
     }
 };
 const resolveOriginalSource = (specifier, base) => {
+    if (!isUrlLikeModuleSpecifier(specifier))
+        return null;
     try {
         return sanitizeSource(new URL(specifier, base).href);
     }
-    catch {
+    catch (cause) {
+        // Unresolvable source specifiers are represented by null.
+        void cause;
         return null;
     }
 };

package/dist/cli/androidCommands.js

@@ -0,0 +1,81 @@
+import { z } from "incur";
+import { AndroidAnalysisService } from "../application/AndroidAnalysisService.js";
+import { JadxProvider } from "../android/JadxProvider.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 service = new AndroidAnalysisService(new JadxProvider(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);
+    }));
+    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/{cliApplicationCommands.js → cli/applicationCommands.js}

@@ -1,20 +1,22 @@
 import { Cli, z } from "incur";
-import { compareApplicationVersionsEvidenceValidated, compareJavaScriptExportShapesEvidenceValidated, compareSourceToBundleEvidenceValidated, traceApplicationFeatureEvidenceValidated, } from "./application/JavaScriptApplicationWorkflowService.js";
-import { traceJavaScriptSemanticsEvidenceValidated } from "./application/JavaScriptSemanticTraceService.js";
-import { evaluateReconstructionCoverage, reconstructionCoverageEvaluationInputSchema, } from "./application/ReconstructionCoverageService.js";
-import { buildReconstructionObligationLedgerEvidenceValidated } from "./application/ReconstructionObligationLedgerService.js";
-import { CLI_COMMANDS } from "./cliCommandNames.js";
-import { parseCliJsonInput } from "./cliJsonInput.js";
-import { logCliCommand } from "./cliLogging.js";
-import { AnalysisInputError, projectAnalysisError, } from "./domain/errors.js";
-import { jsonValueSchema } from "./domain/jsonValue.js";
-import { traceApplicationFeatureInputSchema } from "./domain/javascriptFeatureTraceSchemas.js";
-import { traceJavaScriptSemanticsInputSchema } from "./domain/javascriptSemanticTraceSchemas.js";
-import { compareApplicationVersionsInputSchema } from "./domain/javascriptApplicationVersionComparisonSchemas.js";
-import { compareSourceToBundleInputSchema } from "./domain/sourceToBundleComparisonSchemas.js";
-import { compareJavaScriptExportShapesInputSchema } from "./domain/javascriptExportShapeComparisonSchemas.js";
-import { projectInputIssues } from "./domain/inputIssueProjection.js";
-import { reconstructionObligationLedgerInputSchema } from "./domain/reconstructionObligationLedgerSchemas.js";
+import { compareApplicationVersionsEvidenceValidated, compareJavaScriptExportShapesEvidenceValidated, compareSourceToBundleEvidenceValidated, traceApplicationFeatureEvidenceValidated, } from "../application/JavaScriptApplicationWorkflowService.js";
+import { traceJavaScriptSemanticsEvidenceValidated } from "../application/JavaScriptSemanticTraceService.js";
+import { evaluateReconstructionCoverage, reconstructionCoverageEvaluationInputSchema, } from "../application/ReconstructionCoverageService.js";
+import { buildReconstructionObligationLedgerEvidenceValidated } from "../application/ReconstructionObligationLedgerService.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { parseCliJsonInput } from "../cliJsonInput.js";
+import { logCliCommand } from "../cliLogging.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import {} from "../domain/analysisErrorBase.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { traceApplicationFeatureInputSchema } from "../domain/javascriptFeatureTraceSchemas.js";
+import { traceJavaScriptSemanticsInputSchema } from "../domain/javascriptSemanticTraceSchemas.js";
+import { compareApplicationVersionsInputSchema } from "../domain/javascriptApplicationVersionComparisonSchemas.js";
+import { compareSourceToBundleInputSchema } from "../domain/sourceToBundleComparisonSchemas.js";
+import { compareJavaScriptExportShapesInputSchema } from "../domain/javascriptExportShapeComparisonSchemas.js";
+import { projectInputIssues } from "../domain/inputIssueProjection.js";
+import { reconstructionObligationLedgerInputSchema } from "../domain/reconstructionObligationLedgerSchemas.js";
 /** Register CLI equivalents of provider-neutral application graph workflows. */
 export const registerApplicationCommands = (cli, logger) => {
     registerJsonCommand({

package/dist/{cliBrowserAdvancedCommands.js → cli/browserAdvancedCommands.js}

@@ -1,14 +1,15 @@
 import { Cli, z } from "incur";
-import { browserContext, browserCliError } from "./cliBrowserContext.js";
-import { browserScopeOptions } from "./cliObservationOptions.js";
-import { captureWebScreenshot, compareWebCaptureEvidence, compareWebScreenshotEvidence, discoverWebMcpTools, } from "./application/BrowserObservationService.js";
-import { CdpBrowserProvider } from "./browser/CdpBrowserProvider.js";
-import { logCliCommand } from "./cliLogging.js";
-import { AnalysisInputError } from "./domain/errors.js";
-import { browserCaptureComparisonInputSchema } from "./domain/browserCaptureComparison.js";
-import { discoverWebMcpToolsInputSchema } from "./domain/webMcpDiscovery.js";
-import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, } from "./domain/webScreenshot.js";
-import { CLI_COMMANDS } from "./cliCommandNames.js";
+import { browserContext, browserCliError } from "../cliBrowserContext.js";
+import { browserScopeOptions } from "../cliObservationOptions.js";
+import { captureWebScreenshot, compareWebCaptureEvidence, compareWebScreenshotEvidence, discoverWebMcpTools, } from "../application/BrowserObservationService.js";
+import { CdpBrowserProvider } from "../browser/CdpBrowserProvider.js";
+import { logCliCommand } from "../cliLogging.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { browserCaptureComparisonInputSchema } from "../domain/browserCaptureComparison.js";
+import { discoverWebMcpToolsInputSchema } from "../domain/webMcpDiscovery.js";
+import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, } from "../domain/webScreenshot.js";
+import { safeParseJson } from "../domain/safeJson.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
 /** Register WebMCP, capture-diff, and screenshot CLI equivalents. */
 export const registerAdvancedBrowserCommands = (cli, logger) => {
     registerWebMcp(cli, logger);
@@ -135,11 +136,7 @@ const registerScreenshotDiff = (cli, logger) => {
     });
 };
 const parseJson = (value) => {
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return undefined;
-    }
+    const parsed = safeParseJson(value);
+    return parsed.ok ? parsed.value : undefined;
 };
 const inputError = (operation) => browserCliError(new AnalysisInputError(operation));

package/dist/{cliBrowserCommands.js → cli/browserCommands.js}

@@ -1,13 +1,13 @@
 import { Cli, z } from "incur";
-import { browserContext, browserCliError } from "./cliBrowserContext.js";
-import { analyzeWebBundle, inspectWebPage, listBrowserTargets, observeWebSession, } from "./application/BrowserObservationService.js";
-import { logCliCommand } from "./cliLogging.js";
-import { inspectWebPageInputSchema, listBrowserTargetsInputSchema, } from "./domain/browserObservation.js";
-import { analyzeWebBundleInputSchema } from "./domain/webBundleAnalysis.js";
-import { observeWebSessionInputSchema } from "./domain/browserSession.js";
-import { AnalysisInputError } from "./domain/errors.js";
-import { CLI_COMMANDS } from "./cliCommandNames.js";
-import { browserPageInspectionOptions, browserScopeOptions, observationDuration, } from "./cliObservationOptions.js";
+import { browserContext, browserCliError } from "../cliBrowserContext.js";
+import { analyzeWebBundle, inspectWebPage, listBrowserTargets, observeWebSession, } from "../application/BrowserObservationService.js";
+import { logCliCommand } from "../cliLogging.js";
+import { inspectWebPageInputSchema, listBrowserTargetsInputSchema, } from "../domain/browserObservation.js";
+import { analyzeWebBundleInputSchema } from "../domain/webBundleAnalysis.js";
+import { observeWebSessionInputSchema } from "../domain/browserSession.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { browserPageInspectionOptions, browserScopeOptions, observationDuration, } from "../cliObservationOptions.js";
 /** Register CLI equivalents of the passive browser MCP tools. */
 export const registerBrowserCommands = (cli, logger) => {
     registerTargetList(cli, logger);

package/dist/cli/commandCancellation.js

@@ -0,0 +1,24 @@
+/** Translate one-shot CLI interrupts into awaited cleanup and conventional exit codes. */
+export const withCommandCancellation = async (operation, host = process) => {
+    const controller = new AbortController();
+    let exitCode;
+    const interrupt = () => {
+        exitCode ??= 130;
+        controller.abort();
+    };
+    const terminate = () => {
+        exitCode ??= 143;
+        controller.abort();
+    };
+    host.on("SIGINT", interrupt);
+    host.on("SIGTERM", terminate);
+    try {
+        return await operation(controller.signal);
+    }
+    finally {
+        host.off("SIGINT", interrupt);
+        host.off("SIGTERM", terminate);
+        if (exitCode !== undefined)
+            host.exitCode = exitCode;
+    }
+};