fix: propagate command cancellation

Author: thymikee

src/platforms/ios/runner-transport.ts

@@ -154,7 +154,7 @@ export async function waitForRunner(
     if (remainingMs <= 0) {
       throw buildRunnerConnectError({ port, endpoints, logPath, lastError });
     }
-    const simResponse = await postCommandViaSimulator(device, port, command, remainingMs);
+    const simResponse = await postCommandViaSimulator(device, port, command, remainingMs, signal);
     return new Response(simResponse.body, { status: simResponse.status });
   }
 
@@ -250,6 +250,7 @@ async function postCommandViaSimulator(
   port: number,
   command: RunnerCommand,
   timeoutMs: number,
+  signal?: AbortSignal,
 ): Promise<{ status: number; body: string }> {
   const payload = JSON.stringify(command);
   const args = buildSimctlArgsForDevice(device, [
@@ -265,7 +266,7 @@ async function postCommandViaSimulator(
     payload,
     `http://127.0.0.1:${port}/command`,
   ]);
-  const result = await runCmd('xcrun', args, { allowFailure: true, timeoutMs });
+  const result = await runCmd('xcrun', args, { allowFailure: true, timeoutMs, signal });
   const body = result.stdout as string;
   if (result.exitCode !== 0) {
     const reason = classifyBootFailure({

src/utils/__tests__/exec.test.ts

@@ -27,6 +27,41 @@ test('runCmd enforces timeoutMs and rejects with COMMAND_FAILED', async () => {
   );
 });
 
+test('runCmd aborts with request cancellation details', async () => {
+  const controller = new AbortController();
+  const promise = runCmd(process.execPath, ['-e', 'setTimeout(() => {}, 10_000)'], {
+    signal: controller.signal,
+  });
+  controller.abort();
+
+  await assert.rejects(promise, (error: unknown) => {
+    const err = error as { code?: string; message?: string; details?: Record<string, unknown> };
+    return (
+      err?.code === 'COMMAND_FAILED' &&
+      err.message === 'request canceled' &&
+      err.details?.reason === 'request_canceled'
+    );
+  });
+});
+
+test('runCmd writes stdin through pipeline', async () => {
+  const stdin = Buffer.alloc(256_000, 'a');
+  const result = await runCmd(
+    process.execPath,
+    [
+      '-e',
+      [
+        'let bytes = 0;',
+        'process.stdin.on("data", chunk => { bytes += chunk.length; });',
+        'process.stdin.on("end", () => process.stdout.write(String(bytes)));',
+      ].join(''),
+    ],
+    { stdin },
+  );
+
+  assert.equal(result.stdout, String(stdin.length));
+});
+
 test('whichCmd resolves absolute executable paths without invoking a shell', async () => {
   assert.equal(await whichCmd(process.execPath), true);
 });

src/utils/exec.ts

@@ -2,6 +2,8 @@ import { constants } from 'node:fs';
 import { access, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { spawn, spawnSync, type ChildProcess, type StdioOptions } from 'node:child_process';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
 import { AppError } from './errors.ts';
 
 export type ExecResult = {
@@ -19,6 +21,7 @@ type ExecOptions = {
   stdin?: string | Buffer;
   timeoutMs?: number;
   detached?: boolean;
+  signal?: AbortSignal;
 };
 
 type ExecStreamOptions = ExecOptions & {
@@ -75,27 +78,32 @@ function runSpawnedCommand(
     const stdoutChunks: Buffer[] | undefined = options.binaryStdout ? [] : undefined;
     let stderr = '';
     let didTimeout = false;
+    let didAbort = false;
     const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
     const timeoutHandle = timeoutMs
       ? setTimeout(() => {
           didTimeout = true;
           killProcessTree(child, options.detached);
         }, timeoutMs)
       : null;
+    const onAbort = () => {
+      didAbort = true;
+      killProcessTree(child, options.detached);
+    };
+    if (options.signal?.aborted) {
+      onAbort();
+    } else {
+      options.signal?.addEventListener('abort', onAbort, { once: true });
+    }
 
     if (!options.binaryStdout) child.stdout.setEncoding('utf8');
     child.stderr.setEncoding('utf8');
 
-    child.stdin.on('error', (err: NodeJS.ErrnoException) => {
-      if (err.code !== 'EPIPE') {
-        child.emit('error', err);
-      }
+    void writeChildStdin(child, options.stdin).catch((err: unknown) => {
+      if (isEpipeError(err)) return;
+      reject(createStdinError(executable, cmd, args, err));
+      killProcessTree(child, options.detached);
     });
-    if (options.stdin !== undefined) {
-      child.stdin.end(options.stdin);
-    } else {
-      child.stdin.end();
-    }
 
     child.stdout.on('data', (chunk) => {
       if (options.binaryStdout) {
@@ -115,12 +123,22 @@ function runSpawnedCommand(
 
     child.on('error', (err) => {
       if (timeoutHandle) clearTimeout(timeoutHandle);
-      reject(createSpawnError(executable, cmd, args, err));
+      options.signal?.removeEventListener('abort', onAbort);
+      reject(
+        didAbort
+          ? createCommandCanceledError(executable, cmd, args)
+          : createSpawnError(executable, cmd, args, err),
+      );
     });
 
     child.on('close', (code) => {
       if (timeoutHandle) clearTimeout(timeoutHandle);
+      options.signal?.removeEventListener('abort', onAbort);
       const exitCode = code ?? 1;
+      if (didAbort) {
+        reject(createCommandCanceledError(executable, cmd, args));
+        return;
+      }
       if (didTimeout && timeoutMs) {
         reject(createTimeoutError(executable, cmd, args, timeoutMs, exitCode, stdout, stderr));
         return;
@@ -341,6 +359,29 @@ function createCommandFailedError(
   return new AppError('COMMAND_FAILED', `Failed to run ${executable}`, { cmd, args }, cause);
 }
 
+function createStdinError(
+  executable: string,
+  cmd: string,
+  args: string[],
+  cause: unknown,
+): AppError {
+  return new AppError(
+    'COMMAND_FAILED',
+    `Failed to write stdin for ${executable}`,
+    { cmd, args },
+    cause instanceof Error ? cause : undefined,
+  );
+}
+
+function createCommandCanceledError(executable: string, cmd: string, args: string[]): AppError {
+  return new AppError('COMMAND_FAILED', 'request canceled', {
+    cmd,
+    args,
+    executable,
+    reason: 'request_canceled',
+  });
+}
+
 function createTimeoutError(
   executable: string,
   cmd: string,
@@ -460,3 +501,21 @@ function killProcessTree(child: ChildProcess, detached: boolean | undefined): vo
   }
   child.kill('SIGKILL');
 }
+
+async function writeChildStdin(
+  child: ChildProcess,
+  stdin: string | Buffer | undefined,
+): Promise<void> {
+  if (!child.stdin) return;
+  if (stdin === undefined) {
+    child.stdin?.end();
+    return;
+  }
+  await pipeline(Readable.from([stdin]), child.stdin);
+}
+
+function isEpipeError(error: unknown): boolean {
+  return (
+    error instanceof Error && 'code' in error && (error as NodeJS.ErrnoException).code === 'EPIPE'
+  );
+}