agent-gauntlet 0.8.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-gauntlet",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "A CLI tool for testing AI coding agents",
   "license": "Apache-2.0",
   "author": "Paul Caplan",

package/src/cli-adapters/claude.ts

@@ -1,10 +1,10 @@
-import { exec, spawn } from "node:child_process";
+import { exec } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
 import { GAUNTLET_STOP_HOOK_ACTIVE_ENV } from "../commands/stop-hook.js";
-import type { CLIAdapter } from "./index.js";
+import { type CLIAdapter, runStreamingCommand } from "./index.js";
 
 const execAsync = promisify(exec);
 const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
@@ -94,65 +94,17 @@ export class ClaudeAdapter implements CLIAdapter {
 
 		// If onOutput callback is provided, use spawn for real-time streaming
 		if (opts.onOutput) {
-			return new Promise((resolve, reject) => {
-				const chunks: string[] = [];
-				const inputStream = fs.open(tmpFile, "r").then((handle) => {
-					const stream = handle.createReadStream();
-					return { stream, handle };
-				});
-
-				inputStream
-					.then(({ stream, handle }) => {
-						const child = spawn("claude", args, {
-							stdio: ["pipe", "pipe", "pipe"],
-							env: {
-								...process.env,
-								[GAUNTLET_STOP_HOOK_ACTIVE_ENV]: "1",
-							},
-						});
-
-						stream.pipe(child.stdin);
-
-						let timeoutId: ReturnType<typeof setTimeout> | undefined;
-						if (opts.timeoutMs) {
-							timeoutId = setTimeout(() => {
-								child.kill("SIGTERM");
-								reject(new Error("Command timed out"));
-							}, opts.timeoutMs);
-						}
-
-						child.stdout.on("data", (data: Buffer) => {
-							const chunk = data.toString();
-							chunks.push(chunk);
-							opts.onOutput?.(chunk);
-						});
-
-						child.stderr.on("data", (data: Buffer) => {
-							// Only log stderr, don't include in return value
-							opts.onOutput?.(data.toString());
-						});
-
-						child.on("close", (code) => {
-							if (timeoutId) clearTimeout(timeoutId);
-							handle.close().catch(() => {});
-							cleanup().then(() => {
-								if (code === 0 || code === null) {
-									resolve(chunks.join(""));
-								} else {
-									reject(new Error(`Process exited with code ${code}`));
-								}
-							});
-						});
-
-						child.on("error", (err) => {
-							if (timeoutId) clearTimeout(timeoutId);
-							handle.close().catch(() => {});
-							cleanup().then(() => reject(err));
-						});
-					})
-					.catch((err) => {
-						cleanup().then(() => reject(err));
-					});
+			return runStreamingCommand({
+				command: "claude",
+				args,
+				tmpFile,
+				timeoutMs: opts.timeoutMs,
+				onOutput: opts.onOutput,
+				cleanup,
+				env: {
+					...process.env,
+					[GAUNTLET_STOP_HOOK_ACTIVE_ENV]: "1",
+				},
 			});
 		}
 

package/src/cli-adapters/codex.ts

@@ -1,9 +1,9 @@
-import { exec, spawn } from "node:child_process";
+import { exec } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
-import type { CLIAdapter } from "./index.js";
+import { type CLIAdapter, runStreamingCommand } from "./index.js";
 
 const execAsync = promisify(exec);
 const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
@@ -98,61 +98,13 @@ export class CodexAdapter implements CLIAdapter {
 
 		// If onOutput callback is provided, use spawn for real-time streaming
 		if (opts.onOutput) {
-			return new Promise((resolve, reject) => {
-				const chunks: string[] = [];
-				const inputStream = fs.open(tmpFile, "r").then((handle) => {
-					const stream = handle.createReadStream();
-					return { stream, handle };
-				});
-
-				inputStream
-					.then(({ stream, handle }) => {
-						const child = spawn("codex", args, {
-							stdio: ["pipe", "pipe", "pipe"],
-						});
-
-						stream.pipe(child.stdin);
-
-						let timeoutId: ReturnType<typeof setTimeout> | undefined;
-						if (opts.timeoutMs) {
-							timeoutId = setTimeout(() => {
-								child.kill("SIGTERM");
-								reject(new Error("Command timed out"));
-							}, opts.timeoutMs);
-						}
-
-						child.stdout.on("data", (data: Buffer) => {
-							const chunk = data.toString();
-							chunks.push(chunk);
-							opts.onOutput?.(chunk);
-						});
-
-						child.stderr.on("data", (data: Buffer) => {
-							// Only log stderr, don't include in return value
-							opts.onOutput?.(data.toString());
-						});
-
-						child.on("close", (code) => {
-							if (timeoutId) clearTimeout(timeoutId);
-							handle.close().catch(() => {});
-							cleanup().then(() => {
-								if (code === 0 || code === null) {
-									resolve(chunks.join(""));
-								} else {
-									reject(new Error(`Process exited with code ${code}`));
-								}
-							});
-						});
-
-						child.on("error", (err) => {
-							if (timeoutId) clearTimeout(timeoutId);
-							handle.close().catch(() => {});
-							cleanup().then(() => reject(err));
-						});
-					})
-					.catch((err) => {
-						cleanup().then(() => reject(err));
-					});
+			return runStreamingCommand({
+				command: "codex",
+				args,
+				tmpFile,
+				timeoutMs: opts.timeoutMs,
+				onOutput: opts.onOutput,
+				cleanup,
 			});
 		}
 

package/src/cli-adapters/cursor.ts

@@ -1,9 +1,9 @@
-import { exec, spawn } from "node:child_process";
+import { exec } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
-import type { CLIAdapter } from "./index.js";
+import { type CLIAdapter, runStreamingCommand } from "./index.js";
 
 const execAsync = promisify(exec);
 const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
@@ -90,61 +90,13 @@ export class CursorAdapter implements CLIAdapter {
 
 		// If onOutput callback is provided, use spawn for real-time streaming
 		if (opts.onOutput) {
-			return new Promise((resolve, reject) => {
-				const chunks: string[] = [];
-				const inputStream = fs.open(tmpFile, "r").then((handle) => {
-					const stream = handle.createReadStream();
-					return { stream, handle };
-				});
-
-				inputStream
-					.then(({ stream, handle }) => {
-						const child = spawn("agent", [], {
-							stdio: ["pipe", "pipe", "pipe"],
-						});
-
-						stream.pipe(child.stdin);
-
-						let timeoutId: ReturnType<typeof setTimeout> | undefined;
-						if (opts.timeoutMs) {
-							timeoutId = setTimeout(() => {
-								child.kill("SIGTERM");
-								reject(new Error("Command timed out"));
-							}, opts.timeoutMs);
-						}
-
-						child.stdout.on("data", (data: Buffer) => {
-							const chunk = data.toString();
-							chunks.push(chunk);
-							opts.onOutput?.(chunk);
-						});
-
-						child.stderr.on("data", (data: Buffer) => {
-							// Only log stderr, don't include in return value
-							opts.onOutput?.(data.toString());
-						});
-
-						child.on("close", (code) => {
-							if (timeoutId) clearTimeout(timeoutId);
-							handle.close().catch(() => {});
-							cleanup().then(() => {
-								if (code === 0 || code === null) {
-									resolve(chunks.join(""));
-								} else {
-									reject(new Error(`Process exited with code ${code}`));
-								}
-							});
-						});
-
-						child.on("error", (err) => {
-							if (timeoutId) clearTimeout(timeoutId);
-							handle.close().catch(() => {});
-							cleanup().then(() => reject(err));
-						});
-					})
-					.catch((err) => {
-						cleanup().then(() => reject(err));
-					});
+			return runStreamingCommand({
+				command: "agent",
+				args: [],
+				tmpFile,
+				timeoutMs: opts.timeoutMs,
+				onOutput: opts.onOutput,
+				cleanup,
 			});
 		}
 

package/src/cli-adapters/gemini.ts

@@ -1,9 +1,9 @@
-import { exec, spawn } from "node:child_process";
+import { exec } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
-import type { CLIAdapter } from "./index.js";
+import { type CLIAdapter, runStreamingCommand } from "./index.js";
 
 const execAsync = promisify(exec);
 const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
@@ -130,61 +130,13 @@ ${escapedBody}
 
 		// If onOutput callback is provided, use spawn for real-time streaming
 		if (opts.onOutput) {
-			return new Promise((resolve, reject) => {
-				const chunks: string[] = [];
-				const inputStream = fs.open(tmpFile, "r").then((handle) => {
-					const stream = handle.createReadStream();
-					return { stream, handle };
-				});
-
-				inputStream
-					.then(({ stream, handle }) => {
-						const child = spawn("gemini", args, {
-							stdio: ["pipe", "pipe", "pipe"],
-						});
-
-						stream.pipe(child.stdin);
-
-						let timeoutId: ReturnType<typeof setTimeout> | undefined;
-						if (opts.timeoutMs) {
-							timeoutId = setTimeout(() => {
-								child.kill("SIGTERM");
-								reject(new Error("Command timed out"));
-							}, opts.timeoutMs);
-						}
-
-						child.stdout.on("data", (data: Buffer) => {
-							const chunk = data.toString();
-							chunks.push(chunk);
-							opts.onOutput?.(chunk);
-						});
-
-						child.stderr.on("data", (data: Buffer) => {
-							// Only log stderr, don't include in return value
-							opts.onOutput?.(data.toString());
-						});
-
-						child.on("close", (code) => {
-							if (timeoutId) clearTimeout(timeoutId);
-							handle.close().catch(() => {});
-							cleanup().then(() => {
-								if (code === 0 || code === null) {
-									resolve(chunks.join(""));
-								} else {
-									reject(new Error(`Process exited with code ${code}`));
-								}
-							});
-						});
-
-						child.on("error", (err) => {
-							if (timeoutId) clearTimeout(timeoutId);
-							handle.close().catch(() => {});
-							cleanup().then(() => reject(err));
-						});
-					})
-					.catch((err) => {
-						cleanup().then(() => reject(err));
-					});
+			return runStreamingCommand({
+				command: "gemini",
+				args,
+				tmpFile,
+				timeoutMs: opts.timeoutMs,
+				onOutput: opts.onOutput,
+				cleanup,
 			});
 		}
 

package/src/cli-adapters/github-copilot.ts

@@ -1,9 +1,9 @@
-import { exec, spawn } from "node:child_process";
+import { exec } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
-import type { CLIAdapter } from "./index.js";
+import { type CLIAdapter, runStreamingCommand } from "./index.js";
 
 const execAsync = promisify(exec);
 const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
@@ -103,61 +103,13 @@ export class GitHubCopilotAdapter implements CLIAdapter {
 
 		// If onOutput callback is provided, use spawn for real-time streaming
 		if (opts.onOutput) {
-			return new Promise((resolve, reject) => {
-				const chunks: string[] = [];
-				const inputStream = fs.open(tmpFile, "r").then((handle) => {
-					const stream = handle.createReadStream();
-					return { stream, handle };
-				});
-
-				inputStream
-					.then(({ stream, handle }) => {
-						const child = spawn("copilot", args, {
-							stdio: ["pipe", "pipe", "pipe"],
-						});
-
-						stream.pipe(child.stdin);
-
-						let timeoutId: ReturnType<typeof setTimeout> | undefined;
-						if (opts.timeoutMs) {
-							timeoutId = setTimeout(() => {
-								child.kill("SIGTERM");
-								reject(new Error("Command timed out"));
-							}, opts.timeoutMs);
-						}
-
-						child.stdout.on("data", (data: Buffer) => {
-							const chunk = data.toString();
-							chunks.push(chunk);
-							opts.onOutput?.(chunk);
-						});
-
-						child.stderr.on("data", (data: Buffer) => {
-							// Only log stderr, don't include in return value
-							opts.onOutput?.(data.toString());
-						});
-
-						child.on("close", (code) => {
-							if (timeoutId) clearTimeout(timeoutId);
-							handle.close().catch(() => {});
-							cleanup().then(() => {
-								if (code === 0 || code === null) {
-									resolve(chunks.join(""));
-								} else {
-									reject(new Error(`Process exited with code ${code}`));
-								}
-							});
-						});
-
-						child.on("error", (err) => {
-							if (timeoutId) clearTimeout(timeoutId);
-							handle.close().catch(() => {});
-							cleanup().then(() => reject(err));
-						});
-					})
-					.catch((err) => {
-						cleanup().then(() => reject(err));
-					});
+			return runStreamingCommand({
+				command: "copilot",
+				args,
+				tmpFile,
+				timeoutMs: opts.timeoutMs,
+				onOutput: opts.onOutput,
+				cleanup,
 			});
 		}
 

package/src/cli-adapters/index.ts

@@ -1,9 +1,137 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import type { FileHandle } from "node:fs/promises";
+import fs from "node:fs/promises";
+
 export interface CLIAdapterHealth {
 	available: boolean;
 	status: "healthy" | "missing" | "unhealthy";
 	message?: string;
 }
 
+/**
+ * Collects stderr from a child process and returns a getter for the accumulated output.
+ * Also forwards each chunk to the optional onOutput callback.
+ */
+export function collectStderr(
+	child: ChildProcess,
+	onOutput?: (text: string) => void,
+): () => string {
+	const chunks: string[] = [];
+	child.stderr?.on("data", (data: Buffer) => {
+		const text = data.toString();
+		chunks.push(text);
+		onOutput?.(text);
+	});
+	return () => chunks.join("");
+}
+
+/**
+ * Builds an Error for a non-zero process exit, including stdout and stderr if available.
+ * Both stdout and stderr are included to ensure usage limit messages are captured
+ * regardless of which stream the CLI writes them to.
+ */
+export function processExitError(
+	code: number | null,
+	getStderr: () => string,
+	getStdout?: () => string,
+): Error {
+	const stderr = getStderr();
+	const stdout = getStdout?.() ?? "";
+	const output = [stdout, stderr].filter(Boolean).join("\n");
+	return new Error(
+		`Process exited with code ${code}${output ? `\n${output}` : ""}`,
+	);
+}
+
+export async function runStreamingCommand(opts: {
+	command: string;
+	args: string[];
+	tmpFile: string;
+	timeoutMs?: number;
+	onOutput?: (chunk: string) => void;
+	cleanup: () => Promise<void>;
+	env?: NodeJS.ProcessEnv;
+}): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const chunks: string[] = [];
+		const inputStream = fs.open(opts.tmpFile, "r").then((handle) => {
+			const stream = handle.createReadStream();
+			return { stream, handle };
+		});
+
+		inputStream
+			.then(({ stream, handle }) => {
+				const child = spawn(opts.command, opts.args, {
+					stdio: ["pipe", "pipe", "pipe"],
+					env: opts.env,
+				});
+
+				stream.pipe(child.stdin);
+
+				let timeoutId: ReturnType<typeof setTimeout> | undefined;
+				if (opts.timeoutMs) {
+					timeoutId = setTimeout(() => {
+						child.kill("SIGTERM");
+						reject(new Error("Command timed out"));
+					}, opts.timeoutMs);
+				}
+
+				child.stdout.on("data", (data: Buffer) => {
+					const chunk = data.toString();
+					chunks.push(chunk);
+					opts.onOutput?.(chunk);
+				});
+
+				const getStderr = collectStderr(child, opts.onOutput);
+
+				child.on("close", (code) => {
+					void finalizeProcessClose({
+						code,
+						timeoutId,
+						handle,
+						cleanup: opts.cleanup,
+						chunks,
+						getStderr,
+						resolve,
+						reject,
+					});
+				});
+
+				child.on("error", (err) => {
+					if (timeoutId) clearTimeout(timeoutId);
+					handle.close().catch(() => {});
+					opts.cleanup().then(() => reject(err));
+				});
+			})
+			.catch((err) => {
+				opts.cleanup().then(() => reject(err));
+			});
+	});
+}
+
+export async function finalizeProcessClose(opts: {
+	code: number | null;
+	timeoutId?: ReturnType<typeof setTimeout>;
+	handle: FileHandle;
+	cleanup: () => Promise<void>;
+	chunks: string[];
+	getStderr: () => string;
+	resolve: (value: string) => void;
+	reject: (error: Error) => void;
+}): Promise<void> {
+	if (opts.timeoutId) clearTimeout(opts.timeoutId);
+	await opts.handle.close().catch(() => {});
+	await opts.cleanup();
+
+	if (opts.code === 0 || opts.code === null) {
+		opts.resolve(opts.chunks.join(""));
+	} else {
+		opts.reject(
+			processExitError(opts.code, opts.getStderr, () => opts.chunks.join("")),
+		);
+	}
+}
+
 export function isUsageLimit(output: string): boolean {
 	const lower = output.toLowerCase();
 	return (

package/src/commands/clean.ts

@@ -7,12 +7,13 @@ import {
 	initDebugLogger,
 	mergeDebugLogConfig,
 } from "../utils/debug-log.js";
+import { deleteExecutionState } from "../utils/execution-state.js";
 import { acquireLock, cleanLogs, releaseLock } from "./shared.js";
 
 export function registerCleanCommand(program: Command): void {
 	program
 		.command("clean")
-		.description("Archive logs (move current logs into previous/)")
+		.description("Archive logs and reset execution state")
 		.action(async () => {
 			let config: Awaited<ReturnType<typeof loadConfig>> | undefined;
 			let lockAcquired = false;
@@ -27,14 +28,17 @@ export function registerCleanCommand(program: Command): void {
 				);
 				initDebugLogger(config.project.log_dir, debugLogConfig);
 
-				// Log the command invocation
+				// Acquire lock BEFORE logging - prevents clean from running during active gauntlet run
+				await acquireLock(config.project.log_dir);
+				lockAcquired = true;
+
+				// Log the command invocation (only after lock acquired)
 				const debugLogger = getDebugLogger();
 				await debugLogger?.logCommand("clean", []);
 				await debugLogger?.logClean("manual", "user_request");
 
-				await acquireLock(config.project.log_dir);
-				lockAcquired = true;
 				await cleanLogs(config.project.log_dir);
+				await deleteExecutionState(config.project.log_dir);
 				await releaseLock(config.project.log_dir);
 				console.log(chalk.green("Logs archived successfully."));
 			} catch (error: unknown) {

package/src/commands/index.ts

@@ -10,3 +10,4 @@ export { registerReviewCommand } from "./review.js";
 export { registerRunCommand } from "./run.js";
 export { registerStopHookCommand } from "./stop-hook.js";
 export { registerValidateCommand } from "./validate.js";
+export { registerWaitCICommand } from "./wait-ci.js";