rea-agents 6.2.0 → 6.3.0

package/dist/ghidra/GhidraLauncher.js

@@ -12,9 +12,16 @@ import { ghidraJavaLaunch } from "./GhidraJavaLaunch.js";
 import { snapshotGhidraExtensions, } from "./extensions/GhidraExtensions.js";
 /** Local launch failure retained as the cause of a provider-neutral error. */
 export class GhidraLaunchError extends Error {
+    #partialLaunch;
     constructor(message, options) {
-        super(message, options);
+        const { partialLaunch, ...errorOptions } = options ?? {};
+        super(message, errorOptions);
         this.name = "GhidraLaunchError";
+        this.#partialLaunch = partialLaunch;
+    }
+    /** Process ownership retained for the client to retry an incomplete rollback. */
+    get partialLaunch() {
+        return this.#partialLaunch;
     }
 }
 /** Launch Ghidra without copying scripts into or modifying its installation. */
@@ -89,7 +96,7 @@ export class GhidraHeadlessLauncher {
                         : { signal: options.signal }),
                 })
                 : { ...scriptCommand, environment };
-            started = await spawnOwnedProviderProcess({
+            started = await (this.options.spawnProcess ?? spawnOwnedProviderProcess)({
                 command: command.command,
                 arguments: command.arguments,
                 runId: session.runId,
@@ -102,6 +109,7 @@ export class GhidraHeadlessLauncher {
                 hostEnvironment: {},
                 ...(options.signal === undefined ? {} : { signal: options.signal }),
             });
+            const partialLaunch = ownedGhidraLaunch(started, paths, platform);
             await writeGhidraRuntimeFile(paths.ownershipPath, `${JSON.stringify({
                 run_id: session.runId,
                 transport: session.transport,
@@ -115,29 +123,45 @@ export class GhidraHeadlessLauncher {
                 created_at: new Date().toISOString(),
             })}\n`, platform);
             if (isAborted(options.signal)) {
-                await cleanupStartedProcess(started, platform);
-                return err(new AnalysisCancelledError("open_binary"));
+                throw new AnalysisCancelledError("open_binary");
             }
-            const spawned = started;
-            return ok({
-                ...ownedGhidraProcess(spawned, platform),
-                projectRoot: paths.projectRoot,
-                ghidraLogPath: paths.ghidraLogPath,
-                scriptLogPath: paths.scriptLogPath,
-            });
+            return ok(partialLaunch);
         }
         catch (cause) {
-            if (started !== undefined)
-                await cleanupStartedProcess(started, platform).catch((cause) => {
-                    // best-effort cleanup: started-process cleanup must not mask the launch failure.
-                    void cause;
-                });
-            return isAborted(options.signal)
-                ? err(new AnalysisCancelledError("open_binary"))
-                : err(new GhidraLaunchError("Ghidra headless launch failed", { cause }));
+            const primary = isAborted(options.signal)
+                ? new AnalysisCancelledError("open_binary", { cause })
+                : new GhidraLaunchError("Ghidra headless launch failed", { cause });
+            if (started === undefined)
+                return err(primary);
+            let cleanupFailure;
+            try {
+                const cleanup = await cleanupStartedProcess(started, platform);
+                if (!cleanup.cleaned)
+                    cleanupFailure = new Error(`Ghidra process cleanup was incomplete: ${cleanup.reason}`);
+            }
+            catch (failure) {
+                cleanupFailure = failure;
+            }
+            if (cleanupFailure !== undefined) {
+                const partialLaunch = ownedGhidraLaunch(started, paths, platform);
+                const primaryMessage = isAborted(options.signal)
+                    ? primary.message
+                    : `Ghidra headless launch failed: ${cause instanceof Error ? cause.message : String(cause)}`;
+                return err(new GhidraLaunchError(`${primaryMessage}; process cleanup remains incomplete`, {
+                    cause: new AggregateError([primary, cleanupFailure], "Ghidra launch rollback did not release its process", { cause: primary }),
+                    partialLaunch,
+                }));
+            }
+            return err(primary);
         }
     }
 }
+const ownedGhidraLaunch = (spawned, paths, platform) => ({
+    ...ownedGhidraProcess(spawned, platform),
+    projectRoot: paths.projectRoot,
+    ghidraLogPath: paths.ghidraLogPath,
+    scriptLogPath: paths.scriptLogPath,
+});
 const ownedGhidraProcess = (spawned, platform) => ({
     process: spawned.process,
     ownsProcessLifetime: true,

package/dist/hopper/HopperCleanup.js

@@ -160,7 +160,7 @@ const stopProcess = async (input, state) => {
     }
     input.logger.info(diagnostic, "Owned Hopper launcher shutdown completed");
     if (stopped.status !== "incomplete") {
-        if (input.resources.launch?.shutdownMode === "process-cleanup" &&
+        if (input.resources.launch?.providerLifetime === "launcher-process" &&
             stopped.status !== "not-owned")
             input.resources.shutdownConfirmed = true;
         state.processStopped = true;

package/dist/ida/IdaOperationRunner.js

@@ -288,6 +288,8 @@ export class IdaOperationRunner {
             referenced_strings: [],
             referenced_names: [],
             basic_blocks: [],
+            native_api: null,
+            native_value_flow: null,
             limitations: [
                 ...IDA_LIMITATIONS,
                 ...this.limitations,

package/dist/ida/IdaSessionClient.js

@@ -101,8 +101,10 @@ export class IdaSessionClient {
         }
         const document = parameters.document;
         if (document !== undefined &&
-            document !== this.target.path &&
-            document !== this.target.sourcePath)
+            (typeof document !== "string" ||
+                (!sameIdaHostPath(document, this.target.path) &&
+                    (this.target.sourcePath === undefined ||
+                        !sameIdaHostPath(document, this.target.sourcePath)))))
             return err(new AnalysisInputError(operation, undefined, [
                 {
                     path: ["document"],

package/dist/inspector/JavaScriptRuntimeScope.js

@@ -21,11 +21,6 @@ export const inspectorExclusionKey = (reason) => {
 /** Resolve a protocol location exposed by the explicitly selected Inspector endpoint. */
 export const authorizeRuntimeLocation = async (value, signal) => {
     throwIfRuntimeObservationCancelled(signal);
-    if (value.startsWith("node:") && value.length > 0)
-        return {
-            allowed: true,
-            location: { kind: "builtin", specifier: value },
-        };
     if (value.startsWith("file:")) {
         const filePath = await authorizedElectronFile(value);
         throwIfRuntimeObservationCancelled(signal);
@@ -33,6 +28,15 @@ export const authorizeRuntimeLocation = async (value, signal) => {
             ? { allowed: false, reason: "not_approved" }
             : { allowed: true, location: { kind: "file", file_path: filePath } };
     }
+    return projectReportedRuntimeUrl(value);
+};
+/** Project non-file Inspector URLs without filesystem access. */
+export const projectReportedRuntimeUrl = (value) => {
+    if (value.startsWith("node:") && value.length > 0)
+        return {
+            allowed: true,
+            location: { kind: "builtin", specifier: value },
+        };
     let url;
     try {
         url = new URL(value);

package/dist/inspector/V8InspectorCaptureProjection.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { authorizeRuntimeLocation, inspectorExclusionKey, throwIfRuntimeObservationCancelled, } from "./JavaScriptRuntimeScope.js";
+import { authorizeRuntimeLocation, inspectorExclusionKey, projectReportedRuntimeUrl, throwIfRuntimeObservationCancelled, } from "./JavaScriptRuntimeScope.js";
 /** Empty durable-location exclusion counters. */
 export const createInspectorExclusionCounts = () => ({
     unsupported_location: 0,
@@ -15,26 +15,29 @@ export const describeInspectorTargetLimitations = () => [
 ];
 const LOCATION_AUTHORIZATION_WORKERS = 8;
 /** Canonically authorize, deduplicate, and sort one bounded raw capture. */
-export const finalizeInspectorCapture = async ({ input, runtime, target, state, authorizeLocation = authorizeRuntimeLocation, signal, }) => {
-    throwIfRuntimeObservationCancelled(signal);
+export const finalizeInspectorCapture = async ({ input, runtime, target, state, authorizeLocation = authorizeRuntimeLocation, locationMode = "verify", signal, }) => {
+    if (locationMode === "verify")
+        throwIfRuntimeObservationCancelled(signal);
     const exclusions = createInspectorExclusionCounts();
     const scripts = new Map();
     const draftsByUrl = new Map();
-    for (const draft of state.scripts) {
-        const drafts = draftsByUrl.get(draft.rawUrl) ?? [];
-        drafts.push(draft);
-        draftsByUrl.set(draft.rawUrl, drafts);
-    }
+    if (locationMode === "verify")
+        for (const draft of state.scripts) {
+            const drafts = draftsByUrl.get(draft.rawUrl) ?? [];
+            drafts.push(draft);
+            draftsByUrl.set(draft.rawUrl, drafts);
+        }
     const groups = [...draftsByUrl];
     const authorizedGroups = new Array(groups.length);
     let nextGroup = 0;
     let stopScheduling = false;
+    let unresolvedScripts = 0;
     const worker = async () => {
         try {
             for (;;) {
-                throwIfRuntimeObservationCancelled(signal);
                 if (stopScheduling)
                     return;
+                throwIfRuntimeObservationCancelled(signal);
                 const index = nextGroup;
                 nextGroup += 1;
                 const group = groups[index];
@@ -53,12 +56,18 @@ export const finalizeInspectorCapture = async ({ input, runtime, target, state,
             throw cause;
         }
     };
-    const workerResults = await Promise.allSettled(Array.from({ length: Math.min(LOCATION_AUTHORIZATION_WORKERS, groups.length) }, worker));
+    const workerResults = locationMode === "verify"
+        ? await Promise.allSettled(Array.from({ length: Math.min(LOCATION_AUTHORIZATION_WORKERS, groups.length) }, worker))
+        : [];
     const failedWorker = workerResults.find((result) => result.status === "rejected");
-    throwIfRuntimeObservationCancelled(signal);
+    if (locationMode === "verify")
+        throwIfRuntimeObservationCancelled(signal);
     if (failedWorker?.status === "rejected")
         throw failedWorker.reason;
-    for (const { drafts, decision } of authorizedGroups) {
+    for (const group of authorizedGroups) {
+        if (group === undefined)
+            continue;
+        const { drafts, decision } = group;
         for (const draft of drafts) {
             if (!decision.allowed) {
                 exclusions[inspectorExclusionKey(decision.reason)] += 1;
@@ -68,6 +77,14 @@ export const finalizeInspectorCapture = async ({ input, runtime, target, state,
             scripts.set(script.script_key, script);
         }
     }
+    if (locationMode === "reported")
+        for (const draft of state.scripts) {
+            const location = partialScriptLocation(draft.rawUrl);
+            if (location.kind === "unresolved")
+                unresolvedScripts += 1;
+            const script = scriptFromDraft(draft, location);
+            scripts.set(script.script_key, script);
+        }
     const items = [...scripts.values()].sort((left, right) => left.script_key < right.script_key
         ? -1
         : left.script_key > right.script_key
@@ -85,7 +102,8 @@ export const finalizeInspectorCapture = async ({ input, runtime, target, state,
         : left.context_key > right.context_key
             ? 1
             : 0);
-    throwIfRuntimeObservationCancelled(signal);
+    if (locationMode === "verify")
+        throwIfRuntimeObservationCancelled(signal);
     return {
         runtime,
         target: {
@@ -132,6 +150,11 @@ export const finalizeInspectorCapture = async ({ input, runtime, target, state,
                     "The discovery-reported file location cannot be verified; loaded script locations are resolved independently from Debugger.scriptParsed.",
                 ]
                 : []),
+            ...(unresolvedScripts === 0
+                ? []
+                : [
+                    `${String(unresolvedScripts)} observed script location${unresolvedScripts === 1 ? " remains" : "s remain"} unverified; raw URLs and script metadata are retained.`,
+                ]),
             "Scripts collected before attachment may have been garbage-collected and therefore omitted.",
             "A bounded observation window cannot establish that an unobserved script or behavior never occurs.",
             "The declared Node/Electron process role is not authenticated by the Inspector protocol.",
@@ -157,3 +180,13 @@ const scriptFromDraft = (draft, location) => {
         status: "observed-loaded",
     };
 };
+const partialScriptLocation = (reportedUrl) => {
+    const projection = projectReportedRuntimeUrl(reportedUrl);
+    if (projection.allowed)
+        return projection.location;
+    return {
+        kind: "unresolved",
+        reported_url: reportedUrl,
+        reason: "location-authorization-not-attempted",
+    };
+};

package/dist/inspector/V8InspectorProvider.js

@@ -54,19 +54,30 @@ export class V8InspectorProvider {
     }
     async observe(input, options = {}) {
         let connection;
+        let discovery;
+        let target;
+        let state;
         let primaryFailure;
         let failed = false;
         let cleanupFailure;
         let cleanupFailed = false;
+        let connectionClosePromise;
         let outcome;
+        const closeConnection = () => {
+            if (connection === undefined)
+                return Promise.resolve();
+            connectionClosePromise ??= closeInspectorConnection(connection, options.signal);
+            return connectionClosePromise;
+        };
         try {
-            const discovery = await discoverV8Inspector(input.inspector_endpoint, "observe_javascript_runtime", options.signal);
-            const target = await authorizedTarget(discovery.targets, input, discovery.runtime.product);
+            discovery = await discoverV8Inspector(input.inspector_endpoint, "observe_javascript_runtime", options.signal);
+            target = await authorizedTarget(discovery.targets, input, discovery.runtime.product);
             if (input.runtime_kind !== undefined)
                 assertRuntimeKind(target, input.runtime_kind);
             connection = await CdpConnection.connect(target.webSocketUrl, "observe_javascript_runtime", options.signal, { maxPayloadBytes: INSPECTOR_MAX_PAYLOAD_BYTES });
-            const state = emptyCaptureState();
-            const removeListener = connection.onEvent((event) => ingestEvent(event, state));
+            const captureState = emptyCaptureState();
+            state = captureState;
+            const removeListener = connection.onEvent((event) => ingestEvent(event, captureState));
             try {
                 await connection.send("Runtime.enable", {}, undefined, options.signal);
                 await connection.send("Debugger.enable", {}, undefined, options.signal);
@@ -79,7 +90,7 @@ export class V8InspectorProvider {
                 input,
                 runtime: discovery.runtime,
                 target,
-                state,
+                state: captureState,
                 ...(options.signal === undefined ? {} : { signal: options.signal }),
             });
             outcome = ok(javascriptRuntimeObservationSchema.parse(result));
@@ -87,12 +98,53 @@ export class V8InspectorProvider {
         catch (cause) {
             failed = true;
             primaryFailure = cause;
-            outcome = err(providerError(cause, "observe_javascript_runtime"));
+            let error = providerError(cause, "observe_javascript_runtime");
+            if (state !== undefined &&
+                discovery !== undefined &&
+                target !== undefined &&
+                (cause instanceof BrowserObservationError ||
+                    options.signal?.aborted === true)) {
+                const reason = options.signal?.aborted === true
+                    ? "cancelled"
+                    : cause instanceof BrowserObservationError
+                        ? cause.reason
+                        : "protocol_error";
+                try {
+                    await closeConnection();
+                }
+                catch (cause) {
+                    cleanupFailed = true;
+                    cleanupFailure = cause;
+                }
+                try {
+                    const partialObservation = await finalizeInspectorCapture({
+                        input,
+                        runtime: discovery.runtime,
+                        target,
+                        state,
+                        locationMode: "reported",
+                    });
+                    error = new BrowserObservationError("observe_javascript_runtime", reason, {
+                        cause: error,
+                        ...(error.userMessage === undefined
+                            ? {}
+                            : { detail: error.userMessage }),
+                        partialObservation,
+                    });
+                }
+                catch (projectionFailure) {
+                    error = new BrowserObservationError("observe_javascript_runtime", reason, {
+                        cause: new AggregateError([error, projectionFailure], "Inspector failure and partial-observation projection both failed"),
+                        detail: `${error.message} Partial observations could not be projected.`,
+                    });
+                }
+            }
+            outcome = err(error);
         }
         finally {
             if (connection !== undefined)
                 try {
-                    await closeInspectorConnection(connection, options.signal);
+                    await closeConnection();
                 }
                 catch (cause) {
                     cleanupFailed = true;
@@ -212,7 +264,7 @@ const ingestScript = (event, state) => {
     state.scriptsObserved += 1;
     const value = recordValue(event.params);
     const rawUrl = cdpStringValue(value?.url);
-    if (rawUrl === undefined || rawUrl === "") {
+    if (rawUrl === undefined) {
         state.invalidScripts += 1;
         retainEvent(state, 0);
         return;

package/dist/main/shutdown.js

@@ -3,24 +3,51 @@ import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { MCP_SHUTDOWN_FAILED } from "./messages.js";
 export const createShutdown = (input) => {
     const { handle, session, dependencies, serverLogger } = input;
-    let shutdownPromise;
+    let shutdownAttempt;
+    const cleanupOwners = [
+        { close: () => handle.close(), closed: false },
+        ...(input.closeAndroid === undefined
+            ? []
+            : [{ close: input.closeAndroid, closed: false }]),
+        {
+            close: async () => {
+                const closed = await session.close({ retainProviderDocuments: true });
+                if (!closed.ok)
+                    throw closed.error;
+            },
+            closed: false,
+        },
+    ];
+    let shutdownUnregistered = false;
     let unregisterShutdown = () => undefined;
     const shutdown = async () => {
-        shutdownPromise ??= (async () => {
-            unregisterShutdown();
-            const results = await Promise.allSettled([
-                handle.close(),
-                input.closeAndroid?.(),
-                session.close({ retainProviderDocuments: true }).then((closed) => {
-                    if (!closed.ok)
-                        throw closed.error;
-                }),
-            ]);
+        if (shutdownAttempt !== undefined)
+            return shutdownAttempt;
+        const pending = cleanupOwners.filter(({ closed }) => !closed);
+        const attempt = (async () => {
+            const results = await Promise.allSettled(pending.map(async (owner) => {
+                await owner.close();
+                owner.closed = true;
+            }));
+            const failures = [];
             for (const result of results)
                 if (result.status === "rejected")
-                    throw result.reason;
+                    failures.push(result.reason);
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1)
+                throw new AggregateError(failures, "Multiple MCP cleanup operations failed");
+            if (!shutdownUnregistered) {
+                unregisterShutdown();
+                shutdownUnregistered = true;
+            }
         })();
-        return shutdownPromise;
+        shutdownAttempt = attempt;
+        void attempt.catch(() => {
+            if (shutdownAttempt === attempt)
+                shutdownAttempt = undefined;
+        });
+        return attempt;
     };
     const requestShutdown = () => {
         shutdown().catch((cause) => {
@@ -35,24 +62,41 @@ export const createShutdown = (input) => {
     unregisterShutdown = dependencies.registerShutdown(requestShutdown);
     return { shutdown, request: requestShutdown };
 };
-const describeShutdownFailure = (cause) => {
-    if (cause instanceof AnalysisError)
-        return { analysis_error: projectAnalysisError(cause) };
-    if (cause instanceof Error) {
-        const code = "code" in cause ? cause.code : undefined;
-        return {
-            name: cause.name,
-            message: cause.message,
-            ...(typeof code === "string" ||
-                (typeof code === "number" && Number.isFinite(code))
-                ? { code }
-                : {}),
-        };
+const describeShutdownFailure = (cause) => describeShutdownFailureNode(cause, new WeakSet());
+const describeShutdownFailureNode = (cause, active) => {
+    if (typeof cause === "object" && cause !== null) {
+        if (active.has(cause))
+            return { type: "cyclic_error" };
+        active.add(cause);
+    }
+    try {
+        if (cause instanceof AnalysisError)
+            return { analysis_error: projectAnalysisError(cause) };
+        if (cause instanceof Error) {
+            const code = "code" in cause ? cause.code : undefined;
+            return {
+                name: cause.name,
+                message: cause.message,
+                ...(typeof code === "string" ||
+                    (typeof code === "number" && Number.isFinite(code))
+                    ? { code }
+                    : {}),
+                ...(cause instanceof AggregateError
+                    ? {
+                        errors: cause.errors.map((error) => describeShutdownFailureNode(error, active)),
+                    }
+                    : {}),
+            };
+        }
+        if (cause === null ||
+            typeof cause === "string" ||
+            typeof cause === "boolean" ||
+            (typeof cause === "number" && Number.isFinite(cause)))
+            return { type: cause === null ? "null" : typeof cause, value: cause };
+        return { type: typeof cause };
+    }
+    finally {
+        if (typeof cause === "object" && cause !== null)
+            active.delete(cause);
     }
-    if (cause === null ||
-        typeof cause === "string" ||
-        typeof cause === "boolean" ||
-        (typeof cause === "number" && Number.isFinite(cause)))
-        return { type: cause === null ? "null" : typeof cause, value: cause };
-    return { type: typeof cause };
 };

package/dist/main/transport.js

@@ -29,7 +29,7 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
             // The SDK can discard a discovery probe and construct a replacement server.
             const android = createAndroidAnalysisProvider(serverContext.environment);
             androidProviders.push(android);
-            return (dependencies.createServer ?? createServer)(session, session, {
+            return (dependencies.createServer ?? createServer)({ kind: "session", session }, {
                 logger: serverContext.logger,
                 environment: serverContext.environment,
                 delivery: serverContext.delivery,

package/dist/native/AppleObjcDispatchFacets.js

@@ -146,7 +146,7 @@ export const decodeObjcDispatchFacets = (input) => {
         if (superclass.name === null && superclass.address === null && !root)
             failures.push(`Superclass of ${name} requires external binding resolution`);
         const ivarList = read.pointer(ro + 48n);
-        let ivarCount = 0;
+        let ivarCount = meta ? null : 0;
         if (ivarList !== 0n && !meta) {
             const stride = read.u32(ivarList), count = read.u32(ivarList + 4n);
             if (stride !== 32)
@@ -198,8 +198,8 @@ export const decodeObjcDispatchFacets = (input) => {
                         BigInt(Number.MAX_SAFE_INTEGER)
                     ? Number(BigInt(item.implementation_address))
                     : null,
-                is_required: false,
-                is_optional: false,
+                is_required: null,
+                is_optional: null,
             })),
             properties: readObjcPropertiesOf(read, read.pointer(ro + 64n), {
                 owner: name,

package/dist/native/AppleObjcProperties.js

@@ -5,19 +5,29 @@ import { issue } from "./AppleDispatchDecodeFacts.js";
  */
 export const parsePropertyAttributes = (name, attributes) => {
     const tokens = attributes.length === 0 ? [] : splitAttributes(attributes);
-    const value = (code) => tokens.find((token) => token.startsWith(code))?.slice(1) ?? null;
+    const typeAttributes = tokens.filter((token) => token[0] === "T");
+    const typeAttribute = typeAttributes.length === 1 ? typeAttributes[0] : undefined;
+    const typeEncoding = typeAttribute !== undefined && typeAttribute.length > 1
+        ? typeAttribute.slice(1)
+        : null;
+    const value = (code) => tokens.find((token) => token[0] === code)?.slice(1) ?? null;
     return {
         name,
-        type_encoding: value("T"),
+        type_encoding: typeEncoding,
         attributes: tokens.map((token) => ({
             name: token.slice(0, 1),
             value: token.slice(1),
-            is_weak: token === "W",
-            is_atomic: false,
-            is_copy: token === "C",
-            is_strong: token === "&",
         })),
-        is_readonly: tokens.includes("R"),
+        atomicity: tokens.includes("N")
+            ? "nonatomic"
+            : typeEncoding === null
+                ? null
+                : "atomic",
+        is_readonly: tokens.includes("R")
+            ? true
+            : typeEncoding === null
+                ? null
+                : false,
         getter: value("G"),
         setter: value("S"),
     };