Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(ghidra): recover stale clients on same-target reopen (#2014)
lyly4573e8cf35de
diff --git a/src/adb/AdbProvider.test.ts b/src/adb/AdbProvider.test.tsindex f9fb6f520..4d6c13001 100644--- a/src/adb/AdbProvider.test.ts+++ b/src/adb/AdbProvider.test.ts@@ -495,7 +495,7 @@ it("reads a bounded logcat dump with the caller count and buffer", async () => {const { binary } = await writeAdbStub(shellStub({logcat:- "08-10 13:00:00.000 I/Tag( 123): first\\n08-10 13:00:01.000 I/Tag( 123): second\\n",+ "08-10 13:00:00.000 I/Tag( 123): first\n08-10 13:00:01.000 I/Tag( 123): second\n",}),);const result = await evidenceResult(providerOver(binary), {@@ -903,7 +903,7 @@ it("resolves packages by case-insensitive substring", async () => {const { binary } = await writeAdbStub(shellStub({"pm:list":- "package:/data/app/x/base.apk=com.whatsapp\\npackage:/data/app/y/base.apk=com.whatsapp.w4b\\npackage:/data/app/z/base.apk=com.example\\n",+ "package:/data/app/x/base.apk=com.whatsapp\npackage:/data/app/y/base.apk=com.whatsapp.w4b\npackage:/data/app/z/base.apk=com.example\n",}),);const result = await evidenceResult(providerOver(binary), {@@ -1109,20 +1109,23 @@ exit 1`,it("quotes caller text before adb joins the remote shell command", async () => {const { binary, root } = await writeAdbStub(- (root) => `if [ "$1" = "version" ]; then ${VERSION_BLOCK}; exit 0; fi+ () => `if [ "$1" = "version" ]; then ${VERSION_BLOCK}; exit 0; fishift 3# Model adb's remote command joining, then execute the resulting shell string.-printf '#!/bin/sh\nprintf "%%s" "$@" > "${join(root, "observed")}"\n' > "${join(root, "ls")}"-chmod +x "${join(root, "ls")}"-PATH="${root}:$PATH" sh -c "$*"+sh -c "$*"`,);- const value = `/sdcard/a 'quoted'; touch ${join(root, "injected")}`;- await providerOver(binary).execute({+ const value = join(root, `device 'quoted'; touch ${join(root, "injected")}`);+ await mkdir(value, { recursive: true });+ const result = await evidenceResult(providerOver(binary), {operation: "list_adb_directory",input: { serial: "device", device_path: value },});- expect(await readFile(join(root, "observed"), "utf8")).toContain(value);+ expect(result).toMatchObject({+ device_path: value,+ entries: [],+ coverage: "complete",+ });await expect(readFile(join(root, "injected"))).rejects.toThrow();});diff --git a/src/cli/webModuleCommands.ts b/src/cli/webModuleCommands.tsindex b14f23da5..0e58ea804 100644--- a/src/cli/webModuleCommands.ts+++ b/src/cli/webModuleCommands.ts@@ -32,13 +32,13 @@ export const registerWebModuleCommands = (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",- )- .optional(),+ ),importMapBaseUrl: importMapInputSchema.shape.base_url- .describe("HTTP(S) import-map base URL; requires --import-map-path")- .optional(),+ .optional()+ .describe("HTTP(S) import-map base URL; requires --import-map-path"),}),run: ({ args, options }) =>withCommandCancellation(async (signal) => {diff --git a/src/ghidra/GhidraClient.ts b/src/ghidra/GhidraClient.tsindex f2ccd381d..7731cf872 100644--- a/src/ghidra/GhidraClient.ts+++ b/src/ghidra/GhidraClient.ts@@ -7,6 +7,10 @@ import type { ProgressReporter } from "../application/ProgressReporter.js";import { AnalysisError } from "../domain/analysisErrorBase.js";import type { JsonValue } from "../domain/jsonValue.js";import { ProviderCleanupError } from "../domain/providerCleanupError.js";+import {+ providerRetryAction,+ type ProviderOperationHealth,+} from "../domain/providerOperationHealth.js";import { err, ok, type Result } from "../domain/result.js";import { silentLogger } from "../logger.js";import type { Logger } from "pino";@@ -477,6 +481,32 @@ export class GhidraClient {});}+ /** Observed failures that prevent a retained session from being reused. */+ operationHealthSnapshot(): ProviderOperationHealth | undefined {+ const exit = this.#process?.observedExit();+ const state =+ exit !== undefined+ ? "exited"+ : this.#socket?.destroyed === true+ ? "unreachable"+ : this.#startPromise === undefined &&+ (this.#process !== undefined ||+ this.#socket !== undefined ||+ this.#runtimeRoot !== undefined ||+ this.#socketRoot !== undefined ||+ this.#snapshotOwners.size > 0)+ ? "unknown"+ : undefined;+ if (state === undefined) return undefined;+ return {+ state,+ stage: null,+ retryAction: providerRetryAction(state),+ exitCode: exit?.code ?? null,+ requests: [],+ };+ }+/** Latest bounded local diagnostics, with bearer material redacted. */diagnostics(): Readonly<Record<string, JsonValue>> {return structuredClone(this.#diagnostics());@@ -633,7 +663,7 @@ export class GhidraClient {deadline,failure: this.#failure,isClosed: () => this.#closing,- processExited: () => this.#process?.snapshot().exitCode !== undefined,+ processExited: () => this.#process?.observedExit() !== undefined,startupTimeoutMs: this.#options.startupTimeoutMs,handlers: {data: this.#onSocketData,diff --git a/src/ghidra/GhidraProviderClient.ts b/src/ghidra/GhidraProviderClient.tsindex b7ba24e0a..d2b963e52 100644--- a/src/ghidra/GhidraProviderClient.ts+++ b/src/ghidra/GhidraProviderClient.ts@@ -108,7 +108,10 @@ export type GhidraProviderClientFactory = (Partial<Pick<GhidraClient,- "runtimeLineage" | "readTargetSnapshot" | "hashTargetSnapshot"+ | "operationHealthSnapshot"+ | "runtimeLineage"+ | "readTargetSnapshot"+ | "hashTargetSnapshot">>;@@ -840,6 +843,7 @@ export const createGhidraProviderClient = (input: {}),);},+ operationHealthSnapshot: () => client.operationHealthSnapshot?.(),runtimeLineageSnapshots: () => {const observation = client.runtimeLineage?.() ?? null;return observation === nulldiff --git a/src/process/ProviderProcess.ts b/src/process/ProviderProcess.tsindex 1768c6c5b..d7b95613f 100644--- a/src/process/ProviderProcess.ts+++ b/src/process/ProviderProcess.ts@@ -78,6 +78,15 @@ export type ProviderProcessLaunch =readonly cleanup?: () => Promise<ProcessCleanupResult>;};+/**+ * Process exit recorded by the supervisor.+ * Independent of retained stream diagnostics.+ */+export interface ProviderProcessExitObservation {+ readonly code: number | null;+ readonly signal: NodeJS.Signals | null;+}+/** Detached diagnostics captured for one supervised provider process. */export interface ProviderProcessSnapshot {/** True only when a configured diagnostic budget excluded output bytes. */@@ -233,10 +242,7 @@ export class ProviderProcessSupervisor {readonly #options: ProviderProcessSupervisorOptions;readonly #stdout = new ProcessOutputCapture();readonly #stderr = new ProcessOutputCapture();- readonly #exit = deferred<{- readonly code: number | null;- readonly signal: NodeJS.Signals | null;- }>();+ readonly #exit = deferred<ProviderProcessExitObservation>();readonly #outputClose = deferred<void>();#outputClosed = false;#stdoutObservedBytes = 0;@@ -271,9 +277,7 @@ export class ProviderProcessSupervisor {readonly #onError = (cause: Error): void => {this.#options.onDiagnostic?.({ type: "error", message: cause.message });};- #exitObservation:- | { readonly code: number | null; readonly signal: NodeJS.Signals | null }- | undefined;+ #exitObservation: ProviderProcessExitObservation | undefined;#stopPromise: Promise<ProviderProcessStopResult> | undefined;#disposed = false;@@ -292,6 +296,16 @@ export class ProviderProcessSupervisor {this.#recordExit(launch.process.exitCode, launch.process.signalCode);}+ /**+ * Recorded process exit without concatenating retained stream diagnostics.+ * Undefined until exit or close is observed.+ */+ observedExit(): ProviderProcessExitObservation | undefined {+ const exit = this.#exitObservation;+ if (exit === undefined) return undefined;+ return { code: exit.code, signal: exit.signal };+ }+/** Latest retained output and exit observation, with explicit configured truncation. */snapshot(): ProviderProcessSnapshot {return {diff --git a/src/process/ProviderProcessOutput.test.ts b/src/process/ProviderProcessOutput.test.tsindex b24f7646e..28dc87dff 100644--- a/src/process/ProviderProcessOutput.test.ts+++ b/src/process/ProviderProcessOutput.test.ts@@ -1,6 +1,6 @@import { EventEmitter } from "node:events";import { PassThrough } from "node:stream";-import { expect, it } from "vitest";+import { expect, it, vi } from "vitest";import { ProviderProcessSupervisor } from "./ProviderProcess.js";it("exit does not establish complete output when a producer closes its streams later", async () => {@@ -34,6 +34,57 @@ it("exit does not establish complete output when a producer closes its streams l}});+it("reads an observed exit without materializing stream diagnostics", () => {+ const producer = Object.assign(new EventEmitter(), {+ stdout: new PassThrough(),+ stderr: new PassThrough(),+ exitCode: null,+ signalCode: null,+ kill: () => false,+ });+ const supervisor = new ProviderProcessSupervisor({+ process: producer,+ ownsProcessLifetime: false,+ });+ try {+ producer.stdout.write("retained-diagnostic");+ const snapshot = vi.spyOn(supervisor, "snapshot");+ expect(supervisor.observedExit()).toBeUndefined();+ producer.emit("exit", null, "SIGKILL");+ expect(supervisor.observedExit()).toEqual({+ code: null,+ signal: "SIGKILL",+ });+ expect(snapshot).not.toHaveBeenCalled();+ expect(supervisor.snapshot()).toMatchObject({+ stdout: { text: "retained-diagnostic" },+ exitCode: null,+ signal: "SIGKILL",+ });+ } finally {+ supervisor.dispose();+ }+});++it("observes an exit that completed before supervision", () => {+ const producer = Object.assign(new EventEmitter(), {+ stdout: new PassThrough(),+ stderr: new PassThrough(),+ exitCode: 2,+ signalCode: null,+ kill: () => false,+ });+ const supervisor = new ProviderProcessSupervisor({+ process: producer,+ ownsProcessLifetime: false,+ });+ try {+ expect(supervisor.observedExit()).toEqual({ code: 2, signal: null });+ } finally {+ supervisor.dispose();+ }+});+it("reports a reached process memory limit only when the handle observed one", () => {let reached = false;const producer = Object.assign(new EventEmitter(), {diff --git a/tests/boundary/mcp/ghidraReopen.test.ts b/tests/boundary/mcp/ghidraReopen.test.tsnew file mode 100644index 000000000..bdac57233--- /dev/null+++ b/tests/boundary/mcp/ghidraReopen.test.ts@@ -0,0 +1,346 @@+import { spawn, type ChildProcess } from "node:child_process";+import { access, mkdir, readFile, writeFile } from "node:fs/promises";+import { join } from "node:path";+import { fileURLToPath } from "node:url";++import { Client, InMemoryTransport } from "@modelcontextprotocol/client";+import { describe, expect, it } from "vitest";++import { AnalysisProviderRegistry } from "../../../src/application/binary/AnalysisProviderRegistry.js";+import { composeBinarySession } from "../../../src/application/binary/BinarySessionComposition.js";+import { LazyAnalysisProvider } from "../../../src/application/binary/LazyAnalysisProvider.js";+import { parseConfig } from "../../../src/config/parseConfig.js";+import { elf } from "../../../src/domain/binaryTarget.fixture.js";+import { ok } from "../../../src/domain/result.js";+import { GhidraClient } from "../../../src/ghidra/GhidraClient.js";+import type { GhidraInstallationHost } from "../../../src/ghidra/GhidraInstallation.js";+import type {+ GhidraLaunchSession,+ GhidraLauncher,+} from "../../../src/ghidra/GhidraLauncher.js";+import { GhidraProvider } from "../../../src/ghidra/GhidraProvider.js";+import { silentLogger } from "../../../src/logger.js";+import { createServer } from "../../../src/server/createServer.js";+import { parseMcpToolError } from "../../fixtures/mcpToolError.js";+import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";+import { waitForExit } from "../../support/process/processFixture.js";++const fixturePath = fileURLToPath(+ new URL("../../fixtures/fakeGhidra.mjs", import.meta.url),+);++type FixtureLaunch = {+ child: ChildProcess;+ runtimeRoot: string;+ endpointPath: string;+};++class FixtureLauncher implements GhidraLauncher {+ readonly launches: FixtureLaunch[] = [];+ readonly requests: string[] = [];+ cleanupAllowed = true;+ cleanupAttempts = 0;++ async launch(session: GhidraLaunchSession) {+ const projectRoot = join(session.runtimeRoot, "project");+ await mkdir(projectRoot, { recursive: true });+ const child = spawn(process.execPath, [fixturePath], {+ stdio: ["ignore", "pipe", "pipe", "ipc"],+ env: {+ ...process.env,+ REA_GHIDRA_FIXTURE_CONFIG: JSON.stringify({+ endpointPath: session.endpointPath,+ token: session.token,+ runId: session.runId,+ providerVersion: session.providerVersion,+ profileDigest: session.profileDigest,+ targetSha256: session.targetSha256,+ transport: session.transport,+ }),+ },+ });+ this.launches.push({+ child,+ runtimeRoot: session.runtimeRoot,+ endpointPath: session.endpointPath,+ });+ child.on("message", (value: unknown) => {+ if (+ typeof value === "object" &&+ value !== null &&+ "method" in value &&+ typeof value.method === "string"+ )+ this.requests.push(value.method);+ });+ return ok({+ process: child,+ ownsProcessLifetime: true as const,+ projectRoot,+ ghidraLogPath: join(session.runtimeRoot, "ghidra.log"),+ scriptLogPath: join(session.runtimeRoot, "script.log"),+ cleanup: async () => {+ this.cleanupAttempts += 1;+ if (!this.cleanupAllowed)+ return {+ cleaned: false as const,+ reason: "fixture cleanup is not yet confirmed",+ };+ const signaled = child.exitCode === null && child.signalCode === null;+ if (signaled) child.kill("SIGTERM");+ return (await waitForExit(child, 2_000))+ ? { cleaned: true as const, signaled }+ : { cleaned: false as const, reason: "fixture child did not exit" };+ },+ });+ }+}++const installationHost: GhidraInstallationHost = {+ platform: "linux",+ architecture: "x64",+ readText: () => "application.version=12.1.4\n",+ executable: () => true,+ probeJava: () => ({+ version: "21.0.11",+ major: 21,+ home: "/fixture/jdk-21",+ bits: 64,+ runtime: "jdk",+ }),+};++// Only installation discovery and the Java bridge are simulated. Requests use+// the production client, real child/socket and public MCP session routing.+const connectGhidra = async () => {+ const directory = await createTestTempDirectory("rea-ghidra-reopen-");+ const target = join(directory, "target.elf");+ const source = elf(2, 1, 62);+ await writeFile(target, source);+ const config = parseConfig({+ GHIDRA_INSTALL_DIR: "/fixture/ghidra_12.1.4_PUBLIC",+ });+ if (!config.ok) throw config.error;+ const launcher = new FixtureLauncher();+ const clients: GhidraClient[] = [];+ const provider = new GhidraProvider(+ config.value,+ silentLogger,+ {},+ installationHost,+ (options) => {+ const client = new GhidraClient({+ ...options,+ launcher,+ platform: process.platform,+ startupTimeoutMs: 5_000,+ });+ clients.push(client);+ return client;+ },+ );+ const lazy = new LazyAnalysisProvider({+ identity: provider.identity(),+ capabilities: provider.capabilities(),+ load: () => Promise.resolve(provider),+ });+ const session = composeBinarySession(+ new AnalysisProviderRegistry([+ {+ identity: () => provider.identity(),+ capabilities: () => provider.capabilities(),+ inspectAvailability: () => provider.inspectAvailability(),+ inspectTargetSupport: (value) => provider.inspectTargetSupport(value),+ resolveAnalysisProfile: (value, options) =>+ provider.resolveAnalysisProfile(value, options),+ createClient: (value, profile, context) =>+ lazy.createClient(value, profile, context),+ },+ ]),+ );+ const server = createServer(+ { kind: "session", session },+ { logger: silentLogger },+ );+ const mcp = new Client({ name: "ghidra-reopen", version: "1.0.0" });+ const [clientTransport, serverTransport] =+ InMemoryTransport.createLinkedPair();+ const close = async () => {+ launcher.cleanupAllowed = true;+ await Promise.allSettled([mcp.close(), server.close()]);+ const closed = await session.close();+ try {+ for (const client of clients)+ expect((await client.close()).ok).toBe(true);+ expect(closed.ok).toBe(true);+ } finally {+ for (const { child } of launcher.launches) {+ if (child.exitCode === null && child.signalCode === null)+ child.kill("SIGTERM");+ expect(await waitForExit(child, 2_000)).toBe(true);+ }+ }+ for (const launched of launcher.launches) await expectReleased(launched);+ expect(await readFile(target)).toEqual(source);+ };+ try {+ await server.connect(serverTransport);+ await mcp.connect(clientTransport);+ } catch (cause) {+ await close();+ throw cause;+ }+ return {+ clients,+ launcher,+ close,+ open: () =>+ mcp.callTool({ name: "open_binary", arguments: { path: target } }),+ query: (addressSuffix: number) =>+ mcp.callTool({+ name: "list_strings",+ arguments: { address: `0x200${addressSuffix}` },+ }),+ };+};++const firstLaunch = (launcher: FixtureLauncher): FixtureLaunch => {+ const first = launcher.launches[0];+ if (first === undefined) throw new Error("Expected a running Ghidra fixture");+ return first;+};++const expectReleased = async ({+ child,+ runtimeRoot,+ endpointPath,+}: FixtureLaunch) => {+ expect(await waitForExit(child, 2_000)).toBe(true);+ await expect(access(runtimeRoot)).rejects.toMatchObject({ code: "ENOENT" });+ await expect(access(endpointPath)).rejects.toMatchObject({ code: "ENOENT" });+};++const disconnect = async (+ child: ChildProcess,+ client: GhidraClient | undefined,+) => {+ if (client === undefined)+ throw new Error("Expected a connected Ghidra client");+ await new Promise<void>((resolve, reject) => {+ const timer = setTimeout(() => {+ child.off("message", received);+ reject(new Error("Fixture did not acknowledge socket disconnection"));+ }, 2_000);+ const received = (message: unknown) => {+ if (+ typeof message !== "object" ||+ message === null ||+ !("event" in message) ||+ message.event !== "disconnected"+ )+ return;+ clearTimeout(timer);+ child.off("message", received);+ resolve();+ };+ child.on("message", received);+ child.send("disconnect");+ });+ await expect+ .poll(async () => (await client.ping({ timeoutMs: 200 })).ok)+ .toBe(false);+ expect(child.exitCode).toBeNull();+ expect(child.signalCode).toBeNull();+};++describe.skipIf(process.platform === "win32")(+ "Ghidra MCP session recovery over Unix sockets",+ () => {+ it("keeps open lazy, reuses a live child, and replaces an exited child on reopen", async () => {+ const harness = await connectGhidra();+ try {+ expect((await harness.open()).isError).not.toBe(true);+ expect((await harness.open()).isError).not.toBe(true);+ expect(harness.clients).toHaveLength(0);+ expect(harness.launcher.launches).toHaveLength(0);+ expect((await harness.query(1)).isError).not.toBe(true);+ const old = firstLaunch(harness.launcher);+ expect((await harness.open()).isError).not.toBe(true);+ expect((await harness.query(2)).isError).not.toBe(true);+ expect(harness.launcher.launches).toHaveLength(1);+ await expect+ .poll(+ () =>+ harness.launcher.requests.filter(+ (method) => method === "list_strings",+ ).length,+ )+ .toBe(2);+ expect(old.child.kill("SIGTERM")).toBe(true);+ expect(await waitForExit(old.child, 2_000)).toBe(true);+ expect(old.child.signalCode).toBe("SIGTERM");+ expect((await harness.open()).isError).not.toBe(true);+ await expectReleased(old);+ expect(harness.clients).toHaveLength(1);+ expect(harness.launcher.launches).toHaveLength(1);+ expect((await harness.query(3)).isError).not.toBe(true);+ expect(harness.clients).toHaveLength(2);+ expect(harness.launcher.launches).toHaveLength(2);+ } finally {+ await harness.close();+ }+ });++ it("retires a disconnected live child before lazily starting a replacement", async () => {+ const harness = await connectGhidra();+ try {+ expect((await harness.open()).isError).not.toBe(true);+ expect((await harness.query(1)).isError).not.toBe(true);+ const old = firstLaunch(harness.launcher);+ await disconnect(old.child, harness.clients[0]);+ expect((await harness.open()).isError).not.toBe(true);+ await expectReleased(old);+ expect(harness.clients).toHaveLength(1);+ expect(harness.launcher.launches).toHaveLength(1);+ expect((await harness.query(2)).isError).not.toBe(true);+ expect(harness.clients).toHaveLength(2);+ expect(harness.launcher.launches).toHaveLength(2);+ } finally {+ await harness.close();+ }+ });++ it("retains failed cleanup and refuses replacement until cleanup can be retried", async () => {+ const harness = await connectGhidra();+ try {+ expect((await harness.open()).isError).not.toBe(true);+ expect((await harness.query(1)).isError).not.toBe(true);+ const old = firstLaunch(harness.launcher);+ await disconnect(old.child, harness.clients[0]);+ harness.launcher.cleanupAllowed = false;+ for (let attempt = 1; attempt <= 2; attempt += 1) {+ expect(parseMcpToolError(await harness.open())).toMatchObject({+ error: { code: "cleanup_incomplete" },+ });+ expect(harness.launcher.cleanupAttempts).toBe(attempt);+ expect(harness.clients).toHaveLength(1);+ expect(harness.launcher.launches).toHaveLength(1);+ expect(old.child.exitCode).toBeNull();+ expect(old.child.signalCode).toBeNull();+ await access(old.runtimeRoot);+ }+ harness.launcher.cleanupAllowed = true;+ expect((await harness.open()).isError).not.toBe(true);+ await expectReleased(old);+ expect(harness.launcher.cleanupAttempts).toBe(3);+ expect(harness.clients).toHaveLength(1);+ expect(harness.launcher.launches).toHaveLength(1);+ expect((await harness.query(2)).isError).not.toBe(true);+ expect(harness.clients).toHaveLength(2);+ expect(harness.launcher.launches).toHaveLength(2);+ } finally {+ await harness.close();+ }+ });+ },+);diff --git a/tests/boundary/providers/ghidra/ghidraClient.test.ts b/tests/boundary/providers/ghidra/ghidraClient.test.tsindex 5b04f6c47..43abedb3d 100644--- a/tests/boundary/providers/ghidra/ghidraClient.test.ts+++ b/tests/boundary/providers/ghidra/ghidraClient.test.ts@@ -232,6 +232,7 @@ describe("GhidraClient captured source snapshot", () => {if (!started.ok) throw started.error;const close = vi.spyOn(OwnedFileHandle.prototype, "close")+ .mockRejectedValueOnce(new Error("snapshot descriptor close failed")).mockRejectedValueOnce(new Error("snapshot descriptor close failed"));try {await expect(client.hashTargetSnapshot()).resolves.toMatchObject({@@ -240,11 +241,19 @@ describe("GhidraClient captured source snapshot", () => {});const owner = close.mock.contexts[0];expect(owner).toBeInstanceOf(OwnedFileHandle);+ await expect(client.close()).resolves.toMatchObject({+ ok: false,+ error: { cleanupIncomplete: true },+ });+ expect(client.operationHealthSnapshot()).toMatchObject({+ state: "unknown",+ });const closed = await client.close();if (!closed.ok) throw closed.error;+ expect(client.operationHealthSnapshot()).toBeUndefined();expect(close.mock.contexts.filter((context) => context === owner),- ).toHaveLength(2);+ ).toHaveLength(3);} finally {close.mockRestore();}@@ -591,11 +600,15 @@ describe("GhidraClient runtime removal failures", () => {},});await expect(access(runtimeRoot)).resolves.toBeUndefined();+ expect(client.operationHealthSnapshot()).toMatchObject({+ state: "unknown",+ });} finally {await chmod(runtimeRoot, 0o700);}await expect(client.close()).resolves.toEqual({ ok: true, value: null });+ expect(client.operationHealthSnapshot()).toBeUndefined();await expect(access(runtimeRoot)).rejects.toMatchObject({code: "ENOENT",});@@ -626,16 +639,21 @@ describe("GhidraClient cleanup and diagnostics", () => {const client = clientFor(launcher, {runId: "11111111-1111-4111-8111-111111111111",});+ expect(client.operationHealthSnapshot()).toBeUndefined();await expect(client.start()).resolves.toMatchObject({ ok: true });+ expect(client.operationHealthSnapshot()).toBeUndefined();+ const child = await launcher.started;await client.close();+ expect(client.operationHealthSnapshot()).toBeUndefined();expect(client.diagnostics()).toMatchObject({runtime_root: launcher.runtimeRoots[0],transport: HOST_TRANSPORT,endpoint_path: launcher.endpointPaths[0],project_root: join(launcher.runtimeRoots[0] ?? "", "project"),process_id: expect.any(Number),+ exit_code: child.exitCode,run_id: "11111111-1111-4111-8111-111111111111",});await expect(access(launcher.runtimeRoots[0] ?? "")).rejects.toMatchObject({diff --git a/tests/fixtures/fakeGhidra.mjs b/tests/fixtures/fakeGhidra.mjsindex 92f698001..b08410793 100644--- a/tests/fixtures/fakeGhidra.mjs+++ b/tests/fixtures/fakeGhidra.mjs@@ -31,7 +31,10 @@ if (mode === "exit") process.exit(73);if (mode === "silent") setInterval(() => undefined, 1_000);else {await rm(endpointPath, { force: true });+ const sockets = new Set();const server = createServer((socket) => {+ sockets.add(socket);+ socket.once("close", () => sockets.delete(socket));socket.setEncoding("utf8");const state = {buffer: { value: "" },@@ -45,6 +48,11 @@ else {};socket.on("data", (chunk) => onSocketData(socket, server, chunk, state));});+ process.on("message", (message) => {+ if (message !== "disconnect") return;+ for (const socket of sockets) socket.destroy();+ process.send?.({ event: "disconnected" });+ });if (transport === "unix-socket") server.listen(endpointPath);else {server.listen(0, "127.0.0.1", async () => {