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 { spawn, type ChildProcess } from "node:child_process";
import { setImmediate as nextTurn } from "node:timers/promises";
import { Writable } from "node:stream";
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import {
runUpdateCommand,
UPDATE_COMMAND_OUTPUT_BYTES,
} from "../../src/application/UpdateRuntime.js";
const execution = vi.hoisted(() => ({ spawn: vi.fn() }));
vi.mock("cross-spawn", () => ({ default: execution.spawn }));
let child: ChildProcess | undefined;
beforeEach(() => {
execution.spawn.mockReset();
execution.spawn.mockImplementation(
(
executable: string,
args: readonly string[],
options: Parameters<typeof spawn>[2],
) => {
if (executable !== process.execPath)
throw new Error("Only owned Node fixtures may execute");
child = spawn(executable, [...args], options);
return child;
},
);
});
afterEach(async () => {
vi.restoreAllMocks();
if (
child !== undefined &&
child.exitCode === null &&
child.signalCode === null
) {
const closed = new Promise<void>((resolve) => {
child!.once("close", resolve);
});
child.kill("SIGKILL");
await closed;
}
child = undefined;
});
const command = (script: string) => [process.execPath, "-e", script];
it.each(["stdout", "stderr"])(
"rejects incomplete %s metadata after draining the command",
async (stream) => {
const result = await runUpdateCommand(
command(
`process.stdout.write('"6.5.0"');process.${stream}.write(' '.repeat(${UPDATE_COMMAND_OUTPUT_BYTES}))`,
),
process.env,
);
expect(result).toMatchObject({
ok: false,
error: expect.stringContaining("complete-output retention budget"),
});
expect(child?.exitCode).toBe(0);
},
);
it("accepts exactly the combined byte budget and preserves split UTF-8", async () => {
const result = await runUpdateCommand(
command(
`process.stdout.write('x'.repeat(${UPDATE_COMMAND_OUTPUT_BYTES - 3}));const b=Buffer.from('界');process.stdout.write(b.subarray(0,1));setTimeout(()=>process.stdout.write(b.subarray(1)),10)`,
),
process.env,
);
expect(result.ok).toBe(true);
if (result.ok) {
expect(Buffer.byteLength(result.value)).toBe(UPDATE_COMMAND_OUTPUT_BYTES);
expect(result.value.endsWith("界")).toBe(true);
}
});
it("refuses malformed UTF-8 instead of interpreting replacement text", async () => {
expect(
await runUpdateCommand(
command("process.stdout.write(Buffer.from([255]))"),
process.env,
),
).toMatchObject({
ok: false,
error: expect.stringContaining("invalid UTF-8"),
});
});
it("waits for physical close after an early process error", async () => {
let settled = false;
const pending = runUpdateCommand(
command("setTimeout(()=>process.stdout.write('late output'),50)"),
process.env,
).then((result) => {
settled = true;
return result;
});
child!.emit("error", new Error("controlled process error"));
await Promise.resolve();
expect(settled).toBe(false);
expect(await pending).toEqual({
ok: false,
error: "controlled process error",
});
expect(child?.exitCode).toBe(0);
});
it("joins the final human progress write before reporting success", async () => {
let acknowledge!: (cause?: Error | null) => void;
let started!: () => void;
const writing = new Promise<void>((resolve) => {
started = resolve;
});
const destination = new Writable({
write(_chunk, _encoding, callback) {
acknowledge = callback;
started();
},
});
vi.spyOn(process, "stderr", "get").mockReturnValue(
destination as typeof process.stderr,
);
let settled = false;
const pending = runUpdateCommand(
command("process.stdout.write('final progress')"),
process.env,
"human",
).then((result) => {
settled = true;
return result;
});
const closed = new Promise<void>((resolve) => {
child!.once("close", resolve);
});
await writing;
await closed;
expect(settled).toBe(false);
acknowledge(new Error("final progress refused"));
expect(await pending).toMatchObject({
ok: false,
error: expect.stringContaining("final progress refused"),
});
expect(destination.writableEnded).toBe(false);
await nextTurn();
expect(destination.listenerCount("error")).toBe(0);
});