Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
import { createServer } from "node:http";
import { mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { pathToFileURL } from "node:url";
import { expect, it, onTestFinished, vi } from "vitest";
import { WebSocketServer } from "ws";
import { CdpConnection } from "../browser/CdpConnection.js";
import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
import { observeJavaScriptRuntime } from "../application/javascript/JavaScriptRuntimeObservationService.js";
import { observeJavaScriptRuntimeInputSchema } from "../domain/javascript/javascriptRuntimeObservation.js";
import { V8InspectorProvider } from "./V8InspectorProvider.js";
const inspectorCloseFixture = async () => {
const root = await mkdtemp(join(tmpdir(), "rea-inspector-close-owner-"));
const scriptPath = join(root, "target.js");
await writeFile(scriptPath, "globalThis.fixture = true;\n");
const scriptUrl = pathToFileURL(scriptPath).href;
let endpoint = "";
const server = createServer((request, response) => {
response.setHeader("content-type", "application/json");
if (request.url === "/json/version")
response.end(
JSON.stringify({
Browser: "Node.js/v24.18.0",
"Protocol-Version": "1.3",
"V8-Version": "fixture",
}),
);
else if (request.url === "/json/list")
response.end(
JSON.stringify([
{
id: "fixture",
type: "node",
url: scriptUrl,
attached: false,
webSocketDebuggerUrl: endpoint.replace("http:", "ws:") + "/fixture",
},
]),
);
else response.writeHead(404).end();
});
const sockets = new WebSocketServer({ server, path: "/fixture" });
let acceptedConnections = 0;
const connectionWaiters = new Map<number, () => void>();
sockets.on("connection", (socket) => {
acceptedConnections += 1;
connectionWaiters.get(acceptedConnections)?.();
socket.on("message", (raw) => {
const command = JSON.parse(raw.toString()) as { id: number };
socket.send(JSON.stringify({ id: command.id, result: {} }));
});
});
const waitForConnections = (count: number): Promise<void> =>
acceptedConnections >= count
? Promise.resolve()
: new Promise<void>((resolve) => connectionWaiters.set(count, resolve));
let resolveCloseStarted: (() => void) | undefined;
const closeStarted = new Promise<void>((resolve) => {
resolveCloseStarted = resolve;
});
let rejectFirstClose: ((cause: Error) => void) | undefined;
let closeCalls = 0;
const closeFailures = new Set<number>([2]);
const firstClose = new Promise<void>((_resolve, reject) => {
rejectFirstClose = reject;
});
const originalClose = CdpConnection.prototype.close;
const closeSpy = vi
.spyOn(CdpConnection.prototype, "close")
.mockImplementation(function (this: CdpConnection): Promise<void> {
closeCalls += 1;
if (closeCalls === 1) {
resolveCloseStarted?.();
return firstClose;
}
if (closeFailures.delete(closeCalls))
return Promise.reject(new Error("controlled retry remains pending"));
return originalClose.call(this);
});
onTestFinished(async () => {
closeSpy.mockRestore();
if (closeCalls > 0) rejectFirstClose?.(new Error("fixture finalization"));
await new V8InspectorProvider().close();
for (const socket of sockets.clients) socket.terminate();
await new Promise<void>((resolve) => sockets.close(() => resolve()));
if (server.listening)
await new Promise<void>((resolve) => server.close(() => resolve()));
await rm(root, { recursive: true, force: true });
});
await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
const address = server.address();
if (address === null || typeof address === "string")
throw new Error("Inspector fixture did not bind a TCP port");
endpoint = `http://127.0.0.1:${String(address.port)}`;
const input = observeJavaScriptRuntimeInputSchema.parse({
inspector_endpoint: endpoint,
target_id: "fixture",
observation_ms: 0,
});
return {
input,
endpoint,
closeStarted,
closeFailures,
closeSpy,
waitForConnections,
rejectFirstClose: (cause: Error) => rejectFirstClose?.(cause),
get acceptedConnections() {
return acceptedConnections;
},
};
};
it("retains cancelled final-close ownership and retries the exact transport before replacement observation", async () => {
const fixture = await inspectorCloseFixture();
const {
input,
endpoint,
closeStarted,
closeFailures,
closeSpy,
waitForConnections,
rejectFirstClose,
} = fixture;
const controller = new AbortController();
const cancellationReason = new Error("cancelled during transport close");
const observing = observeJavaScriptRuntime(new V8InspectorProvider(), input, {
signal: controller.signal,
});
await closeStarted;
controller.abort(cancellationReason);
let firstObservationSettled = false;
void observing.finally(() => {
firstObservationSettled = true;
});
await Promise.resolve();
expect(firstObservationSettled).toBe(false);
rejectFirstClose?.(new Error("controlled final socket close failure"));
const result = await observing;
expect(result.ok).toBe(false);
if (result.ok) throw new Error("Expected cleanup-incomplete cancellation");
const error = result.error;
expect(error.cleanupIncomplete).toBe(true);
expect(error.cleanupResources).toEqual(["browser_transport"]);
expect(error.cleanupPrimary).toBeInstanceOf(AnalysisCancelledError);
expect(error.cleanupPrimary?.cause).toBe(cancellationReason);
expect(error.partialObservation).toMatchObject({
predicate_type: "rea.javascript-runtime-observation",
operation: "observe_javascript_runtime",
normalized_result: {
target: { target_id: "fixture" },
},
});
expect(projectAnalysisError(error).code).toBe("cleanup_incomplete");
const blocked = await observeJavaScriptRuntime(
new V8InspectorProvider(),
input,
);
expect(blocked.ok).toBe(false);
if (blocked.ok)
throw new Error("Expected unresolved transport admission refusal");
expect(blocked.error.cleanupIncomplete).toBe(true);
expect(fixture.acceptedConnections).toBe(1);
const recovered = await observeJavaScriptRuntime(
new V8InspectorProvider(),
input,
);
expect(recovered.ok).toBe(true);
expect(error.cleanupIncomplete).toBe(false);
expect(error.cleanupResources).toEqual([]);
expect(fixture.acceptedConnections).toBe(2);
closeFailures.add(5);
const cleanupOnly = await observeJavaScriptRuntime(
new V8InspectorProvider(),
input,
);
expect(cleanupOnly.ok).toBe(false);
if (cleanupOnly.ok) throw new Error("Expected close-only cleanup failure");
expect(cleanupOnly.error.cleanupIncomplete).toBe(true);
expect(cleanupOnly.error.cleanupResources).toEqual(["browser_transport"]);
expect(cleanupOnly.error.partialObservation).toMatchObject({
predicate_type: "rea.javascript-runtime-observation",
operation: "observe_javascript_runtime",
});
expect(fixture.acceptedConnections).toBe(3);
const activeInput = observeJavaScriptRuntimeInputSchema.parse({
inspector_endpoint: endpoint,
target_id: "fixture",
observation_ms: 30_000,
});
const activeController = new AbortController();
const activeObservation = observeJavaScriptRuntime(
new V8InspectorProvider(),
activeInput,
{ signal: activeController.signal },
);
try {
await waitForConnections(4);
let shutdownSettled = false;
const shutdown = new V8InspectorProvider().close().then(() => {
shutdownSettled = true;
});
const queuedObservation = observeJavaScriptRuntime(
new V8InspectorProvider(),
input,
);
await new Promise<void>((resolve) => setImmediate(resolve));
expect(shutdownSettled).toBe(false);
expect(fixture.acceptedConnections).toBe(4);
expect(cleanupOnly.error.cleanupIncomplete).toBe(false);
expect(cleanupOnly.error.cleanupResources).toEqual([]);
activeController.abort(new Error("finish the admitted observation"));
const activeResult = await activeObservation;
expect(activeResult.ok).toBe(false);
await shutdown;
expect(shutdownSettled).toBe(true);
await waitForConnections(5);
const queuedResult = await queuedObservation;
expect(queuedResult.ok).toBe(true);
expect(fixture.acceptedConnections).toBe(5);
expect(closeSpy).toHaveBeenCalledTimes(8);
} finally {
activeController.abort(new Error("fixture finalization"));
}
});