rea-agents 1.6.0 → 2.0.0

package/dist/ghidra/protocol.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { err, ok } from "../domain/result.js";
+const responseSchema = z
+    .object({
+    id: z.number().int().positive(),
+    ok: z.boolean(),
+    result: jsonValueSchema.optional(),
+    error: z
+        .object({
+        code: z.string().min(1).max(128),
+        message: z.string().min(1).max(4_096),
+    })
+        .strict()
+        .optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.ok && value.result === undefined)
+        context.addIssue({
+            code: "custom",
+            path: ["result"],
+            message: "Successful Ghidra response requires a result",
+        });
+    if (!value.ok && value.error === undefined)
+        context.addIssue({
+            code: "custom",
+            path: ["error"],
+            message: "Failed Ghidra response requires an error",
+        });
+    if (!value.ok && value.result !== undefined)
+        context.addIssue({
+            code: "custom",
+            path: ["result"],
+            message: "Failed Ghidra response cannot include a result",
+        });
+    if (value.ok && value.error !== undefined)
+        context.addIssue({
+            code: "custom",
+            path: ["error"],
+            message: "Successful Ghidra response cannot include an error",
+        });
+});
+/** Expected operation failure returned by the authenticated Java bridge. */
+export class GhidraRemoteError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "GhidraRemoteError";
+    }
+}
+/** Parse one complete Java-bridge response without accepting extra fields. */
+export const parseGhidraResponseLine = (line) => {
+    try {
+        const parsed = JSON.parse(line);
+        const response = responseSchema.safeParse(parsed);
+        return response.success
+            ? ok(response.data)
+            : err(new Error("Ghidra bridge response has an invalid shape"));
+    }
+    catch (cause) {
+        return err(new Error("Ghidra bridge response is not valid JSON", { cause }));
+    }
+};
+/** Project one validated response into its result or remote failure. */
+export const ghidraResponseResult = (response) => response.ok
+    ? ok(response.result ?? null)
+    : err(new GhidraRemoteError(response.error?.code ?? "bridge_error", response.error?.message ?? "Ghidra bridge request failed"));

package/dist/hopper/BridgeLauncher.js

@@ -1,11 +1,12 @@
-import { spawn } from "node:child_process";
 import { execFile } from "node:child_process";
 import { chmod, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join } from "node:path";
 import { promisify } from "node:util";
 import { HopperCancelledError, HopperStartError } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
-import { cleanupOwnedProcessGroup, } from "../application/ProcessOwnership.js";
+import { cleanupOwnedProcessGroup } from "../process/ProcessOwnership.js";
+import { spawnOwnedProviderProcess, } from "../process/ProviderProcess.js";
+import { waitForAbortableDelay } from "../process/ProviderDeadline.js";
 import writeFileAtomic from "write-file-atomic";
 const execFileAsync = promisify(execFile);
 const HOPPER_BACKGROUND_STARTUP_MS = 5_000;
@@ -64,13 +65,14 @@ export class HopperApplicationLauncher {
                 return err(new HopperCancelledError());
             const linuxDemo = linuxDemoLaunch(this.options, session, args);
             const ownershipCommand = linuxDemo?.ownershipCommand ?? this.options.launcherPath;
-            const started = await spawnLauncher(linuxDemo?.command ?? this.options.launcherPath, linuxDemo?.args ?? args, session.runId);
-            if (!started.ok)
-                return started;
-            const child = started.value;
-            const pid = child.pid;
-            if (pid === undefined)
-                return err(new HopperStartError({ cause: new Error("missing launcher PID") }));
+            const started = await spawnOwnedProviderProcess({
+                command: linuxDemo?.command ?? this.options.launcherPath,
+                arguments: linuxDemo?.args ?? args,
+                runId: session.runId,
+                expectedCommand: ownershipCommand,
+            });
+            const child = started.process;
+            const pid = started.ownership.leaderPid;
             const ownership = {
                 schema_version: 1,
                 run_id: session.runId,
@@ -84,18 +86,18 @@ export class HopperApplicationLauncher {
                 await writeFileAtomic(join(session.directory, "ownership.json"), `${JSON.stringify(ownership)}\n`, { encoding: "utf8", mode: 0o600 });
             }
             catch (cause) {
-                await cleanupOwnedProcessGroup(ownedProcessGroup(session, pid, ownershipCommand));
+                await cleanupOwnedProcessGroup(started.ownership);
                 return err(new HopperStartError({ cause }));
             }
             return ok({
                 process: child,
                 ownsProcessLifetime: true,
                 shutdownByCleanup: ownsProcessLifetime,
-                cleanup: () => cleanupOwnedProcessGroup(ownedProcessGroup(session, pid, ownershipCommand)),
+                cleanup: () => cleanupOwnedProcessGroup(started.ownership),
             });
         }
         catch (cause) {
-            return err(new HopperStartError({ cause }));
+            return err(hopperLaunchFailure(cause, options.signal));
         }
     }
 }
@@ -117,34 +119,11 @@ const linuxDemoLaunch = (options, session, hopperArgs) => {
         ],
     };
 };
+const hopperLaunchFailure = (cause, signal) => signal?.aborted === true
+    ? new HopperCancelledError()
+    : new HopperStartError({ cause });
 /** Select the version-pinned adapter from the caller's explicit launch mode. */
 export const usesLinuxDemo = (options) => options.launchMode === "verified_linux_demo";
-const spawnLauncher = async (command, args, runId) => {
-    const child = spawn(command, args, {
-        stdio: ["ignore", "ignore", "pipe"],
-        detached: process.platform !== "win32",
-        env: { ...process.env, REA_PROCESS_RUN_ID: runId },
-    });
-    return new Promise((resolve) => {
-        const onSpawn = () => {
-            child.off("error", onError);
-            resolve(ok(child));
-        };
-        const onError = (cause) => {
-            child.off("spawn", onSpawn);
-            resolve(err(new HopperStartError({ cause })));
-        };
-        child.once("spawn", onSpawn);
-        child.once("error", onError);
-    });
-};
-const ownedProcessGroup = (session, pid, launcherPath) => ({
-    runId: session.runId,
-    leaderPid: pid,
-    processGroupId: pid,
-    expectedCommand: launcherPath,
-    expectedParentPid: process.pid,
-});
 const prepareHopperApplication = async (launcherPath, signal) => {
     const appBundle = hopperApplicationBundle(launcherPath);
     if (appBundle === undefined)
@@ -160,22 +139,8 @@ const prepareHopperApplication = async (launcherPath, signal) => {
         "-a",
         appBundle,
     ]);
-    return waitForDelay(HOPPER_BACKGROUND_STARTUP_MS, signal);
-};
-const waitForDelay = (milliseconds, signal) => {
-    if (signal?.aborted === true)
-        return Promise.resolve(false);
-    return new Promise((resolve) => {
-        const timer = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve(true);
-        }, milliseconds);
-        const onAbort = () => {
-            clearTimeout(timer);
-            resolve(false);
-        };
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
+    return ((await waitForAbortableDelay(HOPPER_BACKGROUND_STARTUP_MS, signal)) ===
+        "elapsed");
 };
 const hopperApplicationBundle = (launcherPath) => {
     if (basename(launcherPath) !== "hopper")

package/dist/hopper/HopperAnalysisProfile.js

@@ -0,0 +1,106 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { createAnalysisProfile } from "../domain/analysisProfile.js";
+import { AnalysisCancelledError, ProviderAdapterError, } from "../domain/errors.js";
+import { err, ok } from "../domain/result.js";
+/** Resolve Hopper open semantics without placing its CLI flags in BinaryTarget. */
+export const resolveHopperAnalysisProfile = async (target, options) => {
+    if (target.kind !== "executable" && target.kind !== "database")
+        return ok({ profile: null, compatibility: {} });
+    const derived = hopperLoaderArgsForTarget(target);
+    if (!derived.ok)
+        return derived;
+    const loaderArgs = options.loaderArgsOverride.length === 0
+        ? derived.value
+        : [...options.loaderArgsOverride];
+    const compatibility = { loaderArgs: [...loaderArgs] };
+    const launcherDigest = await sha256File(options.launcherPath, options.signal);
+    if (!launcherDigest.ok)
+        return launcherDigest;
+    if (launcherDigest.value === undefined)
+        return ok({ profile: null, compatibility });
+    const provider = {
+        id: options.provider.id,
+        name: options.provider.name,
+        version: `launcher-sha256:${launcherDigest.value}`,
+    };
+    return ok({
+        profile: createAnalysisProfile(provider, 1, {
+            target_kind: target.kind,
+            target_format: target.format,
+            architecture: target.architecture ?? null,
+            available_architectures: [
+                ...(target.availableArchitectures ?? []),
+            ].sort(),
+            loader: {
+                source: options.loaderArgsOverride.length === 0
+                    ? "derived"
+                    : "configured_override",
+                argument_count: loaderArgs.length,
+                arguments_sha256: createHash("sha256")
+                    .update(JSON.stringify(loaderArgs))
+                    .digest("hex"),
+            },
+        }),
+        compatibility,
+    });
+};
+/** Derive Hopper's complete non-interactive CLI loader selection. */
+export const hopperLoaderArgsForTarget = (target) => {
+    if (target.kind === "database")
+        return ok([]);
+    const architecture = target.architecture;
+    if (architecture === undefined)
+        return err(new ProviderAdapterError("hopper", "resolve_analysis_profile"));
+    const flag = hopperArchitectureFlag(architecture);
+    switch (target.format) {
+        case "mach-o":
+            return ok((target.availableArchitectures?.length ?? 0) > 1
+                ? ["-l", "FAT", flag, "-l", "Mach-O"]
+                : ["-l", "Mach-O", flag]);
+        case "elf":
+            return ok(["-l", "ELF", flag]);
+        case "pe":
+            return ok(["-l", "WinPE", flag]);
+        default:
+            return err(new ProviderAdapterError("hopper", "resolve_analysis_profile"));
+    }
+};
+const hopperArchitectureFlag = (architecture) => {
+    switch (architecture) {
+        case "x86":
+            return "--intel-32";
+        case "x86_64":
+            return "--intel-64";
+        case "arm":
+            return "--armv7";
+        case "arm64":
+            return "--aarch64";
+    }
+};
+const sha256File = async (path, signal) => {
+    if (signalIsAborted(signal))
+        return err(new AnalysisCancelledError("open_binary"));
+    const stream = createReadStream(path);
+    const onAbort = () => {
+        stream.destroy();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+        const hash = createHash("sha256");
+        for await (const chunk of stream)
+            hash.update(chunk);
+        return signalIsAborted(signal)
+            ? err(new AnalysisCancelledError("open_binary"))
+            : ok(hash.digest("hex"));
+    }
+    catch {
+        return signalIsAborted(signal)
+            ? err(new AnalysisCancelledError("open_binary"))
+            : ok(undefined);
+    }
+    finally {
+        signal?.removeEventListener("abort", onAbort);
+    }
+};
+const signalIsAborted = (signal) => signal?.aborted === true;