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(cli): stop quietly when the stdout reader closes early (#3781)
Kaoru08225e8f7c536ecd
diff --git a/docs/cli.md b/docs/cli.mdindex 736c0de37..e475964fd 100644--- a/docs/cli.md+++ b/docs/cli.md@@ -352,6 +352,11 @@ command, objdump, Rizin and GDB. In these paths, a returned structuredsignal-derived status. This describes the current source routing; it is not aclaim that every command or provider runtime has been independently exercised.+When the reader of piped output closes early, as `rea ... | head` does, the+CLI stops writing, prints no error and exits `141` (`128 + 13`, the status of a+SIGPIPE-terminated writer). The operation itself may have completed; only its+output was declined.+`inspect-artifact` also returns a structured cancelled result, but its directanalysis cancellation path does not set a signal-derived exit status, so itexits `1`. Setup has its own contract: cancellation exits `0`. Treat thediff --git a/scripts/rea.mjs b/scripts/rea.mjsindex 75ee552c5..3db1cbf55 100755--- a/scripts/rea.mjs+++ b/scripts/rea.mjs@@ -14,6 +14,10 @@ process.env.REA_PACKAGE_VERSION = packageJson.version;const isMcpMode =args.length === 1 && (args[0] === "--mcp" || args[0] === "mcp");const isMcpDoctorMode = args[0] === "mcp" && args[1] === "doctor";+/** Exit status of a writer terminated by SIGPIPE (128 + 13). */+const SIGPIPE_EXIT_STATUS = 141;+// Set once the reader of CLI output has closed the pipe.+let stdoutClosed = false;const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");// Windows home lookup throws for an empty USERPROFILE. Dependencies resolve@@ -55,13 +59,14 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {const { runEntrypoint } = await import("../dist/mcp/main.js");await runEntrypoint();} else if (isMcpDoctorMode) {+ guardClosedStdout();const { runProductionMcpDoctorCli } =await import("../dist/cli-runtime/mcpDoctor.js");const result = await runProductionMcpDoctorCli(args.slice(2), {dispatcherPath: fileURLToPath(import.meta.url),packageRoot,});- process.stdout.write(result.output);+ writeStdout(result.output);process.exitCode = result.exitCode;} else {const { cliConfigurationError, createCli } =@@ -73,13 +78,14 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {renderEmptyFilteredCliOutput,validateCliOutputArguments,} = await import("../dist/cli-runtime/cliOutput.js");+ guardClosedStdout();const outputArguments = validateCliOutputArguments(args);const configurationError = cliConfigurationError(process.env);if (configurationError !== undefined) {process.stderr.write(`${configurationError}\n`);process.exitCode = 1;} else if (!outputArguments.ok) {- process.stdout.write(renderCliOutputArgumentError(outputArguments));+ writeStdout(renderCliOutputArgumentError(outputArguments));process.exitCode = 1;} else {let wroteOutput = false;@@ -87,18 +93,43 @@ if (!(await compiledRuntimeExists(runtimeFiles))) {await createCli(process.env, resultOutput).serve(args, {stdout: (output) => {if (resultOutput?.handled) {- if (resultOutput.failed) process.stderr.write(output);+ if (resultOutput.failed && !stdoutClosed)+ process.stderr.write(output);return;}if (output.length > 0) wroteOutput = true;- process.stdout.write(output);+ writeStdout(output);},+ // A command failure caused by the closed pipe keeps the pipe's status.+ exit: (code) => process.exit(stdoutClosed ? SIGPIPE_EXIT_STATUS : code),});if (!wroteOutput && !resultOutput?.handled)- process.stdout.write(renderEmptyFilteredCliOutput(args) ?? "");+ writeStdout(renderEmptyFilteredCliOutput(args) ?? "");}}+/**+ * A reader that closes the pipe early, as `rea ... | head` does, has declined+ * the rest of the output. Stop writing without reporting a failure, and exit+ * with the status a SIGPIPE-terminated writer reports. MCP stdio keeps its own+ * client lifecycle.+ */+function guardClosedStdout() {+ process.stdout.on("error", (cause) => {+ if (cause?.code === "EPIPE") {+ stdoutClosed = true;+ process.exitCode = SIGPIPE_EXIT_STATUS;+ return;+ }+ // Other failures stay unhandled unless a pending JSON write reports them.+ if (process.stdout.listenerCount("error") === 1) throw cause;+ });+}++function writeStdout(output) {+ if (!stdoutClosed) process.stdout.write(output);+}+async function compiledRuntimeExists(paths) {for (const path of paths) {try {diff --git a/tests/boundary/cli/closedStdout.test.ts b/tests/boundary/cli/closedStdout.test.tsnew file mode 100644index 000000000..8227d0b16--- /dev/null+++ b/tests/boundary/cli/closedStdout.test.ts@@ -0,0 +1,84 @@+import { join, resolve } from "node:path";+import { DatabaseSync } from "node:sqlite";++import { describe, expect } from "vitest";++import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";+import { cliTest } from "../../support/cli/cliFixture.js";+import type { TestProcesses } from "../../support/process/processFixture.js";++/** Run the CLI, closing its stdout reader after `bytes` (0: before any write). */+const runWithClosedReader = async (+ processes: TestProcesses,+ arguments_: readonly string[],+ bytes: number,+) => {+ const child = processes.spawn(+ process.execPath,+ [resolve("scripts/rea.mjs"), ...arguments_],+ { env: { PATH: process.env.PATH ?? "", REA_LOG_LEVEL: "silent" } },+ );+ let received = 0;+ if (bytes === 0) child.stdout.destroy();+ else+ child.stdout.on("data", (chunk: Buffer) => {+ received += chunk.length;+ if (received >= bytes) child.stdout.destroy();+ });+ child.stdin.end();+ let stderr = "";+ child.stderr.setEncoding("utf8");+ child.stderr.on("data", (chunk: string) => (stderr += chunk));+ const code = await new Promise<number | null>((done) =>+ child.once("close", done),+ );+ return { code, stderr, received };+};++// Windows reports a closed pipe reader through a different error path.+describe.skipIf(process.platform === "win32")(+ "CLI with a closed stdout",+ () => {+ cliTest.for([+ ["toon", ["capabilities", "--format", "toon"]],+ ["json", ["capabilities", "--format", "json"]],+ ["mcp doctor", ["mcp", "doctor", "--json"]],+ ] as const)(+ "stops quietly with the SIGPIPE status when the reader closes first ($0)",+ async ([, arguments_], { processes }) => {+ const result = await runWithClosedReader(processes, arguments_, 0);+ expect(result).toMatchObject({ code: 141, stderr: "" });+ },+ );++ cliTest(+ "stops quietly when the reader closes during streamed JSON",+ async ({ processes }) => {+ const directory = await createTestTempDirectory("rea-closed-stdout-");+ const database = join(directory, "rows.db");+ const writer = new DatabaseSync(database);+ writer.exec("CREATE TABLE t (v TEXT)");+ const insert = writer.prepare("INSERT INTO t VALUES (?)");+ // 4 MiB of rows outlasts any pipe buffer, so writes continue after close.+ for (let row = 0; row < 64; row += 1) insert.run("x".repeat(65_536));+ writer.close();+ const result = await runWithClosedReader(+ processes,+ [+ "inspect-sqlite-database",+ database,+ "--table",+ "t",+ "--row-limit",+ "64",+ "--format",+ "json",+ ],+ 1,+ );+ expect(result.received).toBeGreaterThan(0);+ expect(result).toMatchObject({ code: 141, stderr: "" });+ },+ );+ },+);